nltk
Affected
- introduced
3.10.0, fixed3.10.4(ecosystem)
Fixed versions
3.10.4
Fix
- Fixed version
3.10.4pip install --upgrade nltk==3.10.4
Advisory
Also known as: CVE-2026-126304
NLTK: Symlink escape in YCOECorpusReader lets a psd/pos directory symlink read files outside the corpus root within the data sandbox
Summary
YCOECorpusReader builds two nested corpus sub-readers whose roots are derived from self.root.join("psd") and self.root.join("pos") (nltk/corpus/reader/ycoe.py). Because FileSystemPathPointer.join() (nltk/data.py) performs a purely lexical containment check and never resolves symlinks, and because CorpusReader.__init__ (nltk/corpus/reader/api.py) validates a sub-reader root only against the global NLTK data sandbox and not against the enclosing corpus root, a directory symlink named psd or pos planted inside a YCOE corpus lets the reader anchor its nested sub-readers outside the YCOE corpus root. An attacker who controls the contents of a YCOE corpus loaded under pathsec.ENFORCE=True can make parsed_sents(), tagged_words(), and related methods return file content from other locations inside the allowed data sandbox, defeating the per-corpus-root containment boundary the pathsec controls are meant to enforce.
Root Cause
NLTK's pathsec controls are designed to keep each corpus reader confined to its own corpus root. The scoped containment is enforced through validate_path(..., required_root=self._root) at read time. However, the containment invariant is violated at reader-construction time for nested readers:
FileSystemPathPointer.join() accepts a component that is a directory symlink because it only checks the joined string lexically (os.path.normpath plus a startswith prefix test) and never calls resolve().CorpusReader.__init__ validates the resulting sub-reader root string, but calls validate_path without required_root, so only the global-sandbox layer runs; the scoped per-corpus-root layer is skipped. The symlink is resolved by that global check, its target is found to be inside the allowed sandbox, and the sub-reader is accepted with its root pointing at the escaped target.From that point every read the sub-reader performs is scoped to the already-escaped root, so no later guard re-anchors it to the YCOE corpus root.
Affected functions:
- nltk.corpus.reader.ycoe.YCOECorpusReader.__init__ (nltk/corpus/reader/ycoe.py) builds nested sub-readers from self.root.join("psd")/("pos") without containing them to the parent root
- nltk.corpus.reader.api.CorpusReader.__init__ (nltk/corpus/reader/api.py) validates a sub-reader root only against the global sandbox (validate_path without required_root)
- nltk.data.FileSystemPathPointer.join (nltk/data.py) applies a lexical prefix check only and never resolves symlinks
Impact
An attacker who controls the directory contents of a YCOE corpus that is loaded by a victim application under pathsec.ENFORCE=True (the default in the affected releases) can read file content that lives outside the YCOE corpus root but inside an allowed NLTK data root. The disclosure is bounded to the global NLTK data sandbox: a symlink whose target resolves outside every allowed root is rejected at construction, so this is not an arbitrary-filesystem read. The demonstrated capability is read-only cross-corpus-root disclosure. In a multi-tenant or automated-ingestion deployment the accessible scope includes other corpora placed under the shared data path and the shared system temporary directory, which is a default allowed root and can hold other processes' sensitive temporary files. There is no integrity or availability impact.
Proof of Concept
Dependencies: a released nltk (3.10.0 through 3.10.3) on a POSIX host. No third-party packages. The only allowed data root is a fresh temp sandbox; ENFORCE is left at its default of True.
Steps:
nltk.data.path entry.doc1.psd / doc1.pos outside the YCOE corpus root.psd and pos entries are directory symlinks pointing at the victim directory.YCOECorpusReader on that root and read it.import os, tempfile, nltk
from nltk import pathsec
sandbox = os.path.realpath(tempfile.mkdtemp())
pathsec.ENFORCE = True
nltk.data.path = [sandbox]
pathsec._ALLOWED_ROOTS_CACHE = None
from nltk.corpus.reader.ycoe import YCOECorpusReader
victim = os.path.join(sandbox, "victim", "psd_secret")
victim_pos = os.path.join(sandbox, "victim", "pos_secret")
os.makedirs(victim); os.makedirs(victim_pos)
open(os.path.join(victim, "doc1.psd"), "w").write("(S (SECRET leaked-out-of-ycoe-root))\n")
open(os.path.join(victim_pos, "doc1.pos"), "w").write("SECRET_NN leaked-out-of-ycoe-root_NN\n")
ycoe = os.path.join(sandbox, "corpora", "ycoe_evil"); os.makedirs(ycoe)
os.symlink(victim, os.path.join(ycoe, "psd"))
os.symlink(victim_pos, os.path.join(ycoe, "pos"))
reader = YCOECorpusReader(ycoe)
print(reader.parsed_sents())
print(reader.tagged_words())
psd sub-reader real root : /tmp/ycoe_poc_zc35zihw/victim/psd_secret
ycoe corpus root : /tmp/ycoe_poc_zc35zihw/corpora/ycoe_evil
parsed_sents() : [Tree('S', [Tree('SECRET', ['leaked-out-of-ycoe-root'])])]
tagged_words() : [('SECRET', 'NN'), ('leaked-out-of-ycoe-root', 'NN')]
ESCAPE CONFIRMED: YCOE read out-of-root content via psd/pos symlink
A negative control with real (non-symlink) psd/pos directories stays contained, and a symlink whose target is /etc is rejected at construction with a PermissionError, confirming the escape is bounded to the sandbox.
Attack Chain
pathsec.ENFORCE=True.psd and pos entries to directory symlinks pointing at another directory inside the allowed sandbox.YCOECorpusReader.__init__ calls self.root.join("psd"); FileSystemPathPointer.join() returns a pointer to <root>/psd after a lexical-only check that never resolves the symlink.CorpusReader.__init__ calls validate_path(root) without required_root, so the scoped per-corpus-root layer is skipped; only the global-sandbox layer runs and it resolves the symlink to an in-sandbox target and accepts it.find_corpus_fileids and the read-time validate_path(required_root=self._root) both anchor to that escaped root, so all reads are treated as in-root.parsed_sents(), tagged_words(), tagged_sents(), and words() return file content from outside the YCOE corpus root but inside the allowed sandbox: read-only cross-corpus-root disclosure.Bypass Evidence
The relevant guards are the pathsec containment checks that were added to confine corpus readers to their roots. They do not block this path:
FileSystemPathPointer.join() (nltk/data.py) checks joined == root or joined.startswith(root + os.sep) on the lexical, non-resolved path. A psd component that is a directory symlink yields <root>/psd, which satisfies the prefix test, and the symlink is never resolved. FileSystemPathPointer.__init__ uses os.path.abspath, which also does not resolve symlinks.CorpusReader.__init__ (nltk/corpus/reader/api.py) invokes validate_path(root, context="CorpusReader.__init__") with no required_root. In validate_path, the scoped layer is guarded by if required_root: and is therefore skipped; only the global-sandbox layer runs, which resolves the symlink target and accepts it because it lies inside nltk.data.path.validate_path(path, required_root=self._root) uses the sub-reader's own self._root, which is already the escaped target, so it cannot detect the escape. find_corpus_fileids computes resolved_root = os.path.realpath(root.path) on the escaped root, so its commonpath descent guard also confines to the escaped target rather than the YCOE root.High Basis: The source's own band: HIGH
3.10.0, fixed 3.10.4 (ecosystem)3.10.4
3.10.4pip install --upgrade nltk==3.10.4Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0