Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPublish malicious Git repository
-
DeliveryVictim clones and opens in GitAhead
-
ExploitCheckout/stage invokes clean/smudge filter
-
ExecutionCrafted filename injected into bash -c
-
ImpactArbitrary 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Command injection in GitAhead 2.7.1 and earlier on macOS allows an attacker to execute arbitrary shell commands as the v
Insecure automatic update handling in GitAhead 2.5.0 through 2.7.1 allows a network-positioned attacker to deliver and e
EUVD-2026-94306
GHSA-q252-mvpj-37m5
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB