llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · gitpython

GHSA-83VG-56QC-22M7

GitPython validates a submodule's ".git" path only after cloning into it (RCE)

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -8 d de la divulgación
Exposición28 dDesde la divulgación, 22 oct 2026, 11:41 a. m.
Detección25 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 3.2.1
Monitoreo
Detectada
14 oct 26
22 oct 26
17 nov 26
20 nov 26
14 oct 26
23 oct 26
1 nov 26
10 nov 26
20 nov 26
FechaFaseEventoDetalle
Remediación Parche 3.2.1 gitpython · -8 d desde divulgación
Divulgación Publicada GHSA-83VG-56QC-22M7 divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

`create_submodule(name, path, url)` clones a submodule into the repo's own `.git`
directory before it rejects the path. A `path` of ".git/hooks" is accepted by the
pre-clone check, so the submodule is cloned straight into the live hooks directory,
and a file named `post-checkout` in the submodule becomes an executable
`.git/hooks/post-checkout`. On 3.2.0+ the later index check does raise `ValueError`,
but only after the clone already wrote to disk, and it does not remove the planted
hook; on 3.1.x there is no such check and the call succeeds silently. Either way the
hook runs on the next git operation (e.g. checkout), giving code execution.

Details

The checkout path is validated too late, after the clone has already mutated disk.
This breaks the "validate before mutation" invariant that commit 43a43cd8 ("Validate
submodule checkout and metadata paths before mutation") set out to enforce.

Submodule.add() calls the permissive path check before cloning, and the strict check
only reaches the ".git" alias at index time, after _clone_repo has written to disk:

git/objects/submodule/base.py (Submodule.add)
599: path = cls._to_relative_path(repo, path) # accepts ".git/hooks"
673: mrepo = cls._clone_repo(repo, url, path, name, ...) # clones into <worktree>/.git/hooks
714: index.add([sm], write=True) # strict check only triggers here

git/index/base.py (IndexFile._preprocess_add_items)
732: _validate_repo_path(entry.path) # rejects ".git", too late

_to_relative_path only blocks `..`/absolute/out-of-tree paths; `.git` aliases are
rejected only by _validate_repo_path, which was added in 3.2.0 (commit a75aedf3) and
runs at the index boundary. The ValueError it raises at line 732 does not roll back
what _clone_repo already wrote.

Version-dependent behavior:
- 3.2.0 .. tip bda18e08: _validate_repo_path raises ValueError at index.add, but the
hook is already on disk and is not removed (incorrect order of validation vs. clone).
- 3.1.x (e.g. 3.1.59): _validate_repo_path does not exist and _to_relative_path does
not reject `.git`; create_submodule(path=".git/hooks", ...) returns with no error at
all and the hook is planted silently.

Proof of concept

Setup:
evilsub/ : a git repo whose ROOT contains an executable file named post-checkout (the payload)
victim/ : a git repo with at least 1 commit and a second branch, whose .git/hooks has NO
sample hooks (the state of a minimal/CI checkout, or `git init` with an empty
template dir, or GIT_TEMPLATE_DIR/init.templateDir empty)

import git, os.path as osp
try:
git.Repo("victim").create_submodule(name="x", path=".git/hooks", url=osp.abspath("evilsub"))
except ValueError:
pass # 3.2.0+: ".git" is rejected, but only AFTER the clone, so the plant already happened.
# 3.1.x: no exception is raised at all; the call succeeds and still plants the hook.

#### victim/.git/hooks/post-checkout now exists, mode 0755, attacker-controlled, on every
#### affected version. Any later checkout runs it:
#### git -C victim checkout <other-branch> -> the hook runs -> code execution

Verified live:
- tip bda18e08 (3.2.0 + 3 commits): create_submodule raised ValueError from
git/index/base.py:732, yet .git/hooks/post-checkout was present and executable, and
`git checkout` executed it.
- 3.1.59: create_submodule returned with no error; .git/hooks/post-checkout was planted
and executed by `git checkout`.

Impact

Arbitrary code execution. A library/app that creates a submodule from an
attacker-influenced `path` ends up with an attacker-controlled executable in
`.git/hooks`, which git runs on ordinary later operations. This affects any service
that derives a submodule checkout path from untrusted data, e.g. one that ingests a
submodule spec (name/path/url) from a user-supplied manifest or API request and feeds
`path` into create_submodule. On 3.2.0+ the library's own validation is the thing that
fails: it correctly rejects the `.git` path, but only after the submodule has already
been cloned into place, so an app that traps the ValueError reasonably believes the
unsafe path was blocked.

Preconditions (hence AC:H): (1) the app passes an attacker-influenced submodule `path`;
(2) the target hook name is free in `.git/hooks`, true for minimal/CI/container
checkouts and whenever init.templateDir/GIT_TEMPLATE_DIR is empty. With the default
sample hooks present, `git clone` refuses the non-empty destination and no plant occurs.

Affected: all tested versions from 3.1.x (3.1.59) through the current tip bda18e08
(3.2.0 + 3 commits). 3.1.x plants silently; 3.2.0+ plants despite raising ValueError.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
gitpython< 3.2.1
3.2.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypigitpython
Corregida 3.2.1 -8 d 3.2.1 no afectada
Versiones corregidas3.2.1
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://nvd.nist.gov/vuln/detail/CVE-2026-114145
Otrahttps://github.com/gitpython-developers/GitPython/security/advisories/GHSA-83vg-56qc-22m7
Otrahttps://github.com/gitpython-developers/GitPython/pull/2264
Otrahttps://github.com/gitpython-developers/GitPython/commit/97eadb888d2f99567e3113f4e455be4ca128f697
Otrahttps://github.com/gitpython-developers/GitPython
Otrahttps://github.com/gitpython-developers/GitPython/releases/tag/3.2.1

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.