/

CVE-2026-42429

Severity:

HIGH RISK

(7.1)

Improper Authorization in OpenClaw Gateway HTTP

CVE-2026-42429

Modified

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Privilege Escalation to Unauthorized Write Operations

Severity:

HIGH RISK

(7.1)

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 versions before 2026.4.8 contain an authorization flaw in the gateway plugin's HTTP authentication flow that incorrectly expands read-only operator requests into write-capable runtime permissions.

When identity-bearing operator.read requests pass through the affected gateway auth route, they may be treated as operator.write, allowing attackers to perform unauthorized runtime operations.

Affected context

The vulnerability occurs in OpenClaw deployments that use the gateway plugin's HTTP authentication mechanism to enforce operator permissions.

It is relevant where:

  • Operator roles such as operator.read and operator.write are used to constrain runtime actions
  • Runtime operations are proxied through the gateway rather than accessed directly
  • Downstream services rely on the gateway to correctly translate and enforce authorization scopes

In such contexts, read-scoped requests routed through the gateway can be mistakenly transformed into write-level permissions.

Exploit preconditions

  • Attack surface: HTTP endpoints exposed by the OpenClaw gateway plugin's authentication/authorization route.
  • Required access: Ability to send authenticated or identity-bearing HTTP requests that are intended to be scoped as operator.read.
  • Trigger point: Submission of read-scoped operator requests (e.g., inspection, status, or query operations) through the vulnerable gateway auth path.
  • Why exploitation is possible: The authorization logic widens or maps operator.read identity information into runtime permissions that are effectively operator.write, failing to preserve the intended least-privilege semantics.

Why this happens

This issue stems from improper authorization checks and scope handling within the gateway plugin's HTTP authentication and permission mapping logic.

Instead of strictly enforcing the distinction between read-only (operator.read) and write-capable (operator.write) privileges, the gateway improperly broadens or conflates these roles when constructing runtime permissions.

This aligns with CWE-863: Incorrect Authorization, where the system authorizes more access than intended due to flawed policy evaluation, scope translation, or role mapping, enabling privilege escalation from read to write.

Potential impact

  • Attackers with read-scoped access may perform unauthorized write operations on runtime resources.
  • Modification or disruption of running operations or workflows that were expected to be read-only observable.
  • Integrity compromise of runtime configuration, state, or operational data.
  • Escalation from monitoring/inspection capabilities to active control over operational behavior.
  • Indirect impact on availability if unauthorized writes cause service instability or failures.

General mitigation guidance

Effective mitigation focuses on tightening authorization boundaries and ensuring scopes are not broadened during authentication or routing:

  • Enforce strict separation between read and write roles in the gateway, ensuring no automatic widening of scopes or fallback to broader permissions.
  • Implement explicit, least-privilege authorization checks in the gateway layer, mapping operator.read and operator.write to distinct runtime permission sets.
  • Use centralized authorization policies (e.g., policy-as-code) where scopes and role mappings are declared and audited rather than hard-coded.
  • Introduce defense-in-depth by having downstream services re-validate scope or role claims instead of fully trusting gateway-provided privileges.
  • Log and monitor access control decisions, especially where the gateway translates identities into runtime permissions, to detect unusual patterns or scope expansions.

How teams detect issues like this

Organizations can detect and monitor for this class of issue using:

  • Static analysis and code review: Look for authorization logic that:
  • Maps multiple roles (read and write) to the same effective permission set.
  • Performs permissive defaulting (e.g., treating unknown scopes as write or full access).
  • Trusts incoming scopes without validating them against a canonical policy store.
  • Configuration and policy audits: Review gateway and access-control policies to ensure read-only roles are never translated into write-capable runtime privileges.
  • Runtime logging and anomaly detection: Collect detailed logs of:
  • Incoming scopes/roles on the gateway.
  • Resulting runtime permissions attached to each request.

Then use automated analysis to identify patterns where read-scoped identities trigger write operations.

  • Security testing: Incorporate authorization tests into CI/CD and pre-release testing to verify that read-only credentials cannot perform write actions via the gateway.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/d7c3210cd6f5fdfdc1beff4c9541673e814354d5
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-4f8g-77mw-3rxc
vulncheck.comvulncheck.com/advisories/openclaw-privilege-escalation-via-gateway-plugin-http-authentication

Frequently asked

questions

It can be, if the OpenClaw gateway endpoints are exposed over the network and an attacker can send identity-bearing requests through the affected HTTP auth route. The exploitability depends on how widely reachable the gateway is and how identities are issued.

An attacker typically needs access to credentials, tokens, or a calling context that grants them operator.read or equivalent read-scoped permissions. From there, they can leverage the gateway's flawed authorization handling to gain effective write access to runtime operations.

The safest general fix is to enforce explicit, least-privilege authorization mapping in the gateway:

  • Preserve the distinction between read and write scopes at every layer.
  • Avoid any automatic scope widening or fallback to broader roles.
  • Ensure downstream services independently verify that incoming requests are permitted to perform write operations.

Prevention relies on adopting robust access-control design practices:

  • Model roles and scopes clearly, and encode them in centralized, auditable policy.
  • Apply defense-in-depth, where both the gateway and backend services enforce authorization.
  • Add targeted tests for privilege boundaries (e.g., validating that read-only accounts cannot perform writes).
  • Use automated checks (static analysis, policy linters, and CI tests) to flag code paths that merge or broaden roles without explicit justification.
Find out what's already
exploitable in your codebase.