/

CVE-2026-32915

Severity:

HIGH RISK

(8.8)

Broken / Missing Authorization in OpenClaw Subagent Sandbox

CVE-2026-32915

Analyzed

Vulnerability type

Category:

Broken / Missing Authorization

CWE:

CWE-863

Impact:

Privilege Escalation and Cross-Session Interference

Severity:

HIGH RISK

(8.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 before 2026.3.11 contains a sandbox boundary bypass where leaf subagents can issue control requests against the parent requester scope instead of being confined to their own session tree.

Under these conditions, a low-privilege sandboxed leaf worker may steer or terminate sibling runs and trigger execution under broader tool policies, effectively escalating its operational impact within the orchestration environment.

Affected context

This vulnerability appears in OpenClaw deployments that:

  • Use subagents (leaf workers) operating under sandboxed or restricted policies
  • Rely on a hierarchical session tree with parent–child requester scopes
  • Expose a control surface for subagent management (e.g., starting, steering, or stopping runs)
  • Do not fully enforce scope-aware authorization checks on subagent control requests

In such setups, a leaf subagent that should only affect its own session can instead interact with the broader control surface and influence other runs.

Exploit preconditions

  • Attack surface: Internal orchestration and agent-control APIs exposed to subagents.
  • Required access: Ability for a low-privilege leaf worker to submit control or management requests (e.g., to steer, pause, or terminate runs).
  • Trigger point: Submission of a crafted control request that is incorrectly evaluated against the parent requester scope instead of the leaf worker's own sandboxed session tree.
  • Why exploitation is possible: Authorization logic does not strictly bind control actions to the initiating subagent's scope, allowing requests to be processed with broader privileges and visibility than intended.

Why this happens

The underlying issue is an authorization flaw where access control decisions are made without correctly constraining the effective scope of the caller.

Instead of enforcing that each leaf subagent can only interact with its own session tree, the system resolves control operations (such as steering or terminating runs) against the parent requester context.

This corresponds to CWE-863: Incorrect Authorization, where a system performs permission checks but fails to ensure that they are applied to the correct object, resource, or scope, enabling actions outside the intended sandbox boundary.

Potential impact

  • A low-privilege leaf worker could steer or modify the behavior of sibling runs.
  • Subagents may terminate or disrupt sibling sessions, causing denial of service for other workloads.
  • Runs could be executed under broader or less restrictive tool policies than intended, effectively escalating the operational capabilities of a low-privilege subagent.
  • Cross-tenant or cross-user interference may occur if multiple isolated workloads share the same orchestration environment.
  • Integrity of orchestration policies and workflow outcomes can be undermined by unauthorized cross-session manipulation.

General mitigation guidance

Effective mitigation focuses on enforcing strict, scope-aware authorization and hardening the subagent sandbox boundaries:

  • Ensure that all subagent control operations are evaluated against the initiating subagent's own session tree and not inherited or resolved through parent requester scope.
  • Implement explicit resource scoping and ownership checks for each control action (e.g., verifying that the caller owns or is explicitly granted permission to manage the target run).
  • Apply least-privilege policies to subagents, limiting available control operations to only those needed for their role.
  • Segment or isolate subagent execution contexts so that policy elevation or cross-session access cannot be achieved solely via control API misuse.
  • Use defense-in-depth with explicit deny rules for cross-scope actions unless they are specifically allowed by configuration or policy.

How teams detect issues like this

Detection generally involves a combination of policy validation, code review, and behavioral monitoring:

  • Code review & design review: Examine the subagent control surface to confirm that all control actions enforce strict scope and ownership checks; flag any paths where parent or global scopes are used by default.
  • Static analysis: Define rules or patterns that detect authorization decisions lacking explicit resource scoping or that reference a parent/global context when called from leaf or sandboxed workers.
  • Runtime monitoring: Log all subagent control requests with caller identity, effective scope, and target run; alert on cross-session control actions or unexpected privilege elevations.
  • Policy-based enforcement: Introduce authorization policies (e.g., in a policy engine) that formally define allowed relationships between subagents and targets, and block or flag any violations.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-4w7m-58cg-cmff
vulncheck.comvulncheck.com/advisories/openclaw-sandbox-boundary-bypass-via-subagent-control-surface

Frequently asked

questions

It depends on how OpenClaw is exposed. The flaw is in the internal authorization between subagents and the control surface; exploitation typically requires the ability to run or influence a low-privilege leaf worker that can send control requests.

An attacker generally needs low-privilege access as a sandboxed leaf subagent or the ability to cause such a subagent to issue crafted control requests. They do not need direct administrative access to the orchestration layer to abuse this specific flaw.

The most robust fix is to enforce strict, scope-aware authorization on all subagent control operations so that a subagent can only affect its own session tree and explicitly permitted resources, never resolving through a parent or global scope by default.

Design agent orchestration and sandboxing with clear, enforced boundaries: always bind authorization to explicit resource ownership, model scopes as first-class entities, validate these rules through tests and policy engines, and regularly review control paths to ensure that no cross-scope actions are possible without deliberate, audited configuration.

Find out what's already
exploitable in your codebase.