Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain command-input access to steered agent
-
DeliveryCraft payload with escaped newlines
-
ExploitParser mis-splits, allowlist validates prefix only
-
ExecutionHidden command executes past guard
-
ImpactArbitrary code execution on host
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 an OpenClaw deployment before 2026.8.1 where the attacker can feed command input into an agent whose exec allowlist is the security boundary - i.e., a steered/running agent turn (UI:P) and a low-trust caller position in the command path (PR:L). The specific trigger is crafting input containing escaped newlines that the allowlist parser mis-tokenizes, causing it to validate only the visible portion while an appended hidden command executes. Limiting factors: an operator must be actively driving the agent, the attacker must already reach the command-input surface, and the flaw only matters where the allowlist prompt is relied on to gate execution; patched (2026.8.1+) installs are unaffected. |
| Impact | This is a genuine command-injection flaw (CWE-78) in OpenClaw's exec allowlist parser: escaped newlines desynchronize the parser so hidden commands slip past allowlist validation and run without the expected authorization prompt, yielding full host code execution (VC:H/VI:H/VA:H). The vendor CVSS 4.0 of 8.6 (AV:N/AC:L/PR:L/UI:P) is defensible for the technical impact, but the real-world risk is materially tempered by two gating factors baked into the vector: PR:L (the attacker/steered agent must already have a foothold in the low-trust command path) and UI:P (an operator/user must be driving an agent turn that processes the malicious input). No EPSS score, no CISA KEV listing, and no public exploit code accompany this record, so there is no evidence of active or automatable exploitation - the signal set is 'no public exploit identified at time of analysis.' Net: a high-CVSS, real-RCE bug whose practical priority is moderated by its niche footprint and the need for a pre-existing agent/allowlist context rather than a widespread, wormable threat. No conflicting signals in the data, though EPSS/KEV absence is simply missing data, not a low-risk confirmation. |
| Exploit ScenarioDerived | An attacker who can supply command input to a steered OpenClaw agent (e.g., via a task, message, or tool argument the operator has partly allowlisted) embeds escaped newlines that confuse the exec allowlist parser. The parser validates only the visible prefix while the hidden trailing command executes on the host at the agent process's privileges, with no re-prompt shown to the operator. No public proof-of-concept is referenced in the available data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 26, 2026
Command injection in OpenClaw versions before 2026.8.1 lets an attacker who can supply command input to an agent turn slip hidden commands past the exec allowlist: escaped newlines desynchronize the allowlist parser, which validates only the visible portion of the input while the appended command executes without the expected authorization prompt. Successful exploitation yields full code execution on the host (VC:H/VI:H/VA:H, CVSS 4.0 base 8.6; independently assessed as CVSS 3.1 8.8 AV:N/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:H), though it requires the operator to be actively driving the affected agent turn (UI:P) and the attacker to already hold a low-privilege position on the command-input surface (PR:L). No public exploit code has been identified at time of analysis and the flaw is not in CISA KEV, but the allowlist-bypass nature of the bug means any environment relying on the exec allowlist as its execution boundary should treat this as high priority.
RemediationAI
Upgrade to OpenClaw 2026.8.1 or later, the first version outside the affected range, which is the vendor-released fix for this parser desynchronization issue; verify the deployed build reports 2026.8.1+ and reference the upstream advisory https://github.com/openclaw/openclaw/security/advisories/GHSA-9f86-pvv5-rxfw. Where immediate upgrade is not possible, do not treat the exec allowlist as the sole execution gate: disable the agent's exec/shell capability entirely for untrusted or semi-trusted operators (highest assurance, but removes legitimate automation), or run the OpenClaw agent inside a container or sandbox with a read-only host mount and a restricted filesystem/user namespace so a bypassed command cannot reach host resources (effective containment, at the cost of operational flexibility for legitimate exec workflows). Additionally, restrict the command-input surface so only fully trusted operators can drive agent turns, since the assessed vector requires a low-privilege caller position (PR:L) and an actively driven turn (UI:P), and monitor agent transcripts and process telemetry for backslash-newline continuations and unexpected secondary commands as a detective control. Note these are compensating controls with residual risk - they limit blast radius or attacker population but do not correct the underlying parser mismatch, which only the 2026.8.1 upgrade resolves.
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 flaw is a classic CWE-78 OS command injection arising from parser-level input handling rather than from a missing check: OpenClaw's exec allowlist logic tokenizes submitted command input to decide whether it matches an approved pattern and whether an authorization prompt is required. Escaped newline sequences (e.g. a backslash-newline continuation) are interpreted differently by the allowlist tokenizer than by the underlying shell or command executor, so the two components desynchronize - the validator inspects and approves only the visible leading command, while the executor treats the escaped newline as a boundary and runs the additional hidden command that follows. This is a parsing-differential bug in the same family as allowlist bypasses via command separators, quoting, or line continuations; the security boundary is only as strong as the tokenizer's agreement with the shell that ultimately runs the string. The CPE cpe:2.3:a:openclaw:openclaw:*:*:*:*:*:*:*:* confirms the affected component is the OpenClaw application itself across all releases prior to the 2026.8.1 boundary, with no platform or edition qualifier, and the upstream GitHub security advisory (GHSA-9f86-pvv5-rxfw) plus the VulnCheck advisory both track this as a command-injection-via-escaped-newlines issue attributed to VulnCheck reporting.
Know when Openclaw 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:N/PR:L/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable agent input with low-privilege caller foothold (PR:L) and operator-driven turn (UI:R); parser bypass yields host RCE at process privileges, so C/I/A:H, scope unchanged.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
OpenClaw versions before 2026.8.1 contain a command parser vulnerability where escaped newlines confuse exec allowlist parsing, allowing hidden commands to execute. Attackers can craft input with escaped newlines to bypass allowlist validation and execute additional commands without expected authorization prompts.
Articles & Coverage 1
Technical POC Analysis
Bug class (per the advisory): CWE-78 OS Command Injection, with CWE-863 Incorrect Authorization as the associated weakness.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A command-injection weakness in OpenClaw agent versions before 2026.8.1 lets a low-privileged user who can supply input to an agent turn smuggle hidden commands past the exec allowlist and gain full code execution on the host. Because the allowlist is validated only on the visible portion of the input, any team that treats that allowlist as its execution boundary - especially where agents accept command input from users outside the immediate team - has a weakened control rather than a blocked attack path. Leadership should care because successful exploitation gives an attacker the same host privileges as the agent, and the affected population is any operator-driven agent workflow processing untrusted command input.
No vendor-released patch identified at time of analysis. Interim mitigations: disable or restrict agent turns that accept command input from untrusted or cross-team sources; enforce deny-by-default command execution instead of relying on the exec allowlist; normalize and reject escaped newline and control characters in all command input at the agent boundary; limit the exec-allowlist surface to a small set of authenticated, low-privilege operators; run agent workloads in a segmented host or container with least-privilege service accounts to contain full code execution; enable exec-decision logging and host-level process monitoring to detect appended or unexpected commands; and monitor the vendor advisory for a fixed release at or above 2026.8.1. Exploitation status: no public exploit identified at time of analysis. Authentication: authenticated (CVSS vector PR:L), with operator interaction required (UI:R/UI:P).
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.
Auth bypass in OpenClaw voice-call extension before 2026.2.1. EPSS 0.68%. PoC and patch available.
Privilege escalation in OpenClaw (pre-2026.3.28) allows unauthenticated remote attackers to gain administrative access b
OpenClaw versions 2026.2.22 through 2026.2.24 contain a privilege escalation vulnerability that allows authenticated att
An authorization mismatch vulnerability in OpenClaw versions prior to 2026.3.1 allows authenticated users with operator.
OpenClaw versions prior to 2026.1.29 automatically establish WebSocket connections to attacker-controlled gateway URLs e
Path traversal in OpenClaw through version 2026.3.23 enables unauthenticated remote attackers to read arbitrary files in
Directory-context bypass in OpenClaw before 2026.8.1 allows authenticated attackers with user interaction to reuse an 'a
Unauthenticated access to the noVNC observer interface in OpenClaw's Docker sandbox browser allows anyone who can reach
OpenClaw versions before 2026.2.26 allow authenticated attackers to write arbitrary files outside the workspace director
OpenClaw versions prior to 2026.2.22 contain a shell environment variable injection vulnerability in the system.run func
OpenClaw versions prior to 2026.2.22 contain a resource exhaustion vulnerability where the application fails to consiste
OpenClaw versions prior to 2026.3.1 contain a sandbox escape vulnerability that allows authenticated attackers with low
EUVD-2026-87491
GHSA-w63f-m9c2-9g74
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB