Git Security Vulnerabilities: Six New CVEs, Patched Versions and What Developers Must Update

Git security vulnerabilities disclosed on November 10, 2026, affect several fundamental repository operations, including recursive clones, reference handling, merges, binary patches and imports. The Git project has released patched versions addressing six CVEs, with fixes available in Git 2.56.1 and supported maintenance releases.

The most serious concern is a vulnerability that can lead to arbitrary code execution during recursive cloning of a malicious repository. Other flaws can cause unintended filesystem writes, memory corruption or crashes when Git processes specially crafted inputs.

GitHub’s official November 10 security announcement recommends updating Git and applications that bundle their own copies of the tool. GitHub also confirmed that it has deployed fixes across its hosted services and published updates for supported GitHub Enterprise Server versions.

For developers, the practical lesson is straightforward: Git is not merely a version-control command used on trusted source code. It is also a parser and processor of potentially untrusted repository data, and that makes it part of the software supply-chain attack surface.

What Are the Six New Git Security Vulnerabilities?

The November 10 release addresses six distinct flaws.

Technical classifications are based on GitHub’s November 10 disclosure. The table does not assign severity scores or claim that exploitation has been observed in the wild.

The vulnerabilities do not all have the same prerequisites or consequences. Some require a malicious repository, others require specially crafted patches or import streams, and certain cases particularly affect services processing untrusted content.

CVE-2026-111760: Code execution through recursive clones

This flaw involves an integer truncation during Git’s handling of unusually long index paths.

Git normally validates paths before writing files into a working tree, including protections against overwriting repository metadata. However, the truncation can create a mismatch between the name validated and the name ultimately written.

An attacker can exploit that discrepancy to replace a submodule’s .git file with a symbolic link pointing toward malicious configuration or hooks.

During a subsequent recursive clone operation, Git may use that attacker-controlled configuration and execute code.

The patch rejects extremely long index-entry paths before truncation can occur.

This is particularly relevant to automated systems that clone third-party repositories with submodules enabled.

Git Security Vulnerabilities in Reference Handling

CVE-2026-113408: Path traversal through advertised HEAD references

When cloning an empty repository using Git protocol v2, a server can advertise a symbolic HEAD reference pointing to an unborn branch.

An unborn branch is a branch reference that does not yet point to a commit.

Before the fix, Git did not adequately validate the advertised target before storing it locally.

A malicious server could supply a reference name containing path-traversal components. Under the files reference backend, a later branch update could then write outside the intended reference directory.

The patched release validates the advertised symbolic-reference target and strengthens validation for other reference names received through protocol v2.

The broader engineering issue is the trust boundary between a remote Git server and the local filesystem.

Repository metadata received from a remote endpoint should not be treated as a safe filesystem path without appropriate validation.

Memory Corruption in Git Merge Operations

Two of the disclosed vulnerabilities involve memory safety during merge-related processing.

CVE-2026-114467: Stack corruption when removing signatures

Git previously assumed that a message would contain no more than two GPG signatures when stripping signatures.

A specially crafted message containing additional signatures could cause Git to write beyond a fixed-size stack array.

According to GitHub, merging a tag with more than two signatures can trigger the flaw, potentially causing memory corruption or denial of service.

The fix removes the fixed-size limitation and handles messages with an arbitrary number of signatures.

This issue may also affect hosting services that perform merges on behalf of users.

CVE-2026-105437: Heap corruption during large merges

Git’s merge machinery calculates the memory needed to construct a merge result.

Under certain extreme conditions, including many conflicts combined with a large conflict-marker-size attribute, the size calculation can overflow.

That may cause Git to allocate a buffer smaller than the eventual output requires.

Writing the merge result into the undersized buffer can corrupt heap memory.

The patch introduces checked arithmetic and size-appropriate types, rejecting merge results that cannot be represented safely.

This flaw is especially relevant to automation or hosting infrastructure that merges content submitted by untrusted users.

