/

CVE-2026-43530

Severity:

HIGH RISK

(8.8)

Missing Authorization / Policy Enforcement in OpenClaw Exec

CVE-2026-43530

Analyzed

Vulnerability type

Category:

Missing Authorization / Policy Enforcement

CWE:

CWE-863

Impact:

Authorization Bypass Leading to Execution of High-Risk Applets

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 versions 2026.2.23 through 2026.4.11 contain a weakened exec approval binding flaw in how BusyBox and Toybox multi-call applets are evaluated and approved.

By obscuring which specific applet will actually run inside an opaque multi-call binary, an attacker can bypass exec approval rules and downgrade the perceived risk of unsafe applet invocations.

Affected context

This vulnerability appears in environments using OpenClaw's exec approval or command-allowlisting mechanisms in combination with BusyBox or Toybox multi-call binaries.

It is most relevant where:

  • Exec approval policies are defined per binary or per command name
  • BusyBox or Toybox are used as wrapper binaries for multiple applets (e.g., busybox sh, busybox wget)
  • Security controls rely on OpenClaw's interpretation of which applet is being launched to determine risk or allow/deny decisions

The risk increases when high-privilege or sensitive operations are exposed via BusyBox/Toybox applets and are expected to be tightly controlled.

Exploit preconditions

  • Attack surface: Processes launched under OpenClaw's exec approval system, particularly calls to BusyBox or Toybox.
  • Required access: Ability to trigger or influence process execution on systems protected by OpenClaw (e.g., running commands, crafting scripts, or configuring jobs that invoke BusyBox/Toybox).
  • Trigger point: Executing a multi-call BusyBox/Toybox binary in a way that obscures or misrepresents the applet actually being invoked to the exec approval logic.
  • Why exploitation is possible: OpenClaw's exec approval binding does not correctly resolve or bind the specific internal applet within opaque multi-call binaries, causing the policy engine to evaluate a lower-risk or generic identity instead of the true, potentially dangerous applet.

Why this happens

The root cause is a mismatch between the authorization model and the actual execution semantics of BusyBox and Toybox multi-call binaries.

OpenClaw's exec approval mechanism appears to associate risk and policy with a superficial or generic representation of the executed binary, rather than the concrete applet that will run.

This maps to CWE-863: Incorrect Authorization, because the system checks and classifies the wrong subject (the generic multi-call binary) instead of the real, high-risk operation (the specific applet).

The abstract insecure pattern is an authorization layer that:

  • Trusts incomplete metadata about the operation being authorized, and
  • Fails to normalize or fully resolve compound executables before making allow/deny decisions.

Potential impact

  • Attackers may execute high-risk BusyBox/Toybox applets that would otherwise be blocked by exec approval.
  • Security policies based on per-command risk classification can be silently bypassed.
  • System hardening assumptions (e.g., blocking shell, networking, or file-manipulation applets) can be undermined.
  • Privilege escalation may occur if restricted applets are invoked under higher-privileged contexts that rely on OpenClaw for control.
  • Defense-in-depth layers built around strict exec approval may provide a false sense of security.

General mitigation guidance

Effective mitigation centers on strengthening the binding between authorization decisions and the actual applet or operation being run.

Pattern-oriented strategies include:

  • Normalize execution targets: Ensure the exec approval logic resolves BusyBox/Toybox applets to a canonical identity before policy evaluation (e.g., normalize to the actual applet name or effective entry point).
  • Policy at applet granularity: Define and enforce rules at the level of specific applets instead of only the top-level multi-call binary.
  • Guard high-risk applets explicitly: Treat shells, networking tools, file editors, and other sensitive applets as high-risk regardless of how they are invoked, including aliases and multi-call entry points.
  • Constrain invocation patterns: Favor explicit, transparent command invocation patterns in critical paths (e.g., calling dedicated binaries instead of opaque multi-call wrappers).
  • Least privilege execution: Run processes governed by exec approval with minimal necessary privileges so that any approval mistake has limited blast radius.

How teams detect issues like this

To detect this class of flaw and similar authorization gaps:

  • Static analysis of policy engine: Review code that maps process execution metadata (argv[0], symlinks, multi-call wrappers) to policy subjects, looking for cases where derived identities differ from actual behavior.
  • Configuration and policy review: Examine exec approval rules for assumptions that treat BusyBox/Toybox as a single low-risk binary rather than a collection of heterogeneous applets.
  • Behavioral monitoring: Correlate approved execution logs with actual system activity, looking for cases where low-risk approvals precede clearly high-risk operations (e.g., network connections, shell spawns, mass file changes).
  • Test harnesses: Build automated tests that invoke representative sets of BusyBox/Toybox applets under different invocation patterns and verify that the expected policy decisions are enforced.
  • Automated tooling: Use security testing or policy linting tools to flag ambiguous or generic rules that do not account for multi-call binaries, especially in high-privilege execution domains.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/666f48d9b882a8a1415ca53f9567c72499d850c9
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-2cq5-mf3v-mx44
vulncheck.comvulncheck.com/advisories/openclaw-weakened-exec-approval-binding-via-busybox-and-toybox-applet-execution

Frequently asked

questions

Exploitability depends on where OpenClaw's exec approval is used as a gatekeeper. In environments where BusyBox or Toybox provide powerful applets and exec approval is expected to block them, the issue can have broad impact. In deployments that do not rely on multi-call binaries or do not use exec approval for security decisions, impact is more limited.

An attacker generally needs the ability to cause commands to run under OpenClaw's control—such as user-level shell access, the ability to submit jobs or scripts, or to influence automated processes that invoke BusyBox/Toybox. The vulnerability does not, by itself, grant new access; it weakens controls on what can be done with existing access.

The most robust approach is to bind exec approval to the real operation being executed by fully resolving BusyBox/Toybox applets, and then defining policies at that applet level. Where possible, replace opaque multi-call invocations in critical paths with dedicated, single-purpose binaries whose identities are straightforward for the policy engine to classify.

Design authorization and approval mechanisms to operate on normalized, fully resolved representations of actions, not just superficial command names or wrapper binaries. During design and code review, pay special attention to compound executables, aliases, and indirection layers, and enforce policies that treat all invocation forms of high-risk operations consistently.

Find out what's already
exploitable in your codebase.