Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlant prompt injection in agent-read content
-
DeliveryAI agent ingests malicious instruction
-
ExploitCraft echo *$(...) glob-token command
-
ExecutionparseCommandLine discards substitution, prefix matches allowlist
-
ImpactAuto-approval runs arbitrary command locally
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation completeness
|
| Exploitation Conditions | Exploitation requires two concrete conditions: (1) Roo Code's auto-approval (command allowlist) feature must be enabled so that commands matching an approved prefix run without a manual prompt; and (2) the attacker must land an indirect prompt injection into content the agent processes (e.g. source files, repository data, web content, or issues) to steer it into emitting a command of the form 'echo *$(...)'. The core flaw is that parseCommandLine() discards command substitutions adjacent to * or ? glob tokens, so the crafted command is evaluated against the allowlist as if only the benign prefix were present. Limiting factors: if auto-approval is disabled the user must manually approve each command and the bypass yields no silent execution; the malicious command must still match a configured allowlisted prefix; and the attacker needs a viable injection channel into the agent's context. Not exploitable against versions after 3.54.0 if the parser is fixed. |
| Impact | Multiple signals point to a genuine but conditionally-gated risk. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H, score 7.7) indicates a network-reachable flaw with no privileges needed but a required attack precondition (AT:P) and passive user interaction (UI:P), which together signal that exploitation is not fully turnkey. No EPSS score is provided in the input, so exploitation-probability cannot be quantified. The CVE is NOT listed in CISA KEV and there is no evidence of active exploitation. However, the references include a dedicated VulnCheck advisory and a GitHub technical writeup (roocode-glob-token.md) that document the exact bypass primitive (echo *$(...)) and the vulnerable source lines in parse-command.ts, so the exploitation technique is effectively public. The practical risk is real for any deployment running Roo Code <=3.54.0 with auto-approval/allowlisting enabled, because the flaw converts an indirect prompt injection into unapproved local command execution (full C/I/A high). It is materially de-prioritized where auto-approval is disabled, since the user then manually approves each command. The AT:P and UI:P metrics are the honest limiters: this is a high-impact flaw gated behind a specific feature state and an injection foothold, not a wormable internet-facing RCE. |
| Exploit ScenarioDerived | A developer uses Roo Code with auto-approval enabled, restricting the agent to an allowlisted command prefix (e.g. echo). An attacker plants indirect prompt-injection content in a file, repository, web page, or issue that the agent reads, instructing it to run a command like 'echo *$(malicious)'; parseCommandLine() discards the command substitution sitting next to the glob character, so the command matches the allowlisted prefix and the hidden substitution executes without user approval. The exact bypass command and vulnerable code lines are publicly documented in the referenced VulnCheck advisory and GitHub writeup. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Auto-approval command filtering in Roo Code through 3.54.0 can be bypassed, letting an attacker run commands that should have required explicit user approval. The flaw lives in parseCommandLine(), which drops command substitutions written next to '*' or '?' glob tokens, so a payload such as 'echo *$(...)' is checked against the allowlist as though it were only the benign prefix 'echo'. Exploitation is conditionally gated and requires two things to line up: the auto-approval/command-allowlist feature must be enabled, and the attacker must land an indirect prompt injection in content the agent reads (source files, repository data, issues, or web content); version 3.54.0's CVSS 4.0 base score is 7.7 (AV:N/AC:L/AT:P/PR:N/UI:P), and our independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:R with high confidentiality, integrity, and availability impact once those conditions are met. No confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis, though the referenced public technical writeup documents the bypass pattern in detail.
RemediationAI
No vendor-released patch is identified in the available data, so the primary defensive action is to disable Roo Code's auto-approval / command-allowlist feature so every agent-issued command requires explicit user confirmation; the trade-off is more approval prompts and reduced agent throughput, but it fully removes the silent-execution path this bypass depends on. If auto-approval must remain enabled, narrow the allowlist to exclude prefixes whose real-world invocations can absorb glob-adjacent substitutions (for example, avoid allowlisting bare echo/print-style commands), and upgrade past 3.54.0 to a build in which parseCommandLine() has been corrected - confirm the parser change in the upstream repository (https://github.com/RooCodeInc/Roo-Code/blob/v3.54.0/src/shared/parse-command.ts#L148-L172) before treating a given release as fixed, since no patched version is named in the provided references. Because the delivery vector is indirect prompt injection, also restrict the agent's exposure to untrusted content: do not point it at unreviewed repositories, issues, or web pages during auto-approved sessions, and treat all agent-consumed text as untrusted input; the trade-off is reduced usefulness on untrusted codebases. The public writeup at https://github.com/7rah/oss-cve/blob/6adb836d24ca446fd168c3acdc4c170beb77fe0f/roocode-glob-token.md and the VulnCheck advisory can be used to build detection rules for commands containing glob characters adjacent to '$(' or backtick substitutions.
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
Roo Code is an AI coding agent/VS Code extension that can execute shell commands on the user's behalf; to reduce prompt fatigue it offers an auto-approval mode in which commands matching user-configured allowlist prefixes execute without a confirmation prompt. The vulnerability is classified CWE-184 (Incomplete List of Disallowed Inputs), i.e. an allowlist implementation gap rather than a memory-safety or injection-sink bug. The root cause is in the command parser at src/shared/parse-command.ts (lines 148-172 in the v3.54.0 tree): when tokenizing a command line, command substitutions placed immediately adjacent to the '*' or '?' glob metacharacters are discarded, so the string used for allowlist comparison is materially different from the string that is actually executed. The CVSS 4.0 vector's AT:P (Attack Requirements: Present) reflects that the attack is not unconditional - the model must be steered into emitting the crafted command and auto-approval must be on. The vector's PR:N indicates the attacker does not need credentials on the target; the practical prerequisite is indirect prompt injection through content the agent ingests, making this a supply-chain/context-poisoning style attack against the agent's tool-execution boundary.
Know when Roo Code 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:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Needs auto-approval enabled plus a successful prompt injection (attack requirement) so AC:H; no attacker privileges (PR:N); the agent operator must be running it (UI:R); arbitrary local command execution gives C/I/A:H.
Primary rating from Vendor (vulncheck).
CVSS VectorVendor: vulncheck
DescriptionCVE.org
Roo Code through 3.54.0 contains a command approval bypass vulnerability in parseCommandLine() that discards command substitutions placed next to * or ? glob characters. Attackers using indirect prompt injection can craft commands like echo *$(...) that match allowlisted prefixes, executing denied commands without user approval when auto-approval is enabled.
Executive ViewAI
Roo Code, an AI coding assistant deployed to our development teams, is vulnerable through version 3.54.0 to a command-filtering bypass that can cause the agent to execute commands it should have blocked, giving an attacker the same execution rights as the developer running the tool. The attack is network-reachable and unauthenticated but requires user interaction and two conditions to align: the auto-approval/command-allowlist feature must be enabled, and an attacker must land an indirect prompt injection in content the agent reads; there is no public exploit identified at time of analysis and no vendor-released patch identified at time of analysis. Leadership should care because successful exploitation could expose source code, credentials, and build pipelines on developer workstations, and because the absence of a fix leaves mitigation on us.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the auto-approval/command-allowlist feature, require explicit manual approval for all agent-initiated commands, run the agent in a sandboxed and least-privilege environment with no access to production secrets, block or sanitize untrusted content the agent reads (source files, repository data, issues, web content), and monitor command-execution logs for unexpected activity.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Arbitrary command execution in Roo Code (the open-source AI coding agent) through version 3.54.0 lets attackers slip pas
Roo Code is an AI-powered autonomous coding agent that lives in users' editors. Rated critical severity (CVSS 9.9), this
Roo Code is an AI-powered autonomous coding agent. Prior to 3.22.6, if the victim had "Write" auto-approved, an attacker
Roo Code is an AI-powered autonomous coding agent. The project-specific MCP configuration for the Roo Code agent is stor
Command approval bypass in Roo Code through 3.54.0 allows unauthenticated remote attackers to execute shell commands tha
Command-approval bypass in Roo Code through 3.54.0 lets attacker-influenced input cause the agent to execute arbitrary s
Command approval bypass in Roo Code through 3.54.0 lets an attacker get denied shell commands auto-approved and executed
Roo Code through 3.54.0 can execute shell commands that its command auto-approval allowlist is meant to deny, because ge
Cleartext transmission of OAuth credentials in RooCodeInc Roo-Code up to version 3.51.1 exposes sensitive OAuth tokens t
Path traversal in RooCodeInc Roo-Code through version 3.51.1 allows remote unauthenticated attackers to read and write f
Code injection in RooCodeInc Roo-Code through version 3.51.1 allows remote attackers to execute arbitrary code via the E
Code injection in RooCodeInc Roo-Code up to version 3.51.1 allows a remote low-privileged attacker to execute injected c
EUVD-2026-99246
GHSA-66pw-2qq8-258w
NVD
CVE.org
EPSS
Exploit-DB