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 thebrowser.requestguard. - Why exploitation is possible: The authorization and mutation-guard logic is applied only to the
browser.requestpath, while thenode.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.

