llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · nltk

GHSA-53PG-5QP8-MHVR

NLTK: Uncontrolled recursion in WordNet Synset hypernym walkers (max_depth/min_depth/hypernym_paths/hypernym_distances) causes DoS

Parche disponible
Descargar PNG JSON
CVSS 3.1
5.5
Media
CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versión3.10.4
Exposición7 hDesde la divulgación, 19 nov 2026, 6:49 p. m.
Detección1 minDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Monitoreo
Detectada
Fuente: GitHub Security Advisories +2
10:00 a. m.
06:49 p. m.
07:00 p. m.
02:18 a. m.
10:00 a. m.
02:05 p. m.
06:09 p. m.
10:13 p. m.
02:18 a. m.
FechaFaseEventoDetalle
Monitoreo Detectada Ingresó al índice
Divulgación Publicada GHSA-53PG-5QP8-MHVR divulgada · CVSS 5.5 (GitHub)
Divulgación Modificada Última actualización del registro
Monitoreo Fuente: GitHub Security Advisories Registro visto por primera vez en GitHub Security Advisories
Monitoreo Fuente: OSV Registro visto por primera vez en OSV
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

Four hypernym-walking methods on the WordNet `Synset` class in `nltk/corpus/reader/wordnet.py` (`max_depth`, `min_depth`, `hypernym_paths`, and `hypernym_distances`) traverse the hypernym pointer graph by direct recursion with no visited-node set and no depth cap. WordNet `data.<pos>` file content is untrusted corpus input in NLTK, the same trust boundary the project already treats as attacker-controlled across its corpus-content hardening work. When the parsed hypernym graph contains a cycle, or a chain deeper than the interpreter recursion limit, these methods recurse without bound and raise an uncaught `RecursionError`, aborting the traversal and any worker that does not catch it. No special privileges are needed; the victim only has to load an attacker-supplied corpus and call any of several shipped public methods that reach these walkers.

Root Cause

`Synset.max_depth` computes `1 + max(h.max_depth() for h in hypernyms)` and only assigns its `_max_depth` memo after that recursive expression fully returns. Because Python evaluates the right-hand side completely before binding the left-hand side, the memo is never set on a node that is still on the recursion stack, so a cyclic graph re-enters the same not-yet-memoized node indefinitely. `min_depth`, `hypernym_paths`, and `hypernym_distances` follow the same recursive descent with no cycle detection. The security invariant that graph traversal over untrusted corpus data must terminate is violated: the pointer offsets parsed from the data file are stored verbatim with no graph-shape validation, so the attacker controls the graph topology. The sibling walkers in the same class (`closure`, `tree`, `_shortest_hypernym_paths`) were hardened with acyclic/visited guards, which shows cyclic hypernym graphs are an in-scope threat that these four methods simply were not converted to handle.

Affected functions in nltk/corpus/reader/wordnet.py:
  Synset.max_depth          (nltk/corpus/reader/wordnet.py:550)
  Synset.min_depth          (nltk/corpus/reader/wordnet.py:564)
  Synset.hypernym_paths     (nltk/corpus/reader/wordnet.py:666)
  Synset.hypernym_distances (nltk/corpus/reader/wordnet.py:768)
Untrusted pointer stored at nltk/corpus/reader/wordnet.py:1694
Re-entry edge: hypernyms() (:138) -> _related('@') (:1103) -> synset_from_pos_and_offset (:1104)

Impact

An attacker who can supply a WordNet `data.<pos>` corpus file that the victim loads (for example a downloaded, mirrored, or user-provided WordNet corpus) can construct a hypernym pointer graph that is cyclic or deeper than the recursion limit. When the application then calls any hypernym-depth or path method, the walker recurses without bound and raises an uncaught `RecursionError`, terminating the current traversal and any request or worker process that does not handle it. Under a raised or removed recursion limit, unbounded recursion can instead exhaust the native stack and abort the process. The impact is availability only; there is no confidentiality or integrity effect. Reachable public entry points include `hypernym_paths` and `hypernym_distances` directly, and `max_depth`/`min_depth` indirectly through `lowest_common_hypernyms`, `wup_similarity`, `path_similarity`, and `lch_similarity`.

Proof of Concept

`Requires only the nltk package under test on PYTHONPATH; no network or WordNet data download. The reader is instantiated with __new__ to skip unrelated OMW/lexname loading, the same technique NLTK's own recursion-DoS hardening test uses; the parser and the walker under test are unmodified library code.`

  1. Build a `WordNetCorpusReader` without its unrelated data-loading side effects.
  2. Parse two synset records whose `@` (hypernym) pointers reference each other, forming a 2-cycle.
  3. Call `Synset.max_depth()` on one of them.
import sys
sys.setrecursionlimit(1500)
from nltk.corpus.reader.wordnet import WordNetCorpusReader

reader = WordNetCorpusReader.__new__(WordNetCorpusReader)
reader._synset_offset_cache = {"n": {}}
reader._lexnames = ["adj.all"]
reader._lemma_pos_offset_map = {"w88": {"n": [88]}, "w99": {"n": [99]}}

def make(offset, partner):
    line = f"{offset:08d} 00 n 01 w{offset} 0 001 @ {partner:08d} n 0000 | gloss"
    s = reader._synset_from_pos_and_line("n", line)
    reader._synset_offset_cache["n"][offset] = s
    return s

