CVE-2026-128134: NLTK: untrusted search path in dot2img allows local code exec
GHSA-7mxv-7h3q-9324HIGHNLTK's dot2img function launches the Graphviz dot binary without the ownership check and environment scrubbing that NLTK applies elsewhere, so a local attacker who can write to a group- or world-writable directory on the victim's PATH can plant a trojan dot that runs with the victim's privileges. The CVSS is 7.8 (local, low privileges, no user interaction), and a public PoC is described in the advisory, though no exploit module, Nuclei template or KEV listing exists. EPSS is low in absolute terms (0.00184) but sits in the top 92% percentile, and nltk has 1,884 downstream dependents, with notebook rendering of DependencyGraph objects triggering the call automatically. Exposure is concentrated on shared data-science hosts, JupyterHub servers and CI runners where PATH directories may be writable. Upgrade to nltk 3.10.4, which carries the fix, and audit PATH directories for group/world-writable permissions on any host that renders dependency graphs.
What is the risk?
Moderate overall, High on shared multi-user hosts. Exploitation is trivial once the attacker has write access to a PATH directory (AC:L, PR:L), needs no control over NLTK inputs, and yields full code execution as the victim (C/H, I/H, A/H). Remote exploitation is not possible by itself and the attacker needs a prior local foothold, which limits the exposure on single-user workstations and hardened containers. Exploitation is not observed in the wild: it is not in CISA KEV, there is no Nuclei template, and EPSS is 0.00184. The nltk package has a risk score of 28/100, an OpenSSF Scorecard of 5.7/10 and 51 other CVEs, which reflects a recurring pattern of untrusted-search-path issues in this project (the prior GHSA-6hwm-xvph-95vm was only partially remediated). Shared notebook servers and CI/CD runners are the most realistic targets for privilege escalation and lateral movement.
How does the attack unfold?
What systems are affected?
| Package | Ecosystem | Vulnerable Range | Patched |
|---|---|---|---|
| Jupyter | pip | <= 3.10.3 | 3.10.4 |
Do you use Jupyter? You're affected.
How severe is it?
What is the attack surface?
What should I do?
1 step1) Upgrade nltk to 3.10.4 or later, which routes dot through the trusted-execution path (PR #3887, commit b002a7288). 2) Until patched, remove any group- or world-writable directory from the PATH of accounts that run NLTK, and install Graphviz in a directory writable only by root or the owning user. 3) Audit shared Jupyter, JupyterHub and CI hosts with a check such as 'find $(echo $PATH | tr : " ") -maxdepth 0 -perm /022' and fix permissions, including Homebrew /usr/local/bin with group-write. 4) Avoid rendering DependencyGraph objects in notebooks on shared hosts until patched, or uninstall Graphviz where it is not needed. 5) Detection: monitor for unexpected files named dot in writable PATH directories, file integrity changes to dot binaries, and child processes spawned by python or jupyter that resolve to non-system dot paths. 6) Inventory nltk with SBOM or pip tooling and flag versions <= 3.10.3.
How is it classified?
Which compliance frameworks are affected?
This CVE is relevant to:
Frequently Asked Questions
What is CVE-2026-128134?
NLTK's dot2img function launches the Graphviz dot binary without the ownership check and environment scrubbing that NLTK applies elsewhere, so a local attacker who can write to a group- or world-writable directory on the victim's PATH can plant a trojan dot that runs with the victim's privileges. The CVSS is 7.8 (local, low privileges, no user interaction), and a public PoC is described in the advisory, though no exploit module, Nuclei template or KEV listing exists. EPSS is low in absolute terms (0.00184) but sits in the top 92% percentile, and nltk has 1,884 downstream dependents, with notebook rendering of DependencyGraph objects triggering the call automatically. Exposure is concentrated on shared data-science hosts, JupyterHub servers and CI runners where PATH directories may be writable. Upgrade to nltk 3.10.4, which carries the fix, and audit PATH directories for group/world-writable permissions on any host that renders dependency graphs.
Is CVE-2026-128134 actively exploited?
No confirmed active exploitation of CVE-2026-128134 has been reported, but organizations should still patch proactively.
How to fix CVE-2026-128134?
1) Upgrade nltk to 3.10.4 or later, which routes dot through the trusted-execution path (PR #3887, commit b002a7288). 2) Until patched, remove any group- or world-writable directory from the PATH of accounts that run NLTK, and install Graphviz in a directory writable only by root or the owning user. 3) Audit shared Jupyter, JupyterHub and CI hosts with a check such as 'find $(echo $PATH | tr : " ") -maxdepth 0 -perm /022' and fix permissions, including Homebrew /usr/local/bin with group-write. 4) Avoid rendering DependencyGraph objects in notebooks on shared hosts until patched, or uninstall Graphviz where it is not needed. 5) Detection: monitor for unexpected files named dot in writable PATH directories, file integrity changes to dot binaries, and child processes spawned by python or jupyter that resolve to non-system dot paths. 6) Inventory nltk with SBOM or pip tooling and flag versions <= 3.10.3.
What systems are affected by CVE-2026-128134?
This vulnerability affects the following AI/ML architecture patterns: Jupyter notebook environments, NLP preprocessing pipelines, Shared data science workstations, CI/CD runners for ML projects, Training pipelines using nltk.
What is the CVSS score for CVE-2026-128134?
CVE-2026-128134 has a CVSS v3.1 base score of 7.8 (HIGH). The EPSS exploitation probability is 0.18%.
What is the AI security impact?
Affected AI Architectures
MITRE ATLAS Techniques
AML.T0010.001AI SoftwareAML.T0011User ExecutionAML.T0050Command and Scripting InterpreterCompliance Controls Affected
What are the technical details?
Original Advisory
## Summary `nltk.parse.dependencygraph.dot2img` invokes the Graphviz `dot` executable without the trusted-execution guarantees that NLTK applies to its other native-tool wrappers. The function resolves `dot` by bare name and then runs the resolved absolute path with a raw `subprocess.run`, omitting the ownership/writability check and the loader-environment scrub that `nltk.pathsec.spawn_trusted` provides. On a POSIX host, a local, unprivileged actor who can write to any group/world-writable directory that appears on the victim's `PATH` can plant a trojan `dot`; when the victim later renders a `DependencyGraph` (for example in a Jupyter notebook, which auto-invokes `_repr_svg_`) or calls `dot2img` directly, the planted binary executes as the victim. The advisory GHSA-6hwm-xvph-95vm (CVE-2026-78680) addressed the same untrusted-search-path class for the Graphviz `dot` invoker in `nltk/translate/api.py`, but `dot2img` received only part of that remediation and remains exploitable. ## Root Cause NLTK's native-tool security model layers four defenses (documented in `nltk/EXTERNAL_TOOL_SECURITY.md`): (1) `find_binary` refuses a current-working-directory-relative match; (2) `resolve_trusted_executable` verifies the resolved file is a regular file that no other unprivileged user can replace (private parent directories, owner is the user or root, no group/world write bit); (3) shell execution is refused; (4) `safe_env` scrubs loader and interpreter environment variables before exec. Layers 2, 3, and 4 are reached only through `nltk.pathsec.spawn_trusted`. `dot2img` calls `find_binary("dot")` (layer 1 only), then executes the result with `subprocess.run([dot_binary, ...])` and no `env=` argument. Layer 1 rejects only non-absolute matches, so an absolute path returned by the `which` search stage survives even when the file lives in a writable directory. Because `dot2img` never calls `spawn_trusted`, the ownership check and environment scrub never run. ```text nltk/parse/dependencygraph.py:626 dot_binary = find_binary("dot") # layer 1 only nltk/parse/dependencygraph.py:631 subprocess.run([dot_binary, "-T%s" % t], ...) # no trust check, no env= nltk/parse/dependencygraph.py:638 subprocess.run([dot_binary, "-T%s" % t], ...) # binary-format branch, same gap nltk/internals.py:1034 if searching_bare_name and not os.path.isabs(path): continue # skips only relative matches nltk/translate/api.py:145 process = spawn_trusted(dot_binary, [f"-T{output_format}"], ...) # hardened sibling ``` ## Impact Prerequisites: a POSIX host on which the attacker is a local, unprivileged user (or code) able to write to a group/world-writable directory that appears on the victim's `PATH`. This includes the commonly cited case of a Homebrew `/usr/local/bin` with `drwxrwxr-x` permissions, or a writable directory placed early on `PATH`. The attacker plants a trojan `dot` there. When the victim renders a `DependencyGraph` (notebook `_repr_svg_` auto-invocation) or calls `dot2img` directly, the trojan executes as the victim, yielding arbitrary local code execution in the victim's account: a local privilege-escalation and lateral-movement primitive. Because the child environment is not scrubbed, loader-injection variables (for example `LD_PRELOAD`, `DYLD_*`, `GCONV_PATH`) also reach the child, providing an additional execution surface. No control over NLTK inputs is required. ## Proof of Concept `Requires: POSIX host, an importable NLTK build from the affected tree, and Python 3. No third-party dependencies.` 1. Create a world-writable directory and write an executable `dot` script into it that drops a marker and emits fake SVG. 2. Prepend that directory to `PATH` and run from a neutral working directory (so this is not the current-working-directory vector). 3. Show that `resolve_trusted_executable` refuses the planted binary (so the hardened path would raise) while `dot2img` executes it. ```python import os, stat, tempfile, subprocess, sys d = tempfile.mkdtemp() dot = os.path.join(d, "dot") with open(dot, "w") as f: f.write("#!/bin/sh\ntouch " + os.path.join(d, "MARKER") + "\necho '<svg><!-- planted dot ran --></svg>'\n") os.chmod(dot, 0o777) os.chmod(d, 0o777) os.environ["PATH"] = d + os.pathsep + os.environ["PATH"] os.chdir("/") from nltk.pathsec import resolve_trusted_executable from nltk.parse.dependencygraph import dot2img print("resolve_trusted_executable(planted dot):", resolve_trusted_executable(os.path.join(d, "dot"))) out = dot2img("digraph G { a -> b }") print("dot2img stdout:", repr(out)) print("planted dot executed (marker created):", os.path.exists(os.path.join(d, "MARKER"))) ``` ```text resolve_trusted_executable(planted dot): None dot2img stdout: '<svg><!-- planted dot ran --></svg>\n' planted dot executed (marker created): True ``` ## Attack Chain 1. **Exposure:** On a shared POSIX host, a group/world-writable directory is present on the victim's `PATH` (for example a writable directory early on `PATH`, or a Homebrew `/usr/local/bin` with group-write). The attacker writes a trojan `dot` into it. 2. **Control:** The attacker fully controls the contents of the planted `dot` file; no control over NLTK inputs is needed. 3. **Path:** The victim renders a `DependencyGraph` (notebook display triggers `_repr_svg_` at `nltk/parse/dependencygraph.py:209`, which calls `dot2img`) or calls `dot2img` directly. 4. **Guard:** `find_binary("dot")` applies layer 1 only (`nltk/internals.py:1034`), which discards a relative current-working-directory match but returns the attacker's absolute path from the `which` stage; `dot2img` never invokes `resolve_trusted_executable` (layer 2) or `safe_env` (layer 4), unlike the hardened sibling `nltk/translate/api.py:145`. 5. **Primitive:** `subprocess.run([dot_binary, "-T%s" % t], ...)` (`nltk/parse/dependencygraph.py:631` and `:638`) executes the untrusted absolute path with the full inherited environment. 6. **Result:** Arbitrary local code execution as the victim, plus a loader-injection surface via the unscrubbed environment. ## Bypass Evidence Canonical prior advisory: GHSA-6hwm-xvph-95vm (CVE-2026-78680), "Uncontrolled search path when invoking the Graphviz 'dot' binary" (CWE-426/CWE-427), patched at `>= 3.10.3`. That remediation was two-part: a uniform layer-1 current-working-directory refusal in `find_binary`, and a routing of native-tool `dot` invocations through `nltk.pathsec.spawn_trusted` (layers 2 and 4). Inspection of the current released tree (nltk 3.10.3) shows `dot2img` received the layer-1 change (the function was rewritten from a bare `subprocess.run(["dot", ...])` to `find_binary("dot")` plus a run of the absolute path, with a CWE-426/427 comment at `nltk/parse/dependencygraph.py:622-625`) but did NOT receive the `spawn_trusted` routing. The sibling `nltk/translate/api.py:145` does route through `spawn_trusted`, and `nltk/EXTERNAL_TOOL_SECURITY.md` lists Graphviz `dot` only under `translate/api.py`; `dot2img` is absent from the hardened-wrapper inventory. Attempts to invalidate the finding all failed: (a) the claim that the fix covers all `dot` resolution is refuted because layer 1 filters only non-absolute matches and `dot2img` never reaches layers 2/4; (b) the duplicate hypothesis is refuted by a negative control, planting `./dot` in the working directory with none on `PATH` makes `find_binary("dot")` raise `LookupError`, so the prior fix's working-directory guard still fires and this is the distinct residual ownership/environment gap; (c) the "system dot shadows the trojan" objection is refuted because realistic exploitation prepends the writable directory on `PATH` or replaces a `dot` already living in a writable `PATH` directory; (d) both the text and binary format branches share the identical unguarded exec, so it is not format-specific. A fresh PoC on the examined tree confirms `resolve_trusted_executable` refuses the planted binary while `dot2img` executes it. ## Affected Versions - `Ecosystem: pip (PyPI)` - `Package: nltk` - `Confirmed affected range: <= 3.10.3` - `Latest release checked: 3.10.3 (PyPI, latest published release as of the review date; source tree VERSION == 3.10.3)` - `Fix status: 3.10.4` The `dot2img` function has invoked `dot` via a raw subprocess since well before the prior advisory. The prior advisory's `spawn_trusted` standardization routed only the sibling `translate/api.py` invoker through the trusted-execution chokepoint, so this residual gap in `dot2img` exists from at least that remediation release onward and remains present in the latest published release (3.10.3). Precise introduction and remediation boundaries below 3.10.3 could not be independently established in this environment (no git tags or release history in the checkout); the confirmed statement is that the latest published release is affected and no fix for `dot2img` exists. ## Suggested Fix Route `dot2img`'s execution through `nltk.pathsec.spawn_trusted(dot_binary, ["-T%s" % t], input=...)`, mirroring the sibling `nltk/translate/api.py`, so that the ownership/writability check (layer 2) and the loader-environment scrub (layer 4) apply, and handle `TrustError`/`OSError` with the same refusal pattern used at `nltk/translate/api.py:152-157`. Apply the change to both the text-format and binary-format branches. Add Graphviz `dot` under `nltk/parse/dependencygraph.py` to the per-wrapper inventory in `nltk/EXTERNAL_TOOL_SECURITY.md` so the second invoker is tracked. Interim mitigation without a code change: ensure no group/world-writable directory appears on the `PATH` of any account that renders NLTK dependency graphs, and install Graphviz in a directory writable only by the user or root. --- Reported by zx (GitHub: @manus-pi). ## Fix status (2026-09-28) Status: IN PROGRESS (fix on an open pull request, not yet on develop). Two open pull requests carry a fix. PR: #3753 "[Do not merge yet] Fix GHSA-8mgp-746c-j5xp: URL-scheme bypass of pathsec.validate_path", open; head da55cab0e at the time of this note (a develop merge on top of 238f81500, the head on which the verdicts below were measured). Fix commit: cf12a5e6a (internals.java() refuses a binary that resolve_trusted_executable rejects, _java_child_env drops the loader environment and pins PATH, dependencygraph.dot2img runs through pathsec.spawn_trusted). Probe: nltk/test/unit/security_probes/ghsa_7mxv_7h3q_9324.py (on that PR); verdict on its head: FIXED (planted absolute java refused with TrustError; loader and JVM environment scrubbed). PR: #3887 "Resolve every executed tool binary absolute-only: prover9/mace4, megam, tadm, java, hunpos (untrusted search path, CWE-426/427)", open; head 3ac1c5641 at the time of this note (a develop merge on top of 16b1de8ee, the head on which the verdicts below were measured). Fix commits: 992884a02 (the JVM is resolved before spawning and spawned through spawn_trusted) and b002a7288 (dot is spawned through the trusted path in dependencygraph). The #3753 probe run against this head reports STATIC (the planted java is refused with LookupError before the trust guard is reached). The probe run against develop 2fa3f48fe: VULNERABLE (java() executed a planted untrusted binary from a writable directory). Release: none.
Exploitation Scenario
On a shared JupyterHub or ML workstation, a low-privileged user or compromised process finds a world-writable directory early on the PATH of a data scientist who has elevated access to datasets and cloud credentials. The attacker drops an executable script named dot that quietly runs a payload (for example exfiltrating cloud keys or adding an SSH key) and then emits plausible SVG so nothing looks wrong. When the data scientist renders a parsed sentence's DependencyGraph in a notebook, nltk calls dot2img, which executes the planted binary with the victim's privileges and full environment. The attacker gains code execution in the victim's account and can pivot to training data, model registries and other infrastructure.
Weaknesses (CWE)
CWE-426Untrusted Search PathPrimaryCWE-427Uncontrolled Search Path ElementPrimaryCWE-426Untrusted Search PathCWE-427Uncontrolled Search Path ElementCWE-426 — Untrusted Search Path: The product searches for critical resources using an externally-supplied search path that can point to resources that are not under the product's direct control.
- [Architecture and Design, Implementation] Hard-code the search path to a set of known-safe values (such as system directories), or only allow them to be specified by the administrator in a configuration file. Do not allow these settings to be modified by an external party. Be careful to avoid related weaknesses such as CWE-426 and CWE-428.
- [Implementation] When invoking other programs, specify those programs using fully-qualified pathnames. While this is an effective approach, code that uses fully-qualified pathnames might not be portable to other systems that do not use the same pathnames. The portability can be improved by locating the full-qualified paths in a centralized, easily-modifiable location within the source code, and having the code refer to these paths.
Source: MITRE CWE corpus.
CVSS Vector
CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:HReferences
Timeline
Related Vulnerabilities
CVE-2023-2557410.0JupyterHub LTI13: JWT forgery enables full auth bypass
Same package: jupyterCVE-2024-3970010.0JupyterLab extension-template: CI workflow RCE
Same package: jupyterCVE-2026-441809.8Jupyter Enterprise Gateway: root privilege bypass in Kubernetes
Same package: jupyterCVE-2026-235379.1Feast: unauth file write to RCE via /save-document
Same package: jupyterCVE-2026-545279.0jupyterlab-git: stored XSS escalates to full RCE
Same package: jupyter