/

CVE-2026-42431

Severity:

HIGH RISK

(8.1)

Authorization Bypass in OpenClaw Persistent Browser Profile

CVE-2026-42431

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Unauthorized Configuration and Profile Modification

Severity:

HIGH RISK

(8.1)

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.4.8 contains an authorization bypass in the node.invoke(browser.proxy) path that permits unauthorized mutation of persistent browser profiles.

By abusing this path, an attacker can circumvent the browser.request persistent profile-mutation guard and change browser configurations that are expected to be protected.

Affected context

The vulnerability appears in OpenClaw deployments that use persistent browser profiles and rely on the browser.request layer to enforce profile-mutation controls.

Specifically, instances where:

  • Persistent browser profiles are stored and reused across sessions
  • Profile changes are supposed to be guarded by access-control checks in browser.request
  • node.invoke(browser.proxy) is available as an alternate execution or control channel

In such contexts, code paths through node.invoke(browser.proxy) may bypass the normal guardrails designed to prevent unauthorized profile modification.

Exploit preconditions

  • Attack surface: Interfaces or components that can call node.invoke(browser.proxy) or influence calls to it.
  • Required access: Ability to trigger or inject requests that reach the node.invoke(browser.proxy) path (e.g., via scripting hooks, internal APIs, or misconfigured integrations); exact access level depends on how OpenClaw is embedded or exposed.
  • Trigger point: Execution of node.invoke(browser.proxy) operations that act on persistent browser profiles without passing through the browser.request guard.
  • Why exploitation is possible: The authorization and mutation-guard logic is applied only to the browser.request path, while the node.invoke(browser.proxy) path can reach the same persistent profile objects without equivalent authorization checks, enabling a privilege/guard bypass.

Why this happens

The underlying issue is an authorization logic inconsistency: OpenClaw relies on browser.request to enforce a persistent profile-mutation guard, but fails to apply the same checks on the node.invoke(browser.proxy) path.

This creates a secondary route to sensitive operations (profile mutation) that is not subject to the same access-control policy.

Conceptually, this maps to CWE-863: Incorrect Authorization, where the system authorizes actions based on incomplete or incorrect enforcement of intended security policies.

The bug class is a missing or incomplete centralization of access-control checks across all code paths that can modify shared, persistent browser configuration state.

Potential impact

  • Attackers could modify persistent browser profiles without passing normal authorization guards.
  • Browser security/privacy settings may be weakened or disabled.
  • Proxy, certificate, or custom header configurations could be altered to facilitate traffic interception or tracking.
  • Default homepages, extensions, or startup URLs may be changed to malicious or phishing destinations.
  • Long-lived sessions or stored tokens associated with the profile could be exposed to higher risk via altered security posture.

General mitigation guidance

Mitigation typically focuses on unifying and hardening authorization checks around all profile-mutation paths:

  • Centralize access-control logic so that every operation capable of mutating persistent browser profiles passes through the same guard or policy decision point.
  • Treat persistent browser configurations as high-value assets and require explicit authorization for any write operation, regardless of call path (browser.request, node.invoke(browser.proxy), or others).
  • Apply a default-deny approach to profile mutation APIs, exposing only narrowly scoped, well-audited methods for required modifications.
  • Introduce clear separation between read-only and read-write operations on browser profiles, enforcing stricter policies (and potentially different roles) for write access.
  • Reduce the privilege of components and modules that can invoke low-level browser proxies, limiting their ability to alter persistent state directly.

How teams detect issues like this

Detection efforts can focus on discovering inconsistent or missing authorization checks around profile mutation:

  • Use static analysis to locate all code paths that call node.invoke(browser.proxy) or related APIs and verify that each is preceded by a consistent authorization or guard module.
  • During code review, flag any direct mutation of persistent browser profiles that does not go through the primary guard layer used by browser.request.
  • Implement architectural policies that require registration of any function capable of modifying persistent profiles, and periodically audit that registry against actual call sites.
  • Employ runtime logging or auditing for all profile-write operations, and monitor for writes originating from unexpected components or contexts.
  • Automated security review tools can help surface missing access checks, especially if configured with custom rules for OpenClaw's profile and proxy APIs.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/d7c3210cd6f5fdfdc1beff4c9541673e814354d5
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-cmfr-9m2r-xwhq
vulncheck.comvulncheck.com/advisories/openclaw-persistent-profile-mutation-via-node-invoke-browser-proxy-bypass

Frequently asked

questions

Exploitability depends on how widely the node.invoke(browser.proxy) pathway is exposed. In environments where untrusted or semi-trusted code can trigger or influence this path, the vulnerability can be broadly exploitable and enable unauthorized profile changes.

An attacker must be able to cause node.invoke(browser.proxy) to operate on persistent browser profiles, either by directly invoking it or by controlling inputs that are processed through it. This may require internal application access, plugin-level access, or control over automation scripts, depending on the deployment.

The most robust fix is to centralize authorization so that all persistent profile mutations—regardless of entry point—are funneled through a single, consistently enforced guard. Any low-level APIs like node.invoke(browser.proxy) should either be restricted to read-only behavior or forced to consult the same access-control logic before writes.

Prevention typically involves designing with a clear security architecture: define sensitive resources (like persistent profiles), ensure a single authoritative policy layer for access control, and prohibit alternative code paths from bypassing that layer. Regular security reviews and automated checks for "guardless" mutation operations further reduce the chance of reintroducing similar authorization bypasses.

Find out what's already
exploitable in your codebase.