Alta

GitPython: parse_actor_and_date() es vulnerable a retroceso cuadrático en líneas de identidad con formato incorrecto

  • Publicada: 27.10.2026
  • Actualizado: 01.11.2026 10:00

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:

python
_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

python
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:

python
_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.
  • ' '*n a 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
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.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) gitpython < 3.2.0 3.2.0

Referencias

Puntuación CVSS -
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.

Todas (43) en el archivo
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

  1. 2022: 1
  2. 2023: 3
  3. 2024: 1
  4. 2025: 0
  5. 2026: 38
Gravedad:
  1. GitPython: parse_actor_and_date() es vulnerable a retroceso cuadrático en líneas de identidad con formato incorrecto esta entrada
    Alta CVE-2026-110856 < 3.2.0 3.2.0
  2. Alta · 8.8 CVE-2026-42215 >= 3.1.30, < 3.1.47 3.1.47

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.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.