
Loading

Loading
We use strictly necessary cookies to run this site, and analytics cookies to understand how it's used. See our Privacy Policy for details.
A GitHub-reviewed security advisory, not necessarily under active exploitation the way our CISA KEV advisories are, but a real, disclosed vulnerability in an open-source dependency.
Affected packages
Vulnerable: >= 3.9.4, <= 3.10.3
Patched in 3.10.4
Details
nltk.sem.chat80.sql_query() opens a SQLite database by handing the result of nltk.data.find(dbname) straight to sqlite3.connect() without the path-containment check that the NLTK data sandbox (nltk.pathsec) is meant to enforce. nltk.data.find() applies only lexical checks to the resource name and returns a FileSystemPathPointer whose path is normalized with os.path.abspath but never resolved for symlinks. As a result, an in-root symbolic link that points at a SQLite file outside every registered NLTK data root is followed by SQLite, and the caller receives query results from the out-of-sandbox database. An attacker who can place a file inside a directory the application trusts as an NLTK data root can read SQLite databases that the pathsec sandbox is supposed to keep out of reach.
The security invariant is that file access performed through NLTK data resolution must stay within the configured data roots; the sandbox enforces this in nltk.pathsec via validate_path and pathsec.open, which resolve the real path (Path(...).resolve()) and reject targets outside the allowed roots. sql_query() never reaches that enforcement point. It calls nltk.data.find(dbname), whose guards operate purely on the resource-name string, and FileSystemPathPointer.__init__ performs only os.path.abspath plus an existence check, which does not collapse symlinks. The pointer is then passed to sqlite3.connect(str(path)), so the containment decision that FileSystemPathPointer.open() would delegate to pathsec.open is bypassed entirely. The sibling functions in the same module that create or write databases (cities2table, val_dump, val_load) obtain their protection from a validation call in later development, but the read sink sql_query performs no equivalent check in any published release.
nltk/sem/chat80.py -> sql_query(): path = nltk.data.find(dbname); sqlite3.connect(str(path))
nltk/data.py -> find(): lexical name guards only; returns FileSystemPathPointer
nltk/data.py -> FileSystemPathPointer.__init__(): os.path.abspath + os.path.exists (no symlink resolution)
nltk/data.py -> FileSystemPathPointer.open() -> nltk.pathsec.open (the containment guard that sql_query never calls)
An attacker who can write into a directory the application registers as an NLTK data root (a shared or writable corpus directory, or a downloaded corpus) can plant a symbolic link at the expected resource location that points at a SQLite database elsewhere on the filesystem. When the application invokes sql_query() (directly or via sql_demo()) for that resource, SQLite follows the link and the query executes against the out-of-sandbox database, returning its rows to the caller. This escapes the pathsec confidentiality boundary. The read primitive is bounded to SQLite-format files that are readable by the process user: a non-SQLite target raises sqlite3.DatabaseError rather than leaking content. A caller-supplied write query would be redirected onto the out-of-sandbox target and SQLite may create sidecar files (-wal, -journal) next to it, which is a plausible integrity side effect rather than a demonstrated arbitrary-write primitive. Exploitation requires the same local write capability into a trusted data root as the related symlink-read sandbox-escape issues already recorded for this project.
Requires the published nltk 3.10.3 wheel and a writable directory registered as an NLTK data root. No network access is needed.
corpora/city_database/city.db pointing at the outside database.sql_query() for the in-root resource name.import os, tempfile, sqlite3, nltk, nltk.data
from nltk.sem import chat80
work = tempfile.mkdtemp()
root = os.path.join(work, "nltk_data")
corp = os.path.join(root, "corpora", "city_database")
os.makedirs(corp)
secret = os.path.join(work, "outside", "secret.db")
os.makedirs(os.path.dirname(secret))
con = sqlite3.connect(secret)
con.execute("CREATE TABLE t (x text)")
con.execute("INSERT INTO t VALUES ('OUT-OF-SANDBOX-SECRET')")
con.commit(); con.close()
os.symlink(secret, os.path.join(corp, "city.db"))
nltk.data.path.insert(0, root)
ptr = nltk.data.find("corpora/city_database/city.db")
try:
ptr.open().read() # pathsec route: blocked
except Exception as e:
print("open() blocked:", type(e).__name__)
cur = chat80.sql_query("corpora/city_database/city.db", "SELECT * FROM t")
print("sql_query rows:", cur.fetchall()) # sink route: follows the symlink
open() blocked: PermissionError
sql_query rows: [('OUT-OF-SANDBOX-SECRET',)]
sql_query() (or sql_demo(), which calls it) and resolves the target database through nltk.data.find, using at least one directory the attacker can write to as a data root.nltk.data.find applies its lexical name guards (_UNSAFE_NO_PROTOCOL_RE, encoded and normalized-form checks), which inspect only the name string and pass, then returns a FileSystemPathPointer whose __init__ applies os.path.abspath and an existence check without resolving the symlink.FileSystemPathPointer.open() delegating to nltk.pathsec.open, which resolves the real path and rejects out-of-root targets) is never invoked, because sql_query() passes the raw pointer string to sqlite3.connect() instead of opening through the pointer.sqlite3.connect(str(path)) opens the symlink target; the kernel follows the link out of every data root and the cursor executes the query against the outside database.The relevant guard is the pathsec containment enforced by nltk.pathsec.open/validate_path, reached through FileSystemPathPointer.open(). On an identical pointer produced from the planted symlink, ptr.open() raises PermissionError with an "Unauthorized path" security violation, confirming the guard is active and correct for the sandbox route. sql_query() does not call .open() and does not call validate_path; it passes the unresolved pointer string directly to sqlite3.connect(), so the guard never runs on this path and the read succeeds. Attempts to invalidate the finding were made and failed: nltk.data.find was checked for a hidden containment or real-path resolution and has none (its guards are name-string only, and FileSystemPathPointer.__init__ uses abspath, not realpath); SQLite was confirmed to follow the link and read the outside file rather than opening the link node; and the possibility that an existing published fix already covers this sink was refuted by inspecting the published artifacts, where no containment check is present on sql_query. The behavior was reproduced against the exact published 3.10.3 wheel (verified by its published SHA-256 digest).
Ecosystem: PyPIPackage: nltkConfirmed affected range: >= 3.9.4, <= 3.10.3Latest release checked: 3.10.3 (PyPI, wheel SHA-256 ff9598a8e20518ee0d557745890cc4435b9578489e2dcbc69c4f81fa060caf7c)Fix status: 3.10.4The pathsec sandbox that this issue bypasses was introduced in 3.9.4; the immediately preceding release 3.9.3 does not ship nltk/pathsec.py and therefore does not present this sandbox-escape surface. Every published release from 3.9.4 through the current latest 3.10.3 ships nltk/pathsec.py with ENFORCE = True and ships sql_query() without any containment check, so all of them are affected. Each affected wheel was fetched from PyPI and inspected directly. No published release removes the sink or adds the guard, so no fixed version exists at the time of review.
Enforce the data-root containment invariant on the resolved database path before opening it. In sql_query(), validate the path through the same mechanism the sibling functions use (for example validate_path(str(path), context="chat80.sql_query")) or open the database through the pointer's sandboxed open path rather than passing the raw string to sqlite3.connect(). The remediation should resolve symbolic links (real-path resolution) and reject targets outside the registered data roots, and it should cover any other read sinks that connect to on-disk databases resolved through nltk.data.find. As an interim mitigation, applications should ensure that no attacker-writable directory is registered as an NLTK data root and should avoid calling sql_query/sql_demo on resources that live in shared or untrusted locations.
Reported by zx (GitHub: @manus-pi).
Status: IN PROGRESS (fix on an open pull request, not yet on develop).
PR: #3888 "Validate chat80.sql_query dbname for path containment (CWE-59/73)", open; head e0e890f51 at the time of this note. This is the same sink and vector as GHSA-xv54-447f-mj22 (now closed).
Fix commits: 9f5d2ea6d (sql_query calls validate_path before nltk.data.find, as cities2table, val_dump and val_load already do) and 47bd0476e (the file behind a sql_query resource name is resolved through the data roots and validated, and its store is pinned).
The advisory PoC (an in-root corpora/city_database/city.db symlink to an out-of-root SQLite file, resolved through find()) re-run on the PR head e0e890f51: refused with PermissionError (Security Violation [chat80.sql_query]: Unauthorized path, naming the symlink's resolved out-of-root target); the same resource name backed by a real in-root database still returns its rows on that head. On develop 2fa3f48fe the PoC returns the rows of the out-of-root database, so develop is VULNERABLE.
Probe: nltk/test/unit/security_probes/ghsa_xv54_447f_mj22.py on the PR (the sibling advisory GHSA-xv54-447f-mj22), FIXED on the PR head (absolute path, traversal and a symlink inside a scratch directory are all security-rejected). Those three cases are also rejected on develop by find() itself; the in-root symlink above is the case that only the PR closes.
Release: none.
EPSS, exploit probability
Low0.20%
estimated chance of real-world exploitation in the next 30 days, higher than 9.8% of every CVE FIRST.org scores
Refreshed 11/16/2026, via FIRST.org's EPSS model, not CVSS, this measures likelihood of exploitation, not how severe it would be.
More pip advisories
Talk to us about this
Find out whether this dependency (or others like it) is actually reachable in your codebase.
Get help patching, or building dependency-scanning into your pipeline going forward.
A secure code review or supply chain review finds this before an advisory does.