CVE-2026-114583: 
Python Interpreter vulnerability analysis and mitigation

CVE-2026-114583 is a directory traversal vulnerability in Python's tarfile standard library module affecting CPython versions prior to 3.16.0. The tarfile.tar_filter security filter can be bypassed using crafted link entries — including symlinks with empty or directory-like names — to redirect subsequent archive members outside the intended extraction directory, allowing a malicious tar archive to cause tarfile.extractall() with filter="tar" to write files outside the destination directory. This vulnerability is the tarfile.tar_filter counterpart of CVE-2026-7774, which covered tarfile.data_filter. It was disclosed on October 22, 2026, and carries a CVSS v4.0 base score of 6.9 (Medium) (Github Advisory, Feedly).

The root cause is improper path validation in tarfile.tar_filter (Lib/tarfile.py), which failed to correctly handle link entries — particularly symlinks with empty or directory-like names (e.g., names that normalize to os.curdir via os.path.normpath). The original check compared a member's real path against the real path of the destination directory, which could be manipulated: a symlink named x pointing to . could be extracted first, causing subsequent members to be redirected outside the intended extraction root. The fix rejects any link entry whose normalized name equals os.curdir, making the destination link check lexical rather than filesystem-based. This is classified as a path traversal issue (related to CWE-22) and requires no privileges or user interaction — only the ability to supply a crafted tar archive to a process calling tarfile.extractall() with filter="tar" (CPython PR #160098, CPython Issue #160097).

Successful exploitation allows an attacker to write arbitrary files outside the intended extraction directory, subject to the permissions of the extracting process. This can lead to overwriting sensitive configuration files, injecting malicious scripts, or achieving code execution if writable locations such as startup scripts, cron jobs, or application code directories are targeted. Confidentiality is not directly impacted, but integrity of the affected system is high; availability impact is not inherent to the vulnerability itself (Github Advisory, Feedly).

There is no public proof-of-concept exploit and no evidence of in-the-wild exploitation at the time of disclosure. The EPSS score is 0.0, and the vulnerability is not listed in CISA's Known Exploited Vulnerabilities (KEV) catalog. Exploitation requires an attacker to supply a crafted tar archive to a target process that calls tarfile.extractall() with filter="tar", which is a realistic scenario in applications that process user-supplied archives (Github Advisory, Feedly).

1. Craft a malicious tar archive: Create a tar archive containing a symlink entry with an empty or directory-like name (e.g., a symlink named with an empty string or a name that normalizes to . via os.path.normpath) pointing to a target directory outside the intended extraction path.
2. Add a redirect member: Include a subsequent archive member (e.g., a regular file) in the archive whose path, when resolved through the previously placed symlink, resolves to a location outside the extraction directory (e.g., ../../etc/cron.d/malicious).
3. Deliver the archive: Supply the crafted tar archive to a target application or process that calls tarfile.extractall(path=dest, filter="tar") on untrusted input — for example, via a file upload endpoint, a package manager, or a CI/CD pipeline.
4. Trigger extraction: When the vulnerable CPython process extracts the archive, the tar_filter fails to reject the malicious symlink, allowing the redirect to succeed and writing the payload file to the attacker-chosen path outside the destination directory.
5. Achieve objective: Depending on the permissions of the extracting process and the target path, the attacker may overwrite configuration files, inject code into application directories, or place files in locations that trigger execution (e.g., cron jobs, init scripts) (CPython PR #160098, CPython Issue #160097).

• File System: Unexpected files appearing outside the designated extraction directory following a tar extraction operation; symlinks with empty or .-equivalent names present in extracted archive contents; new or modified files in sensitive directories (e.g., /etc/cron.d/, application config directories) with timestamps matching archive extraction events.
• Logs: Application or system logs showing tarfile.extractall() calls processing externally supplied archives; Python process logs with unexpected file write operations to paths outside the intended extraction root.
• Process: Python processes writing files to unexpected filesystem locations; unusual child processes spawned shortly after archive extraction (indicative of code execution via dropped scripts).

Upgrade CPython to version 3.16.0 or later, which includes the fix that rejects link entries whose normalized name equals os.curdir. Backports have been prepared for CPython 3.11, 3.12, 3.13, 3.14, and 3.15 (see PRs #160339–#160343). As an immediate workaround, avoid using filter="tar" when extracting archives from untrusted sources; use filter="data" instead, which applies stricter restrictions. Additionally, validate and restrict the permissions of the process performing extraction to minimize the impact of any path traversal (CPython PR #160098, Github Advisory).

The vulnerability was reported and fixed by community contributor StanFromIreland, with the fix reviewed and approved by CPython core developer encukou. The issue was noted on the Python security announcement mailing list and discussed on oss-security. Social media activity was limited to automated CVE tracking posts on Mastodon (infosec.exchange) and Bluesky. No significant broader media coverage or notable researcher commentary beyond the CPython development community has been observed (Python Security Announce, oss-sec).