/

CVE-2026-32918

Severity:

HIGH RISK

(8.4)

Improper Authorization in OpenClaw Session Sandbox

CVE-2026-32918

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Sandbox Escape and Unauthorized Session State Access

Severity:

HIGH RISK

(8.4)

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.11 contains a sandbox escape vulnerability in the session_status tool that allows sandboxed subagents to read or modify session state belonging to their parent or sibling sessions.

By supplying arbitrary sessionKey values, an attacker can operate outside their intended sandbox scope, potentially tampering with persisted model overrides and other sensitive session data.

Affected context

This vulnerability affects OpenClaw deployments using the session_status tool to introspect or manipulate session state for agents and subagents.

It is particularly relevant where:

  • Subagents are assumed to be confined to isolated session sandboxes
  • The session_status tool is exposed to untrusted or semi-trusted agent logic
  • Session state includes sensitive configuration such as persisted model overrides, routing decisions, or user-specific context

The risk increases in multi-tenant environments where different users or workflows share the same OpenClaw infrastructure.

Exploit preconditions

  • Attack surface: The session_status tool interface invoked by sandboxed subagents or other session-scoped components.
  • Required access: Ability to call session_status and control the sessionKey parameter from within a sandboxed subagent or scoped context.
  • Trigger point: Sending a crafted request or invocation that specifies a sessionKey for a parent or sibling session instead of the caller's own session.
  • Why exploitation is possible: The authorization check for session_status relies on the supplied sessionKey without enforcing that it belongs to the caller's sandbox, allowing bypass of intended isolation boundaries.

Why this happens

The core issue is an authorization flaw where access control is performed implicitly or inadequately on a parameter that identifies the target session.

Instead of deriving or strictly validating the effective session scope from trusted context, the implementation trusts the caller-provided sessionKey, enabling access to session data outside the caller's sandbox.

This aligns with CWE-863: Improper Authorization, where the system fails to correctly verify whether the subject (sandboxed subagent) is permitted to act upon the specified object (parent or sibling session state).

Abstractly, this reflects a broken multi-tenant isolation pattern: resource identifiers are externally controllable and not bound to the authenticated or sandboxed identity.

Potential impact

  • Sandboxed subagents may read sensitive data from parent or sibling sessions, including user context and configuration.
  • Attackers can modify session state outside their scope, influencing behavior of other agents or workflows.
  • Persisted model overrides can be tampered with, leading to unexpected or malicious model behavior.
  • Cross-session data leakage that undermines tenant isolation and privacy guarantees.
  • Indirect escalation of privileges if modified session state grants broader capabilities to other components.

General mitigation guidance

Effective mitigation focuses on enforcing strict authorization around session identifiers and sandbox boundaries:

  • Derive the target session identity from trusted execution context (e.g., caller's bound session) rather than caller-controlled parameters whenever possible.
  • Where a sessionKey parameter is necessary, validate that it belongs to the caller's authorized scope (e.g., same sandbox, tenant, or ownership).
  • Implement centralized access control checks for session operations, ensuring read and write paths use the same authorization logic.
  • Treat session state as multi-tenant data and apply least-privilege principles, exposing only the minimal subset of state required to subagents.
  • Design the sandbox API surface so that subagents cannot reference arbitrary session identifiers, preferring capability-style handles tied to their own context.

How teams detect issues like this

High-level approaches for detecting similar authorization flaws include:

  • Static analysis rules that flag direct use of caller-controlled identifiers (like sessionKey) in authorization or lookup logic without accompanying ownership checks.
  • Code review practices that require explicit mapping between a caller's identity/sandbox and the resources they are allowed to access, especially in session and tenant management code.
  • Policy enforcement that discourages "pass-through" resource identifiers in privileged tools (such as session_status) without server-side derivation or validation.
  • Runtime monitoring and logging that capture cross-session access patterns, such as a single subagent querying multiple distinct sessionKey values, enabling anomaly detection.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-wcxr-59v9-rxr8
vulncheck.comvulncheck.com/advisories/openclaw-session-sandbox-escape-via-session-status-tool

Frequently asked

questions

It can be exploitable wherever untrusted or semi-trusted code (such as sandboxed subagents) can invoke session_status and control the sessionKey. External remote access is not strictly required; the key factor is the ability to influence that parameter within the environment.

An attacker must have the capability to execute within a sandboxed subagent or similar context that can call session_status. From there, supplying arbitrary sessionKey values allows access beyond the intended sandbox.

Bind session operations to the caller's authenticated or sandbox identity, deriving the effective session target from trusted context rather than from user-controlled input, and enforce centralized authorization checks for any cross-session operation.

Architect session and tenant handling around strong isolation guarantees: treat any resource identifier from untrusted sources as untrusted, validate ownership before use, standardize access-control utilities for session operations, and include these patterns in code review and security testing guidelines.

Find out what's already
exploitable in your codebase.