Binary Patch and Import Vulnerabilities

CVE-2026-114469: Out-of-bounds reads in binary patches

Git rejects patches larger than approximately 1 GiB because its patch-processing implementation cannot safely handle larger inputs.

The vulnerable check considered the supplied patch size but not sufficiently the size of its decompressed content.

Because binary patches are compressed and encoded, a relatively small input can expand into a much larger representation.

A crafted patch could therefore bypass the initial size restriction and cause an out-of-bounds read, crashing Git.

The fix checks the declared uncompressed size before processing the patch.

This is a familiar class of input-validation problem: a compressed payload’s transport size is not necessarily a safe measure of the memory required to process it.

CVE-2026-114466: Unsafe filesystem access through fast-import

The git fast-import command processes streams of instructions used to construct repository history.

Some commands can access files outside the repository. Git already restricts certain unsafe features when they arrive through untrusted input streams.

However, three additional features lacked the same protection.

The rewrite-submodules-from and rewrite-submodules-to features could read arbitrary files, potentially exposing information through error messages.

The export-pack-edges option could create files or append to existing ones.

The patched Git release rejects these features when supplied through an input stream unless the caller explicitly enables --allow-unsafe-features.

Developers should enable that option only when they trust the program producing the import stream.

Which Git Versions Fix the November 2026 Vulnerabilities?

The Git project released fixes in Git 2.56.1 and several maintenance branches.

The recommended approach is to install Git 2.56.1 or the patched version appropriate to the maintenance series provided by the operating system or Git distributor.

On Linux, a distribution may backport security fixes without adopting the latest upstream version number. Administrators should therefore consult the distributor’s security advisory rather than rely only on a numerical comparison.

How to Check Your Installed Git Version

Open a terminal and run:

git --version

This reports the Git executable currently resolved through the shell’s environment.

However, the result does not necessarily identify every copy of Git installed on the machine.

Integrated development environments, desktop clients, CI runners and other applications may bundle separate Git binaries.

Why bundled Git installations matter

Updating the system Git package does not automatically patch every application that includes its own Git implementation or executable.

GitHub says it is coordinating patched releases of GitHub Desktop and the GitHub Copilot app.

GitHub also states that Codespaces and GitHub Actions will receive patched versions.

Organizations should confirm updates through the relevant product release channels rather than assume a system-level package update covers all developer tools.

GitHub Enterprise Server Security Updates

GitHub confirmed that its hosted GitHub.com and GitHub Enterprise Cloud environments, including Enterprise Cloud with data residency, have received fixes.

For GitHub Enterprise Server, the company identified these updated releases:

Administrators should prioritize upgrading supported installations, particularly those that accept contributions or repository content from users outside the organization’s trust boundary.

GitHub’s disclosure does not establish that every other Git-hosting service has already applied the fixes. Operators should verify their own deployment status.

Why These Git Security Vulnerabilities Matter for CI/CD

Modern CI/CD systems routinely clone repositories, fetch branches, apply patches, perform merges and process contributions.

These activities can expose Git to content controlled by external contributors.

A workflow that recursively clones an unfamiliar repository or processes an untrusted import stream creates a different risk profile from a developer working exclusively with internally maintained repositories.

The vulnerability disclosures reinforce the need to treat source-control operations as security-sensitive execution steps.

TechnologyHQ recently examined GitHub Actions workflow log secret scanning, which helps eligible organizations detect supported exposed credentials in CI/CD output.

The new Git vulnerabilities concern an earlier stage of the trust chain: what can happen while the repository itself is being fetched, parsed or transformed.

Both areas matter because a compromised workflow environment may expose credentials or affect later build and deployment steps.

Practical controls for automation

Security teams should inventory the Git versions used by self-hosted runners, build containers, repository mirrors and internal automation services.

They should also review whether workflows process untrusted repositories or patches with privileges beyond what the task requires.

