GitPython versions from 1.4.0 up to but not including 3.67.1_18 contain a vulnerability in the parse_actor_and_date() function where a regular expression causes quadratic backtracking on malformed author/committer/tagger identity lines. This leads to CPU exhaustion when processing crafted commit or tag objects with malformed identity lines missing or having invalid epoch or timezone data. The issue was fixed in version 3.67.1_18 by changing the regex to prevent overlapping matches and eliminate the backtracking.
GitPython's _clone() method improperly expands environment variables in the separate_git_dir parameter derived from attacker-controlled .gitmodules submodule names. This leads to leakage of environment variable values as directory names on disk and in debug logs when cloning and updating submodules from a malicious repository. The flaw allows an attacker to cause secret environment variables to be exposed persistently on disk and in verbose logging output.
Hydra's instantiate() API in the dvc product allows execution of arbitrary Python callables specified by the _target_ field in configuration. The blacklist intended to block unsafe targets was incomplete, allowing bypasses via wrappers like timeit.timeit, pickle.loads deserialization, and other indirect callables. This enables an attacker who can supply untrusted Hydra configuration to execute code with the application's privileges. The issue affects dvc versions from 3.67.1_10 up to but not including 3.67.1_15. A fix is available in version 3.67.1_15.
Hydra's logging configuration allowed unsafe callable resolution, enabling attackers controlling the logging config to execute arbitrary code with application privileges. This occurred because Hydra passed logging configuration directly to Python's logging.config.dictConfig() without mediating callable resolution through its target policy. Versions prior to 3.67.1_15 are affected. Hydra 1.3.6 and later apply stricter controls including blacklists and whitelists to restrict callable invocation during logging setup. Users should upgrade to fixed versions and avoid untrusted logging configurations.
Hydra versions 1.3.4 through 1.3.6 and 1.4.0.dev4 through 1.4.0.dev9 contain a vulnerability where mutable module-level state allows modification of target blocklists. This enables an attacker controlling configuration with multiple sibling _target_ entries to remove a target from the blocklist and instantiate it, bypassing intended restrictions. The issue affects the legacy/default path without an execution whitelist and is fixed in versions 1.3.7 and 1.4.0.dev10. Users should avoid passing untrusted configuration to instantiate() and upgrade to fixed versions.
CVE-2026-104874 is a reference leak vulnerability in the items-view union and subtraction operators of the aio-libs/multidict Python package versions 6.7.0 through 6.9.0. This flaw allows a remote client to cause unbounded, unreclaimable memory growth by leaking references to key-identity and value objects during certain set operations on dictionary views. The leak occurs because the code fails to release new strong references created during operand parsing, leading to a monotonic increase in resident memory until the process is terminated.
Dulwich's stash pop function is vulnerable to a symlink directory traversal that allows writing arbitrary files outside the repository worktree. This occurs because the function uses os.path.exists which follows symlinks, enabling an attacker to craft a malicious repository that writes files such as .git/hooks/post-checkout, leading to remote code execution on the victim's machine during subsequent git operations.
Dulwich's porcelain.checkout(paths=[]) function uses raw os.open calls without symlink protections, allowing an attacker to write arbitrary files via symlink traversal. This can lead to remote code execution by overwriting Git hooks such as .git/hooks/post-checkout. The vulnerability affects versions from 3.62.0 up to but not including 3.67.1_10 and is fixed in 3.67.1_10.
Dulwich's filter_branch.py in version 1.2.7 has a symlink directory traversal vulnerability in the _apply_index_filter() function. When processing commit history, symlinked tree entries from ancestor commits persist in the working directory and can redirect file writes from descendant commits to arbitrary filesystem locations. This allows an attacker to craft a malicious repository that, when processed with filter_branch, can write attacker-controlled content to arbitrary locations, potentially achieving remote code execution by writing to .git/hooks/. A fix is available in version 3.67.1_10.
A high-severity denial of service (DoS) vulnerability exists in the dulwich library's Pack.resolve_object method. The flaw occurs when resolving an OFS_DELTA object with a delta_offset of zero, causing infinite recursion and CPU exhaustion. This can cause processes using dulwich to hang or crash. The vulnerability violates the Git packfile specification, which explicitly forbids delta_offset of zero. A fix is available in dulwich version 3.67.1_10.
Hydra's hydra.utils.instantiate() function can lead to arbitrary code execution if it processes untrusted configuration data containing a malicious _target_ value. This vulnerability arises because instantiate() resolves and calls Python objects specified in configuration, allowing an attacker controlling _target_ and its arguments to execute code with the privileges of the calling process. The issue affects applications or libraries that pass untrusted or semi-trusted config, CLI overrides, or model metadata directly to instantiate() without restricting allowed targets. Hydra 1.3.4 introduces a blacklist to mitigate this risk, and the upcoming 1.4 line will implement an allowlist model for stronger protection. Users should upgrade to 1.3.4 or later and validate _target_ values before instantiation when handling untrusted input.
The pyasn1 library's univ.Real type has a vulnerability where converting decoded REAL values with large exponents to Python floats causes excessive CPU and memory consumption. This can hang processes when operations like printing, logging, or comparing decoded REAL values from untrusted ASN.1 data are performed. The issue affects pyasn1 versions from 0.63.4 up to but not including 3.67.1_10. It is fixed in version 3.67.1_10. Applications that do not handle ASN.1 REAL values or do not convert these values are not affected.
A vulnerability in pyasn1's BER/CER/DER decoders and encoders causes quadratic time complexity when processing OBJECT IDENTIFIER and RELATIVE-OID values with many arcs. This can lead to denial of service by consuming excessive CPU resources when decoding or encoding crafted ASN.1 data. The issue affects multiple codecs and is fixed in pyasn1 version 0.6.4. Limiting the size of untrusted ASN.1 input before decoding can mitigate the risk.
A denial of service vulnerability exists in the pyasn1 BER/CER/DER decoder due to unbounded long-form tag IDs. The decoder accumulates continuation octets without an upper limit, allowing crafted inputs to cause excessive CPU usage. On Python 3.11 and later, oversized tag IDs can also trigger unhandled ValueErrors during error message formatting, potentially bypassing error handling. This affects applications decoding untrusted BER/CER/DER inputs using pyasn1 versions >=0.63.4 and <3.67.1_10. The issue is fixed in version 3.67.1_10 by limiting tag ID length and improving error handling.
Dulwich versions from 0.23.2 up to but not including 1.2.5 contain a vulnerability in the submodule update and clone commands when using recurse_submodules=True. The vulnerability allows an attacker controlling a repository's .gitmodules and tree gitlink path to write files into the victim's .git/hooks directory without path validation. This enables arbitrary code execution when git or dulwich subsequently runs the malicious hooks. The flaw arises from lack of validation of submodule paths and permissive file mode preservation during submodule tree materialization.
Dulwich, a Git server implementation, has a denial-of-service vulnerability due to unbounded memory allocation when processing crafted thin packs during push operations. A malicious client with push access can send a tiny crafted thin pack that declares a large destination size, causing Dulwich to allocate excessive memory unrelated to the actual data size. This affects Dulwich-based Git servers exposing git-receive-pack functionality. The issue is patched in Dulwich version 3.67.1_6 and later.
Dulwich's porcelain.format_patch function previously did not sanitize commit subject lines properly when generating patch filenames. This allowed malicious commit subjects containing path traversal sequences or illegal filename characters to cause patch files to be written outside the intended output directory or cause failures on Windows. The issue was fixed in Dulwich version 1.2.5 by sanitizing commit subjects to safe filename components. Users processing untrusted commits should upgrade or apply recommended workarounds.
Dulwich contains a command injection vulnerability in its merge driver implementation. The `ProcessMergeDriver` function substitutes file paths from the git tree into shell commands using the `%P` placeholder and executes them with `subprocess.run(..., shell=True)`. An attacker who can cause a victim to merge a malicious branch with crafted 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. A fix is available in version 3.67.1_6.
Dulwich on Windows allows arbitrary file write via specially crafted tree entries containing NTFS-hostile path elements. This can lead to remote code execution when cloning or checking out a malicious Git repository. The vulnerability arises from improper validation of filenames containing backslashes, NTFS alternate data stream markers, and NTFS 8.3 short-name aliases. The issue is fixed in Dulwich version 1.2.5 and later. No effective workaround exists prior to patching, and users should upgrade to mitigate the risk.
The pyasn1 library contains a denial of service vulnerability caused by unbounded recursion when decoding ASN.1 data with deeply nested indefinite-length SEQUENCE or SET tags. An attacker can supply a crafted payload that triggers recursive decoding calls without depth checks, leading to a RecursionError or out-of-memory condition, crashing the host application. This affects services using pyasn1 for parsing untrusted ASN.1 data such as LDAP, SNMP, Kerberos, and X.509 parsers. The vulnerability is fixed in pyasn1 version 3.67.0_1.