CVE-2026-129230: NLTK: Uncontrolled recursion in WordNet Synset hypernym walkers (max_depth/min_depth/hypernym_paths/hypernym_distances) causes DoS
Medium CVSS 5.5
- OSV id
- GHSA-53pg-5qp8-mhvr
- Also known as
- CVE-2026-129230
- Published
- Last modified
Affected packages
| Package | Affected versions | Fixed in |
|---|---|---|
| nltk PyPI |
< 3.10.4 | 3.10.4 |
How to fix it
Upgrade nltk to 3.10.4 or later.
# in requirements.txt: change the line to nltk==3.10.4
pip install -r requirements.txt
- If it is an indirect dependency, upgrade the package that depends on it, or add a minimum version constraint for it (e.g. in constraints.txt, or as a dependency in pyproject.toml).
- Check the changelog for breaking changes (especially across major versions), update the lockfile with the package manager, and run your tests.
Not sure whether your project uses an affected version? Check your lockfile below for free.
Details
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.
- Build a
WordNetCorpusReaderwithout its unrelated data-loading side effects. - Parse two synset records whose
@(hypernym) pointers reference each other, forming a 2-cycle. - 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
- 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 t
References
- GHSA-53pg-5qp8-mhvr on OSV.dev
- Web: https://github.com/nltk/nltk/security/advisories/GHSA-53pg-5qp8-mhvr
- Advisory: https://nvd.nist.gov/vuln/detail/CVE-2026-129230
- Web: https://github.com/nltk/nltk/pull/3895
- Web: https://github.com/nltk/nltk/commit/34adf1ee425b5c817d2a88c674bac68672e3ab26
- Package: https://github.com/nltk/nltk
- Web: https://github.com/nltk/nltk/releases/tag/v3.10.4
Am I affected?
Upload or paste your lockfile. We check every package version in it against OSV.dev, this advisory included, and email you the vulnerable ones with the version that fixes them. Free, and no account needed.
About this data
Source: GitHub Advisory Database via OSV.dev (CC-BY 4.0). Severity comes from the advisory's own rating when it has one, else from its CVSS score.