The Git project has officially released a comprehensive suite of security patches designed to mitigate six distinct vulnerabilities that have been identified across various core functionalities of the version control system. These flaws, which range from arbitrary code execution risks during repository cloning to memory corruption issues during complex merge operations, represent a significant security concern for developers, hosting providers, and organizations that rely on Git to manage their source code.
As of November 17, 2026, the Git project has rolled out version 2.56.1, which serves as the primary vehicle for these critical fixes. To ensure widespread coverage, the project has also backported these security improvements to maintenance releases for versions 2.55.1, 2.54.1, 2.53.1, 2.52.1, 2.51.3, and 2.50.2. Security experts and project maintainers are urging users across all environments—from individual developers to large-scale enterprise server administrators—to update their Git installations immediately and to ensure that any third-party applications bundling Git are also patched.
Understanding the Vulnerabilities
The complexity of modern version control systems means that even minor logical errors in how data is processed can lead to severe security implications. The vulnerabilities identified in this release touch upon the fundamental ways Git interacts with local filesystems, remote repositories, and memory management.
Perhaps the most alarming of these is CVE-2026-111760, which centers on the risks associated with cloning malicious repositories. Under normal operations, Git performs rigorous checks on file paths before writing them to a working tree, specifically to prevent a repository from overwriting its own metadata. However, researchers discovered an integer truncation flaw in Git’s index handling. This flaw allows an extremely long, malicious path to pass initial validation under one name, only to be written using a shorter, malicious name. By exploiting this discrepancy, an attacker operating a rogue Git server can trick a user’s client into overwriting the local .git directory or configuration files.
The consequences are severe: if a user performs a recursive clone, the attack can trigger the execution of arbitrary code immediately. Even in non-recursive clones, the attacker can replace the top-level .git metadata, potentially leading to code execution the next time a user runs commands like git status in the affected directory. The fix deployed in the latest update ensures that Git now rejects excessively long index entry paths before they can be truncated or manipulated.
A second critical issue, tracked as CVE-2026-113408, involves path traversal through a server’s advertised HEAD. When Git protocol v2 is used to clone an empty repository, the server can provide a symbolic reference (symref) pointing to an unborn branch. Historically, Git failed to properly validate the target of this symref before storing it locally. A malicious server could supply a name containing path-traversal sequences, which, when combined with the files reference backend, could allow an attacker to write files outside of the intended reference directory. The new release mandates strict validation of all advertised targets and symbolic-reference names received via protocol v2, closing this traversal loophole.
Memory Corruption and Patch Handling
In addition to repository interaction risks, the update addresses several memory-related vulnerabilities that could lead to crashes or, in some cases, remote code exploitation. CVE-2026-114467 involves stack corruption that occurs when Git strips GPG signatures from a message. The system previously assumed a maximum of two signatures per message, utilizing a fixed-size stack array to hold them. A specifically crafted message containing more than two signatures can trigger a write past the end of this array, resulting in memory corruption. This is particularly dangerous for hosting services that automatically handle merges on behalf of users, as they could be targeted by malicious tags. The patch replaces this fixed-size array with a more robust mechanism that accommodates any number of signatures.

The security team also addressed CVE-2026-114469, which concerns out-of-bounds reads during the application of binary patches. While Git has existing safeguards to reject patches larger than 1 GiB to prevent resource exhaustion, the check only considered the compressed size of the patch as supplied. Because binary patches are compressed and encoded, a small file could expand significantly, bypassing the input-size check and causing an out-of-bounds read that crashes the Git process. The update now requires Git to verify the declared uncompressed size before processing begins, ensuring that large or malicious patches cannot cause memory-related instabilities.
A similar theme of memory safety appears in the fix for CVE-2026-105437, which addresses heap corruption during large merge operations. The merge machinery calculates memory requirements before writing output, but this calculation can overflow when processing exceptionally large results—such as those involving extensive merge conflicts combined with a large conflict-marker-size attribute. This overflow can cause the system to allocate a buffer that is too small for the actual data, leading to heap corruption. The new patch employs size-appropriate data types and rigorous arithmetic checks to reject merges that cannot be safely processed within the system’s memory limits.
Filesystem Security and Hardening
The final vulnerability, CVE-2026-114466, focuses on filesystem access via git fast-import streams. This command, designed for high-performance repository construction, reads a stream of instructions that can, in some cases, interact with files outside the intended repository. While existing protections were in place for most commands, three specific features—rewrite-submodules-from, rewrite-submodules-to, and export-pack-edges—lacked sufficient safeguards. These features could be misused to read arbitrary files or create/append to existing ones on the host machine. The updated Git version now blocks these features by default unless the caller explicitly enables the --allow-unsafe-features flag, which should only be used in trusted environments.
Alongside these specific fixes, the Git project has implemented general hardening measures. These include additional overflow checks for index entry allocations during tree processing and checkout operations. By preventing allocation sizes from overflowing or being truncated during the copy process, the developers have introduced an extra layer of defense against potential memory-based attacks that might not have been captured by the specific CVE patches.
Immediate Action Required
The breadth of these vulnerabilities highlights the ongoing challenges of maintaining secure infrastructure for distributed version control. The Git project, along with major repository hosting services, strongly emphasizes that updating the core Git binary is the most effective defense. Administrators managing automated build pipelines, continuous integration services, or any server-side infrastructure that processes incoming repositories are advised to prioritize these updates, as these services are often the most exposed to untrusted input.
For developers who cannot immediately deploy the patch, the project advises adopting a "zero trust" approach toward repository handling. This includes cloning only from trusted sources, avoiding the cloning of untrusted repositories, and exercising extreme caution when merging content or processing binary patches from unknown contributors. While these manual precautions can mitigate some risks, they do not serve as a substitute for the underlying security fixes provided by the version 2.56.1 update.
The collaborative effort behind these patches underscores the critical role of the global developer community in securing the tools upon which modern software development is built. Researchers and contributors—including Robert Chen, Luke Martin, pwn2addr, and developers like Elijah Newren, Toon Claes, and Karthik Nayak—have worked to identify and resolve these issues, ensuring that the Git ecosystem remains a secure environment for collaborative software engineering. As the industry moves forward, the focus remains on proactive hardening and the timely dissemination of security updates to prevent the exploitation of these fundamental Git components.

