Network graph showing Git security vulnerabilities being mitigated with cryptographic shields and patched connection nodes

Git Security Vulnerabilities: 6 New Critical Patches Released

The Git project has released updates to address six serious Git security vulnerabilities that allow arbitrary code execution, unauthorized file overwrites, and memory corruption. As announced on the GitHub Blog by Elijah Newren on November 10, 2026, the primary update is delivered in Git version 2.56.1. The maintenance team also issued backports across older release streams, specifically Git 2.55.1, 2.54.1, 2.53.1, 2.52.1, 2.51.3, and 2.50.2.

Software development workflows rely heavily on Git commands executing safely in local environments, automated staging pipelines, and multi-tenant hosting environments. When these low-level operations contain parsing flaws, cloning untrusted repositories or processing external patches can compromise local machines and continuous integration workers. Development teams should inspect their active versions and apply the official maintenance builds immediately.

Six Git Security Vulnerabilities Addressed in Git 2.56.1

The released updates correct six specific common vulnerabilities and exposures (CVEs), ranging from recursive checkout flaws to memory handling issues during large merges. Each vulnerability stems from edge cases where Git parsed incoming repository data without strict boundary or length verification.

The first flaw, indexed as CVE-2026-111760, enables arbitrary code execution during recursive clones. Git normally checks paths prior to writing files into a working tree, rejecting any path intended to overwrite repository metadata. However, an integer truncation bug in index handling caused very long file paths to pass initial validation under one length and then get written using a shorter name. Attackers could exploit this behavior to replace a submodule’s .git file with a symbolic link targeting directories with malicious configuration or hooks, leading to arbitrary code execution when Git processes that directory. The fix rejects oversized index entry paths before length truncation can take place.

The second issue, CVE-2026-113408, involves directory traversal when connecting to an untrusted server via Git protocol v2. When a client clones an empty repository, the remote server can advertise a HEAD symbolic reference pointing to an unborn branch that lacks commits. Git previously stored this target locally without validating the path. A rogue server could return path-traversal sequences, causing operations using the files reference backend to write outside the intended reference directory. The new release validates advertised symref targets and reference names received over protocol v2.

The third flaw, CVE-2026-114467, causes stack corruption when stripping GPG signatures. The parsing routine assumed messages would contain at most two signatures, storing them in a fixed-size stack array. Merging a tag crafted with more than two signatures overflows this array, producing memory corruption and potential denial of service. The patch replaces the static array with dynamic handling that accepts arbitrary signature counts.

The fourth bug, CVE-2026-114469, causes out-of-bounds reads during binary patch processing. Git enforces a limit of approximately 1 GiB on incoming patches to avoid memory exhaustion, but it previously checked only the compressed transfer size. Because binary patches are compressed and encoded, an attacker could supply an input that expands beyond the limit after decompression, crashing Git. The fix inspects the declared uncompressed size before processing begins.

The fifth flaw, CVE-2026-105437, triggers heap corruption during large merges. When Git calculates memory allocations for merge outputs, integer overflow can occur if many conflicts combine with large conflict-marker-size settings. This overflow produces an undersized memory buffer, leading to out-of-bounds writes on the heap. Git 2.56.1 introduces checked arithmetic and appropriate integer types, rejecting merge operations whose output size exceeds safe limits.

The sixth flaw, CVE-2026-114466, permits unauthorized filesystem access through git fast-import streams. While Git restricts most commands that touch files outside the repository in untrusted streams, three features remained unrestricted: rewrite-submodules-from, rewrite-submodules-to, and export-pack-edges. The submodule rewrite options could read arbitrary files and leak data via error messages, while the pack-edges flag could create or append to local files. Git now blocks these operations in fast-import streams unless the user explicitly passes the --allow-unsafe-features flag.

Why Addressing Git Security Vulnerabilities Matters for Development Teams

Securing source control tools is foundational for maintaining safe infrastructure. Many modern workflows automatically pull and examine third-party code. Because these Git security vulnerabilities affect cloning, merging, and patch handling, any developer or server that interacts with public repositories or automated pull requests could be vulnerable.

  • Continuous Integration Workers: Build runners executing automated git clone --recursive commands against pull requests submitted by public contributors risk remote execution.
  • Multi-Tenant Hosting Platforms: Services that compute diffs or process merges on behalf of users face denial of service and memory corruption through malformed tags or large conflict markers.
  • Local Workstations: Engineers evaluating open-source packages or submodules can inadvertently run malicious hook scripts through symlink redirection.
  • Data Ingestion Pipelines: Tools ingesting fast-import streams could leak sensitive configuration files through unvalidated submodule rewrite directives.

Alongside these specific fixes, the Git maintenance group introduced additional hardening. The update adds overflow validation to index entry allocations used during tree processing and checkout routines. These checks prevent memory allocation sizes from being truncated before Git copies path information into memory buffers.

How Platforms and Vendors Are Rolling Out Defenses

GitHub has reported that mitigation patches are already active on GitHub.com, GitHub Enterprise Cloud, and GitHub Enterprise Cloud with data residency. For self-hosted instances, GitHub Enterprise Server updates are available across versions 3.19.15, 3.20.11, 3.21.9, and 3.22.4, with administrators advised to upgrade promptly.

Because Git is bundled inside desktop applications and integrated development environments, updates are rolling out across multiple downstream tools. Coordinated releases are underway for GitHub Desktop and the GitHub Copilot application. Patched builds are also being deployed to GitHub Actions runners and GitHub Codespaces environments.

For organizations operating their own Linux build servers, package managers from distributions like Debian, Ubuntu, Fedora, and Alpine are preparing or publishing updated binaries. Engineering teams should not assume updating desktop tools protects the entire pipeline; servers running custom automation require direct package updates.

Frequently Asked Questions About Git Security Vulnerabilities

How can developers verify if their systems are safe from these Git security vulnerabilities?

Developers should run git --version in their terminals. Safe versions include Git 2.56.1, or backported maintenance releases 2.55.1, 2.54.1, 2.53.1, 2.52.1, 2.51.3, and 2.50.2. Any lower version running untrusted repository tasks remains vulnerable.

What steps reduce risk if an immediate update is not possible?

Teams unable to patch immediately should avoid recursive clones of unverified repositories and decline to merge untrusted tags or branches. Developers should also avoid applying binary patches or running fast-import commands sourced from untrusted parties until patched binaries are installed.

Do these vulnerabilities only affect command-line Git users?

No, these vulnerabilities also affect graphical user interfaces and development tools that embed Git binaries or libraries. Any application using an unpatched bundled Git binary to clone submodules or parse commits carries the same security risks.

Securing CI/CD Pipelines and Custom Build Workflows

Maintaining security across automated environments requires treating developer tooling with the same diligence as public web servers. Wasif Ahmed designs resilient deployment pipelines and back-office infrastructure, frequently auditing tool versions and deployment environments within custom software development projects to protect against upstream supply chain risks.

When engineering teams connect automated webhook triggers, Make.com workflows, or AI automation tasks to GitHub repositories, ensuring the underlying runners run updated binaries prevents pipeline compromise. Applying the latest security patches for these Git security vulnerabilities guarantees that automated checkout tasks, repository synchronization scripts, and server-side merges process untrusted code safely.

If you need assistance auditing your deployment pipelines, configuring server security, or building reliable automated workflows, visit the contact page to start a conversation.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top
Secret Link