GitPython: parse_actor_and_date() podatne na kwadratowy backtracking przy nieprawidłowo sformatowanych liniach tożsamości
Podsumowanie
Problem ten stanowi pozostałość po GHSA-g5vv-9gxw-82hx / CVE-2026-87819. Poprawka w 3.1.60 wyeliminowała wyrażenia regularne z Actor._from_string, lecz parse_actor_and_date krok wcześniej nadal przetwarza tę samą linię autora/commitera/taggera za pomocą _re_actor_epoch. Wzorzec ten wykazuje kwadratowy backtracking w przypadku brakującej lub nieprawidłowo sformatowanej końcowej wartości epoki bądź strefy czasowej, w związku z czym ta sama klasa powolnego parsowania jest nadal osiągalna w 3.1.62.
Szczegóły
git/objects/util.py:322:
_re_actor_epoch = re.compile(r"^.+? (.*) (\d+) ([+-]\d+).*$")
Zarówno .+?, jak i (.*) mogą dopasować ten sam ciąg spacji, a wymagana końcówka (\d+) ([+-]\d+) jest sprawdzana dopiero po nich. W przypadku długiej linii bez prawidłowej końcówki algorytm wyszukiwania ponawia próbę w każdym punkcie podziału.
Wywołanie następuje z poziomu parse_actor_and_date (git/objects/util.py:335), które przetwarza linie autora i commitera w Commit._deserialize (git/objects/commit.py:917, :931) oraz linię taggera w git/objects/tag.py:129.
Opublikowany ładunek (litery wraz z niezamkniętym <) wykonuje się szybko w 3.1.62. Zastąpienie liter spacjami prowadzi jednak do znacznego spowolnienia:
Linia autora (po author ) |
2 KB | 8 KB | 32 KB |
|---|---|---|---|
'a'*n + ' <' (ładunek z biuletynu) |
0.0 ms | 0.1 ms | 0.4 ms |
' '*n |
28 ms | 453 ms | 7,700 ms |
| Prawidłowa linia, długa nazwa (kontrola) | 0.0 ms | 0.0 ms | 0.0 ms |
Koszt obliczeniowy rośnie o około 16x przy każdym zwiększeniu długości o 4x.
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
Odczytanie Commit.author w obiekcie commita, którego linia autora zawiera 32 KB spacji oraz nieprawidłową końcówkę (brak epoki, brak strefy czasowej, nienumeryczna epoka lub błędna strefa czasowa), zajmuje około 7.2 s na pojedynczy dostęp. Ta sama linia z prawidłową końcówką 1191999972 -0700 wymaga 1.3 ms.
Uwaga dotycząca reprodukcji: git hash-object -t commit -w odrzuca taki obiekt (missingEmail), w związku z czym obiekt testowy utworzono przy użyciu --literally. Zdalne repozytorium może go jednak udostępnić, ponieważ opcje fetch.fsckObjects oraz transfer.fsckObjects mają domyślnie wartość false. Odpowiada to modelowi dostarczenia opisanemu w CVE-2026-87819 („craft a commit object with a malformed author field”).
Wpływ
Wyczerpanie zasobów procesora (CWE-1333) w aplikacjach używających GitPython do odczytu commitów lub tagów z niezaufanych repozytoriów (narzędzia CI, skanery repozytoriów, integracje platform hostingu kodu). Każdy dostęp do Commit.author, Commit.committer lub TagObject.tagger na spreparowanym obiekcie trwa kilka sekund, a repozytorium może zawierać wiele takich obiektów.
Sugerowana poprawka
Dopasowanie początkowej nazwy pola za pomocą .[^ ]* zamiast .+?. Obydwa wzorce zatrzymują się na pierwszej spacji po pierwszym znaku, ale .[^ ]* nie nakłada się na kolejny element (.*), co eliminuje problem backtrackingu:
_re_actor_epoch = re.compile(r"^.[^ ]* (.*) (\d+) ([+-]\d+).*$")
_re_only_actor = re.compile(r"^.[^ ]* (.*)$")
Weryfikacja na aktualnej gałęzi main (73a72c9):
- Test różnicowy na 368 liniach aktorów (rzeczywiste formaty oraz przypadki brzegowe): 0 różnic w grupach dopasowań dla obu wyrażeń regularnych.
' '*nprzy 64 KB: 32,170 ms przed zmianą, 0.98 ms po zmianie. Prawidłowe linie nie uległy zmianie (0.01 ms).- Dotychczasowy zestaw testów zwraca identyczne wyniki zaliczeń/błędów ze zmianą i bez niej.
- Nowy test regresyjny
test_parse_actor_and_date_malformed_line_is_linearkończy się niepowodzeniem przy starym wzorcu (8.4 s) i sukcesem po zastosowaniu poprawki (0.5 s).
Pełny patch (poprawka wraz z testem regresyjnym) znajduje się poniżej:
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_"),
Wykryto przy wsparciu AI (Claude) i zweryfikowano ręcznie.
Brian Willows
Co trzeba zrobić
Zaktualizuj GitPython do wersji 3.2.0 lub nowszej.
Czego dotyczy
Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | gitpython | < 3.2.0 | 3.2.0 |
Odnośniki
- 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
- Wektor 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- Słabość (CWE)
CWE-1333- Platforma
- Python (PyPI)
- Paczka
gitpython- Ujawniono
- 27.10.2026
- Aktualizacja
- 01.11.2026 10:00
Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.
OSV / GitHub Advisory Database - GHSA-m64x-33q8-m5h7 - CC BY 4.0
Historia podatności: gitpython
Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.
- Wszystkich wpisów
- 43
- Pierwsza → ostatnia
- 12.2022 10.2026
- Bez poprawki
- 0
- Wykorzystywana w atakach
- 0
Rozkład istotności
- Krytyczna 3
- Wysoka 30
- Średnia 10
Ujawnienia w latach
- 2022: 1
- 2023: 3
- 2024: 1
- 2025: 0
- 2026: 38
-
GitPython: parse_actor_and_date() podatne na kwadratowy backtracking przy nieprawidłowo sformatowanych liniach tożsamości ten wpis
Dowiedz się, które podatności dotyczą Twojej aplikacji
Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.