CVE-2026-47712: Dulwich Path-Traversal Vulnerability in Patch File Generation

Technical summary

CVE-2026-47712 is a path-traversal vulnerability in Dulwich versions 0.24.0 through 1.2.4 affecting the dulwich.porcelain.format_patch() function. The vulnerability stems from insufficient sanitization of commit subject lines when deriving patch filenames. The original get_summary() function only replaced spaces with dashes but left path separators (/, \), parent-directory traversal sequences (..), and other filesystem-hostile characters intact. These unsanitized characters were then passed directly to os.path.join(outdir, filename), allowing a crafted commit subject to construct relative paths that escape the target output directory. The fix implements Git's format_sanitized_subject sanitization scheme: retaining only alphanumeric characters, periods, and underscores; collapsing runs of other characters to single dashes; collapsing consecutive periods to single periods; stripping trailing dots and dashes; and enforcing a length limit. This ensures the resulting filename is safe for use in path operations.

Business impact

The business risk is contained to organizations that use Dulwich to process untrusted or adversarially-controlled Git repositories. Primary concerns include: (1) unauthorized file creation in system directories or other sensitive locations if a path-traversal payload escapes the intended patch output directory; (2) potential code injection if generated patches are later executed or imported without validation; (3) denial-of-service scenarios where files are written to fill disk space or overwrite critical application files. Organizations using Dulwich in automated CI/CD pipelines, patch-processing workflows, or code review systems with external repository sources face the highest risk.

Affected systems

Dulwich versions 0.24.0 through 1.2.4 are vulnerable. The library is used by Python-based Git tools and integrations; identify systems running affected versions by checking Dulwich dependencies in your codebase. The vulnerability only manifests when format_patch() is called with untrusted or malicious commit data—local, trusted repositories pose minimal risk. Systems that download or clone external Git repositories and automatically generate patches are particularly exposed.

Exploitability

Exploitation requires the ability to influence a commit's subject line that will be processed by vulnerable Dulwich code. In practice, this means an attacker must either: (1) push a malicious commit to a repository that a target system automatically processes, or (2) socially engineer a user into cloning a repository containing such a commit. The attack surface is limited to scenarios where Dulwich processes untrusted commits. User interaction is required (the user must initiate patch generation), and the impact is local (files written to the local filesystem). The CVSS 3.1 score of 3.3 (LOW) reflects low attack complexity, no network vector, and limited integrity impact.

Remediation

Upgrade Dulwich to version 1.2.5 or later, which implements proper subject-line sanitization. For organizations unable to upgrade immediately, the vendor advisory recommends: (1) using format_patch(..., stdout=True) to capture patch output directly rather than writing to the filesystem; (2) validating the resolved path of any generated patch file against the intended output directory using os.path.realpath() before trusting it; (3) pre-screening commit subjects and rejecting any containing path-traversal characters (/, \, ..) before calling format_patch(). These workarounds reduce risk but are not substitutes for patching.

Patch guidance

Upgrade to Dulwich 1.2.5 or later. This version is available via pip (pip install --upgrade dulwich). Verify your current version with `pip show dulwich` or in your requirements.txt/pyproject.toml. If using a package manager or container image, ensure the base image or package repository is updated. Test the upgrade in a non-production environment first, particularly if you have custom integrations with Dulwich's patch-generation API.

Detection guidance

Audit your codebase for calls to dulwich.porcelain.format_patch() with user-controlled or externally-sourced commit data. Check Git logs and patch-generation workflows for commits with unusual subject lines containing path-traversal characters. Monitor for unexpected files written outside designated patch directories. If you process untrusted repositories, review recent patch-generation logs for any anomalies. Consider deploying a simple validation wrapper around format_patch() that checks the resolved path of generated files against the intended output directory.

Why prioritize this

This vulnerability is low-severity but warrants timely attention in systems that process untrusted external Git repositories. Prioritize patching in development environments, CI/CD systems, and code-review platforms that integrate Dulwich. Organizations using Dulwich only for trusted, internal repositories can deprioritize but should still plan an upgrade cycle. The fix is straightforward and non-breaking, making this an ideal candidate for routine dependency updates.

Risk score, explained

The CVSS 3.1 score of 3.3 reflects: (1) local attack vector—the attacker must influence commit data on or before the target system processes it; (2) low attack complexity—exploiting the vulnerability requires only crafting a subject line with special characters; (3) no privileges required; (4) user interaction required—someone must call format_patch(); (5) limited scope and impact—only local integrity is affected (unauthorized file creation), with no confidentiality or availability impact. The score is appropriate for a path-traversal vulnerability with local scope, though in specific contexts (e.g., a hosted Git service), impact could be more severe.

Frequently asked questions