UnixFileLock, used by FileLock and AsyncFileLock on Unix systems, truncates and can change permissions of any regular file that another local user renames or hard-links onto the lock path before the lock is acquired. This allows a local attacker with write access to certain directories to cause the lock user to truncate and potentially expose files to unauthorized read/write access. The vulnerability affects all filelock releases up to and including 4.2.0 and requires specific conditions such as writable non-sticky directories or disabled kernel hardlink protections. The CVSS 3.1 score is 6.1 (Medium).
The filelock vulnerability (CVE-2026-112908) affects versions of the poetry package >=2.4.2 and <2.5.1_1. It involves the StrictSoftFileLock and AsyncStrictSoftFileLock classes creating claim directories without applying the intended restrictive mode, resulting in directories that may be writable by other local users under certain umask or ACL configurations. This allows another local user with write access to unlink claim files, causing the lock to be bypassed and potentially allowing concurrent holders to write protected data without detection. The vulnerability has a medium severity with a CVSS score of 5.3 and is fixed in version 2.5.1_1.
A vulnerability in virtualenv's venv creator allows attacker-controlled pathnames containing Unicode line boundary characters (e.g., U+2028) to inject additional configuration keys into the pyvenv.cfg file during readback. This can alter the 'home' path and 'include-system-site-packages' setting, potentially changing the interpreter's standard library location and weakening environment isolation. The issue affects virtualenv versions from 20.0.0b1 up to but not including 2.5.1_1. A fix is available in version 2.5.1_1.
A vulnerability in virtualenv's app-data seeder allows deletion of files outside the intended environment during seed package reinstallation. This occurs because the uninstall process joins paths from distribution metadata without verifying containment within the environment, enabling deletion of arbitrary user files if malicious metadata is present. The issue requires an environment reused with attacker-controlled metadata and deletion rights by the invoking user. A fix is available in versions 1.2.2_1 and 2.5.1_1.
A vulnerability in virtualenv's xonsh activation script allows attacker-controlled prompt text to become executable code during environment activation if the xonsh source decoding uses legacy multibyte encodings like GBK or Big5. This occurs because the UTF-8 encoded activation script is read with a different codec, causing escape characters to be misinterpreted and enabling code injection. The issue affects POSIX activation scripts and requires an attacker to control the prompt or destination argument passed to virtualenv and a user to activate the environment with the affected encoding. A fix is available in virtualenv version 2.5.1_1.
CVE-2026-113717 is a vulnerability in virtualenv's pip seeder when used with the --download option. The issue arises because the pip seeder downloads bundled wheels with download=False, skipping virtualenv's wheel digest verification. This allows an attacker controlling the index configured in pip.conf to serve a modified pip wheel that bypasses the digest check, potentially installing tampered code. The vulnerability requires both --seeder pip and --download options to be enabled. A fix is available in virtualenv version 2.5.1_1.
CVE-2026-113714 is a vulnerability in virtualenv's wheel download and caching mechanism. The issue arises because downloaded wheel files are placed directly into a reusable cache before verification completes. Verification uses pip's textual output to select the file to check, which can be manipulated by a malicious package index. This can cause a modified wheel to be cached and reused despite failing verification, potentially leading to the use of tampered packages. The flaw does not bypass TLS or affect the default PyPI setup and was fixed in virtualenv version 2.5.1_1.
A vulnerability in virtualenv's deletion error handler can cause unintended permission changes on symlink targets. When a deletion fails on a symbolic link inside a read-only directory, the handler uses lstat() to get mode bits but applies them with chmod(), which follows the symlink. This can change the target's permissions to 0777 if the target is owned by the invoking user and initially not writable. The issue affects virtualenv versions from 2.4.2 up to but not including 2.5.1_1. A fix is available in version 2.5.1_1.
A vulnerability in Poetry's virtualenv handling allows crafted prompt values containing line boundaries to inject additional configuration lines into the pyvenv.cfg file. This can overwrite critical configuration keys such as 'home', which tooling uses to locate the base interpreter. The issue arises because pyvenv.cfg is line-based with no escape syntax, and the write operation did not sanitize line boundaries, allowing injection of arbitrary config lines. This can lead to configuration corruption or redirection of interpreter paths when the prompt value is influenced by external input such as CI job templates or environment variables. Fixed in Poetry versions 1.2.2_1 and 2.5.0 by collapsing line boundaries to spaces during serialization.
Virtualenv versions prior to 1.2.2_1 and 2.5.0 do not verify the integrity of downloaded pip and setuptools wheels before use. This allows a compromised index, stale mirror, or man-in-the-middle attacker to substitute malicious wheels that virtualenv would cache and use without warning. The issue is fixed by verifying the downloaded wheel's SHA256 hash against PyPI's public JSON API, except when a custom index is configured.
Poetry's virtual environment activation scripts for bash, zsh, and fish shells improperly handle paths containing shell metacharacters. This flaw allows embedded commands in such paths to execute when the activation script is sourced. The issue arises from double quoting of shlex-quoted paths, which leads to premature termination of quotes and unquoted shell code execution. This vulnerability affects Poetry versions from 2.2.0 up to but not including 2.5.0 and was fixed in version 2.5.0.
Dulwich's porcelain.checkout(paths=[...]) function uses raw os.open calls that follow symlinks, bypassing symlink protections and allowing arbitrary file writes. An attacker can craft a malicious repository with symlinks that cause checkout to overwrite files such as .git/hooks/post-checkout, enabling remote code execution on subsequent git operations. The vulnerability affects Poetry versions from 2.2.0 up to but not including 2.4.2. A patch is available to fix this issue by replacing the raw os.open usage with a safer method that detects symlinks.
Dulwich's stash pop function in version 1.2.7 is vulnerable to a symlink directory traversal that allows an attacker to write arbitrary files outside the repository worktree. This occurs because the function uses os.path.exists() which follows symlinks, enabling writes through malicious intermediate symlinks. An attacker can craft a repository that, when a victim pops a stash, writes attacker-controlled files such as .git/hooks/post-checkout, leading to remote code execution on the victim's machine during subsequent git operations. A patch is available to mitigate this issue by verifying symlink resolution before writing files.
A denial of service (DoS) vulnerability exists in the dulwich library's Pack.resolve_object method. When resolving an OFS_DELTA object with a delta_offset of zero, the method enters an infinite recursive loop due to self-referential offset calculation. This causes CPU exhaustion and process crashes in applications using dulwich for Git packfile operations. The vulnerability affects dulwich versions >=1.2.0 and <2.4.2. A patch is available to explicitly reject delta_offset == 0 and prevent infinite recursion.
Dulwich's filter_branch.py in Poetry versions 2.2.0 up to but not including 2.4.2 contains a symlink directory traversal vulnerability in the CommitFilter._apply_index_filter() function. This occurs because materialized tree entries, including symlinks, persist in the working directory between commits, allowing an attacker to redirect file writes to arbitrary filesystem locations. An attacker can exploit this by crafting a malicious repository that causes filter_branch to write attacker-controlled content to arbitrary locations, potentially achieving remote code execution if writes target .git/hooks/. A fix is available that involves cleaning the working directory between commit iterations or verifying symlinks before writing files.
Dulwich versions from 0.23.2 up to but not including 1.2.5 contain a path traversal vulnerability in the submodule update and clone functions when recurse_submodules is enabled. An attacker can craft a malicious upstream repository with a .gitmodules file and a matching gitlink entry that specifies a submodule path inside the parent repository's .git directory, such as .git/hooks. This causes the attacker's submodule contents to be written directly into the victim's .git/hooks directory with executable permissions, leading to arbitrary code execution when git hooks are triggered.
CVE-2026-47734 is a denial-of-service vulnerability in Dulwich-based Git servers that accept pushes. An attacker with push access can send a crafted thin pack with a maliciously large declared delta size, causing the server to allocate excessive memory and potentially exhaust system resources. This affects servers exposing git-receive-pack functionality via Dulwich. The issue is patched in Dulwich version 1.2.5 and later.
A vulnerability in Dulwich's porcelain.format_patch function allows commit subjects to be used unsafely as patch filenames. This can lead to directory traversal, causing patch files to be written outside the intended output directory. The issue also causes failures on Windows due to illegal filename characters and can produce excessively long filenames. The flaw is fixed in Dulwich version 1.2.5.
Dulwich's merge driver functionality is vulnerable to command injection via the `%P` placeholder in merge driver commands. An attacker who can cause a victim to merge an untrusted branch with malicious file paths can execute arbitrary commands on the victim's system. This requires the victim to have a merge driver configured that uses the `%P` placeholder. The vulnerability affects Poetry versions from 2.2.0 up to but not including 2.4.1_3 and has been assigned CVE-2026-42563.
Dulwich versions from 1.2.0 up to but not including 2.4.1_3 on Windows allow arbitrary file write via specially crafted Git tree entries containing NTFS-hostile path elements. This can lead to remote code execution when cloning or checking out malicious repositories. The vulnerability arises because Dulwich's path-element validator accepted filenames with backslashes, NTFS alternate-data-stream markers, and certain 8.3 short-name aliases, enabling attackers to plant files inside the victim's .git directory or escape the working tree. The issue is fixed in Dulwich 2.4.1_3.