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.invokefunctionality to authenticated clients system.runor 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.invokeparameters. - 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.runcommands. - Trigger point: Submission of a crafted
node.invokerequest 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.runare 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.invokecalls 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.

