Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app exposing WekaClassifier model path
-
DeliverySubmit crafted model_filename with traversal sequence
-
ExploitBypass nltk.pathsec containment check
-
ExecutionWeka JVM writes/probes files via -d/-l
-
ImpactArbitrary file write outside allowed data root
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an application that uses NLTK's WekaClassifier AND passes attacker-controllable values into the model_filename or model argument; a functioning Weka Java/JVM toolchain must also be installed and invoked. Under these conditions the nltk.pathsec containment that normally restricts paths to allowed data roots is bypassed, enabling file writes (Weka -d) or existence probes (Weka -l) outside those roots. Limiting factors: this is a non-default, niche integration - the vast majority of NLTK deployments never invoke WekaClassifier - and the attacker must control the specific model-path argument. The CVSS PR:N indicates no authentication to the vulnerable function itself, but AT:P reflects the required application-wiring/configuration precondition. |
| Impact | The CVSS 4.0 score of 8.3 (High) is driven by a network vector with low complexity and no required privileges (AV:N/AC:L/PR:N/UI:N), combined with a high integrity impact (VI:H) reflecting arbitrary file write via the Weka '-d' option. However, the vector also carries AT:P (Attack Requirements: Present), which signals that exploitation is NOT unconditional - it depends on an application actually routing attacker-controlled input into the WekaClassifier model_filename/model argument. No EPSS score, CISA KEV listing, or public exploit was provided in the intelligence, so exploitation status is 'no public exploit identified at time of analysis.' Signals are therefore consistent but modest: the flaw is legitimately network-reachable and unauthenticated at the function level, yet the AT:P requirement plus the niche nature of the WekaClassifier integration (which needs an installed Weka JVM) sharply narrows the realistically exploitable population. This reads as a real-but-situational issue rather than a mass-exploitation priority: treat it as high-priority ONLY where an application exposes Weka classification with user-influenced model paths. Note that EPSS/KEV/POC data were absent from the input, so widespread-exploitation likelihood could not be quantified and should be verified against VulnCheck/EPSS feeds. |
| Exploit ScenarioDerived | An application that calls NLTK's WekaClassifier and lets a user influence the model_filename or model argument is targeted by a remote attacker who supplies a path containing traversal sequences. Because the input bypasses nltk.pathsec containment, the invoked Weka JVM writes attacker-chosen files (via -d) or probes for file existence (via -l) outside the permitted data roots. No public proof-of-concept was identified in the provided intelligence. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Path traversal in NLTK's WekaClassifier integration (all versions through 3.10.3) lets attackers who control the model_filename or model argument escape nltk.pathsec containment and drive the Weka JVM to write files outside permitted data roots via the -d option, or probe for file existence via -l. There is no public exploit identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV), but exploitation requires an application that wires attacker-controllable values into WekaClassifier and has a working Weka Java/JVM toolchain installed - a non-default, niche integration that most NLTK deployments never invoke. Under those preconditions, the CVSS 4.0 base score of 8.3 is driven by a network vector with high integrity impact (VI:H), while the AT:P metric reflects the required application-wiring precondition.
RemediationAI
Patch available per vendor advisory: apply the fix documented in the NLTK security advisory GHSA-j456-xh4h-cpf2 (https://github.com/nltk/nltk/security/advisories/GHSA-j456-xh4h-cpf2) and upgrade to a release later than 3.10.3 once the vendor-confirmed patched version is published, also tracking the VulnCheck advisory for affected-version confirmation. Because the flaw is only reachable when an application forwards attacker-controllable model paths, the most effective immediate compensating control is to stop passing user-, tenant-, or request-derived values into the model_filename or model argument of WekaClassifier and instead resolve them from a server-side allowlist of known model names, which eliminates the traversal entirely but requires application code changes and breaks any dynamic model-upload feature. If dynamic model paths are required, canonicalize and validate the resulting path (realpath resolution, reject symlinks, enforce a fixed allowed root) before invocation and keep nltk.pathsec enabled as intended, accepting that custom validation can be bypassed if it diverges from NLTK's own policy. Deployments that never use WekaClassifier should disable or remove the Weka integration path entirely to shrink the attack surface at the cost of losing Weka-based classification. Where the integration must stay, run the process with least-privilege filesystem permissions and in a container or sandbox with read-only mounts outside the designated data roots, so that a successful -d write or -l probe is limited to a disposable filesystem region, at the cost of additional operational complexity and possible breakage of legitimate model persistence.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is a CWE-22 path traversal in NLTK's WekaClassifier wrapper, which shells out to the Weka Java/JVM toolchain. NLTK exposes a path-containment mechanism, nltk.pathsec, intended to restrict library file operations to explicitly allowed data roots; WekaClassifier's handling of the model path is not validated against that policy before being passed to the JVM. Attackers who supply the model_filename or model argument can therefore influence Weka command-line parameters such as -d (write the trained model to an arbitrary path) and -l (load/probe a model file, leaking existence information), operating outside the intended roots. CPE data (cpe:2.3:a:nltk:nltk:*:*:*:*:*:*:*:*) marks all NLTK releases through 3.10.3 as affected. The vulnerable surface is the inter-process boundary between the Python library and the external JVM: any application code that forwards user- or tenant-controlled model paths into WekaClassifier inherits the traversal, while code paths that hard-code model locations are unaffected. The assessed CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:L) treats the vulnerable function as reachable without authentication but rates complexity high because the deployment must both use WekaClassifier and pass attacker-controlled model paths.
Know when Nltk gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:L/SC:N/SI:N/SA:N
Network-reachable and unauthenticated at the function (PR:N), but AC:H because exploitation depends on an app routing untrusted input into the model path; file write gives I:H, probing C:L, overwrite A:L.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
NLTK through 3.10.3 contains a path traversal vulnerability in WekaClassifier that allows attackers to bypass nltk.pathsec containment by supplying unvalidated model paths. Attackers controlling the model_filename or model argument can make the weka JVM write files via -d or probe files via -l outside allowed data roots.
Technical POC Analysis
CWE-22 (path traversal), with CWE-73 also assigned.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity path traversal vulnerability affects NLTK's optional WekaClassifier integration through version 3.10.3, potentially allowing an attacker who can influence model arguments to cause file writes outside intended directories when that integration and a Weka JVM are present. The risk is concentrated in the small subset of environments that actively wire untrusted input into this non-default component; standard NLTK deployments are unlikely to be exposed. No vendor-released patch identified at time of analysis, and no public exploit identified at time of analysis, so leadership should focus on confirming whether the Weka integration is used and applying interim access controls.
No vendor-released patch identified at time of analysis. Disable or avoid NLTK WekaClassifier in all deployments unless strictly required; never pass attacker-controllable values to model_filename or model; allowlist and validate model paths; run the integration with least privilege and a restricted filesystem/JVM sandbox; remove the Weka Java/JVM toolchain where not needed; monitor for unexpected file writes and Weka -d/-l invocations.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Arbitrary code execution in the Natural Language Toolkit (NLTK) before 3.10.3 allows attackers to bypass the library's p
Arbitrary code execution in NLTK (Natural Language Toolkit) through 3.9.4 allows attackers to run Python code when a vic
Arbitrary code execution in the NLTK (Natural Language Toolkit) Python library affects all versions through its data dow
StreamBackedCorpusView in NLTK before 3.10.0 allows arbitrary local file reads by calling Python's builtins.open() direc
Symlink-based path traversal in NLTK's FramenetCorpusReader before version 3.10.2 permits attackers with write access to
Unbounded recursion in NLTK's JSONTaggedDecoder.decode_obj() (nltk/jsontags.py) allows unauthenticated remote attackers
Path traversal and pickle deserialization protections in NLTK before 3.10.0 are effectively disabled by default - pathse
XML Entity Expansion (Billion Laughs) in NLTK before 3.10.3 allows unauthenticated remote attackers to cause denial of s
Server-side request forgery in NLTK before 3.10.3 allows unauthenticated remote attackers to reach internal HTTP service
Symlink escape in NLTK's CorpusReader.open() allows local attackers to read arbitrary files outside the designated corpu
Path traversal in NLTK's FramenetCorpusReader and NKJPCorpusReader (all versions before 3.10.0) enables unauthenticated
NLTK (Natural Language Toolkit) is a suite of open source Python modules, data sets, and tutorials supporting research a
EUVD-2026-98660
GHSA-9fgx-q9j8-3j83
NVD
CVE.org
EPSS
Exploit-DB