Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlant prompt injection in agent-read content
-
DeliveryAgent ingests malicious instructions
-
ExploitEmit $(...) command substitution in command position
-
ExecutionBypass echo allowlist approval check
-
ImpactShell executes arbitrary commands on host
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service Interpretation consistency
|
| Exploitation Conditions | Exploitation requires a victim running Roo Code <=3.54.0 with the command auto-approval feature enabled and at least one allowlisted command (e.g., echo) in the approval list - the bypass works by placing a command substitution $(...) in command position so parseCommandLine() only validates the allowlisted token while the shell executes the substituted output. The attacker must also deliver indirect prompt injection through content the agent processes (web pages, repository files, issues, or dependency docs), and the developer must actively operate the agent against that attacker-controlled content (reflected in UI:P and AT:P). Limiting factors: if auto-approval/allowlisting is disabled the approval prompt still fires and the chain breaks, so the non-default allowlist configuration plus required user operation of the agent are the main constraints reducing real-world exposure. |
| Impact | The vendor-supplied CVSS 4.0 base score is 7.7 (High), with AV:N, AC:L, PR:N but tempered by AT:P (a specific attack requirement) and UI:P (passive user interaction), and full VC:H/VI:H/VA:H impact reflecting arbitrary command execution - no scope change to subsequent systems. This is a genuine concern rather than an inflated high-CVSS issue because the vulnerability defeats the product's core security control (the command-approval allowlist), and arbitrary shell execution on a developer's workstation is a high-value outcome. However, several escalating signals are MISSING: there is no EPSS score in the input, no CISA KEV listing (so this is NOT confirmed actively exploited), and no explicit POC=YES flag, though the VulnCheck advisory and a third-party GitHub write-up both describe the exact bypass technique and the description includes a working trigger string ($(echo touch /tmp/x)). The real-world risk is gated by two preconditions that the raw network vector understates: the victim must have command auto-approval configured with an allowlisted command such as echo, and the victim must operate the agent on attacker-controlled content - so exploitation is realistic but not spray-and-pray. Net assessment: a credible, actionable priority for teams running Roo Code <=3.54.0 with auto-approve enabled, but absent KEV/EPSS data the likelihood of mass exploitation cannot be confirmed and appears conditional rather than wormable. |
| Exploit ScenarioDerived | An attacker seeds malicious instructions into content a Roo Code agent will read - a web page, source file, dependency README, or issue tracker entry - using indirect prompt injection. When the developer runs the agent against that content with command auto-approval enabled, the injected instruction asks the agent to run a command like $(echo malicious-payload); parseCommandLine() sees only the allowlisted echo and auto-approves, but the shell performs the command substitution and executes the attacker's output without the user ever confirming. A public write-up and the VulnCheck advisory document the technique, though no weaponized exploit tool is confirmed in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Command-approval bypass in Roo Code through 3.54.0 lets attacker-influenced input cause the agent to execute arbitrary shell commands without the normal user confirmation prompt. The flaw lives in parseCommandLine(), which validates only the first token of a command against the auto-approval allowlist, so a payload such as $(echo touch /tmp/x) placed in command position passes the echo allowlist check while the shell substitutes and runs the embedded command. Exploitation is unauthenticated in the sense that no Roo Code credentials are required (CVSS 4.0 PR:N), but it depends on attack requirements and passive user interaction (AT:P/UI:P): the victim must run a vulnerable build with command auto-approval enabled and at least one allowlisted command, and must direct the agent at attacker-controlled content (web pages, repository files, issues or dependency docs) that carries an indirect prompt injection. Vendor CVSS 4.0 base is 7.7 (High) with full confidentiality, integrity and availability impact on the local host; no scope change to downstream systems, and no public exploit identified at time of analysis - no confirmed actively exploited (CISA KEV) status was reported. The independent assessment rates the flaw CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, emphasizing that the non-default auto-approval/allowlist configuration and the need for the developer to actively operate the agent on hostile content are the primary constraints on real-world exposure.
RemediationAI
No vendor-released patch version is identified in the available intelligence for CVE-2026-110206, and the references point to the vulnerable v3.54.0 source rather than a fixed release, so patch status is best described as no vendor-released patch identified at time of analysis; monitor the RooCodeInc/Roo-Code repository and the VulnCheck advisory for a revised parseCommandLine() implementation and for a version above 3.54.0. Until then, the single most effective mitigation is to turn off command auto-approval entirely - the bypass only short-circuits an approval prompt that would otherwise be shown, so disabling auto-approve (or removing all entries from the allowlist, particularly echo, which is the token used in the published technique) restores the human check at the cost of more manual confirmations and slower agent workflows. Where auto-approval must be retained, restrict the allowlist to utilities that cannot appear in command position with substitution syntax, and avoid allowlisting anything whose output the shell would re-interpret; note that allowlist hardening is fragile because it depends on the same flawed parser. Additional compensating controls include running Roo Code in a container, VM or sandbox with no access to host source trees, credentials or package-manager tokens (trade-off: reduced developer convenience and breakage of tasks needing host tooling), restricting agent access to untrusted web content and untrusted repositories so indirect prompt-injection delivery paths are narrowed (trade-off: less useful for review of third-party code), and monitoring agent terminal activity for command-substitution characters such as $(, backticks and ${ in proposed commands. Each of these reduces exploitation opportunity but none is a substitute for a parser fix; organisations should treat any host where Roo Code auto-approval has been used as potentially compromised and review recent command history for unexpected execution.
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 vulnerability is a classic interpretation conflict (CWE-436) between two parsers that disagree about what a string means: Roo Code's Node/TypeScript auto-approval logic in src/shared/parse-command.ts (around lines 100-172 in the v3.54.0 tag) and the POSIX shell that ultimately runs the command. parseCommandLine() tokenizes the submitted string and compares the leading token against the user-configured allowlist, so $(echo touch /tmp/x) is seen as a call to the allowlisted utility echo and is auto-approved. The shell, however, performs command substitution first, executing the output of echo (i.e. touch /tmp/x) as the actual command in command position. Because the validated token and the executed token are not the same entity, the allowlist check is bypassed entirely rather than merely weakened. The delivery vector is indirect prompt injection: content the AI coding agent ingests during normal operation (fetched web pages, repository files, issue text, dependency documentation) can embed the crafted command string, which the model then proposes as a tool/terminal action. The attack chain therefore requires the agent to be pointed at attacker-controlled content and the auto-approval feature to be configured with at least one allowlisted entry. Note that CWE-436 captures the root-cause family (conflicting interpretation of the same input by two components), and the fix class would normally involve shell-aware parsing - rejecting command substitution, separators, redirections and quoting in command position - or abandoning token allowlists in favour of structured execution without a shell.
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
Payload is delivered remotely via injected content (AV:N) but depends on a configured allowlist and the user operating the agent, so AC:H and UI:R; arbitrary shell execution yields 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 allows attackers to auto-approve arbitrary shell commands by placing a command substitution in command position. Attackers using indirect prompt injection can submit commands like $(echo touch /tmp/x) that pass the echo allowlist check, causing the shell to execute the output without user approval.
Executive ViewAI
Roo Code, an AI-powered coding assistant used by development teams, contains a high-severity command-approval bypass (CVE-2026-110206) that could allow an attacker to execute arbitrary shell commands on a developer's machine without confirmation. This flaw undermines the intended security control and, if exploited, could lead to unauthorized access, data exfiltration, or further compromise of the development environment. No vendor-released patch identified at time of analysis, so organizations relying on Roo Code should immediately assess their exposure and implement interim mitigations to protect their engineering assets.
Disable command auto-approval in Roo Code; remove all allowlisted commands; restrict the agent from accessing untrusted content; monitor for suspicious shell activity; apply vendor patch immediately when available.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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
Auto-approval command filtering in Roo Code through 3.54.0 can be bypassed, letting an attacker run commands that should
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-99247
GHSA-r2h8-r3xm-p2rm
NVD
CVE.org
EPSS
Exploit-DB