/

CVE-2026-35630

Severity:

HIGH RISK

(8.0)

Missing Authorization / Access Control in OpenClaw QQBot

CVE-2026-35630

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Action Execution

Severity:

HIGH RISK

(8.0)

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.5.18 contain a missing authorization check in QQBot native approval buttons, where the configured approver identity is not properly enforced.

As a result, non-approver users can approve pending exec or plugin requests, potentially allowing unauthorized execution of actions that should require explicit privileged approval.

Affected context

This vulnerability arises in OpenClaw deployments that integrate QQBot native approval buttons for workflows such as exec or plugin execution.

In affected versions, the system relies on the presence of an approval button click but does not reliably verify that the click originated from the configured approver identity.

Environments where many users can see and interact with approval messages, especially in shared channels or groups, are more exposed to this issue.

Exploit preconditions

  • Attack surface: QQBot native approval messages and buttons exposed in chat channels.
  • Required access: Ability for a non-approver user to view and interact with approval buttons (e.g., membership in the relevant chat space).
  • Trigger point: Clicking a native approval button associated with pending exec or plugin approval requests.
  • Why exploitation is possible: The backend logic accepts button interactions as valid approvals without enforcing that the actor matches the configured approver identity, resulting in missing authorization checks.

Why this happens

The root cause is a logical access control flaw where the system assumes that the presence of an approval button implies a trusted approver, rather than verifying the identity of the user who clicks it.

This maps to CWE-862: Missing Authorization, where an application exposes a privileged function (approving exec or plugin actions) but fails to enforce that only authorized principals can invoke it.

The approval workflow trusts client-side or front-end context (button placement and visibility) instead of consistently enforcing server-side authorization based on the authenticated user and configured approver list.

Potential impact

  • Non-approver users could authorize exec operations that may run commands or tasks with elevated privileges.
  • Unauthorized users could approve plugin installations, updates, or activations.
  • Bypass of established change-control or approval processes, undermining governance and auditability.
  • Potential lateral movement or expansion of privileges if exec or plugins can access broader system resources.
  • Erosion of trust in automated workflows relying on human approvals for safety checks.

General mitigation guidance

Mitigation centers on enforcing robust server-side authorization checks for all approval actions and avoiding reliance on client-visible controls as the sole gate.

Recommended defensive patterns include:

  • Validating, on the server, that the authenticated user performing an approval is explicitly listed as a permitted approver for that request.
  • Designing approval workflows so that the approval decision is tied to a durable, verifiable identity (e.g., user ID) rather than channel membership or message context.
  • Applying least-privilege principles by limiting who can see and click approval controls for sensitive actions.
  • Implementing audit logging that records approver identities and related metadata to detect anomalies and support investigations.
  • Introducing configurable policies that restrict which roles or groups can perform high-risk approvals (exec, plugin management).

How teams detect issues like this

Detection strategies focus on both code-level and operational indicators:

  • Static analysis / code review: Look for approval endpoints or handlers that change the status of exec or plugin requests without checking the caller's role, group membership, or specific approver lists.
  • Authorization policy review: Ensure that all approval-related routes are subject to the same authorization middleware or policy engine used for other privileged operations.
  • Runtime monitoring: Analyze audit logs for patterns where approvals are frequently performed by users not normally associated with privileged roles, or from unexpected channels.
  • Automated testing: Incorporate security tests that simulate non-approver users attempting to approve pending requests, validating that such attempts are rejected at the API layer.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-mgq6-vr84-7m2j
vulncheck.comvulncheck.com/advisories/openclaw-qqbot-missing-approver-identity-enforcement-in-native-approval-buttons

Frequently asked

questions

Exploitability depends on how widely approval buttons are exposed. In shared channels where many users can see and click approval buttons, any user with access to those channels could potentially exploit the issue. In tightly restricted channels, the exposure is narrower.

An attacker needs sufficient access to view and interact with QQBot approval messages—typically membership in the relevant group or channel. They do not need approver status or elevated backend permissions, only the ability to click the exposed buttons.

The safest pattern is to enforce strict server-side authorization checks for all approval endpoints. Each approval action should verify that the authenticated user is explicitly authorized for that specific approval request, using role or approver lists, and reject any mismatched identities.

To prevent similar flaws, adopt a consistent access control architecture where server-side checks are mandatory for all privileged actions. Use centralized authorization middleware or policy engines, perform regular security-focused code reviews of workflow logic, and include automated tests that exercise negative scenarios (non-approver attempts) for all approval or state-changing operations.

Find out what's already
exploitable in your codebase.