Skip to main content

GitPython EUVDEUVD-2026-65225

| CVE-2026-78679 HIGH
External Control of File Name or Path (CWE-73)
7.1
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with low-privilege credentials
  2. Delivery
    Craft reference value as '--file=<target-path>'
  3. Exploit
    Submit tag creation request to GitPython-backed application
  4. Execution
    TagReference.create() passes value positionally to git, bypassing unsafe guard
  5. Persist
    git reads target file and embeds contents in tag annotation
  6. Impact
    Attacker retrieves file contents from tag message response

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V5 - File Handling File name/path control
Exploitation Conditions

The application must invoke GitPython's TagReference.create() method and allow attacker-controlled input to reach the positional reference parameter without prior sanitization. The CVSS 4.0 PR:L metric confirms that some level of authenticated or low-privilege access is required - unauthenticated exploitation is not supported by the available data. Exploitation is further limited to files readable by the OS account under which the application process runs, meaning a least-privilege deployment materially reduces the blast radius. There is no requirement for a non-default configuration of GitPython itself: the unsafe guard is a built-in mechanism, but the bypass occurs via positional argument passing regardless of how the guard is configured. Applications that never expose tag-creation functionality to user-controlled input are not exploitable.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N) indicates network-reachable exploitation at low complexity requiring only low-privilege access, with high confidentiality impact confined to the vulnerable system. There is no integrity or availability impact, and no subsequent-system impact indicated. In practice, exploitability depends heavily on whether user-controlled input can reach the reference parameter of TagReference.create() in a deployed application - a code-review step that defenders should perform immediately. The Authentication Bypass tag from VulnCheck aligns with the unsafe-guard circumvention described. No EPSS score was provided in the input data, no KEV listing exists, and no public POC has been identified, so this is not a confirmed actively exploited issue at this time. Despite the 7.1 score, real-world risk is moderate-to-high specifically for CI/CD pipelines, repository management platforms, or code hosting tools that accept user-supplied tag reference names - these are the deployments most likely to surface this code path.

Exploit ScenarioDerived

An attacker with low-privilege access to a web-based repository management platform (e.g., a self-hosted CI/CD tool built on GitPython) submits a tag creation request with a crafted reference value such as '--file=/etc/shadow' or '--file=/app/config/secrets.yaml'. GitPython passes this value positionally to the underlying git tag command, bypassing the unsafe guard; git interprets it as a file-read flag and embeds the file contents in the annotated tag message, which is returned to the attacker in the API response.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 25, 2026

Arbitrary file read in GitPython before 3.1.59 allows low-privileged remote attackers to exfiltrate sensitive files by supplying a crafted reference argument to TagReference.create(). The vulnerability arises because a positional reference parameter (e.g., '--file=/etc/passwd') bypasses the library's built-in unsafe option guard, causing git to interpret the value as a flag and return the targeted file's contents embedded in the annotated tag message. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS 4.0 score of 7.1 with high confidentiality impact reflects genuine disclosure risk in any application that exposes this code path to user-controlled input.

RemediationAI

Upgrade GitPython to version 3.1.59 or later, which is the first release addressing this vulnerability per the GitHub security advisory at https://github.com/gitpython-developers/GitPython/security/advisories/GHSA-3wxw-xv34-2frg. If an immediate upgrade is not possible, the most actionable compensating control is to audit all call sites of TagReference.create() in the application codebase and enforce strict allowlist validation on the reference parameter before it reaches GitPython - reject any value beginning with '--' or containing path traversal characters. Additionally, restrict which users or roles can trigger tag-creation operations so that untrusted input cannot reach this code path. Running the application process under a least-privilege OS account limits the set of files an attacker could read, though it does not eliminate the vulnerability. Note that sanitizing at the application layer is a workaround, not a fix - the root cause remains in the library until the patch is applied.

Affected VersionsENISA

GitPython 0 <3.1.59

Affected Packages

pypi gitpython fix: 3.1.59

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

GitPython (CPE: cpe:2.3:a:gitpython-developers:gitpython) is a widely-used Python library that wraps git command-line operations. Internally, TagReference.create() invokes the git tag command and relies on an 'unsafe' option guard to prevent flag injection. CWE-73 (External Control of File Name or Path) captures the root cause: the reference parameter is a positional argument whose value is passed directly to git without sanitization, so a string beginning with '--file=' is interpreted by git as a flag instructing it to read file contents rather than as a literal reference name. The git --file flag causes git to read the specified path and embed its contents in the tag annotation body, which is subsequently surfaced to the caller. This is a classic argument injection pattern - the library's guard logic covers named keyword arguments but not positional ones, leaving a gap.

Know when Gitpython gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (VulnCheck) PRIMARY 7.1 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
vuln.today AI 6.5 MEDIUM

Low privilege required to invoke TagReference.create(); network-reachable if application exposes the path; high confidentiality only, no integrity or availability impact.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
SUSE 6.5 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Red Hat 6.5 MEDIUM

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 25, 2026 - 03:16 EUVD
CVE Published
Aug 25, 2026 - 01:30 cve.org
HIGH 7.1

DescriptionCVE.org

GitPython before 3.1.59 contains an arbitrary file read vulnerability in TagReference.create() where a positional reference parameter bypasses the unsafe option guard. Attackers can supply a reference value like --file=<path> to read arbitrary files, with contents returned in the annotated tag message.

Executive ViewAI

Why It Matters

GitPython versions before 3.1.59 contain an arbitrary file read vulnerability that allows attackers to exfiltrate sensitive configuration files and credentials from systems processing user-supplied input through the TagReference.create() method. Organizations utilizing GitPython in CI/CD pipelines, development tools, and version control integrations face direct risk of confidential data disclosure without immediate mitigation. No vendor patch is currently available, making urgent defensive actions necessary to protect systems handling sensitive data.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include: disable TagReference.create() access from any user-facing application code and restrict to trusted internal operations only; implement strict whitelist-based input validation on reference arguments, rejecting any containing dash prefixes or flag syntax; isolate vulnerable GitPython instances to private network segments with access restricted to approved internal hosts; deploy real-time alerting on TagReference.create() invocations to detect anomalous tag creation; consider implementing an application-layer wrapper that sanitizes or blocks potentially malicious reference arguments before passing to GitPython library functions.

Threat Intelligence Overview

EPSS Score
0.2%
Top 85% exploitable
Prevalence
Medium
popular Python library for git operations, common in dev tooling and CI/CD
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

56
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise High Performance Computing 15 SP4-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP4-LTSS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-LTSS Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy