/

CVE-2026-35674

Severity:

HIGH RISK

(8.8)

Authorization Bypass in OpenClaw Gateway chat.send Route

CVE-2026-35674

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Unauthorized Configuration Mutation

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 Gateway builds before 2026.5.18 contain an authorization scope bypass in the chat.send route that lets scoped clients execute commands requiring higher privileges.

By abusing inherited external routes, an attacker holding only the operator.write scope can bypass operator.approvals and operator.admin checks to perform unauthorized plugin, configuration, MCP, allowlist, and ACP changes.

Affected context

The vulnerability affects OpenClaw deployments that:

  • Expose the Gateway chat.send route to scoped clients (e.g., service-to-service or client applications)
  • Rely on scope-based authorization to separate operator.write from higher-privileged scopes such as operator.approvals and operator.admin
  • Allow external routing or command dispatch through the chat gateway to reach internal operator or management functionality

In these environments, authorization logic in chat.send does not consistently enforce the stricter scopes required by downstream privileged operations.

Exploit preconditions

  • Attack surface: OpenClaw Gateway chat.send HTTP/WebSocket/API endpoint, reachable by clients or services with valid credentials.
  • Required access: Valid client identity with at least the operator.write scope and the ability to send messages or commands via chat.send.
  • Trigger point: Submission of specially crafted chat/command payloads that are routed through inherited external routes toward privileged operator functionality.
  • Why exploitation is possible: The authorization checks on the gateway route are incomplete or misaligned with the checks on the privileged operations, allowing operator.write-scoped requests to be treated as if they possessed operator.approvals or operator.admin for certain command paths.

Why this happens

This issue stems from incorrect authorization logic (CWE-863) where the effective privilege of a request is derived from the gateway route rather than the actual sensitivity of the target operation.

The chat.send route acts as a generic dispatch mechanism and forwards messages into external or inherited routes that eventually perform privileged actions, but the scope validation at the entry point does not enforce the stricter scopes required by those actions.

As a result, the system treats a lower-privileged operator.write token as sufficient to initiate workflows that should demand operator.approvals or operator.admin, leading to a scope escalation path through the routing layer.

Potential impact

  • Unauthorized modification of plugins, including installation, removal, or configuration changes.
  • Unapproved or hidden configuration changes that can alter system behavior or weaken security controls.
  • Unauthorized updates to MCP (model/control/management) parameters, potentially impacting AI behavior or policy enforcement.
  • Manipulation of allowlists and ACP (access control policies), which can open new attack surfaces or grant persistent over-privilege.
  • Indirect privilege escalation where an attacker uses configuration changes to gain broader access or disrupt operations.

General mitigation guidance

Effective mitigation focuses on making authorization contextual and least-privilege-aware across all routing layers:

  • Enforce operation-level authorization: each privileged operation (plugin management, config changes, ACP updates, etc.) should verify its required scopes independently of the gateway route that invoked it.
  • Normalize and centralize scope mapping: define a clear mapping between scopes and operations, and have all entry points reference the same canonical policy rather than ad hoc checks.
  • Restrict generic dispatch endpoints: limit which internal or external routes can be reached from chat.send, especially those performing administrative actions; consider separate administrative APIs that are not exposed through user-facing chat routes.
  • Apply defense-in-depth checks: require stronger scopes or multi-step approval flows (e.g., explicit approvals, dual control) for sensitive configuration and policy mutations.
  • Design scopes using least privilege and avoid over-broad scopes like write that implicitly grant access to administrative workflows.

How teams detect issues like this

To detect similar authorization bypass patterns, organizations can:

  • Perform authorization-oriented code review, validating that each privileged handler enforces its own scope or role requirements and does not rely solely on upstream routing assumptions.
  • Use static analysis or policy-as-code tools to identify routes or methods that:
  • Call administrative or configuration-modifying functions
  • Are guarded only by lower-privilege scopes such as *write
  • Skip or weaken checks compared to other code paths invoking the same operations
  • Implement centralized authorization logging, recording requested scopes, evaluated operations, and decisions; analyze these logs for cases where low-privilege scopes succeed on high-privilege operations.
  • Add unit and integration tests for access-control rules, including negative tests that ensure operator.write cannot reach administrative routes or configuration mutation endpoints.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-hw9r-h9mr-4jff
vulncheck.comvulncheck.com/advisories/openclaw-scope-bypass-via-inherited-chat-send-route

Frequently asked

questions

Yes, if the OpenClaw Gateway chat.send endpoint is accessible over the network and an attacker can obtain or control a client credential with the operator.write scope, the issue can be exploited remotely.

The attacker needs valid access with at least the operator.write scope and the ability to send messages or commands through chat.send. No explicit operator.approvals or operator.admin scope is required if the vulnerable routing logic is present.

The most robust approach is to enforce authorization at the level of each privileged operation, with explicit checks for the correct high-privilege scopes (operator.approvals, operator.admin, etc.), and to ensure that generic gateway routes like chat.send cannot downgrade or bypass these checks.

Model authorization as a centralized, testable policy; avoid relying on implicit trust boundaries in routing layers; require strong scopes for any configuration or policy mutation; and continuously test and audit access-control decisions with both automated tools and targeted security reviews of high-privilege flows.

Find out what's already
exploitable in your codebase.