GitPython: parse_actor_and_date() es vulnerable a retroceso cuadrático en líneas de identidad con formato incorrecto
Resumen
Este problema es un residuo de GHSA-g5vv-9gxw-82hx / CVE-2026-87819. La corrección de 3.1.60 eliminó el uso de expresiones regulares en Actor._from_string, pero parse_actor_and_date continúa ejecutando _re_actor_epoch en la misma línea de autor/committer/tagger un paso antes. Dicho patrón experimenta retroceso cuadrático (quadratic backtracking) cuando falta la época (epoch) o la zona horaria final, o si estas presentan un formato incorrecto, por lo que la misma clase de análisis lento aún es accesible en 3.1.62.
Detalles
git/objects/util.py:322:
_re_actor_epoch = re.compile(r"^.+? (.*) (\d+) ([+-]\d+).*$")
Tanto .+? como (.*) pueden absorber la misma secuencia de espacios, y el final obligatorio (\d+) ([+-]\d+) solo se comprueba después de ellos. En una línea larga que no contenga un final válido, la búsqueda reintenta cada punto de división.
Se invoca desde parse_actor_and_date (git/objects/util.py:335), el cual se ejecuta en las líneas de autor y committer en Commit._deserialize (git/objects/commit.py:917, :931) y en la línea de tagger en git/objects/tag.py:129.
La carga útil publicada (letras junto con un < sin terminar) es rápida en 3.1.62. Reemplazar las letras con espacios no lo es:
línea de autor (tras author ) |
2 KB | 8 KB | 32 KB |
|---|---|---|---|
'a'*n + ' <' (carga útil del aviso) |
0.0 ms | 0.1 ms | 0.4 ms |
' '*n |
28 ms | 453 ms | 7,700 ms |
| línea válida, nombre largo (control) | 0.0 ms | 0.0 ms | 0.0 ms |
El coste computacional aumenta aproximadamente un 16x por cada incremento de 4x en longitud.
PoC
import time
from git.objects.util import parse_actor_and_date
line = "author " + " " * 32000
t = time.perf_counter()
parse_actor_and_date(line)
print(f"{time.perf_counter() - t:.1f} s") # ~7 s on 3.1.62
De extremo a extremo, leer Commit.author en un objeto commit cuya línea de autor contiene 32 KB de espacios seguidos de cualquier terminación malformada (sin época, sin zona horaria, época no numérica o zona horaria inválida) requiere aproximadamente 7.2 s por acceso. La misma línea con una terminación válida de 1191999972 -0700 toma 1.3 ms.
Nota de reproducción: git hash-object -t commit -w rechaza dicho objeto (missingEmail), por lo que el objeto de prueba fue generado con --literally. Un repositorio remoto aún puede entregarlo debido a que fetch.fsckObjects y transfer.fsckObjects están establecidos por defecto en false. Este es el mismo modelo de entrega que CVE-2026-87819 ("craft a commit object with a malformed author field").
Impacto
Agotamiento de CPU (CWE-1333) en cualquier aplicación que use GitPython para leer commits o etiquetas de repositorios no confiables: herramientas de CI, analizadores de repositorios e integraciones de alojamiento de código. Cada acceso a Commit.author, Commit.committer o TagObject.tagger en un objeto manipulado requiere varios segundos, y un repositorio puede albergar muchos objetos de este tipo.
Corrección sugerida
Coincidir el nombre de campo inicial usando .[^ ]* en lugar de .+?. Ambos se detienen en el primer espacio tras el primer carácter, pero .[^ ]* no puede superponerse con el siguiente (.*), eliminando el retroceso:
_re_actor_epoch = re.compile(r"^.[^ ]* (.*) (\d+) ([+-]\d+).*$")
_re_only_actor = re.compile(r"^.[^ ]* (.*)$")
Verificación en la rama main actual (73a72c9):
- Diferencial sobre 368 líneas de actor (patrones reales más casos límite): 0 diferencias en los grupos de coincidencia para cualquiera de las expresiones regulares.
' '*na 64 KB: 32,170 ms antes, 0.98 ms después. Las líneas válidas no presentan cambios (0.01 ms).- La suite de pruebas existente mantiene el mismo conjunto de resultados (éxitos/fallos) con y sin el cambio.
- La nueva prueba de regresión,
test_parse_actor_and_date_malformed_line_is_linear, falla con el patrón anterior (8.4 s) y pasa exitosamente con la corrección (0.5 s).
El parche completo (corrección más prueba de regresión) se adjunta a continuación.
diff --git a/git/objects/util.py b/git/objects/util.py
index a68d701f..d8c0594d 100644
--- a/git/objects/util.py
+++ b/git/objects/util.py
@@ -319,8 +319,11 @@ def parse_date(string_date: Union[str, datetime]) -> Tuple[int, int]:
# Precompiled regexes
-_re_actor_epoch = re.compile(r"^.+? (.*) (\d+) ([+-]\d+).*$")
-_re_only_actor = re.compile(r"^.+? (.*)$")
+# The leading field name ("author", "committer", "tagger") is matched with ``.[^ ]*`` rather than
+# ``.+?``: both stop at the first space after the first character, but ``.[^ ]*`` cannot overlap the
+# following ``(.*)``, so a line with no valid trailing epoch/offset no longer backtracks quadratically.
+_re_actor_epoch = re.compile(r"^.[^ ]* (.*) (\d+) ([+-]\d+).*$")
+_re_only_actor = re.compile(r"^.[^ ]* (.*)$")
def parse_actor_and_date(line: str) -> Tuple[Actor, int, int]:
diff --git a/test/test_util.py b/test/test_util.py
index cf4299d5..e1631420 100644
--- a/test/test_util.py
+++ b/test/test_util.py
@@ -22,6 +22,7 @@ from git.cmd import dashify
from git.objects.util import (
altz_to_utctz_str,
from_timestamp,
+ parse_actor_and_date,
parse_date,
tzoffset,
utctz_to_altz,
@@ -571,6 +572,30 @@ class TestUtils(TestBase):
Actor("name last another", "some-very-long-email@example.com"),
)
+ def test_parse_actor_and_date_malformed_line_is_linear(self):
+ # A long author line whose trailing epoch/offset is missing or malformed used to make
+ # _re_actor_epoch backtrack quadratically: ~7 s per Commit.author access for a 32 KB line.
+ # The parse result must be unchanged; only the time spent reaching it should move.
+ for tail in ("", " notanumber -0700", " 1191999972", " -0700", " 1191999972 xx"):
+ line = "author " + " " * 32000 + tail
+ start = time.perf_counter()
+ actor, epoch, offset = parse_actor_and_date(line)
+ self.assertLess(time.perf_counter() - start, 1.0)
+ self.assertEqual(epoch, 0)
+ self.assertEqual(offset, 0)
+
+ # Well-formed lines, including one with a long name, still parse exactly as before.
+ actor, epoch, offset = parse_actor_and_date(
+ "author Tom Preston-Werner <tom@mojombo.com> 1191999972 -0700"
+ )
+ self.assertEqual(actor, Actor("Tom Preston-Werner", "tom@mojombo.com"))
+ self.assertEqual(epoch, 1191999972)
+ self.assertEqual(offset, 25200)
+
+ actor, epoch, offset = parse_actor_and_date("author " + "a " * 16000 + "<a@b> 1 -0700")
+ self.assertEqual(actor.email, "a@b")
+ self.assertEqual(epoch, 1)
+
@ddt.data(
("name", ""),
("name", "prefix_"),
Identificado con asistencia de IA (Claude) y verificado manualmente.
Brian Willows
Qué hacer
Actualice GitPython a la versión 3.2.0 o posterior.
Software afectado
Haz clic en una tecnología para ver todas sus vulnerabilidades.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | gitpython | < 3.2.0 | 3.2.0 |
Referencias
- https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-m64x-33q8-m5h7
- https://github.com/gitpython-developers/GitPython/pull/2253
- https://github.com/gitpython-developers/GitPython/commit/8290c98d35465a38090cdcc1b17be69967092a15
- https://github.com/gitpython-developers/GitPython
- https://github.com/gitpython-developers/GitPython/releases/tag/3.2.0
- Vector CVSS
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N- Debilidad (CWE)
CWE-1333- Plataforma
- Python (PyPI)
- Paquete
gitpython- Publicada
- 27.10.2026
- Actualizado
- 01.11.2026 10:00
Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.
OSV / GitHub Advisory Database - GHSA-m64x-33q8-m5h7 - CC BY 4.0
Historial de vulnerabilidades: gitpython
Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.
- Entradas en total
- 43
- Primera → última
- 12.2022 10.2026
- Sin corrección
- 0
- Explotada en ataques
- 0
Distribución por gravedad
- Crítica 3
- Alta 30
- Media 10
Divulgaciones por año
- 2022: 1
- 2023: 3
- 2024: 1
- 2025: 0
- 2026: 38
-
GitPython: parse_actor_and_date() es vulnerable a retroceso cuadrático en líneas de identidad con formato incorrecto esta entrada
Identifica las vulnerabilidades de tu aplicación
Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.