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.

