Skip to main content

GitAhead CVE-2026-106058

| EUVDEUVD-2026-94306 HIGH
OS Command Injection (CWE-78)
2026-10-07 VulnCheck GHSA-q252-mvpj-37m5
7.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Publish malicious Git repository
  2. Delivery
    Victim clones and opens in GitAhead
  3. Exploit
    Checkout/stage invokes clean/smudge filter
  4. Execution
    Crafted filename injected into bash -c
  5. Impact
    Arbitrary command executes as victim

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the victim to clone or open an attacker-controlled repository in GitAhead (through 2.7.1) and then perform a checkout or staging operation. The malicious repository must contain a file whose name embeds a $(command) shell substitution and a .gitattributes entry assigning that file to a clean or smudge filter, so GitAhead passes the crafted filename into a filter command executed through bash -c. Limiting factors: the attack depends on social engineering (the victim must choose to open an untrusted repo), requires the described user interaction (checkout/stage), and relies on the attacker shipping both the crafted filename and the .gitattributes filter configuration within the repo; it does not affect users who never interact with hostile repositories.

Impact

This is a genuine but conditional code-execution risk rather than a mass-exploitation emergency. The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:P, score 7.7) is internally consistent with the description: network-reachable because malicious repositories are distributed remotely, but gated by high attack complexity (AC:H), a present attack requirement (AT:P), and required victim interaction (UI:P) - the victim must actually clone/open the hostile repo and trigger a checkout or staging operation in GitAhead. No EPSS score, KEV listing, or public POC was supplied, so there is no public exploit identified at time of analysis and no evidence of active or automatable exploitation; SSVC-style automatability is effectively false because a human must open and interact with a crafted repository. The high VC/VI/VA (full technical impact via arbitrary command execution as the victim user) is what drives severity, not reach or ease. Net: real priority for GitAhead users who clone untrusted repositories, but the combination of required social engineering, user interaction, and high complexity, plus the product's niche/abandoned status, makes widespread opportunistic exploitation unlikely. No conflicting signals in the data, though the absence of EPSS/KEV/POC means exploitation likelihood is inferred, not measured.

Exploit ScenarioDerived

An attacker publishes a repository containing a file named with an embedded $(command) payload and a .gitattributes that routes that file through a clean/smudge filter. A GitAhead user clones or opens the repository and performs a checkout or stages changes, at which point GitAhead substitutes the crafted filename into the filter command string and runs it via bash -c, executing the attacker's command with the victim's privileges. No public POC is referenced, and the attack requires the victim to interact with the malicious repository.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 1.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 07, 2026

OS command injection in GitAhead through 2.7.1 lets a malicious repository execute arbitrary shell commands on the victim's machine during a routine checkout or staging operation, because crafted filenames are substituted unescaped into Git clean/smudge filter commands that GitAhead runs through 'bash -c'. The attack is remote and unauthenticated from the attacker's side (CVSS 4.0 vector PR:N) but high in complexity and gated on user interaction: the victim must clone or open an untrusted repository and then perform a checkout or stage, making it a conditional code-execution risk rather than a mass-exploitation event. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV), though the 7.7 base score and full confidentiality/integrity/availability impact justify prompt attention for anyone using the client with repositories of uncertain provenance.

RemediationAI

