/

CVE-2026-41371

Severity:

HIGH RISK

(8.5)

Broken Access Control / Incorrect Authorization

CVE-2026-41371

Analyzed

Vulnerability type

Category:

Broken Access Control / Incorrect Authorization

CWE:

CWE-863

Impact:

Privilege Escalation and Unauthorized Session Control

Severity:

HIGH RISK

(8.5)

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 before 2026.3.28 contains an authorization flaw in the chat.send path that lets write-scoped gateway callers invoke admin-only session reset functionality.

Under certain conditions, a non-admin caller can rotate target sessions, archive prior transcript state, and issue new session IDs without possessing admin scope.

Affected context

This vulnerability occurs in OpenClaw deployments where:

  • The chat.send API endpoint is exposed to gateway clients with write scope
  • Session reset, rotation, and transcript archival operations are implemented as admin-only controls
  • Authorization checks for these operations are either missing or incorrectly enforced along the chat.send request path

It is most relevant in environments where different roles (e.g., standard users, service accounts, and admins) interact with shared chat sessions and rely on strict separation of duties for session lifecycle management.

Exploit preconditions

  • Attack surface: OpenClaw gateway/API surface exposing the chat.send operation
  • Required access: A valid caller that has write-scoped access (e.g., ability to send messages) but lacks admin privileges
  • Trigger point: Crafted or specially parameterized chat.send requests that cause the backend to execute admin-only session reset or rotation logic
  • Why exploitation is possible: The backend relies on incomplete or misplaced authorization checks, allowing the chat.send code path to reach privileged session management routines without verifying that the caller has admin scope

Why this happens

The underlying bug is an incorrect authorization pattern where privilege checks do not align with the sensitivity of the actions being performed.

In OpenClaw, chat.send is intended for message submission under a write scope, but its implementation also exposes admin-only session management capabilities such as session reset, rotation, and transcript archival.

Because the code path either:

  • Fails to enforce a distinct admin permission for these operations, or
  • Performs authorization checks on the wrong attribute (e.g., write scope rather than explicit admin role),

a lower-privileged caller can indirectly trigger privileged actions.

This maps to CWE-863: Incorrect Authorization, where the system performs access control decisions incorrectly, allowing users to act outside their intended permissions.

Potential impact

  • Unauthorized session resets that may disrupt ongoing conversations
  • Forced session ID rotation for other users or tenants, potentially impacting integrity of conversation state
  • Unauthorized archival of transcript history, affecting data retention and compliance controls
  • Confusion or misattribution of activity due to unexpected session changes
  • Potential abuse as a denial-of-service vector by repeatedly resetting active sessions

General mitigation guidance

Effective mitigation focuses on enforcing clear, role-based authorization boundaries around privileged operations:

  • Separate message-sending functionality from session lifecycle management so that chat.send cannot directly invoke admin-only operations.
  • Require explicit admin roles or scopes for any operation that can reset, rotate, or archive sessions, and centralize these checks in a shared authorization layer.
  • Use a permissions model where each sensitive action (e.g., session.reset, session.rotate, transcript.archive) has its own distinct privilege requirement, rather than relying on broad write access.
  • Apply least privilege to service accounts and API tokens, granting only the minimal scopes needed for message sending, not session management.
  • Introduce secure-by-default API designs where optional parameters that influence session control are ignored unless the caller has the appropriate admin capability.

How teams detect issues like this

Detection and assurance typically involve:

  • Static analysis and code scanning: Define rules that flag routes or methods (like chat.send) that call privileged session management functions without explicit role checks.
  • Code review practices: During review of API handlers, verify that each privileged operation (reset, rotation, archival) is guarded by the correct authorization check, independent of generic write scopes.
  • Access control policy review: Maintain an inventory of all admin-only capabilities and systematically confirm that none are reachable via lower-privilege endpoints.
  • Runtime monitoring and logging: Log all session reset and rotation operations with the caller identity, role, and originating endpoint, then alert on suspicious patterns (e.g., non-admin roles performing these actions).
  • Security testing: Incorporate role-based integration tests that attempt to trigger session management operations using write-only tokens to ensure such requests are rejected.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-5r8f-96gm-5j6g
vulncheck.comvulncheck.com/advisories/openclaw-privilege-escalation-via-chat-send-reset-command

Frequently asked

questions

It is exploitable by any party that can successfully call the chat.send endpoint with write scope but lacks admin privileges, such as certain users, microservices, or external integrations, depending on how access tokens are provisioned.

No. The core issue is that write-scoped callers, which are typically less privileged than admins, can trigger actions that should be restricted to admin scope, resulting in a privilege escalation scenario.

The safest approach is to strictly separate responsibilities: isolate privileged session management operations into dedicated endpoints or service methods with explicit admin-only authorization checks, and ensure that chat.send is limited to message submission functionality under a non-privileged scope.

Implement a consistent authorization framework where each sensitive operation declares the exact role or permission it requires, enforce this via centralized middleware or policy engines, and back it with role-based tests, code review checklists, and automated scanning for endpoints that invoke privileged routines without appropriate checks.

Find out what's already
exploitable in your codebase.