/

CVE-2026-62186

Severity:

HIGH RISK

(7.6)

AuthZ Bypass (CWE-862) in OpenClaw HTTP Overrides

CVE-2026-62186

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-862, CWE-863

Impact:

Privilege Escalation and Policy Bypass

Severity:

HIGH RISK

(7.6)

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 contains an authorization bypass in its OpenAI-compatible HTTP model override handling that lets lower-trust callers invoke operations intended for more privileged roles.

When input paths or override rules are misconfigured, attackers can route requests around admin-only authorization checks and perform restricted actions.

Affected context

This vulnerability arises in OpenClaw deployments that expose OpenAI-compatible HTTP endpoints with model override features.

It is most relevant where:

  • Multiple trust levels or roles (e.g., user vs. admin) share the same gateway
  • Authorization policies are enforced based on paths, routes, or override configurations
  • Model override rules can change execution behavior but are not consistently tied to strong authorization checks

In such environments, a misalignment between routing, override logic, and authorization enforcement can let less-privileged callers access admin-only operations.

Exploit preconditions

  • Attack surface: OpenAI-compatible HTTP API endpoints exposed by OpenClaw
  • Required access: Ability to send requests as a lower-privilege or untrusted caller (e.g., regular user API key or token)
  • Trigger point: Use of specially crafted or misconfigured input paths and override parameters that cause requests to be processed under admin-only logic without corresponding admin authorization checks
  • Why exploitation is possible: Authorization enforcement is incomplete (CWE-862) or applied to the wrong actor/context (CWE-863), allowing certain override-affected routes to skip or weaken admin policy checks when specific path configurations are used

Why this happens

The core issue is an authorization logic gap around how OpenAI-compatible HTTP model overrides are mapped to privileged operations.

Authorization checks are either missing on some override-driven code paths (CWE-862: Missing Authorization) or applied to the wrong principal or context (CWE-863: Incorrect Authorization), allowing non-admin callers to be treated as if they had elevated privileges.

Abstractly, this reflects a pattern where routing or configuration-driven behavior changes system capabilities, but the associated enforcement of access control rules does not consistently follow those changes.

When path-based policies, override rules, and role checks are not tightly coupled, requests can enter privileged execution flows without the required authorization validation.

Potential impact

  • Lower-privilege users may perform operations intended only for administrators
  • Attackers could modify or override model behavior in ways that bypass policy controls
  • Restricted administrative configuration changes could be executed by untrusted callers
  • Audit trails and security assumptions about who can perform certain actions may become unreliable
  • Misuse of privileged operations can lead to data exposure, integrity loss, or service abuse

General mitigation guidance

Effective mitigation focuses on strengthening and centralizing authorization enforcement around all privileged operations, regardless of routing or override configuration.

Helpful defensive patterns include:

  • Defining clear privilege boundaries and mapping every model override or admin-only action to explicit role-based checks
  • Implementing a central authorization layer that is invoked for all HTTP endpoints and override-driven flows, rather than relying on per-path assumptions
  • Treating configuration-driven changes (such as HTTP model overrides or special input paths) as potential privilege escalators and requiring strong, consistent authorization validation
  • Minimizing complexity in access control logic by using declarative policies (e.g., allow/deny lists for privileged operations) that cannot be bypassed by alternate routing
  • Ensuring that default behaviors are conservative, denying access when the authorization context is ambiguous or misconfigured

How teams detect issues like this

Detection typically involves both design-level and implementation-level review of authorization behavior:

  • Static analysis or policy-as-code checks that ensure all privileged operations and override-handling functions call a shared authorization mechanism
  • Code review focusing on route handlers, middleware, and configuration parsing logic to detect paths where admin-only actions can be triggered without explicit role checks
  • Tests and security regression suites that simulate requests from different roles (e.g., user vs. admin) across all override combinations to confirm that unauthorized calls are rejected
  • Logging and monitoring of privileged operation invocations, coupled with anomaly detection for actions executed under non-admin identities
  • Automated authorization linting tools that flag endpoints whose effective capabilities exceed the documented access requirements

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-jhfx-v2j8-x3m6
vulncheck.comvulncheck.com/advisories/openclaw-authorization-bypass-via-http-model-override

Frequently asked

questions

Exploitation requires access to the exposed OpenAI-compatible HTTP API. Any caller with network reach and a lower-privilege identity that can send requests to the affected endpoints may attempt to abuse misconfigured paths and overrides.

In most deployments, attackers need at least the same level of access as a regular user (such as a user API key or token). The vulnerability lies in being able to perform admin-grade actions with non-admin credentials when override routes are misconfigured.

The safest pattern is to centralize and enforce strict role-based authorization for all privileged operations, ensuring that any request that can trigger admin-only behavior is validated through a single, robust authorization mechanism regardless of path or override configuration.

Preventive strategies include designing access control as a first-class, centralized concern; using declarative policies that bind actions to roles; thoroughly testing authorization boundaries with multiple identities; and incorporating security reviews and automated checks for new routes, configuration features, and override mechanisms.

Find out what's already
exploitable in your codebase.