No vendor-released patch identified at time of analysis; the GitHub issue (https://github.com/gitahead/gitahead/issues/661) and the upstream repository (https://github.com/gitahead/gitahead) are the places to track for a fixed release, and any version after 2.7.1 should be adopted as soon as it exists rather than assumed safe in the interim. Until then, the highest-value control is behavioral: do not clone, open, or check out repositories of untrusted origin in GitAhead, and inspect .gitattributes in any incoming repository for filter= assignments referencing clean/smudge drivers, since both the crafted filename and the filter mapping must be present for exploitation to work. Where filters are not essential, unsticking them in the local Git configuration (for example unsetting filter.<driver>.clean and filter.<driver>.smudge, or removing the driver definitions entirely) prevents GitAhead from invoking any shell command during checkout and staging; the trade-off is that legitimate content filters such as Git LFS stop transforming files, so files may appear as raw pointer text and must be fetched by other means. Running GitAhead under a constrained OS account or sandbox with no access to credentials, SSH keys, or production data limits the blast radius if a hostile repository is opened, at the cost of convenience and possible breakage of normal development workflows. Finally, treat the reported CVSS 7.7 as an upper bound rather than a forecast of exploitation: the high attack complexity, the required user interaction, and the absence of any identified public exploit code mean the immediate priority is hygiene around untrusted repositories, not emergency patching of systems that never handle them.

Affected VersionsENISA

GitAhead 0 ≤2.7.1

Affected Packages

euvd gitahead no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

The root cause is CWE-78 (Improper Neutralization of Special Elements used in an OS Command, i.e. OS command injection). Git's gitattributes mechanism supports clean and smudge filter drivers that transform file content when files are staged (clean) or checked out (smudge); a repository's .gitattributes file selects which filter driver applies to which paths, and the driver command is frequently executed via a shell such as 'bash -c'. GitAhead's implementation in src/git/Filter.cpp (lines 43-70, as seen at tag v2.7.1) builds those filter invocations by interpolating the file's path without escaping shell metacharacters. An attacker who ships a file whose name contains a $(command) substitution and an accompanying .gitattributes entry that maps that path to a clean or smudge filter causes the substitution to be evaluated by the shell when the victim checks out or stages the file, yielding command execution in the victim's user context. The affected CPE, cpe:2.3:a:gitahead:gitahead:*:*:*:*:*:*:*:*, uses an unbounded version wildcard, so every release up to and including 2.7.1 is presumed affected; VulnCheck is credited as the reporting source (advisory at vulncheck.com/advisories/gitahead-through-2.7.1-os-command-injection-via-git-filter-filenames). The independent assessment concurs on the mechanics but scores it under CVSS 3.1 as AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, emphasizing the high attack complexity and the mandatory user interaction rather than treating it as a readily exploitable network service flaw.

Know when Gitahead 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.7 HIGH
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Malicious repo is delivered over the network (AV:N) with no prior privileges (PR:N), but the victim must open it and run checkout/staging (UI:R) and the crafted-filename/filter setup raises complexity (AC:H); command execution yields full C/I/A impact.

3.1 AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:N/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

GitAhead through 2.7.1 contains an OS command injection vulnerability in src/git/Filter.cpp that allows malicious repositories to execute commands by substituting crafted filenames into clean/smudge filter commands. Attackers can ship files named with $(command) selected via .gitattributes so checkout or staging runs the command through bash -c as the victim.

Executive ViewAI

Why It Matters

GitAhead, a desktop Git client used by developers through version 2.7.1, can be tricked into executing arbitrary shell commands on a user's workstation when that user clones or opens a repository of untrusted origin and then performs a routine checkout or staging action. Because the flaw yields full compromise of confidentiality, integrity, and availability on the affected endpoint, a single successful attack could expose source code, credentials, and any other data reachable from the developer's machine. No vendor patch is currently available, so risk must be managed through usage restrictions and developer behavior until a fix ships.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis; interim mitigations are to avoid cloning or opening repositories of untrusted provenance in GitAhead through 2.7.1, abstain from checkout and staging operations on such repositories, migrate affected users to a maintained Git client, disable or neutralize Git clean/smudge filter execution for untrusted repositories, run the client under a least-privileged restricted account with sandboxing, and monitor endpoint and network activity for unexpected shell execution originating from the Git client.

Threat Intelligence Overview

EPSS Score
1.2%
Top 33% exploitable
Prevalence
Low
niche desktop Git GUI client, effectively abandoned, small user base
Data Quality
4 sources
Confidence: Medium

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 No
EPSS 1.2%
Patch available No
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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