/

CVE-2026-28473

Severity:

HIGH RISK

(8.1)

Authorization Bypass in OpenClaw Exec Approvals

CVE-2026-28473

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation / Unauthorized Operation Approval

Severity:

HIGH RISK

(8.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 contains an authorization bypass where users with only operator.write scope can approve or deny exec approval requests by invoking the /approve chat command.

Because this command is routed through an internal privileged gateway client that skips the normal operator.approvals permission check, lower-privileged operators can resolve sensitive exec approvals they should not control.

Affected context

This vulnerability affects OpenClaw deployments that:

  • Use the exec approval workflow for controlling privileged exec actions
  • Expose a chat-style interface or bot that supports the /approve command
  • Rely on operator.approvals permissions to gate access to exec.approval.resolve

In such environments, any client or operator identity granted operator.write scope but not operator.approvals may still be able to resolve approval requests through the chat command path.

Exploit preconditions

  • Attack surface: Application control plane / chat or bot interface used to manage exec approvals
  • Required access: An authenticated account or client with operator.write scope and the ability to send /approve commands
  • Trigger point: Sending a crafted /approve chat command that targets an existing exec approval request
  • Why exploitation is possible:
  • The /approve command is implemented via an internal privileged gateway client
  • That gateway directly calls exec.approval.resolve without enforcing the operator.approvals permission check that applies to direct RPC calls
  • As a result, authorization decisions depend on the gateway's elevated privileges rather than the caller's true permission set

Why this happens

The root cause aligns with CWE-863: Incorrect Authorization, specifically an inconsistency between authorization enforcement across different call paths to the same sensitive operation.

OpenClaw correctly protects direct RPC access to exec.approval.resolve with an operator.approvals permission check. However, the chat /approve command is wired through an internal privileged gateway client that skips this check and acts on behalf of the caller without re-evaluating their permissions.

This pattern creates an alternate control path where the same privileged action (resolving exec approvals) is exposed with weaker authorization requirements, leading to privilege escalation for users with only operator.write scope.

Potential impact

  • Lower-privileged operators can approve or deny exec approvals they are not authorized to manage
  • Unauthorized execution of sensitive commands or sessions gated by the approval workflow
  • Bypass of change-control or production access policies enforced via exec approvals
  • Potential lateral movement or expansion of operational access within production or sensitive environments
  • Undermining of auditability and trust in approval logs, as actions appear formally approved despite broken authorization

General mitigation guidance

Effective mitigation typically focuses on centralizing and normalizing authorization checks across all entry points to sensitive operations:

  • Ensure that all paths to exec.approval.resolve (RPC, chat commands, UI, automation hooks) invoke the same authorization layer that enforces operator.approvals.
  • Avoid granting internal gateway clients blanket privileges that bypass per-user permission checks; instead, have gateways re-check the effective permissions of the originating user.
  • Implement a consistent permission model for scopes such as operator.write and operator.approvals, clarifying that approval resolution is a distinct, higher-privilege capability.
  • Prefer secure-by-default command routing patterns where new interfaces (chat/bot, CLI, UI) reuse existing service APIs instead of adding special privileged shortcuts.
  • Apply the principle of least privilege to any internal service accounts or gateway identities that proxy user actions, limiting them to only what is strictly necessary.

How teams detect issues like this

Detection generally involves both code-level review and runtime monitoring:

  • Static analysis & code review:
  • Identify all call sites of exec.approval.resolve and verify that each passes through a common authorization component.
  • Flag internal gateway or bot clients that perform privileged actions on behalf of users without re-checking user permissions or scopes.
  • Review chat or command handlers (/approve, /deny, etc.) for direct invocation of privileged RPCs or services.
  • Policy and configuration review:
  • Examine permission mappings to ensure operator.write does not implicitly confer approval rights.
  • Audit roles and scopes assigned to bot or integration accounts that can submit commands.
  • Runtime and log analysis:
  • Correlate approval resolution events with the scopes/roles of the initiating identities to detect patterns of approvals by accounts lacking operator.approvals.
  • Use automated monitoring rules to alert when a non-approved role resolves exec approvals.

Automated code review or SAST tools can assist by enforcing rules that mandate centralized authorization checks for sensitive operations like approval resolution.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/efe2a464afcff55bb5a95b959e6bd9ec0fef086e
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-mqpw-46fh-299h
vulncheck.comvulncheck.com/advisories/openclaw-authorization-bypass-via-approve-chat-command

Frequently asked

questions

It can be, if the chat or command interface is reachable over the network and an attacker can obtain or compromise an account with operator.write scope. The exploit still requires valid authentication but bypasses the intended approval-specific permission checks.

The attacker needs an authenticated identity with operator.write scope and the ability to send /approve commands through the chat or bot interface. They do not need the higher-privileged operator.approvals permission that should normally guard approval resolution.

Route all approval resolution actions through a single, shared authorization layer that enforces operator.approvals for every call, regardless of entry point. Any internal gateway or bot should act as a transparent proxy that reuses this check instead of using its own elevated credentials.

Design sensitive operations like approvals around centralized access control, require threat modeling for new interfaces (bots, chat commands, integrations), and enforce architectural rules that forbid alternate privileged paths. Regularly audit all invocation paths to critical RPCs and validate that they apply consistent, role-based authorization checks.

Find out what's already
exploitable in your codebase.