Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessClone attacker-crafted repository
-
DeliveryRun filter_branch with index filter
-
ExploitAncestor commit symlink materialized in working dir
-
ExecutionDescendant file write follows symlink into .git/hooks
-
ImpactGit hook executes attacker payload
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the victim run Dulwich's filter_branch with an index_filter (CommitFilter._apply_index_filter) against an attacker-controlled repository, and that the repository contain a specific cross-commit structure: an ancestor commit with a symlink tree entry (mode 120000) pointing to the target directory, and a descendant commit writing a blob beneath that symlink path. The vulnerability is gated by the absence of CWD cleanup between commit iterations and the lack of symlink protection in build_file_from_blob on versions >=0.23.1 through 1.2.7. Limiting factors: requires local access and user interaction (the victim must invoke the history-rewriting operation), affects only the index_filter code path (not plain clone/fetch/checkout), and is fixed in 1.2.8; routine Dulwich use that does not run filter_branch on untrusted repositories is not exposed. |
| Impact | This is a genuine but conditional code-execution risk that should be treated as moderate rather than emergency priority. The vendor-supplied CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:N/UI:P) is the key signal: exploitation is LOCAL, requires no privileges but DOES require active user interaction (UI:P) - the victim must voluntarily run filter_branch with an index filter against an attacker-supplied repository - and carries an additional attack requirement (AT:P), reflecting the specific cross-commit symlink structure that must be crafted. This is not remote-unauthenticated mass-exploitable; it is an attacker-crafted-repository / supply-chain-style vector that depends on the victim performing a specific, non-routine history-rewriting operation. No EPSS score was provided in the input, so probabilistic exploitation likelihood cannot be quantified. The CVE is NOT in CISA KEV and there is no public exploit code identified at time of analysis - the GHSA advisory contains a detailed conceptual attack scenario and root-cause walkthrough but not weaponized exploit code. The signals are internally consistent: high technical impact (VC/VI/VA:H → RCE via .git/hooks) tempered by a local vector and mandatory user interaction. Net: a real, patchable defect worth remediating promptly for anyone who processes untrusted repositories with filter_branch, but low likelihood of opportunistic widespread exploitation. |
| Exploit ScenarioDerived | An attacker publishes a crafted Git repository in which an ancestor commit contains a symlink entry (e.g. 'evil' → '/target_dir') and a descendant commit writes a file beneath that path ('evil/payload'). A victim clones the repository and runs Dulwich's filter_branch with an index filter; because the working directory is not cleaned between commits, the persisted symlink redirects the descendant's file write outside the working directory - into .git/hooks/ - achieving code execution the next time a hook fires. No public exploit code exists, though the advisory documents the full attack path. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Symlink-based path traversal in Dulwich 0.23.1 through 1.2.7 allows an attacker who controls a repository's commit history to write files outside the working directory when a victim runs filter_branch with an index_filter, with code execution possible if the write lands in .git/hooks. Exploitation is conditional: it requires local access and the victim to invoke the history-rewriting operation against the crafted repository, and no public exploit code was identified at time of analysis. Dulwich 1.2.8 fixes the issue by addressing cross-commit symlink persistence.
RemediationAI
Vendor-released patch: Dulwich 1.2.8 or later, which contains the upstream fix commit 9571ac60b851fce228dae7ededb380c6ce9b3fb8; see the advisory at https://github.com/jelmer/dulwich/security/advisories/GHSA-5fqc-mrg8-w798. If upgrading immediately is not possible, do not run filter_branch with an index_filter against untrusted or attacker-supplied repositories; run any required history rewriting in a disposable container or restricted account whose working directory has no write access outside the checkout, and clean the working directory between commits. Additional compensating controls include verifying that materialized tree paths contain no symlink components and making .git/hooks immutable or unwritable during filter operations; these reduce but do not eliminate exposure because the underlying CWD state persistence remains.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Dulwich is a pure-Python implementation of the Git protocol and repository format. The flaw is in CommitFilter._apply_index_filter() in dulwich/filter_branch.py, which calls build_index_from_tree('.', tmp_index_path, ...) and materializes tree entries into the process working directory. Its finally block deletes only the temporary index file, not the files written to CWD, and process_commit() recursively handles parents first, so a symlink tree entry (mode 120000) from an ancestor commit persists and redirects later writes made beneath that path (e.g., ./evil/payload) to an arbitrary target directory; on 1.2.7 build_file_from_blob() has no symlink protection and validate_path_element() checks only path-name patterns, not filesystem symlink state. This is CWE-22 path traversal; the CPE cpe:2.3:a:jelmer:dulwich:* confirms the affected package. The upstream fix is commit 9571ac60b851fce228dae7ededb380c6ce9b3fb8, released in 1.2.8.
Know when Dulwich gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local vector because exploitation requires running filter_branch on a cloned repo; UI:R since the victim must invoke the operation; PR:N as no auth is needed; C/I/A:H from arbitrary file write to .git/hooks yielding code execution.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Dulwich from 0.23.1 before 1.2.8 contains a path traversal vulnerability in CommitFilter._apply_index_filter() that allows attackers to write files outside the working directory via symlinks persisting between commits. Attackers can craft a repository where an ancestor commit's symlink redirects a descendant commit's file writes during filter_branch, enabling code execution by writing into .git/hooks.
Blast Radius
ecosystem impact- 1 pypi packages depend on dulwich (1 direct, 0 indirect)
Ecosystem-wide dependent count for version 0.23.1.
Technical POC Analysis
CWE-22 (with CWE-59 as a secondary classification in the advisory): path traversal via link following in Dulwich's commit-history filtering.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Dulwich, the pure-Python Git implementation used in developer tooling and CI pipelines, carries a symlink path-traversal flaw (CVE-2026-114097, CVSS 7.3) that lets a malicious repository's commit history write files outside the working directory - including into .git/hooks, which can lead to code execution - when a victim runs filter_branch with an index filter. Exploitation is conditional on local access and on the victim invoking the history-rewriting operation against a crafted repository, and no public exploit identified at time of analysis. Leadership should care because the risk concentrates in teams and automated pipelines that process untrusted third-party code, where a single branch-filter job could execute attacker-controlled code on build infrastructure holding source code, credentials, and pipeline secrets.
No vendor patch is confirmed in the supplied patch status, although the advisory identifies Dulwich 1.2.8 as resolving cross-commit symlink persistence; upgrade to 1.2.8 as the primary remediation. Until that upgrade is validated, run filter_branch operations only against trusted repositories inside disposable, least-privilege containers with no access to production secrets, block or monitor writes into .git/hooks, and require human review before running history-rewriting jobs on externally sourced code.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Related Vulnerabilities in Dulwich Path Traversal and DoS Vulnerabilities
View all 5The build_index_from_tree function in index.py in Dulwich before 0.9.9 allows remote attackers to execute arbitrary code
Arbitrary code execution in Dulwich (pure-Python Git implementation) versions 0.23.2 through 1.2.4 allows a malicious up
Dulwich before 0.18.5, when an SSH subprocess is used, allows remote attackers to execute arbitrary commands via an ssh
Buffer overflow in the C implementation of the apply_delta function in _pack.c in Dulwich before 0.9.9 allows remote att
EUVD-2026-106900
GHSA-4hjw-xcwg-8xfj
NVD
CVE.org
EPSS
Exploit-DB