/

CVE-2026-32000

Severity:

HIGH RISK

(7.1)

Command Injection in OpenClaw Lobster Extension Tool

CVE-2026-32000

Modified

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution on Host System

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

OpenClaw versions prior to 2026.2.19 contain a command injection vulnerability in the Lobster extension tool execution path, where a Windows shell fallback is used with shell: true after a subprocess spawn failure.

By injecting shell metacharacters into command arguments that are later passed to this fallback, an attacker can execute arbitrary commands on the host when subprocess launch fails with specific errors.

Affected context

This vulnerability appears in OpenClaw's Lobster extension mechanism when external tools are invoked from the application.

It is most relevant on Windows environments where, after a failed spawn (e.g., EINVAL or ENOENT), the code falls back to a shell-based invocation with shell: true.

The risk is elevated when user-controlled or untrusted data can influence the command arguments passed into this fallback path, particularly in workflows that trigger external tooling or plugins.

Exploit preconditions

  • Attack surface: The Lobster extension tool-execution interface, typically triggered when OpenClaw runs external tools or helper processes.
  • Required access: Ability to supply or influence command arguments (e.g., via project configuration, plugin parameters, or user input that flows into tool invocation).
  • Trigger point: A subprocess launch that fails with EINVAL or ENOENT, causing the code to fall back to Windows shell execution with shell: true.
  • Why exploitation is possible: The shell fallback passes unvalidated arguments to the Windows shell, allowing shell metacharacters to be interpreted as additional commands rather than harmless data.

Why this happens

The underlying issue stems from treating untrusted command arguments as safe when constructing shell commands for a fallback execution path.

When the initial spawn call fails with EINVAL or ENOENT, the implementation switches to using the Windows shell with shell: true, effectively concatenating arguments into a shell command line.

This maps directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), because user-controllable input is not properly escaped or passed as strict arguments, allowing shell metacharacters to alter command structure and behavior.

Potential impact

  • Execution of arbitrary OS commands under the context of the OpenClaw process.
  • Reading, modifying, or deleting files accessible to the OpenClaw user account.
  • Exfiltration or corruption of project data processed by OpenClaw.
  • Establishment of persistence or lateral movement within the developer workstation or CI environment.

General mitigation guidance

Mitigation should focus on eliminating shell-based fallback paths for untrusted input and ensuring arguments are never interpreted by a shell when avoidable.

Recommended defensive patterns include:

  • Prefer direct process invocation APIs that pass arguments as arrays without involving a shell, even on fallback paths.
  • Avoid shell: true or equivalent flags for any command that contains user-influenced components.
  • Introduce strict validation and normalization of command arguments, rejecting or sanitizing characters with special meaning in the Windows shell (e.g., &, |, >, <, ^).
  • Centralize command construction in a dedicated utility that enforces safe patterns and prohibits ad-hoc string concatenation.
  • Run external tools with least-privilege accounts and limit file-system and network access where practical to reduce the blast radius if injection occurs.

How teams detect issues like this

Detection typically involves both code-centric and behavior-centric approaches:

  • Static analysis: Define rules to flag uses of shell: true (or similar shell-invoking APIs) combined with variables derived from configuration files, user input, or plugin parameters.
  • Code review signals: Pay attention to any error-handling paths that switch from safe spawn-like APIs to shell-based execution, and scrutinize string concatenation when forming commands.
  • Configuration and policy enforcement: Establish internal guidelines disallowing shell invocation for dynamic commands in core tooling, enforced via CI checks or linters.
  • Runtime monitoring: On sensitive hosts (developer workstations, CI runners), monitor for unexpected shell processes spawned by OpenClaw and alert on anomalous commands or destinations.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/ba7be018da354ea9f803ed356d20464df0437916
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-7fcc-cw49-xm78
vulncheck.comvulncheck.com/advisories/openclaw-command-injection-via-windows-shell-fallback-in-lobster-tool-execution

Frequently asked

questions

It depends on how OpenClaw is deployed.

On a local workstation, exploitation generally requires a local user or process that can influence extension tool arguments.

In a CI or remote build setting, remote exploitation may be possible if untrusted inputs (for example, from repositories or user-submitted projects) feed into Lobster's tool configuration.

An attacker must be able to control or significantly influence the command arguments passed into the Lobster extension's tool execution, and those arguments must reach the shell fallback path after a spawn failure.

Remove or redesign the shell-based fallback: always invoke external tools via APIs that pass arguments as arrays, and never rely on shell: true for error recovery.

If shell usage is unavoidable, strictly constrain and validate all inputs and avoid including uncontrolled data in the command string.

Adopt a "no shell for untrusted data" policy, centralize command execution in a hardened utility, and use automated checks to flag shell usage with variable input.

During design reviews, pay special attention to error-handling and fallback logic that may re-route execution to less secure code paths.

Find out what's already
exploitable in your codebase.