CVE-2026-76218: GitPython RCE Vulnerability via Repo.init

CVE-2026-76218 Overview

CVE-2026-76218 is a remote code execution vulnerability in GitPython versions before 3.1.58. The flaw exists in the Repo.init method, which forwards unsafe git options to the underlying git binary without validation. Attackers can supply a template parameter pointing to a directory containing malicious git hooks. When subsequent git operations run on the initialized repository, the hooks execute arbitrary code in the context of the application. The vulnerability is tracked under CWE-88: Argument Injection and affects any Python application that exposes Repo.init parameters to untrusted input.

Critical Impact
Attackers who control the template argument passed to Repo.init can achieve arbitrary code execution on the host running GitPython through malicious git hook files.

Affected Products

GitPython versions before 3.1.58
Python applications that pass user-controlled input to Repo.init
Automation pipelines and web services that expose GitPython repository initialization

Discovery Timeline

2026-08-19 - CVE-2026-76218 published to NVD
2026-08-20 - Last updated in NVD database

Technical Details for CVE-2026-76218

Vulnerability Analysis

GitPython is a Python library that wraps the git command-line tool. The Repo.init class method initializes a new repository by invoking git init under the hood. In versions before 3.1.58, the method forwards caller-supplied options directly to the git binary without sanitizing values that git treats as executable configuration.

One such option is --template=<dir>, which instructs git to copy files from a template directory into the new repository's .git folder. Files inside .git/hooks are executed automatically when git performs operations such as commit, push, or merge. An attacker who controls the template path can place a malicious executable at hooks/post-commit or hooks/pre-commit and trigger execution on the next git operation.

Root Cause

The root cause is argument injection [CWE-88] in Repo.init. GitPython accepts arbitrary keyword arguments and translates them into git command-line flags without a safe-list of allowed options. This design assumes callers pass only trusted values, but many downstream applications forward HTTP parameters or configuration values directly into the call.

Attack Vector

The attack requires an application that exposes Repo.init parameters to an external actor and a filesystem location the attacker can write to or reference. A typical exploitation flow begins with an attacker staging a directory that contains a hooks/ subfolder with an executable script. The attacker then triggers the vulnerable application to call Repo.init with a template value pointing at that directory. When the application or a downstream process runs any git operation on the new repository, git invokes the planted hook script, executing attacker-controlled code with the privileges of the GitPython process. Refer to the GitHub Security Advisory and the VulnCheck Security Advisory for advisory details.

Detection Methods for CVE-2026-76218

Indicators of Compromise

Unexpected executable files inside .git/hooks/ directories, particularly post-commit, pre-commit, post-checkout, or post-merge
Git repositories initialized with a template path referencing writable or user-controlled directories
Child processes spawned by Python interpreters that invoke shells or reverse-shell tooling shortly after a git init operation

Detection Strategies

Audit application source code and dependencies for calls to git.Repo.init where any keyword argument originates from untrusted input
Inspect installed GitPython versions across the environment and flag any release earlier than 3.1.58
Correlate process telemetry to detect git subprocesses launching interpreters such as bash, sh, python, or powershell from within a .git/hooks/ path

Monitoring Recommendations

Log all invocations of git init with their full argument list on build servers, CI runners, and application hosts
Monitor filesystem writes to any path ending in .git/hooks/ outside of expected developer workflows
Alert on outbound network connections initiated by short-lived shell processes that are children of git operations

How to Mitigate CVE-2026-76218

Immediate Actions Required

Upgrade GitPython to version 3.1.58 or later across all Python environments, containers, and CI pipelines
Review application code paths that call Repo.init and remove any propagation of untrusted parameters into the template argument or other git options
Rotate credentials accessible from any host where GitPython ran with untrusted Repo.init input

Patch Information

The GitPython maintainers addressed the issue in release 3.1.58 by validating options passed to Repo.init. Details are published in the GitHub Security Advisory GHSA-9rj7-rf2p-w77r. Update via pip install --upgrade GitPython and rebuild any container images that pin an earlier version.

Workarounds

Enforce a hard-coded allow-list of arguments before passing values to Repo.init rather than forwarding user input
Run GitPython workloads under a dedicated low-privilege account with no write access to shared secrets or code repositories
Configure git with core.hooksPath set to a controlled directory owned by root to prevent repository-local hooks from executing

bash

# Configuration example: pin the patched GitPython version and enforce a global hooks path
pip install 'GitPython>=3.1.58'
git config --system core.hooksPath /etc/git/hooks-approved