/

CVE-2026-42436

Severity:

HIGH RISK

(7.7)

Improper Access Control in OpenClaw Browser Snapshot and

CVE-2026-42436

Deferred

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-862

Impact:

Server-Side Request Forgery and Exposure of Internal Web Content

Severity:

HIGH RISK

(7.7)

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 contains an improper access control issue in its browser snapshot, screenshot, and tab routes, where the final browser target is not consistently revalidated after navigation.

Authenticated callers can abuse route-driven navigation to bypass SSRF restrictions and access internal or otherwise disallowed page content.

Affected context

The vulnerability appears in OpenClaw deployments that expose browser-driven routes for snapshots, screenshots, or tab management.

When these routes allow navigation or redirects to a new URL, the system does not consistently re-check the final destination against SSRF and access control policies.

This typically matters in environments where OpenClaw can reach internal services (e.g., intranet sites, cloud metadata endpoints, admin panels) that are not meant to be directly exposed through the product's API.

Exploit preconditions

  • Attack surface: HTTP API routes handling browser snapshot, screenshot, and tab operations.
  • Required access: Valid authenticated access to OpenClaw with permission to call these routes.
  • Trigger point: Issuing navigation or route instructions that cause the embedded browser to move from an initially allowed URL to a restricted or internal URL.
  • Why exploitation is possible: The system validates the initial request but does not consistently validate the final browser target after navigation, allowing SSRF protections and URL allowlists to be bypassed.

Why this happens

This issue stems from incomplete or inconsistent enforcement of authorization and SSRF policies on browser-driven navigation flows.

While initial requests may be checked against allowlists or access rules, subsequent navigations performed by the headless browser—whether via redirects, scripted navigation, or route parameters—are not always revalidated.

This maps to CWE-862: Missing Authorization, because the final resource being requested is never subjected to the same authorization and SSRF checks as the initial request.

Conceptually, the system treats navigation within a browser session as implicitly trusted once the session has been created, instead of evaluating every outbound request against policy.

Potential impact

  • Exposure of internal or non-public web applications accessible from the OpenClaw host network.
  • Reading sensitive configuration pages or administration interfaces that should not be reachable by end users.
  • Accessing cloud provider metadata or internal APIs, depending on network topology.
  • Assisting attackers in mapping internal network structure and available endpoints.
  • Providing a stepping stone for further attacks, such as credential harvesting or privilege escalation via internal applications.

General mitigation guidance

Mitigation typically focuses on enforcing consistent authorization and SSRF controls for every request the embedded browser makes, not just the first one.

Common defensive patterns include:

  • Revalidating the final URL after any navigation, redirect, or route-driven change, and blocking requests that fall outside explicit allowlists.
  • Applying strict URL and host allowlists that are evaluated for each outbound browser request, including subresource loads when practical.
  • Segregating the browser execution environment onto a network segment with tightly limited egress, minimizing reachable internal services.
  • Designing APIs so that clients request actions on high-level, pre-approved targets rather than arbitrary URLs, reducing the need to trust user-supplied navigation.
  • Applying least-privilege to the service account and infrastructure where OpenClaw runs, limiting the damage if SSRF occurs.

How teams detect issues like this

Effective detection combines code-centric and behavior-centric approaches:

  • Static analysis and code review focused on routes that:
  • Accept user-controlled URLs or navigation instructions, and
  • Use a headless browser or HTTP client without consistent post-navigation validation.
  • Reviewing authorization middleware placement to ensure checks apply to every outbound request, not only initial route handlers.
  • Adding logging around browser navigation events (initial URL, redirects, final URL) and monitoring for unexpected access to internal hostnames or IP ranges.
  • Implementing security tests and integration test cases that attempt to navigate from allowed URLs to representative internal or disallowed URLs, verifying that policies block the requests.
  • Optionally, using automated security scanners or custom SSRF test harnesses to exercise snapshot and screenshot endpoints under realistic navigation scenarios.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/b75ad800a59009fc47eaa3471410f69046150e59
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-c4qm-58hj-j6pj
vulncheck.comvulncheck.com/advisories/openclaw-internal-page-content-exposure-via-browser-snapshot-and-screenshot-routes

Frequently asked

questions

Yes, it can be exploited remotely, but only by callers who can authenticate to OpenClaw and access the affected browser-related routes. Once authenticated, an attacker can craft navigation sequences that reach internal or disallowed targets.

The attacker must have valid credentials or an equivalent authenticated context with permission to use the snapshot, screenshot, or tab management routes. They do not typically need direct network access to the internal targets; the server performs the requests on their behalf.

The safest pattern is to enforce strict, centralized URL and host allowlists for all browser activity and revalidate the final target after any navigation or redirect. Each outbound request made by the embedded browser should be checked against authorization and SSRF policies before it is allowed.

When designing features that fetch remote content, treat every network request as untrusted, even if it originates from an existing session or navigation. Apply uniform authorization and SSRF checks at a common enforcement layer, prefer explicit allowlists over ad hoc filtering, and regularly test browser-driven or proxy features with SSRF-focused security tests.

Find out what's already
exploitable in your codebase.