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_typefield - OpenClaw infers conversation type and then applies access control and policy checks based on that classification
- Group-specific controls such as
groupAllowFromandrequireMentionare 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_typeis missing, the system defaults to treating the event as a p2p conversation and therefore skips group-level checks likegroupAllowFromandrequireMention, 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
groupAllowFromrestrictions, causing reactions from unauthorized users or contexts to be accepted. - Group chats that rely on
requireMentionfor 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_typeas 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_typeis 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_typevalues and verify that group protections likegroupAllowFromandrequireMentionare still enforced. - Automated code scanning or security review tools can help highlight places where event classification is used directly to gate authorization decisions.

