Hochghsa:GHSA-23mf-xhv8-69c2

    GitPython: Exposure of Sensitive Information to an Unauthorized Actor (ghsa:GHSA-23mf-xhv8-69c2)

    Veröffentlicht Quellen: Hersteller

    Teilen

    Was ist betroffen, was ist zu tun

    Aktualisieren Sie GitPython auf Version 3.2.0.

    Unklar, ob und wie Sie betroffen sind? Frage zu dieser Schwachstelle stellen

    Metriken

    —

    XIEM Effective CVSS

    Für diese Schwachstelle liegt kein Wert vor.

    —

    CVSS v3

    Für diese Schwachstelle liegt kein Wert vor.

    —

    EPSS-Score

    Für diese Schwachstelle liegt kein Wert vor.

    Alle Metriken anzeigen
    Schweregrad
    Hoch
    Priorität (0–325)

    Der Priorisierungs-Score ist eine zusammengeführte Kennzahl, die mehrere Einzelsignale zu einer einzigen, handlungsleitenden Rangfolge verdichtet: technische Schwere (CVSS), Ausnutzungswahrscheinlichkeit (EPSS), der Status als bekannt ausgenutzt (KEV) und der Kontext des betroffenen Assets. Ziel ist die Antwort auf die einzig wirklich wichtige Frage im Schwachstellenmanagement: Was zuerst?

    Im Glossar lesen
    30.00 Methodik
    Exploit-Reife

    Ein Exploit ist Code oder eine Technik, die eine konkrete Schwachstelle gezielt ausnutzt, um ein unbeabsichtigtes Verhalten zu erzwingen — etwa Code auszuführen oder Rechte auszuweiten. Er ist das Werkzeug, das aus einer theoretischen Lücke einen praktischen Angriff macht.

    Im Glossar lesen
    kein öffentlicher PoC bekannt
    KEV-Status

    Der KEV-Katalog ist eine von der US-Behörde CISA gepflegte Liste von Schwachstellen, für die eine aktive Ausnutzung in der Praxis nachgewiesen ist. Er beantwortet nicht die Frage „wie schwer?“, sondern „wird es bereits angegriffen?“ — und priorisiert damit das Patchen scharf.

    Im Glossar lesen
    —
    Veröffentlicht
    CWE

    CWE ist ein Katalog typischer Schwächen-Arten in Software und Hardware — etwa fehlerhafte Eingabevalidierung, unsichere Speicherbehandlung oder mangelhafte Authentisierung. Während eine CVE eine konkrete Schwachstelle in einem konkreten Produkt benennt, beschreibt eine CWE die zugrunde liegende Fehlerklasse.

    Im Glossar lesen
    CWE-200, CWE-73, CWE-88

    Einordnung nach NIS2 und CRA

    Regelbasierte Einordnung aus Ausnutzungsstatus und Schweregrad. Sie ersetzt keine Prüfung im Einzelfall.

    NIS2

    NIS2 ist die EU-Richtlinie (EU) 2022/2555 zur Erhöhung des Cybersicherheitsniveaus in der Union. Sie weitet Pflichten gegenüber der ersten NIS-Richtlinie deutlich aus: mehr Sektoren, verbindliches Risikomanagement, gestufte Meldepflichten und persönliche Verantwortung der Geschäftsleitung.

    Im Glossar lesen
    Hohe technische Schwere: Bewerten und beheben Sie die Schwachstelle im Schwachstellenmanagement nach Art. 21 Abs. 2 lit. e NIS2 und dokumentieren Sie die Entscheidung.
    CRA

    Der CRA ist die EU-Verordnung (EU) 2024/2847 mit horizontalen Cybersicherheitsanforderungen an „Produkte mit digitalen Elementen“ — von Industriesteuerungen über Software bis zu vernetzten Verbrauchergeräten. Erstmals müssen Hersteller Sicherheit über den gesamten Produktlebenszyklus gewährleisten, Schwachstellen behandeln und Sicherheitsupdates bereitstellen.

    Im Glossar lesen
    Ab dem 11.12.2027 verpflichtet Anhang I Teil II CRA Hersteller betroffener Produkte mit digitalen Elementen, Schwachstellen unverzüglich zu behandeln und Sicherheitsupdates bereitzustellen.
    ISO/IEC 27001

    ISO/IEC 27001 ist der international führende Standard für ein Informationssicherheits-Managementsystem (ISMS). Er beschreibt einen risikobasierten, prozessorientierten Rahmen, um Informationssicherheit systematisch zu planen, umzusetzen, zu überprüfen und zu verbessern.

    Im Glossar lesen
    Maßnahme A.8.8, Management technischer Schwachstellen: Relevanz für Ihre Systeme bewerten, Behebung einplanen und nachweisen.

    Beschreibung

    A note on the referenced files. This report was submitted through GitHub's private vulnerability reporting API, which carries no attachments. Every transcript this report leans on is reproduced inline above, verbatim. The file names it mentions (poc.sh, poc.log, per-case transcripts, evidence.md, negative-controls.md, blob-sweep tables) are the local evidence bundle those inline excerpts were extracted from, with a checksum manifest. I am happy to send the bundle by any channel you prefer, or to open a private fork — just say which. The PoC scripts are self-contained and reproduce the result from a clean environment.


    Affected: <= 3.1.62 — all published releases; also main @ 4905b4af Verified at runtime: GitPython 3.1.62 with git 2.55.0 Date: 2026-09-10 Reporter: MAXI8594


    Threat model

    Attackeranyone who can get the application to clone a URL they control. No account, no credential, no privilege in the consuming application.
    Pre-needa repository they host, with HEAD pointing at a branch whose name is the payload. A git push to a plain git server is enough — no filesystem access to a server is required (raw/06).
    Getsthe contents of any file the application's process can read, returned in band through the exception. /etc/passwd recovered 34 of 34 lines.
    Real-world likelihoodHigh. The vulnerable consumer is six lines of ordinary code with no unusual configuration: Repo.clone_from(user_url) then repo.active_branch.checkout(). allow_unsafe_options=False is the default. Cloning user-supplied URLs is the library's central use case — CI systems, repository importers, scanners and bots.

    On severity relative to the sibling advisories. GitHub, as CNA, scored the three prior advisories in this class at 6.5 / PR:L (CVE-2026-76217, CVE-2026-78678, CVE-2026-78679). This report asks for 7.5 / PR:N, and the difference is one measured fact: in those three, the application had to pass an attacker-influenced value into the API. Here it passes nothing — the clone materialises the hostile branch on its own and repo.active_branch returns it (raw/02). If that reading is not accepted, the PR:L path via Repo.create_head() is also real and lands at 6.5, matching the siblings.

    Summary

    Head.checkout() guards its **kwargs against unsafe Git options but never inspects its own positional argument — the branch name — which reaches the git checkout argv with no -- separator. A repository whose default branch is named --pathspec-from-file=/etc/passwd makes a consumer that merely clones it and checks out the default branch return the entire contents of that file to the caller.

    This is the exact combination of two advisories the project already fixed:

    • CVE-2026-76217 (GHSA-hh9p-6wh2-4mfc) — "Arbitrary file read via --pathspec-from-file in IndexFile.remove() and Head.checkout()". Fixed in 3.1.58 by commit f2550b65, which added the guard to this exact method — but only for **kwargs.
    • CVE-2026-78679 (GHSA-3wxw-xv34-2frg) — "TagReference.create positional reference bypasses kwargs-only --file guard, enabling arbitrary file read (incomplete fix of 3af0c251)". Fixed in 3.1.59 by commit 1b0d2d9b, which applied the positional check to git/refs/tag.py, git/diff.py, git/index/base.py and git/repo/base.py — but not to git/refs/head.py:286.

    f2550b65 states in its own commit message that the audit found the positional variant and applied it to HEAD.reset — 185 lines above Head.checkout, in the same file, in the same commit:

    "The audit also found that reset's positional commit could carry the option before its argument separator. […] Check reset's positional commit as well as keyword options"

    HEAD.reset got the fix. Head.checkout did not, and 1b0d2d9b did not come back for it.

    Affected Asset

    PackageGitPython (PyPI)
    Affected versions<= 3.1.62 — all published releases
    Latest release tested3.1.62
    Also present onmain @ 4905b4af
    Vulnerable filegit/refs/head.py
    Guardline 286 — Git._option_candidates([], kwargs)
    Sinkline 293 — self.repo.git.checkout(self, **kwargs)
    CWECWE-88 (Argument Injection), CWE-73 (External Control of File Name or Path), CWE-200 (Exposure of Sensitive Information)
    CVSS 3.1AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N → 7.5 High

    The version range was established by blob hash against every tag, not by dates: the sink line self.repo.git.checkout(self, **kwargs) — with no -- separator — is present in git/refs/head.py in every tag from 0.3.1-beta2 through 3.1.62. The 3.1.62 blob is byte-identical to main: 7f563374ef9e018b3d5f95054498e8591e112ce2. Full sweep in raw/07-blob-version-sweep.txt.

    The kwargs-only guard first appears in 3.1.58, so 3.1.58–3.1.62 is where "incomplete fix" applies; earlier releases have the same sink with no guard at all.

    Vulnerability Details

    Root cause

    git/cmd.py:1045 — _option_candidates() only inspects the positionals it is handed:

    @classmethod
    def _option_candidates(cls, args: Sequence[Any] = (), kwargs: Optional[Mapping[str, Any]] = None) -> List[str]:
        """Collect possible option spellings before command-line transformation."""
        options = [
            option for option in cls._unpack_args([arg for arg in args if arg is not None]) if option.startswith("-")
        ]
    

    So _option_candidates([], kwargs) means: check the keyword arguments, never check the positional arguments this method puts on the command line. That is fine when the method has no attacker-influenced positional, or when it separates them with --.

    git/refs/head.py:283-293 — Head.checkout() has neither:

            if not allow_unsafe_options:
                Git.check_unsafe_options(
                    options=Git._option_candidates([], kwargs),
                    unsafe_options=Git.unsafe_git_pathspec_from_file_options,
                )
            kwargs["f"] = force
            if kwargs["f"] is False:
                kwargs.pop("f")
    
            self.repo.git.checkout(self, **kwargs)
    

    self is the only positional. It serialises to the branch name, lands in the git checkout argv, and is not in the list the guard inspects. _call_process builds args_list = opt_args + ext_args, so keyword-derived options precede positionals — which is why the rest of the library puts "--" first (Remote.fetch/pull/push, Repo._clone, Repo.archive, IndexFile.remove, Commit.count all do). Head.checkout does not.

    Why the branch name is attacker-controlled

    Git accepts a refname whose branch component begins with - and contains / (raw/02-refname-accepted-and-cloned.txt):

    >>> git check-ref-format 'refs/heads/--pathspec-from-file=/etc/passwd'
        exit=0  stderr=''
        => un refname que empieza con '-' y lleva '/' es VALIDO para git
    
    >>> git -C <bare> update-ref 'refs/heads/--pathspec-from-file=/etc/passwd' beea87239099
        exit=0  stderr=''
    >>> git -C <bare> symbolic-ref HEAD 'refs/heads/--pathspec-from-file=/etc/passwd'
        exit=0
        HEAD del bare = refs/heads/--pathspec-from-file=/etc/passwd
        ref en disco como arbol jerarquico: True
    
    >>> Repo.clone_from('file://<bare>', <victim>)   # la app solo clona
        ramas LOCALES creadas por el clone, sin que nadie las pida:
          refs/heads/--pathspec-from-file=/etc/passwd
        repo.active_branch.name = '--pathspec-from-file=/etc/passwd'
        coincide con el nombre hostil: True
    

    The transcript above also shows the second half: git clone materialises that branch locally on its own when the remote HEAD points at it — the consuming application never asks for it.

    A plain git server accepts the refname over receive-pack, with no --force and no special config (raw/06-push-accepts-refname.txt), so the attacker does no

    Quelle: GitHub Security Advisories

    Betroffene Produkte

    Betroffen sind die folgenden Versionen. Ältere Stände derselben Reihe sind ebenfalls verwundbar, sofern nicht anders angegeben.

    Betroffene Produkte
    Betroffene VersionenBehoben in
    pipGitPython
    • <= 3.1.62
    • 3.2.0

    Weakness-Klassen (CWE)

    • CWE-200Exposure of Sensitive Information to an Unauthorized Actor

      Class

      The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information.

      Eintrag bei MITRE CWE-200
    • CWE-73External Control of File Name or Path

      Base

      The product allows user input to control or influence paths or file names that are used in filesystem operations.

      Eintrag bei MITRE CWE-73
    • CWE-88Improper Neutralization of Argument Delimiters in a Command ('Argument Injection')

      Base

      The product constructs a string for a command to be executed by a separate component in another control sphere, but it does not properly delimit the intended arguments, options, or switches within that command string.

      Eintrag bei MITRE CWE-88