Skip to main content

Claude Code EUVDEUVD-2026-100461

| CVE-2026-86063 HIGH
Download of Code Without Integrity Check (CWE-494)
2026-10-13 security-advisories@github.com GHSA-pq7j-f95f-qfcv
7.5
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Publish malicious plugin repo on permissive Git host
  2. Delivery
    Create SHA-shaped branch matching reviewed commit
  3. Exploit
    Victim installs and pins plugin to trusted hash
  4. Execution
    git checkout resolves to branch tip not pinned SHA
  5. Impact
    Execute attacker-controlled plugin code in user context

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Code integrity verification
Exploitation Conditions

Exploitation requires all of the following: the victim must run Claude Code or Claude Desktop prior to version 2.1.179; the victim must actively install the attacker's plugin AND pin it to the reviewed 40-character commit SHA (UI:A); and the attacker must control the plugin repository on a Git host that permits branch names shaped like a 40-hex SHA (the AT:P attack requirement) so a branch can shadow the pinned commit. Limiting factors that reduce realistic risk: the heavy user interaction and trust decision (install + pin a specific hash), the social-engineering needed to get the victim to trust the repo, the non-universal git-host configuration allowing SHA-shaped branch names, and the fact that patched versions (>= 2.1.179) verify HEAD equals the pinned SHA. The attacker needs no privileges on the victim's system (PR:N), but does need write control over the plugin repository.

Impact

Signals point to a HIGH-impact but LOW-likelihood issue that is a moderate, conditional priority rather than an emergency. The CVSS 4.0 base score is 7.5 with total technical impact (VC:H/VI:H/VA:H) via CWE-494 (download of code without integrity check), meaning successful exploitation yields full attacker-controlled code execution in the victim's context. However, every likelihood signal is muted: CISA SSVC rates Exploitation as 'none', Automatable as 'no', the GitHub advisory and vendor confirm a patch with no KEV listing, and no public exploit was identified. EPSS is NOT provided in the input, so probabilistic exploitation likelihood cannot be quantified - this is a data gap. Crucially, although PR:N (no attacker privileges) could read as 'trivially remote', the vector also carries UI:A (active user interaction) and AT:P (a special attack requirement: a Git host that permits SHA-shaped branch names), so real-world exploitation hinges on social engineering the victim into installing and pinning a malicious plugin. This is a targeted supply-chain / trust-boundary bypass, not a wormable remote flaw. Note also a metadata conflict: the input Tag says 'Information Disclosure', which contradicts CWE-494 and the full C/I/A impact - this is an arbitrary-code-execution/supply-chain weakness, and the tag appears mislabeled.

Exploit ScenarioDerived

An attacker publishes a plugin repository on a Git host that allows SHA-shaped branch names and creates a branch named identically to the 40-character commit SHA a victim previously reviewed and trusts. When the victim installs the plugin and pins it to that 'safe' hash, Claude Code's git checkout resolves to the branch tip instead of the immutable commit, silently installing attacker-controlled code that executes in the user's context. No public exploit code was identified at time of analysis, but the technique is straightforward for anyone controlling the plugin repo.

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 – Oct 13, 2026

Plugin installation in Claude Code and Claude Desktop before 2.1.179 can install attacker-controlled code: the installer pins a plugin to a 40-character commit SHA from a marketplace but then runs git checkout on that string without confirming that the resulting HEAD actually equals the pinned SHA, so an attacker who controls the plugin repository on a Git host that allows branch names shaped like a 40-hex SHA can create a branch named after the 'reviewed' commit and have its tip checked out instead. Exploitation is unauthenticated from the attacker's side (CVSS 4.0 vector PR:N) but requires considerable user interaction - the victim must choose to install the malicious plugin and deliberately pin it to the ostensibly safe hash - which is why our independent assessment rates it a HIGH-impact, LOW-likelihood issue that is a moderate, conditional priority rather than an emergency. No public exploit code has been identified at time of analysis, CISA SSVC records Exploitation: none and Automatable: no, and there is no KEV listing.

RemediationAI

