Summary
OpenClaw's sandbox browser bridge server accepts requests without enforcing gateway authentication, exposing powerful browser control endpoints to local attackers.
On systems running vulnerable versions, a local adversary can enumerate tabs, obtain WebSocket control URLs, execute JavaScript in active sessions, and exfiltrate cookies and session data from authenticated browser contexts.
Affected context
The vulnerability appears in OpenClaw deployments that use the sandbox browser bridge server to control or automate browser instances.
It is relevant where:
- The bridge server runs as a long-lived local service or background component
- Browser sessions are authenticated to sensitive web applications
- The bridge's HTTP/WebSocket endpoints are accessible from the local host or local network environment
In these conditions, the lack of gateway authentication means any local process or user able to send requests to the bridge can interact with active browser sessions.
Exploit preconditions
- Attack surface: Local HTTP/WebSocket interface exposed by the sandbox browser bridge server
- Required access:
- Ability to run code or send HTTP requests on the same machine or local environment where the bridge is listening
- No prior authentication to OpenClaw's gateway is required
- Trigger point:
- Direct calls to browser control endpoints (e.g., tab enumeration, WebSocket URL retrieval, JavaScript execution, cookie access)
- Why exploitation is possible:
- The bridge server does not enforce gateway authentication or equivalent authorization checks before serving browser control operations
- Control endpoints implicitly trust any local caller, treating them as fully privileged automation clients
Why this happens
This issue is an instance of CWE-306: Missing Authentication for Critical Function.
The sandbox browser bridge exposes high-privilege control functions—such as enumerating tabs, executing JavaScript, and accessing cookies—without verifying the identity or authorization of the caller.
Architecturally, the bridge assumes that local access equates to trusted access and omits a security boundary between automation clients and the protected browser context.
As a result, any local actor can invoke sensitive operations that were intended to be gated by OpenClaw's gateway or higher-level authentication mechanisms.
Potential impact
- Local attackers may enumerate open browser tabs and infer active user activity or visited sites.
- Attackers could retrieve WebSocket control URLs and hijack ongoing automation or debugging sessions.
- Arbitrary JavaScript execution in authenticated browser contexts can be used to read DOM content, exfiltrate data, or manipulate user actions.
- Cookies, session tokens, and other sensitive storage accessible to the browser may be extracted and reused for session hijacking.
- Compromise of accounts in web applications where the browser is authenticated, potentially leading to broader data breaches or privilege escalation within those applications.
General mitigation guidance
Effective mitigation focuses on enforcing strong authentication and minimizing implicit trust in local interfaces:
- Introduce mandatory authentication and authorization for all browser bridge endpoints handling tab enumeration, script execution, or cookie access.
- Bind access to a well-defined identity model (e.g., gateway-issued tokens, client certificates, or signed session capabilities) rather than trusting the local host.
- Apply least-privilege design for automation clients, granting only the minimum browser operations necessary for their function.
- Restrict network exposure of the bridge server (e.g., loopback-only bindings, OS-level firewall rules, process-level sandboxing) to reduce the number of potential local callers.
- Treat browser control channels as sensitive surfaces equivalent to authenticated web sessions, and design them with explicit security boundaries in mind.
How teams detect issues like this
Detection can combine code-centric and environment-centric approaches:
- Static analysis and code review:
- Flag HTTP/WebSocket handlers that expose critical browser operations without explicit authentication or authorization checks.
- Look for assumptions that "local = trusted" in networking configuration or handler registration.
- Verify that all entry points to cookie access, JavaScript injection, or tab enumeration require validated credentials or tokens.
- Configuration and runtime monitoring:
- Monitor local network traffic to the bridge server port for unexpected clients or frequent enumeration/script-execution calls.
- Use host-based intrusion detection or EDR tools to identify unrecognized processes communicating with the bridge.
- Policy and CI enforcement:
- Enforce coding standards that mandate authentication middleware or filters on all sensitive server endpoints.
- Integrate automated security review tools that can detect missing auth checks on internal control APIs.

