Wysoka

NLTK: Odmowa usługi w czasie kompilacji regex w funkcjach wyszukiwania i tokenizacji

  • Ujawniono: 19.11.2026
  • Aktualizacja: 22.11.2026 10:00

Podsumowanie

NLTK jest podatny na odmowę usługi (ReDoS) na etapie kompilacji wyrażeń regularnych w funkcjach pomocniczych wyszukiwania. W sytuacji, gdy aplikacja przekazuje niezaufany tekst jako wzorzec wyszukiwania do TokenSearcher.findall() / Text.findall() lub jako wzorzec tokenizera do RegexpTokenizer, wzorzec ten trafia do zewnętrznego silnika regex. Koszt kompilacji tego silnika rośnie w przybliżeniu kwadratowo względem liczby grup przechwytujących. Krótki wzorzec o strukturze () powtórzony wielokrotnie (np. "()" * 25000, około 50 KB) wymusza kilkadziesiąt sekund synchronicznej pracy procesora, zanim w ogóle rozpocznie się dopasowywanie. Limit czasu (wall-clock timeout) wprowadzony w NLTK zabezpiecza wyłącznie fazę dopasowywania i nie działa podczas kompilacji. W efekcie pojedyncze małe żądanie może zablokować rdzeń procesora, a powtarzające się lub równoległe zapytania mogą wyczerpać zasoby i doprowadzić do odmowy usługi.

Przyczyna

Poprzednia poprawka dotycząca problemu z nawrotami (backtracking) podczas dopasowywania (advisory GHSA-rrv8-h7p8-rx55 / CVE-2026-80205) zastąpiła moduł biblioteki standardowej re zewnętrznym silnikiem regex i objęła dopasowywanie limitem czasu. Limit ten jest jednak stosowany wyłącznie w trakcie skanowania korpusu przez skompilowany wzorzec. Kompilacja odbywa się wcześniej, synchronicznie i bez ograniczeń czasowych. Kompilator silnika regex charakteryzuje się złożonością około O(n^2) względem liczby grup wyrażenia regularnego, w związku z czym kontrolowany przez użytkownika wzorzec z wieloma pustymi grupami przenosi główny narzut na etap kompilacji. Brak jest mechanizmu ograniczającego liczbę grup przed kompilacją.

Affected components / functions:
- nltk.text.TokenSearcher.findall  (nltk/text.py)  -> regex.findall(pattern, corpus, timeout=...)
    On released 3.10.0-3.10.2 this sink calls regex.findall directly; on 3.10.3 and later it
    routes through nltk.redos.compile. Either way the regex engine compiles the caller pattern
    with no group-count bound, and the timeout guards only matching.
- nltk.redos.compile  (nltk/redos.py, introduced in 3.10.3)  -> regex.compile(src, flags)
    Called synchronously before the timeout-bearing wrapper exists. On released 3.10.3 there is
    no pre-compile guard at all; on the current development tree a check_pattern bounds source
    length, nesting depth, and counted-repeat product, but not the number of groups.

Wpływ

Nieuwierzytelniony atakujący mogący wpłynąć na ciąg wyrażenia regularnego trafiający do punktów wejściowych wyszukiwania lub tokenizacji w NLTK może doprowadzić do nadmiernego zużycia procesora. Pojedyncze żądanie zawierające wzorzec o wielkości około 50 KB złożony z pustych grup blokuje proces roboczy na kilkadziesiąt sekund. Ponieważ koszt rośnie kwadratowo, a wersja 3.10.3 nie nakłada limitu długości, niewielka liczba równoległych żądań może wyczerpać dostępne rdzenie i zablokować usługę. Podatność nie wpływa na poufność ani integralność; dostępność wraca do normy po zakończeniu kompilacji lub zatrzymaniu procesu.

Proof of Concept

Requires the nltk package (3.10.0 through 3.10.3) and its declared regex dependency. No corpus data or network access is needed.

  1. Skonstruuj wzorzec zawierający wiele pustych grup przechwytujących.
  2. Przekaż go do dowolnego podatnego punktu wejściowego i zmierz czas spędzony przed etapem dopasowywania.
  3. Zaobserwuj, że limit czasu dopasowywania nie zadziała, ponieważ opóźnienie wynika z kompilacji.
python
import time, regex

# Exact released 3.10.0-3.10.2 code path of TokenSearcher.findall:
#   regex.findall(pattern, corpus, timeout=<wall-clock match limit>)
pattern = "()" * 25000            # ~50 KB, 25000 capturing groups; survives the "<>." rewrites
start = time.perf_counter()
try:
    regex.findall(pattern, "<hello><world><foo>", timeout=1.0)
    print(f"completed in {time.perf_counter()-start:.2f}s with NO TimeoutError")
