Guard Core: Kwadratowy ReDoS we wbudowanym wzorcu wykrywania blokuje pętlę zdarzeń pojedynczym żądaniem
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:
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:
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ę.
"""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.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | guard-core | >= 3.5.0, < 3.13.0 | 3.13.0 |
Odnośniki
- https://github.com/Guard-Core/guard-core/security/advisories/GHSA-r7hm-rjvg-xx7j
- https://nvd.nist.gov/vuln/detail/CVE-2026-129302
- https://github.com/Guard-Core/guard-core/pull/68
- https://github.com/Guard-Core/guard-core/commit/c07239fa1c5aa93e3f179440e79dad652977d3e4
- https://github.com/Guard-Core/guard-core/releases/tag/3.13.0
- https://github.com/rennf93/guard-core
- 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
- 2026: 3
-
Guard Core: Kwadratowy ReDoS we wbudowanym wzorcu wykrywania blokuje pętlę zdarzeń pojedynczym żądaniem ten wpis
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.