a = make(88, 99)
b = make(99, 88)
print("hypernym pointers:", dict(a._pointers))
print("hypernyms():", a.hypernyms())
try:
    a.max_depth()
    print("returned normally")
except RecursionError:
    print("VULNERABLE: max_depth() recursed without bound -> RecursionError")
hypernym pointers: {'@': {('n', 99)}}
hypernyms(): [Synset('w99.n.01')]
VULNERABLE: max_depth() recursed without bound -> RecursionError

Attack Chain

  1. Exposure: The victim application loads a WordNet `data.<pos>` corpus file whose content is attacker-supplied. Corpus file content is untrusted input in NLTK, consistent with the project's existing corpus-content hardening.
  2. Control: The attacker fully controls the `@` hypernym pointer offset fields. They are parsed and stored verbatim at `nltk/corpus/reader/wordnet.py:1694` with no graph-shape validation, so the attacker chooses an arbitrary graph topology (a cycle or a chain deeper than the recursion limit).
  3. Path: A shipped public method reaches a walker: `hypernym_paths`/`hypernym_distances` directly, or `lowest_common_hypernyms`/`wup_similarity`/`path_similarity`/`lch_similarity` via `max_depth`/`min_depth`. `hypernyms()` (`:138`) resolves the partner synset through `_related('@')` (`:1103`) and `synset_from_pos_and_offset` (`:1104`), which returns the same cached, still-unmemoized object.
  4. Guard: The only candidate guard, the `_max_depth`/`_min_depth` memo, is assigned only after the recursive expression returns, so it never protects a node still on the stack. No visited set and no depth cap exist on any of the four methods.
  5. Primitive: Unbounded recursion over the attacker-chosen graph.
  6. Result: Uncaught `RecursionError` aborts the traversal and any worker that does not catch it; native stack exhaustion and process abort are possible under a raised recursion limit. Availability impact only.

Bypass Evidence

The relevant candidate guard is the per-instance depth memo. It does not block the path: Python evaluates `1 + max(h.max_depth() for h in hypernyms)` fully before binding `self._max_depth`, so during recursion the memo check `"_max_depth" not in self.__dict__` is still true when the traversal re-enters a node already on the stack. The synset offset cache does not help either; it returns the same object whose memo is still unset, and even a hypothetical fresh object per lookup would also be unmemoized, so termination is unaffected. Attempts to disprove the finding all failed: the claim that the offset cache breaks the cycle is false (same unmemoized object), the claim that no shipped public API reaches the walkers is false (`hypernym_paths`, `hypernym_distances`, `wup_similarity`, `lowest_common_hypernyms` all reach them), and the claim that the reproduction is an artifact of skipping `__init__` is false (only unrelated OMW/lexname loading is skipped; the parser and walker are unmodified). A non-cyclic hypernym chain longer than `sys.getrecursionlimit()` triggers the same failure, so a cycle is not even required. That the maintainers added acyclic/visited guards to the sibling walkers `closure`, `tree`, and `_shortest_hypernym_paths` confirms this is an unhardened gap rather than intended behavior.

Affected Versions

  • `Ecosystem: PyPI`
  • `Package: nltk`
  • `Confirmed affected range: <= 3.10.3`
  • `Latest release checked: 3.10.3 (pypi.org/pypi/nltk/json, verified 2026-09-15)`
  • `Fix status: not fixed`

The four walkers and their missing guards are long-standing WordNet-reader code present in the current published artifact (3.10.3), and no fix has been released. The upper bound `<= 3.10.3` is verified against the exact PyPI-published version. The lower bound is left open because the first affected release was not binary-searched; the vulnerable code predates recent releases.

Suggested Fix

Enforce bounded, cycle-safe traversal in `max_depth`, `min_depth`, `hypernym_paths`, and `hypernym_distances`. Thread a visited-node set through the recursion (skipping nodes already on the current path) and/or impose an explicit maximum depth, mirroring the acyclic helpers already used by `closure`, `tree`, and `_shortest_hypernym_paths` in the same class. As an interim mitigation, applications that must process untrusted corpora can wrap calls to these methods in a `RecursionError` handler and set a conservative `sys.setrecursionlimit`, though this only converts the crash into a handled error rather than removing the unbounded traversal.

---

Reported by zx (GitHub: @manus-pi).

Fix status (2026-09-28)

Status: IN PROGRESS (fix on an open pull request, not yet on develop).

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

Fix commit: 34adf1ee4 "Bound WordNet hypernym recursion and linearize the lemma-marker regex".

No probe. The advisory PoC re-run (two synsets whose @ pointers form a 2-cycle): on the PR head max_depth, min_depth, hypernym_paths and hypernym_distances all raise ValueError; on develop 2fa3f48fe all four raise RecursionError, so develop is still VULNERABLE.

Release: none.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:L
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:R
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida
nltk< 3.10.4
3.10.4
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
PyPInltk
Corregida 3.10.4 — —
Versiones corregidas3.10.4
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-129230
Otrahttps://github.com/nltk/nltk/security/advisories/GHSA-53pg-5qp8-mhvr
Otrahttps://github.com/nltk/nltk/pull/3895
Otrahttps://github.com/nltk/nltk/commit/34adf1ee425b5c817d2a88c674bac68672e3ab26
Otrahttps://github.com/nltk/nltk
Otrahttps://github.com/nltk/nltk/releases/tag/v3.10.4

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.