/

CVE-2026-28466

Severity:

CRITICAL RISK

(9.9)

Improper Authorization in OpenClaw Gateway

CVE-2026-28466

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Remote Code Execution on Connected Nodes by Authenticated Users

Severity:

CRITICAL RISK

(9.9)

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 gateway versions prior to 2026.2.14 contain an authorization flaw in how internal approval fields are handled for node.invoke parameters, allowing authenticated users to bypass exec approval gating for system.run commands.

By injecting approval control fields into invocation requests, an attacker with valid gateway credentials may execute arbitrary commands on connected node hosts, potentially compromising developer workstations and CI runners.

Affected context

This vulnerability exists in OpenClaw deployments where:

  • The gateway exposes node.invoke functionality to authenticated clients
  • system.run or similar command-execution operations are protected by approval gating
  • The gateway trusts or directly propagates client-supplied approval-related fields to internal authorization logic

It primarily affects environments where the gateway has connectivity to developer workstations, CI runners, or other build and automation nodes, and where users have credentials but should not have unrestricted command execution rights.

Exploit preconditions

  • Attack surface: OpenClaw gateway API or interface that accepts node.invoke parameters.
  • Required access: Valid, authenticated gateway credentials (e.g., standard user or service account) with permission to invoke nodes but not necessarily to run arbitrary system.run commands.
  • Trigger point: Submission of a crafted node.invoke request that includes manipulated approval control fields (e.g., flags or metadata that the gateway uses to decide whether a command has passed approval).
  • Why exploitation is possible: The gateway fails to sanitize or ignore client-supplied internal approval fields and does not enforce approval state exclusively on the server side, allowing a caller to tamper with authorization context and bypass exec approval gating.

Why this happens

The core issue is an improper authorization pattern where authorization decisions depend on fields that the client can influence rather than being derived solely from server-controlled state and policy.

In this case, internal approval fields associated with node.invoke and system.run are trusted as part of the decision to allow or deny potentially dangerous command execution. Because these fields are not sanitized or reconstructed on the server, authenticated clients can inject or modify them, making the gateway treat unapproved commands as if they have already passed approval.

This aligns with CWE-863: Improper Authorization, where the system performs security-critical operations without establishing that the user is permitted to perform them, due to flawed or bypassable authorization checks coupled to user-controllable parameters.

Potential impact

  • Execution of arbitrary OS commands on connected node hosts via the OpenClaw gateway
  • Compromise of developer workstations, including exfiltration of source code, credentials, and SSH keys
  • Takeover of CI runners, enabling build pipeline tampering and supply-chain attacks
  • Lateral movement into broader infrastructure reachable from compromised nodes
  • Disruption of build and deployment processes through destructive or resource-exhausting commands

General mitigation guidance

Effective mitigation focuses on enforcing server-side-only authorization and treating any client-supplied approval indicators as untrusted hints at best:

  • Derive approval and authorization decisions exclusively from server-side policy, workflow state, and identity/role information; never accept approval state from client-controlled fields.
  • Strip, ignore, or overwrite any approval-related parameters supplied by clients, reconstructing them from trusted data sources within the gateway.
  • Implement explicit privilege separation for high-risk operations like system.run, ensuring that only well-defined roles or service identities can trigger them, irrespective of client-supplied metadata.
  • Introduce a dedicated policy layer for execution requests that evaluates caller identity, target node, command type, and approval workflow status before allowing command execution.
  • Apply least-privilege on node agents and underlying OS accounts so that even if command execution is exposed, its blast radius is constrained.

How teams detect issues like this

Detection typically involves both code-centric and operational approaches:

  • Code / configuration review:
  • Look for APIs where authorization decisions depend on fields in the request body (e.g., "approved", "is_admin", "workflow_state") rather than on server-maintained state.
  • Identify any part of the gateway that maps user-supplied approval fields directly into internal authorization or workflow objects.
  • Verify that dangerous operations such as system.run are guarded by explicit, centralized authorization checks rather than flags scattered through the code.
  • Static analysis and automated checks:
  • Configure static analysis rules to flag trust in client-set approval or role fields and to detect missing or inconsistent authorization checks before sensitive operations.
  • Use security-focused linters or policy-as-code systems to require explicit authorization decorators or middleware for command-execution endpoints.
  • Runtime monitoring:
  • Monitor gateway logs for unusual patterns of node.invoke calls that include approval-related fields from unexpected clients or roles.
  • Alert on execution of high-risk commands from accounts that historically do not perform such operations, indicating potential abuse of the flaw.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/0af76f5f0e93540efbdf054895216c398692afcd
github.comgithub.com/openclaw/openclaw/commit/318379cdb8d045da0009b0051bd0e712e5c65e2d
github.comgithub.com/openclaw/openclaw/commit/a7af646fdab124a7536998db6bd6ad567d2b06b0
github.comgithub.com/openclaw/openclaw/commit/c1594627421f95b6bc4ad7c606657dc75b5ad0ce
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-gv46-4xfq-jv58
vulncheck.comvulncheck.com/advisories/openclaw-remote-code-execution-via-node-invoke-approval-bypass

Frequently asked

questions

Yes, if the OpenClaw gateway is reachable over the network and an attacker holds valid credentials, they can potentially exploit the issue by sending crafted node.invoke requests. The exploit does not require local access to the node hosts themselves, only to the gateway.

Not necessarily. Any authenticated user or integration that can reach the vulnerable node.invoke functionality and has basic permissions to interact with nodes may be able to abuse the missing approval enforcement, even if they are not intended to execute arbitrary system.run commands.

The most robust fix is to centralize authorization for command execution on the server side and ignore client-provided approval state. Approval decisions should be derived from trusted workflow records, role-based access control rules, and policy checks that are not modifiable by the caller.

Design APIs so that clients can request actions but cannot assert authorization or approval status. Treat all request parameters as untrusted input, enforce access control in a single, well-reviewed layer before executing sensitive operations, and use security reviews, threat modeling, and automated checks to catch any reliance on client-controlled authorization flags.

Find out what's already
exploitable in your codebase.