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.
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)
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.
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.
WordNetCorpusReader without its unrelated data-loading side effects.@ (hypernym) pointers reference each other, forming a 2-cycle.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
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.@ 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).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._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.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.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.
Ecosystem: PyPIPackage: nltkConfirmed affected range: <= 3.10.3Latest release checked: 3.10.3 (pypi.org/pypi/nltk/json, verified 2026-09-15)Fix status: not fixedThe 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.
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).
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.
{
"cwe_ids": [
"CWE-400",
"CWE-674"
],
"github_reviewed": true,
"github_reviewed_at": "2026-11-19T23:49:16Z",
"nvd_published_at": "2026-11-19T18:18:08Z",
"severity": "MODERATE"
}