/

CVE-2026-41378

Severity:

HIGH RISK

(8.8)

Missing Authorization in OpenClaw Node-Gateway Channel

CVE-2026-41378

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation leading to Remote Code Execution on Gateway

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 privilege escalation issue where paired nodes with the role=node can dispatch node.event agent requests that gain unrestricted access to gateway-side tools.

An attacker who controls valid paired node credentials can abuse this missing authorization check to escalate privileges and ultimately achieve remote code execution on the gateway.

Affected context

The vulnerability manifests in OpenClaw deployments that use paired nodes with the role=node to communicate with a central gateway.

The issue resides in the gateway's handling of node.event agent requests, where the gateway exposes tool or agent execution capabilities to nodes without properly constraining or authorizing which operations a node is allowed to trigger.

Environments where nodes are treated as semi-trusted but not fully privileged, and where gateway-side tools can run sensitive or system-level actions, are particularly exposed to risk.

Exploit preconditions

  • Attack surface: Node-to-gateway communication channel, specifically node.event agent request handling.
  • Required access: Valid credentials or pairing keys for a node with role=node, or compromise of such a node.
  • Trigger point: Sending crafted agent.request or node.event messages that cause the gateway to invoke its tools or agents without proper authorization checks.
  • Why exploitation is possible: The gateway does not enforce fine-grained authorization for node-originated agent requests, effectively allowing any paired node to request operations that should be restricted to higher-privilege roles or administrative paths.

Why this happens

This vulnerability is a classic missing authorization flaw, mapped to CWE-862.

The gateway trusts that any request from a paired node with role=node is permitted to access gateway-side tools via node.event agent requests, but fails to enforce role-appropriate permissions or scope restrictions on those operations.

Instead of validating whether a particular node is allowed to trigger a given tool or agent action, the implementation allows broad, unrestricted dispatch.

This insufficient access control at the service boundary allows lower-privileged nodes to invoke high-privilege behaviors, leading to privilege escalation and remote code execution on the gateway host.

Potential impact

  • Gateway-level remote code execution initiated from a compromised or malicious node.
  • Escalation from node-level privileges to full gateway or controller privileges.
  • Unauthorized execution of sensitive gateway tools or maintenance scripts.
  • Lateral movement from the gateway to other internal systems reachable from it.
  • Tampering with orchestration logic, task scheduling, or security controls managed by the gateway.

General mitigation guidance

Mitigation centers on enforcing strict, role-aware authorization for all node-originated agent or tool requests.

Recommended patterns include:

  • Implementing fine-grained authorization checks on the gateway for each agent.request / node.event, binding permissible operations to specific roles, node identities, or labels.
  • Introducing explicit allowlists of gateway-side tools and actions that nodes may trigger, and default-deny for anything not enumerated.
  • Applying the principle of least privilege to node roles so that a role=node account cannot perform administrative or system-level actions.
  • Separating control-plane actions (e.g., code execution, powerful tooling) from regular telemetry or event reporting endpoints.
  • Authenticating and cryptographically binding node identities to their permitted capabilities (e.g., signed claims or capability tokens checked on every request).
  • Hardening gateway execution environments (sandboxing, restricted OS permissions) so that even authorized tooling cannot trivially compromise the host.

How teams detect issues like this

Detection efforts can focus on both code-level and runtime signals:

  • Static analysis & code review:
  • Search for handler functions dealing with node.event or agent.request messages that lack explicit authorization checks or role validation.
  • Flag code paths where gateway tools or command execution APIs are callable from request handlers without permission checks or policy evaluation.
  • Review the design of role and permission models to ensure node roles have clearly scoped capabilities, and verify those checks are enforced at every entry point.
  • Configuration and policy enforcement:
  • Use security policies that require explicit access control annotations for any endpoint capable of executing tools or code.
  • Integrate automated review tools into CI to detect newly introduced handlers that expose tool execution without authorization guards.
  • Operational monitoring:
  • Log all node-initiated tool invocations, including node identity, requested action, and result, and alert on abnormal patterns (e.g., a standard node triggering administrative tools).
  • Monitor for unexpected command execution or changes initiated from node contexts on the gateway.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/a77928b1087e90f2a8903f8e5aca6dec9237ac62
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-gjm7-hw8f-73rq
vulncheck.comvulncheck.com/advisories/openclaw-privilege-escalation-to-remote-code-execution-via-unrestricted-node-event-agent-dispatch

Frequently asked

questions

Exploitation is typically limited to actors who can obtain or control valid role=node credentials or a paired node instance.

However, in many environments nodes may run in less controlled contexts, so compromise of a single node can be enough to pivot into the gateway.

The attacker needs network access to the node-to-gateway channel and the ability to authenticate as a paired node.

This could be achieved by compromising an existing node, stealing its credentials, or abusing misconfigured pairing workflows.

Introduce strict, explicit authorization checks for all gateway paths that execute tools or agents in response to node requests.

Tie permitted operations to specific roles and node identities, and enforce a default-deny posture for any unrecognized or unapproved tool invocation.

Design the system with the assumption that nodes can be compromised and should not be able to perform administrative actions by default.

Implement clear capability models, ensure every privileged operation is guarded by authorization logic, and use automated checks (static analysis, policy-as-code) to prevent new unauthenticated or over-privileged endpoints from being introduced.

Find out what's already
exploitable in your codebase.