On November 10, 2026, the Git project disclosed a high-severity vulnerability, CVE-2026-111760 (CVSS 8.0), that could allow attackers to execute arbitrary commands on a victim's machine through a specially crafted Git repository.
Git is a fundamental component of modern software development, widely used by developers, enterprises, and automated build environments. A vulnerability that could turn a routine repository operation into arbitrary code execution raises significant security concerns, particularly for development environments and software supply chains.
At the beginning of OPSWAT Unit 515's investigation, public technical information was limited. The vulnerability was documented in GitHub's Security Advisory (GHSA-vp2w-7xxj-jvxr), while detailed vulnerability records were not yet available to the team through the CVE Program or National Vulnerability Database (NVD).


OPSWAT Unit 515 independently investigated the vulnerability, analyzed its underlying cause, and successfully reproduced remote code execution through a working Proof of Concept (PoC). The team also verified the effectiveness of the vendor's security patch by testing against both vulnerable and patched Git versions.
This article provides a high-level technical analysis of CVE-2026-111760, presents our PoC validation results, and discusses its security implications and recommended mitigations.
Understanding CVE-2026-111760
CVE-2026-111760 is an integer truncation vulnerability in Git's handling of file path lengths during repository checkout operations. Under specific conditions, the vulnerability can allow a malicious repository to execute arbitrary commands on the system processing it.
Git normally validates file paths before writing them to the local filesystem, including checks designed to prevent repository contents from overwriting protected Git metadata. However, this vulnerability introduces an inconsistency between how Git validates a file path and how that path is subsequently written.
The root cause lies in Git's index handling, where file path lengths are calculated using a 64-bit value but stored in a 32-bit field (ce_namelen). When processing an exceptionally long path exceeding the 32-bit limit, the stored length can be truncated, causing Git to validate the original path while writing to a different, shorter location.
An attacker can exploit this inconsistency to overwrite the .git file used by a submodule or linked worktree, redirecting Git to an attacker-controlled directory containing malicious repository configuration. Subsequent Git operations may then execute attacker-controlled commands.
The vulnerability demonstrates how an integer truncation in a widely used development tool can bypass filesystem protections and lead to arbitrary code execution.
Attack Scenario
An attacker can prepare a specially crafted Git repository containing manipulated file paths and submodule references. When a victim clones the repository with recursive submodules enabled using a vulnerable Git version, the attack can lead to arbitrary code execution.
In the recursive clone scenario validated by OPSWAT Unit 515, the attack follows four stages:
- Malicious repository preparation: The attacker prepares a repository containing an exceptionally long file path, a malicious Git configuration directory, and a submodule referencing a specially crafted repository.
- Recursive repository cloning: A victim clones the attacker-controlled repository using “git clone --recurse-submodules”, triggering the vulnerable path-handling behavior during submodule checkout.
- Git metadata manipulation: Due to integer truncation, Git overwrites the submodule's .git file with an attacker-controlled gitfile that redirects repository metadata to a malicious directory.
- Arbitrary code execution: During recursive submodule initialization, Git processes the redirected repository configuration. An attacker-controlled core.fsmonitor setting is then executed with the privileges of the victim.

Proof of Concept: Reproducing CVE-2026-111760
OPSWAT Unit 515 successfully developed and validated a Proof of Concept (PoC) demonstrating remote code execution through a malicious Git repository in a controlled testing environment.
Testing against Git 2.56.0 confirmed that cloning the crafted repository with recursive submodules enabled could overwrite the submodule's .git file and execute an attacker-controlled command through malicious Git configuration, without requiring the victim to manually execute any repository scripts.
Mitigation and Recommendations
The Git project released security updates addressing CVE-2026-111760 on November 10, 2026. The patch introduces additional path-length validation to prevent integer truncation from bypassing Git's security checks.
To mitigate the risk, organizations should consider the following measures:
- Update Git: Upgrade to the latest available patched Git version. For organizations maintaining older release branches, the vulnerability is also addressed in Git 2.56.1, 2.55.1, 2.54.1, 2.53.1, 2.52.1, 2.51.3, and 2.50.2. Ensure that Git installations across development environments, CI/CD pipelines, and automated build systems are updated.
- Exercise caution with untrusted repositories: Avoid recursively cloning repositories from untrusted sources and exercise caution when checking out untrusted branches in linked worktrees. These precautions do not replace the need for security updates.
- Maintain software visibility with SBOM: Use Software Bill of Materials (SBOM) to track software components and identify potentially vulnerable dependencies. OPSWAT MetaDefender can support software composition visibility and vulnerability management efforts.
- Leverage threat intelligence: Use OPSWAT MetaDefender Threat Intelligence to stay informed about emerging threats, investigate potential indicators of compromise, and support security response activities.
Conclusion
CVE-2026-111760 highlights how vulnerabilities in widely used development tools can introduce security risks across software development and supply chain workflows. Under specific conditions, a routine Git operation can become an entry point for arbitrary code execution.
OPSWAT Unit 515's independent analysis, successful exploitation, and patch validation demonstrate the practical security implications of this vulnerability. Organizations should prioritize security updates, maintain visibility into their development environments, and exercise caution when processing untrusted repositories.