Where possible, isolate untrusted repository processing from production credentials and sensitive files.

Restricting access reduces the potential consequences of a compromised process, although it does not remove the underlying vulnerability.

How This Differs From GitHub’s Recent SSH Security Changes

The November Git security release should not be confused with GitHub’s earlier SSH compatibility changes.

TechnologyHQ’s GitHub SSH security changes guide explains changes to legacy cryptographic algorithms used when establishing SSH connections.

Those changes concern authentication and key-exchange compatibility.

The six newly disclosed Git vulnerabilities concern repository parsing, metadata validation, merges, binary patches and import processing.

A modern SSH configuration does not protect a vulnerable Git implementation from malicious repository data after a connection is established.

Both updates may require developer action, but they address different technical risks.

What Developers and Administrators Should Do Now

The highest-priority action is to install a patched Git release or a vendor-supported package containing the security fixes.

After updating, organizations should verify the versions used by automated workflows and applications that bundle Git.

For systems that cannot be patched immediately, GitHub recommends limiting exposure to untrusted repositories, avoiding recursive clones from unfamiliar sources and refraining from processing untrusted merges, tags, binary patches or fast-import streams.

These measures are temporary risk reductions, not substitutes for installing the fixes.

A practical Git security checklist

• Update Git to a patched release or a distributor-confirmed security backport.

• Check developer workstations, build agents, self-hosted runners and repository services.

• Identify applications that bundle their own Git binaries.

• Upgrade affected GitHub Enterprise Server installations.

• Restrict untrusted recursive clones and repository-processing jobs until patched.

• Test critical development workflows after the update.

The final step matters because Git is foundational infrastructure. Organizations should verify that automated builds, repository integrations and developer tooling continue to work after upgrading.

Frequently Asked Questions

What are the latest Git security vulnerabilities?

On November 10, 2026, the Git project released fixes for six CVEs involving recursive clones, references, merges, binary patches and fast-import streams.

Can a malicious Git repository execute code?

CVE-2026-111760 can lead to code execution during recursive cloning of a specially crafted malicious repository under the conditions described in the advisory.

Which Git version should I install?

Git 2.56.1 contains the fixes. Patched maintenance releases are also available for several earlier version series.

Does updating GitHub Desktop automatically update system Git?

Not necessarily. Applications can bundle their own Git executables, while the operating system may maintain a separate installation.

Has GitHub patched its hosted services?

GitHub states that it deployed fixes across GitHub.com, GitHub Enterprise Cloud and Enterprise Cloud with data residency.

Should I stop using Git until I update?

The disclosure does not require developers to stop using Git entirely. However, unpatched systems should avoid the risky untrusted operations identified in the advisory until fixes can be installed.

The Bottom Line

The November 2026 Git security vulnerabilities demonstrate that source-control tooling remains a critical part of application security.

The six flaws affect different operations, but they share a common lesson: repository content, metadata and import streams must be handled as potentially untrusted input.

For individual developers, updating Git is the immediate priority.

For engineering organizations, the task is broader. Security teams must account for Git installations embedded in build infrastructure, developer applications and repository-hosting services.

Keeping those components patched is essential to protecting the software development pipeline.

Ingrid Maldine

Ingrid Maldine is a business writer, editor and management consultant with extensive experience writing and consulting for both start-ups and long established companies. She has ten years management and leadership experience gained at BSkyB in London and Viva Travel Guides in Quito, Ecuador, giving her a depth of insight into innovation in international business. With an MBA from the University of Hull and many years of experience running her own business consultancy, Ingrid’s background allows her to connect with a diverse range of clients, including cutting edge technology and web-based start-ups but also multinationals in need of assistance. Ingrid has played a defining role in shaping organizational strategy for a wide range of different organizations, including for-profit, NGOs and charities. Ingrid has also served on the Board of Directors for the South American Explorers Club in Quito, Ecuador.