The Git project has released a coordinated set of security updates addressing six vulnerabilities affecting multiple Git maintenance branches.
The announcement was published on November 10, 2026, by Git maintainer Junio C Hamano on the Git mailing list.
The vulnerabilities affect different areas of Git's repository handling, including recursive cloning, reference processing, commit signature handling, binary patch application, merge operations, and the fast-import utility.
The most critical issue is CVE-2026-111760, which can allow remote code execution through a malicious repository during recursive clone operations. An attacker-controlled repository can exploit Git's handling of submodule gitfiles to replace a gitfile with a symbolic link pointing to a directory containing malicious configuration or hooks. These components may contain attacker-controlled code.
Other vulnerabilities can result in unauthorized file writes, stack or heap memory corruption, denial of service, and arbitrary file reads through certain fast-import options.
Git has coordinated fixes across multiple maintenance branches, including:
Git 2.50.2
Git 2.51.3
Git 2.52.1
Git 2.53.1
Git 2.54.1
Git 2.55.1
Git 2.56.1
The announcement also states that maintenance releases are available for older maintenance tracks down to maint-2.43.
Organizations using Git in developer workstations, automated build systems, CI/CD pipelines, and source-code hosting infrastructure should review their installed versions and apply the corresponding security updates.
Vulnerability Details
The coordinated security release addresses six CVEs.
1. CVE-2026-111760 – Remote Code Execution Through Recursive Clones
Attribute | Details |
|---|---|
CVE ID | CVE-2026-111760 |
Affected Component | Recursive clone and submodule handling |
Vulnerability Type | Remote Code Execution |
Severity | High – suggested priority based on potential impact |
Fixed Releases | Git 2.50.2, 2.51.3, 2.52.1, 2.53.1, 2.54.1, 2.55.1, 2.56.1 |
This vulnerability affects Git's recursive clone functionality.
An attacker can prepare a malicious repository that exploits the way Git handles gitfiles associated with submodules.
During a recursive clone operation, Git can be manipulated into overwriting a gitfile with a symbolic link. The symbolic link can point to a directory containing attacker-controlled Git configuration or hooks.
Because Git configuration and hooks can contain executable commands, this can result in execution of attacker-controlled code during subsequent Git operations.
Potential attack scenario:
An attacker prepares a repository containing a specially crafted submodule structure.
A developer or automated system recursively clones the repository.
Git processes the malicious repository and encounters the vulnerable gitfile-handling condition.
The attacker-controlled symbolic link redirects the gitfile to an unintended directory.
Malicious configuration or hooks are introduced.
Subsequent Git operations may execute attacker-controlled commands.
This issue is particularly relevant to automated repository processing, CI/CD systems, and developer environments that clone repositories from untrusted sources.
2. CVE-2026-113408 – Path Traversal Through Unborn HEAD References
Attribute | Details |
|---|---|
CVE ID | CVE-2026-113408 |
Affected Component | Reference handling and files ref backend |
Vulnerability Type | Path Traversal / Arbitrary File Write |
Severity | High – suggested priority based on potential impact |
This vulnerability involves a Git server advertising an unborn HEAD reference containing path traversal characters.
An example provided in the announcement is:
refs/heads/../../../TARGETWhen Git processes this reference using the files ref backend, the path traversal characters can cause reference-updating operations to write to unintended files.
The issue is related to insufficient validation of symbolic reference targets received through the Git protocol.
A malicious or compromised server could therefore provide specially crafted reference information that triggers unintended filesystem writes on the client.
Security impact:
Unauthorized file modification.
Writes outside the expected reference directory.
Potential corruption of files within the affected environment.
Additional security consequences depending on the permissions of the Git process and the target path.
The Git project has addressed this issue by validating reference names and symbolic reference targets in protocol v2 responses.
3. CVE-2026-114467 – Stack Memory Corruption Through Multiple GPG Signatures
Attribute | Details |
|---|---|
CVE ID | CVE-2026-114467 |
Affected Component | Commit signature handling |
Vulnerability Type | Stack Memory Corruption |
Severity | High – suggested priority based on potential impact |
Primary Impact | Denial of Service |
Git's commit signature removal functionality contains a vulnerability when processing commit messages with more than two GPG signatures.
The vulnerable implementation only accounted for two signatures while processing the commit message.
A specially crafted commit containing more than two signatures can therefore trigger stack memory corruption.
The announcement identifies git merge involving a tag with multiple signatures as a way to trigger the issue.
This can cause a denial-of-service condition. The announcement also notes that code-hosting platforms may be affected when such a tag is pushed to a remote repository and a merge operation is initiated.
4. CVE-2026-114469 – Out-of-Bounds Read Through Oversized Binary Patches
Attribute | Details |
|---|---|
CVE ID | CVE-2026-114469 |
Affected Component | Binary patch application |
Vulnerability Type | Out-of-Bounds Read |
Severity | High – suggested priority based on potential impact |
Primary Impact | Denial of Service |
Git restricts patches larger than approximately 1 GiB because its patch application implementation does not handle extremely large files safely.
However, the vulnerable size check only considered the size of the patch as represented in the input.
Binary patches are compressed and encoded, meaning their actual expanded size can be significantly larger than their encoded representation.
An attacker can provide a binary patch with a relatively small encoded size that expands to an extremely large file.
This can bypass the original size validation and cause Git to perform an out-of-bounds memory read, resulting in a crash.
The vulnerability may affect systems processing untrusted binary patches.
5. CVE-2026-105437 – Heap Memory Corruption During Large Merge Operations
Attribute | Details |
|---|---|
CVE ID | CVE-2026-105437 |
Affected Component | Merge processing / xdiff |
Vulnerability Type | Integer Overflow and Heap Memory Corruption |
Severity | High – suggested priority based on potential impact |
Git calculates the size of the buffer required to store merge results.
The vulnerable calculation can overflow when processing extremely large merges involving a large number of conflicts and an unusually large conflict-marker-size.
This can result in an allocated buffer that is smaller than required.
Git subsequently writes beyond the allocated memory boundaries, corrupting the heap. The announcement also describes writes occurring before the beginning of the buffer.
Potential consequences include:
Git process crashes.
Memory corruption.
Denial of service.
Potential additional exploitation depending on the execution environment and memory layout.
The release includes changes to use size_t for merge-buffer calculations and additional overflow checks.
6. CVE-2026-114466 – Arbitrary File Access Through fast-import
Attribute | Details |
|---|---|
CVE ID | CVE-2026-114466 |
Affected Component |
|
Vulnerability Type | Arbitrary File Read |
Severity | High – suggested priority based on potential impact |
Git previously disabled the export-marks feature by default in response to CVE-2019-1348.
However, additional functionality introduced later also allowed reading from arbitrary filesystem paths.
The announcement identifies the following features and options:
rewrite-submodules-torewrite-submodules-fromexport-pack-edges
These features could be used to read files from arbitrary paths.
The security release therefore disables these additional features by default, providing further protection against unauthorized filesystem access through fast-import.
Affected Products and Fixed Versions
The vulnerabilities affect Git releases across multiple maintenance branches.
The coordinated announcement lists the following patched release tags:
Git Maintenance Branch | Security Release |
|---|---|
Git 2.50.x | 2.50.2 |
Git 2.51.x | 2.51.3 |
Git 2.52.x | 2.52.1 |
Git 2.53.x | 2.53.1 |
Git 2.54.x | 2.54.1 |
Git 2.55.x | 2.55.1 |
Git 2.56.x | 2.56.1 |
The announcement additionally states that coordinated fixes are available for older maintenance tracks down to maint-2.43.
Organizations should identify their installed Git maintenance branch and obtain the corresponding patched release rather than assuming that upgrading to the latest major release is the only supported remediation path.
Potential Impact
Successful exploitation of these vulnerabilities may affect development environments, build infrastructure, and source-code hosting platforms.
Remote Code Execution: CVE-2026-111760 may allow attacker-controlled code execution through malicious repositories processed using recursive clone operations.
Unauthorized File Modification: CVE-2026-113408 may allow reference updates to write to unintended filesystem locations through path traversal.
Memory Corruption: CVE-2026-114467 and CVE-2026-105437 can corrupt stack and heap memory during commit signature processing and large merge operations.
Denial of Service: Malicious tags, oversized binary patches, and crafted merge operations may cause Git processes to crash.
Sensitive File Exposure: CVE-2026-114466 may allow arbitrary file reads through unsafe fast-import functionality.
CI/CD Pipeline Compromise: Automated systems that clone and process untrusted repositories may be exposed to malicious repository structures and subsequent code execution.
Developer Environment Compromise: Workstations processing attacker-controlled repositories may be at risk, potentially exposing source code, credentials, SSH keys, and development secrets.
Recommendations
Immediate Actions
Update Git: Upgrade to the appropriate patched maintenance release: 2.50.2, 2.51.3, 2.52.1, 2.53.1, 2.54.1, 2.55.1, or 2.56.1, depending on the installed branch.
Inventory Git Installations: Identify Git installations across developer workstations, Linux servers, Windows endpoints, build agents, containers, and CI/CD infrastructure.
Review Recursive Clone Usage: Identify automated workflows using
git clone --recursiveor recursive submodule initialization, particularly where repositories originate from untrusted sources.Restrict Untrusted Repository Processing: Avoid processing untrusted repositories in privileged environments. Use isolated build workers and restricted filesystem permissions.
Review Submodule Configuration: Investigate unexpected changes to
.gitfiles, submodule metadata, symbolic links, repository configuration, and Git hooks.Review Git Process Activity: Investigate unexpected child processes launched by Git, especially during clone, checkout, merge, and submodule operations.
Inspect Reference Handling: Monitor unusual reference names, path traversal sequences, and unexpected filesystem modifications associated with Git reference updates.
Review Patch Processing: Avoid applying binary patches from untrusted sources until the affected Git installations have been updated.
Review
fast-importUsage: Identify applications and automation workflows usingfast-importand assess whether they depend on the affected features.Preserve Evidence: If suspicious Git activity is identified, preserve repository contents, Git configuration, hooks, filesystem metadata, process execution logs, and CI/CD job records.
Preventive Actions
Enforce Software Update Policies: Establish a process for rapidly deploying Git security maintenance releases across development and production environments.
Isolate Build Environments: Execute repository cloning and compilation in disposable, restricted build environments.
Apply Least Privilege: Ensure Git processes do not run with unnecessary administrative or root privileges.
Secure CI/CD Pipelines: Review permissions, repository trust settings, build secrets, and automated submodule processing.
Monitor Git Hooks: Regularly inspect repository-level and global Git hooks for unauthorized modifications.
Strengthen Repository Validation: Validate submodule URLs, reference names, symbolic links, and repository metadata before processing untrusted repositories.
Monitor Filesystem Changes: Implement file integrity monitoring for sensitive directories used by Git, particularly configuration, hooks, and repository metadata.
Restrict Sensitive File Access: Run Git automation with filesystem permissions that prevent access to unrelated credentials and sensitive system files.
Audit Developer Workstations: Periodically verify Git versions and inspect configurations that could enable unsafe repository processing.
Monitor Vendor Advisories: Follow Git security announcements and apply future backported fixes to supported maintenance branches.
Conclusion
The coordinated Git security releases address six vulnerabilities affecting important repository-handling and file-processing functionality.
CVE-2026-111760 presents the most significant risk because it can enable remote code execution through malicious repositories processed using recursive clone operations. The remaining vulnerabilities affect reference validation, memory handling, binary patch application, merge processing, and file access through fast-import.
Because Git is widely integrated into developer workstations, CI/CD pipelines, build systems, and source-code hosting infrastructure, a vulnerable installation may expose more than an individual developer's workstation.
Organizations should prioritize upgrading Git, restricting the processing of untrusted repositories, reviewing recursive clone workflows, and isolating automated build environments.
The coordinated backports across multiple maintenance branches provide an upgrade path for organizations that cannot immediately move to the latest Git release.