Vendor-released patch: upgrade Claude Code (and Claude Desktop where the same plugin installer is present) to 2.1.179 or later, per the GitHub Security Advisory https://github.com/anthropics/claude-code/security/advisories/GHSA-pq7j-f95f-qfcv and the release at https://github.com/anthropics/claude-code/releases/tag/v2.1.179; patched builds verify that HEAD equals the pinned SHA, which removes the branch-shadowing bypass. Where immediate upgrade is not possible, the highest-value compensating control is to stop pinning plugins to bare 40-character SHA strings and instead pin to annotated, signed tags or to a fully qualified ref, accepting the trade-off that tag names are also attacker-mutable if the repository is compromised, so signing verification must be enforced separately. Before trusting any pinned plugin, manually confirm the resolved revision with git rev-parse HEAD and compare it byte-for-byte against the intended commit, and audit candidate repositories for SHA-shaped branch names with git ls-remote --heads <repo> filtered for 40-hex names - an inexpensive check, but one that only detects the misconfiguration rather than preventing a future push to such a branch. Restricting plugin installation to an internal allowlist or a mirrored, write-protected marketplace reduces exposure to attacker-controlled repositories at the cost of slower plugin onboarding, and disabling third-party marketplace plugins entirely (using only vendored, reviewed plugins) is the safest fallback if the installer cannot be upgraded, though it removes most plugin functionality. Because acquisition depends on a user voluntarily installing and pinning the malicious plugin, user awareness that 'reviewed hash' is not a trust guarantee without independent verification is a meaningful secondary control, not a substitute for patching.

Affected VersionsENISA

claude-code < 2.1.179

Affected Packages

npm @anthropic-ai/claude-code fix: 2.1.179
euvd claude_code fix: 2.1.179

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in npm, 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-494 (Download of Code Without Integrity Check). Claude Code and Claude Desktop resolve marketplace plugin dependencies by checking out a user- or marketplace-pinned commit, but the installer trusted the 40-character SHA string as a git revision without a post-checkout integrity verification (i.e., without asserting git rev-parse HEAD equals the pinned SHA). Git revision resolution is ambiguous when a ref and an object share a name: on hosts that permit 40-hex branch names, git checkout <sha> can resolve to the branch rather than the commit, so the fetched tree is whatever the attacker last pushed to that branch tip rather than the audited commit. The attacker needs write control over the plugin repository and a Git host configuration that allows SHA-shaped branch names - a non-universal but realistic condition - and must then persuade a victim to install and pin that plugin, making the attack a supply-chain/social-engineering chain rather than an automatic remote compromise. The advisory data carries only the generic 'Information Disclosure' tag, which understates the real consequence: arbitrary attacker-chosen plugin code executing with the user's privileges. The vulnerable code path is the plugin installation flow; version 2.1.179 adds the missing HEAD-versus-pinned-SHA verification.

Know when the next one hits your stack

  • 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 (github) PRIMARY 7.5 HIGH
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Attacker needs no victim-side privileges (PR:N) but the victim must install and pin the plugin (UI:R) and the Git host must allow SHA-shaped branches (AC:H); checkout of attacker code yields full C/I/A.

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

Primary rating from Vendor (github).

CVSS VectorVendor: github

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

Lifecycle Timeline

2
Patch available
Oct 13, 2026 - 20:20 EUVD
CVE Published
Oct 13, 2026 - 19:21 cve.org
HIGH 7.5

DescriptionCVE.org

Claude Code is an agentic coding tool. Prior to 2.1.179, the Claude Code and Claude Desktop plugin installation flow runs git checkout for a marketplace-pinned commit without verifying that the resulting HEAD equals the pinned 40-character SHA. An attacker who controls a plugin repository on a Git host that permits SHA-shaped branch names can create a branch named after the reviewed commit, causing checkout to select the branch tip and install attacker-controlled plugin code. Exploitation requires a user to install the malicious plugin and pin it to the ostensibly safe hash. This issue is fixed in version 2.1.179.

Technical POC Analysis

Evidence caveat: no PoC and no patch diff were supplied.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Claude Code and Claude Desktop deployments prior to version 2.1.179 contain a high-severity plugin-installation flaw that could allow attacker-controlled code to run on user endpoints when a user installs and pins a malicious marketplace plugin. This affects developers and other staff who use these AI tools with access to source code, credentials, and local files, creating potential exposure of sensitive intellectual property and downstream supply-chain risk. Exploitation requires deliberate user interaction and no public exploit identified at time of analysis, so leadership should prioritize patching as a conditional, manageable action rather than an emergency.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Medium
popular developer CLI/desktop tool, but plugin-pinning feature is a user subset
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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 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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Vendor StatusVendor

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