except TimeoutError:
    print(f"TimeoutError after {time.perf_counter()-start:.2f}s")

# Negative control: same length, zero groups, compiles in well under a second.
start = time.perf_counter()
regex.findall("a" * 50000, "<hello>", timeout=1.0)
print(f"control (0 groups) completed in {time.perf_counter()-start:.2f}s")
completed in 4.24s with NO TimeoutError
control (0 groups) completed in 0.16s

Dodatkowe pomiary na tym samym hoście: regex.compile("()" * n) skalowało się jako 0.35s / 1.17s / 2.61s / 4.77s dla n = 5000 / 10000 / 15000 / 20000 (złożoność kwadratowa); moduł re.compile("()" * 20000) z biblioteki standardowej zajął 0.14s, co potwierdza, że koszt dotyczy silnika regex oraz liczby grup, a nie długości wzorca. W przypadku tokenizera wywołanie RegexpTokenizer("()" * 20000).tokenize("hello world") zablokowało wykonanie na około 5.1s całkowicie na etapie kompilacji bez zgłoszenia TimeoutError.

Łańcuch ataku

  1. Ekspozycja: Aplikacja udostępnia operacje wyszukiwania regex lub tokenizacji NLTK dla danych wejściowych użytkownika (np. wyszukiwanie oparte na Text.findall() / TokenSearcher.findall() lub RegexpTokenizer ze wzorcem użytkownika).
  2. Kontrola: Atakujący przesyła ciąg () powtórzony n razy. Nie zawiera on białych znaków, <, > ani ., dzięki czemu przechodzi bez zmian przez reguły w TokenSearcher.findall (nltk/text.py) i trafia bezpośrednio do RegexpTokenizer.
  3. Ścieżka: Wzorzec trafia do kompilacji: regex.findall(pattern, corpus, timeout=...) w wydaniu 3.10.0 poprzez 3.10.2, lub nltk.redos.compile do regex.compile w 3.10.3 oraz na ścieżce tokenizera.
  4. Zabezpieczenie: Limit czasu chroni wyłącznie dopasowywanie po zakończeniu kompilacji. W wersji 3.10.3 brak jest weryfikacji wstępnej; w gałęzi rozwojowej sprawdzana jest długość, głębokość zagnieżdżenia i powtórzenia, ale nie liczba grup.
  5. Prymityw: Synchroniczna, nieprzerywalna kompilacja regex ze złożonością kwadratową względem liczby grup.
  6. Rezultat: Małe żądanie zajmuje rdzeń CPU na dziesiątki sekund; równoczesne żądania doprowadzają do całkowitej odmowy usługi.

Analiza obejścia poprawki

Problem wynika z niekompletnej wcześniejszej poprawki (advisory GHSA-rrv8-h7p8-rx55 / CVE-2026-80205), która dotyczyła nawrotów w Text.findall(), wprowadzając silnik regex i limit czasu dla dopasowywania. Nowe dowody wskazują, że kompilacja nie została objęta tym limitem i wykonuje się synchronicznie przed nim.

Wyniki testów weryfikacyjnych:

  • Działanie limitu czasu: regex.findall("()" * 20000, corpus, timeout=1.0) działało przez około 4.3s bez TimeoutError, a RegexpTokenizer("()" * 20000).tokenize(...) zablokowało się na około 5.1s bez TimeoutError. Limit czasu dopasowywania nie przerywa kompilacji.
  • Weryfikacja wstępna (gałąź rozwojowa): przy wejściu () licznik zagnieżdżeń oscyluje między 0 a 1, a limit długości nadal dopuszcza około 50000 grup. Zabezpieczenie akceptuje "()" * 49000, ponieważ nie liczy grup.
  • Pamięć podręczna kompilacji: wewnętrzny mechanizm cache obsługuje tylko krótkie ciągi, a podatne funkcje kompilują bezpośrednio; unikalne wartości n wymuszają nową kompilację za każdym razem.
  • Weryfikacja duplikatów: poprzednie zgłoszenia dotyczyły nawrotów przy dopasowywaniu lub rekursji parsera, a nie narzutu kompilatora.
  • Próby kontrolne: wzorzec o tej samej długości bez grup oraz kompilator re działają szybko, co wskazuje na silnik regex i liczbę grup jako źródło problemu.

Podatne wersje

  • Ecosystem: pip (PyPI)
  • Package: nltk
  • Confirmed affected range: >= 3.10.0, <= 3.10.3
  • Latest release checked: 3.10.3 (PyPI, latest published)
  • Fix status: not fixed

Podatność pojawiła się w wersji 3.10.0, w której wprowadzono silnik regex do obsługi wzorców użytkownika. Wersja 3.9.4 i wcześniejsze korzystały z modułu re dla TokenSearcher.findall (kompilacja liniowa, brak podatności: re.findall). Od 3.10.0 do 3.10.2 funkcja TokenSearcher.findall wywołuje bezpośrednio regex.findall(pattern, corpus, timeout=...) (potwierdzone w 3.10.0). W wersji 3.10.3 dodano nltk/redos.py i skierowano tam RegexpTokenizer. Opublikowany moduł 3.10.3 nie ma żadnych zabezpieczeń wstępnych ani ograniczeń długości. 3.10.3 to najnowsza opublikowana wersja; brak wydanej wersji z poprawką. Aktualna gałąź rozwojowa również pozostaje podatna z powodu braku limitu liczby grup.

Sugerowane rozwiązanie

Wprowadzenie ograniczeń na złożoność wzorca przed przystąpieniem do kompilacji, a nie tylko podczas dopasowywania. Należy w szczególności ograniczyć liczbę grup w wyrażeniu przed przekazaniem go do silnika regex i odrzucać zbyt złożone wzorce. Kontrola musi nastąpić przed wywołaniem regex.compile / regex.findall, obejmując wszystkie punkty wejścia (TokenSearcher.findall / Text.findall, RegexpTokenizer oraz pozostałe funkcje tokenizujące, tagujące i segmentujące).

Zgłoszone przez: zx (GitHub: @manus-pi).

Status poprawki (2026-09-28)

Status: W TOKU (poprawka w otwartym pull requeście, jeszcze nie w develop).

PR: #3895 "[WIP] Bound algorithmic-DoS and uncontrolled-recursion vectors (CWE-400/407/674/1333)", otwarty, head b22ebe144.

Commit z poprawką: 002bcf714 (redos.check_pattern odrzuca wzorzec z liczbą grup przechwytujących przekraczającą MAX_GROUP_COUNT=1000 przed kompilacją; wszystkie wzorce przechodzą przez redos.compile).

Ponowny test PoC (RegexpTokenizer("()" * 20000).tokenize("hello world")): w gałęzi PR rzuca ValueError w czasie poniżej 0.01 s ("regex opens more than 1000 capturing groups; refusing to compile"); w gałęzi develop 2fa3f48fe kompilacja trwała 19.7 s bez błędu, zatem gałąź develop jest nadal PODATNA.

Wydanie: brak.

Co trzeba zrobić

Oficjalna wersja z poprawką nie została jeszcze wydana (prace trwają w ramach otwartego pull requesta #3895). Jako tymczasowe obejście, aplikacje przekazujące dane użytkownika do podatnych interfejsów NLTK powinny weryfikować i odrzucać zbyt długie wzorce lub wzorce z dużą liczbą grup, a także uruchamiać operacje NLTK w procesach roboczych z nałożonymi limitami czasu procesora.

Czego dotyczy

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

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) nltk >= 3.10.0, < 3.10.4 3.10.4

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
nltk
Ujawniono
19.11.2026
Aktualizacja
22.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-32p6-cwhc-8r78 - CC BY 4.0

Historia podatności: nltk

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

Wszystkie (79) w archiwum
Wszystkich wpisów
79
Pierwsza → ostatnia
08.2019 11.2026
Bez poprawki
5
Wykorzystywana w atakach
0

Rozkład istotności

  • Krytyczna 5
  • Wysoka 41
  • Średnia 31
  • Niska 2

Ujawnienia w latach

  1. 2019: 1
  2. 2020: 0
  3. 2021: 2
  4. 2022: 1
  5. 2023: 0
  6. 2024: 1
  7. 2025: 0
  8. 2026: 74
Istotność:
  1. NLTK: Odmowa usługi w czasie kompilacji regex w funkcjach wyszukiwania i tokenizacji ten wpis
    Wysoka · 7.5 CVE-2026-129229 >= 3.10.0, < 3.10.4 3.10.4
  2. Wysoka · 7.8 CVE-2026-78680 < 3.10.3 3.10.3
  3. Wysoka CVE-2026-79674 < 3.10.3 3.10.3
  4. Wysoka · 8.8 CVE-2026-71513 >= 3.10.0, < 3.10.3 3.10.3
  5. Wysoka · 5.9 CVE-2026-62385 < 3.10.0 3.10.0
  6. Wysoka · 7.5 CVE-2026-33231 < 3.9.4 3.9.4
  7. Wysoka · 8.6 CVE-2026-0847 < 3.9.3 3.9.3
Pokaż więcej (6) Widać 40 z 46

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.