Skip to main content

Dulwich CVE-2026-114097

| EUVDEUVD-2026-106900 HIGH
Path Traversal (CWE-22)
2026-10-21 VulnCheck GHSA-4hjw-xcwg-8xfj
7.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Clone attacker-crafted repository
  2. Delivery
    Run filter_branch with index filter
  3. Exploit
    Ancestor commit symlink materialized in working dir
  4. Execution
    Descendant file write follows symlink into .git/hooks
  5. Impact
    Git 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

dulwich 0.23.1 <1.2.8

Affected Packages

pypi dulwich fix: 1.2.8

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

Vendor (VulnCheck) PRIMARY 7.3 HIGH
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
vuln.today AI 7.8 HIGH

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.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 21, 2026 - 02:01 EUVD
CVE Published
Oct 21, 2026 - 00:37 cve.org
HIGH 7.3

DescriptionCVE.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.

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.2%
Top 96% exploitable
Prevalence
Medium
popular pure-Python Git library, but filter_branch is a niche operation
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy