/

CVE-2026-26325

Severity:

HIGH RISK

(7.2)

Authorization Bypass / Improper Access Control

CVE-2026-26325

Analyzed

Vulnerability type

Category:

Authorization Bypass / Improper Access Control

CWE:

CWE-284

Impact:

Execution of commands that bypass allowlist and approval controls on node hosts

Severity:

HIGH RISK

(7.2)

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's node host system.run handler previously evaluated allowlist and approval prompts against a different command string than the one actually executed.

In deployments using node-based execution with allowlist-driven policies, an attacker able to invoke system.run could potentially get an unapproved command executed while a safer-looking command was shown for policy evaluation or user approval.

Affected context

This vulnerability affects OpenClaw deployments that:

  • Use the node host / companion node execution path (i.e., system.run on a node), and
  • Enable an allowlist-based execution policy (e.g., security=allowlist), and
  • Drive approval prompts based on allowlist misses (e.g., ask=on-miss), and
  • Expose a path for an attacker to invoke system.run.

Default configurations and non-node execution paths are not impacted.

Exploit preconditions

  • Attack surface: The system.run interface on a node host or companion node.
  • Required access: Ability for an attacker (or compromised component) to trigger system.run calls with controllable command parameters.
  • Policy configuration: Execution policy must be allowlist-based (security=allowlist) with approval prompting tied to allowlist misses (such as ask=on-miss).
  • Trigger condition: A crafted request where the rawCommand string used for allowlist/approval evaluation does not accurately reflect the command[] argv actually executed.
  • Why exploitation is possible: Authorization and approval logic evaluate one representation of the command (rawCommand), while the runtime uses a different representation (command[]), allowing disjoint policy decisions and execution behavior.

Why this happens

The core issue is an improper enforcement of authorization boundary where policy checks are not aligned with the actual action performed.

OpenClaw's node host system.run handler evaluated allowlist membership and approval decisions against rawCommand, but execution was driven by command[] (argv).

Because these two representations could diverge, an attacker could arrange for a benign-looking rawCommand to pass policy checks while a different, potentially more dangerous command[] executed.

This maps to CWE-284 (Improper Access Control), where the system enforces permissions on a surrogate or incomplete view of the action instead of the real, effective operation.

Potential impact

  • Execution of commands that would normally be blocked by the allowlist policy.
  • Bypassing user approval flows that are expected to gate new or risky commands.
  • Escalation of capabilities within the node environment if system.run can invoke privileged or sensitive utilities.
  • Inconsistent audit trails, where recorded/approved commands differ from what actually ran.

General mitigation guidance

Effective mitigation centers on tightening the relationship between authorization checks and the actual executed action.

Recommended defensive patterns include:

  • Ensuring that policy evaluation and approval prompts operate on the exact same command representation that the runtime will execute (e.g., canonicalized argv).
  • Using a single source of truth for both allowlist matching and process spawning, avoiding parallel parameters that can diverge.
  • Designing allowlist rules around normalized, structured command arguments rather than free-form strings, reducing ambiguity.
  • Applying least-privilege execution for node processes so that even if a command bypasses policy, its impact is constrained.
  • Implementing defensive logging that records both the policy-evaluated command and the executed argv for post-incident analysis, and alerting on mismatches.

How teams detect issues like this

Detection focuses on identifying mismatches between authorized commands and executed behavior:

  • Static analysis / code review:
  • Flag patterns where authorization or allowlist checks use a different variable or representation than the execution call.
  • Review handlers like system.run for dual command fields (rawCommand, command[], etc.) and verify they are kept consistent.
  • Look for any transformation applied after the authorization step but before execution.
  • Runtime monitoring:
  • Log both the inputs used for allowlist/approval decisions and the final executed argv, and alert when they differ.
  • Correlate user approvals with subsequent executed commands to detect unexpected changes.
  • Policy enforcement:
  • Incorporate automated checks (e.g., in CI/CD pipelines) ensuring that security policy decisions reference the same data structure passed to execution APIs.
  • Use security testing or fuzzing focused on multi-field command interfaces to uncover inconsistency bugs.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/cb3290fca32593956638f161d9776266b90ab891
github.comgithub.com/openclaw/openclaw/releases/tag/v2026.2.14
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-h3f9-mjwj-w476

Frequently asked

questions

It can be, but only in deployments where system.run is reachable—directly or indirectly—from a remote attacker. If system.run is exposed through higher-level APIs or workflows that accept untrusted input, a remote adversary may be able to exploit the mismatch.

The attacker must be able to invoke system.run with some control over the command parameters in an environment configured with allowlist-based execution and approval-on-miss. This may require authenticated access or the compromise of another component that can call system.run.

Align authorization with execution by enforcing strict consistency between the command representation used for allowlist/approval evaluation and the argv actually executed, ideally using a single canonical structure for both policy checks and process spawning, with validation at both gateway and node host boundaries.

Design security controls so that authorization checks are performed on the exact data that will drive the operation, avoid duplicate or loosely-coupled parameters describing the same action, incorporate consistency checks into code review and testing, and enforce architectural patterns where policy decision points and enforcement points share a single, validated command representation.

Find out what's already
exploitable in your codebase.