/

CVE-2026-41352

Severity:

HIGH RISK

(8.8)

Missing Authorization in OpenClaw

CVE-2026-41352

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Remote Code Execution via Bypass of Authorization Controls

Severity:

HIGH RISK

(8.8)

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 before 2026.3.31 contains a missing authorization flaw in its node scope gate that lets a device‑paired node bypass proper authentication checks.

An attacker with device pairing credentials can issue arbitrary node commands on the host system without full node pairing validation, potentially resulting in remote code execution.

Affected context

This vulnerability arises in OpenClaw deployments that rely on device pairing and node scope gates to control which nodes may issue commands to the host.

It is relevant where:

  • Nodes are authenticated or trusted via device pairing credentials
  • The node scope gate is expected to enforce fine‑grained authorization on node actions
  • Node commands are ultimately executed on or proxied to the host system

In affected versions, the authorization layer does not fully validate node pairing status before accepting certain node commands, weakening the trust boundary between paired devices and the host.

Exploit preconditions

  • Attack surface: Network‑accessible OpenClaw node interfaces that accept commands from paired devices.
  • Required access: Possession or control of valid device pairing credentials (e.g., from a legitimately paired node, compromised device, or leaked secret).
  • Trigger point: Submission of node commands through an API or protocol path that should be protected by the node scope gate.
  • Why exploitation is possible: The node scope gate fails to enforce complete authorization checks on each command, allowing a device‑paired node to bypass node pairing validation and invoke privileged host‑level operations.

Why this happens

This issue is rooted in CWE-862: Missing Authorization, where an authorization decision is absent or incomplete for a protected action.

The design assumes that possession of device pairing credentials is sufficient to trust a node, but the node scope gate does not consistently verify that the requesting node is properly paired and authorized for the specific commands it sends.

As a result, security‑critical operations on the host can be triggered based solely on device pairing credentials, without robust per‑request authorization checks tied to node identity, scope, or intended capabilities.

Potential impact

  • Execution of arbitrary node commands on the host system, which may lead to remote code execution.
  • Escalation from a limited or nominally trusted device context to full control over the OpenClaw host.
  • Modification or disruption of node workloads, device orchestration, or automation routines.
  • Lateral movement within the environment if host‑level access enables pivoting to other systems or services.
  • Integrity and availability impact on data and operations managed through OpenClaw.

General mitigation guidance

Mitigation patterns focus on strengthening authorization and tightening trust boundaries around device pairing and node commands:

  • Enforce explicit authorization checks at the node scope gate for every sensitive command, binding decisions to both node identity and intended action.
  • Apply principle of least privilege for paired nodes, granting only the minimal command set and capabilities necessary for their role.
  • Introduce capability- or role-based access control (RBAC) for node operations, separating high‑risk host commands from routine node interactions.
  • Require strong, non-reusable binding between a device and its node identity, so possession of credentials alone is not enough to perform privileged operations.
  • Implement defense in depth by validating command intent and parameters server-side, and ensuring host‑level execution layers do not blindly trust upstream authorization.
  • Regularly rotate device pairing credentials and monitor for unexpected new pairings or unusual command patterns.

How teams detect issues like this

Effective detection combines code-centric review with operational monitoring:

  • Static analysis and code review:
  • Look for command execution paths reachable from network inputs where authorization checks (scope, role, pair status) are missing, optional, or placed only at initialization.
  • Verify that node scope gate logic is consistently invoked and that its decisions are enforced before any host-level operation.
  • Flag instances where possession of pairing credentials is treated as implicit full trust without per-action authorization.
  • Architecture and configuration review:
  • Map trust boundaries between nodes and host, confirming that every boundary-crossing operation has an explicit authorization policy.
  • Ensure configuration does not allow "open" or wildcard scopes for paired nodes in production environments.
  • Runtime and log-based detection:
  • Instrument logging around node commands, including node identity, pairing state, and command type, to detect anomalous or high-risk actions.
  • Establish alerts for unusual volumes of privileged node commands or commands originating from unexpected devices or locations.
  • Automated policy enforcement tools can be integrated in CI/CD to check for missing authorization flows and to enforce secure patterns before deployment.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/3886b65ef21d02808c1a106fa1f9f69e22f71c32
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-xj9w-5r6q-x6v4
vulncheck.comvulncheck.com/advisories/openclaw-remote-code-execution-via-node-scope-gate-bypass

Frequently asked

questions

It can be, depending on how OpenClaw is exposed. If attackers can reach the node command interface over a network where device pairing credentials are usable (for example, via VPN or exposed services), they may exploit the issue remotely.

The attacker needs valid device pairing credentials or control over a device that has been paired with the OpenClaw host. With that access, missing authorization checks can allow them to perform actions beyond what a paired node should be allowed to do.

Implement strict, explicit authorization checks at the node scope gate for every privileged operation, tying decisions to authenticated node identity, pairing state, and allowed capabilities rather than assuming that device pairing alone grants broad rights.

Treat device pairing as an authentication step, not as full authorization. Design systems around fine-grained access control, validate all high-risk actions at the server side, apply least privilege to device roles, and incorporate security reviews or automated checks to ensure all sensitive operations are guarded by well-defined authorization policies.

Find out what's already
exploitable in your codebase.