/

CVE-2026-32924

Severity:

CRITICAL RISK

(9.8)

Authorization Bypass in OpenClaw Feishu Reaction Events

CVE-2026-32924

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Policy Bypass in Group Chat Workflows

Severity:

CRITICAL RISK

(9.8)

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.3.12 contain an authorization bypass vulnerability where Feishu reaction events that omit the chat_type field are incorrectly treated as p2p conversations instead of group chats.

This misclassification allows attackers to bypass group-level protections such as groupAllowFrom and requireMention for reaction-derived events in group chats.

Affected context

The vulnerability appears in OpenClaw's handling of Feishu reaction events when processing webhook or event callbacks from Feishu.

Specifically, it affects deployments where:

  • Reaction events originating from group chats may arrive without an explicit chat_type field
  • OpenClaw infers conversation type and then applies access control and policy checks based on that classification
  • Group-specific controls such as groupAllowFrom and requireMention are expected to gate which reactions are honored in downstream automation or integrations

Under these conditions, group chat reactions without chat_type can be silently treated as p2p events and escape the intended group protections.

Exploit preconditions

  • Attack surface: Feishu webhook / event ingestion endpoint or integration that processes reaction events via OpenClaw.
  • Required access: Ability to participate in or interact with a Feishu group chat that is connected to OpenClaw (e.g., send reactions in that group). No direct access to OpenClaw internals is required.
  • Trigger point: Sending reaction events in a group conversation where the incoming payload omits chat_type, causing OpenClaw to fall back to a p2p classification.
  • Why exploitation is possible: The authorization logic is tightly coupled to the inferred conversation type. When chat_type is missing, the system defaults to treating the event as a p2p conversation and therefore skips group-level checks like groupAllowFrom and requireMention, effectively weakening access control.

Why this happens

The root cause is an authorization design flaw where access control decisions depend on a misclassified security context.

In this case, OpenClaw's event handling pipeline uses the chat_type field (p2p vs group) to decide which policy set to apply.

When chat_type is omitted in Feishu reaction events, the implementation defaults to treating the event as a p2p conversation rather than handling the absence as an error or unknown state.

This behavior maps to CWE-863: Incorrect Authorization, because the system authorizes reaction-derived actions under the wrong trust model, failing to enforce group-specific rules.

Conceptually, this is an insecure pattern where missing or ambiguous context is resolved in favor of a more permissive classification instead of a conservative, deny-by-default approach.

Potential impact

  • Attackers can bypass groupAllowFrom restrictions, causing reactions from unauthorized users or contexts to be accepted.
  • Group chats that rely on requireMention for safety controls may see automations or workflows triggered by reactions from users who did not explicitly mention required entities.
  • Unauthorized triggering of bots, workflows, or downstream integrations that respond to reactions in group chats.
  • Escalation of influence in collaborative environments, such as forcing actions, approvals, or notifications that should be gated by group policies.
  • Increased risk of social engineering or misuse of automation where group-level guardrails were assumed to be enforced.

General mitigation guidance

Effective mitigation focuses on tightening authorization logic around event classification and enforcing conservative defaults:

  • Treat missing or ambiguous chat_type as an invalid or unknown state, and fail closed by refusing to process the event or applying the strictest available policy.
  • Decouple authorization rules from a single inferred field by validating group membership and conversation type through multiple attributes or explicit verification with Feishu APIs where appropriate.
  • Apply group-level protections (groupAllowFrom, requireMention, and similar policies) whenever there is any indication that an event may be group-related, not only when a field explicitly states it.
  • Centralize authorization decisions in a dedicated component that consistently handles edge cases like absent fields and malformed payloads.
  • Design policy evaluation to be explicit and complete: all relevant conditions must be satisfied before granting access or triggering workflows, rather than relying on permissive defaults.

How teams detect issues like this

Detection typically involves a combination of review, analysis, and runtime monitoring:

  • Static analysis / code review: Look for authorization branches where conversation type is inferred from a single field such as chat_type, especially where a default value is assigned when the field is missing. Flag any code that processes events without verifying whether the context is group or p2p in a robust way.
  • Policy review: Examine the authorization model for chat integrations to ensure that group-specific policies are not silently skipped in fallback branches.
  • Logging and telemetry: Instrument event handling to log the raw Feishu payload, computed conversation type, and applied policy set. Alert on events where chat_type is absent or where a group identifier coexists with a p2p classification.
  • Behavioral testing: Create automated tests that send synthetic reaction events with missing or inconsistent chat_type values and verify that group protections like groupAllowFrom and requireMention are still enforced.
  • Automated code scanning or security review tools can help highlight places where event classification is used directly to gate authorization decisions.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-m69h-jm2f-2pv8
vulncheck.comvulncheck.com/advisories/openclaw-authorization-bypass-via-misclassified-reaction-events-in-feishu

Frequently asked

questions

Yes. Anyone able to send reactions in a Feishu group chat that is integrated with OpenClaw can potentially trigger the vulnerability via the remote event interface, without needing direct network access to OpenClaw itself.

The attacker generally needs the ability to participate in or interact with a target Feishu group that is wired into OpenClaw.

From there, they can leverage reaction events that are misclassified due to the missing chat_type field to bypass group-level protections.

The safest pattern is to enforce strict, deny-by-default authorization based on robust context determination:

treat missing or ambiguous chat_type as an error, require explicit and validated conversation metadata, and always apply group policies when an event may originate from a group context.

Future prevention involves designing authorization systems that:

  • Do not rely on a single, potentially missing field for security decisions
  • Use conservative defaults when context is unclear
  • Include comprehensive tests for malformed or partial event payloads
  • Centralize and standardize how context (like chat type and membership) is validated before applying policies or triggering actions.
Find out what's already
exploitable in your codebase.