/

CVE-2026-42439

Severity:

HIGH RISK

(8.5)

Authorization Bypass / Missing Authorization in OpenClaw

CVE-2026-42439

Analyzed

Vulnerability type

Category:

Authorization Bypass / Missing Authorization

CWE:

CWE-862, CWE-918

Impact:

SSRF Policy Bypass and Unauthorized Network Access via Tab Navigation

Severity:

HIGH RISK

(8.5)

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.10 contains an authorization bypass that allows attackers to circumvent configured server-side request forgery (SSRF) protections on browser tab actions.

By abusing the /tabs/action endpoint, an attacker can trigger unauthorized tab navigation operations that ignore the intended SSRF policy, potentially reaching internal or otherwise protected resources.

Affected context

The vulnerability appears in OpenClaw deployments that expose browser tab management functionality via HTTP routes, specifically the "select" and "close" actions handled through the /tabs/action endpoint.

It is relevant where SSRF policies are configured to restrict outbound requests or navigation targets, but enforcement relies on higher-level policy checks that the tabs action routes can bypass.

The risk is heightened in environments where tab navigation can reach internal applications, cloud metadata services, administrative panels, or other sensitive endpoints.

Exploit preconditions

  • Attack surface: The OpenClaw HTTP API, particularly the /tabs/action endpoint that manages browser tabs.
  • Required access: Ability to send crafted requests to the affected endpoint (e.g., authenticated user with access to tab actions, or any user if the endpoint is exposed without strong access controls).
  • Trigger point: Invoking the browser tabs "select" or "close" actions in a way that causes the browser to navigate or interact with targets that should be blocked by the SSRF policy.
  • Why exploitation is possible: Authorization checks and SSRF policy enforcement do not consistently apply to the tabs action routes, allowing navigation operations to proceed even when they violate the configured SSRF protections.

Why this happens

This issue stems from missing or incomplete authorization and policy enforcement on a specific control path in the application.

While an SSRF policy is configured to restrict where the browser may send requests, the /tabs/action routes for "select" and "close" actions are not fully covered by the same authorization or policy checks.

This corresponds to CWE-862: Missing Authorization, where the application assumes that callers of a sensitive operation (tab navigation) are already authorized or constrained, but fails to verify that assumption on each request.

Conceptually, the system treats the tabs action API as trusted, allowing it to direct navigation without re-evaluating whether the requested operation complies with SSRF rules and access controls.

Potential impact

  • Attackers may bypass SSRF protections to make the controlled browser navigate to internal services or otherwise restricted endpoints.
  • Sensitive internal web applications or cloud metadata services could be probed or accessed indirectly via tab navigation.
  • Logging, monitoring, or audit expectations around allowed outbound requests can be undermined.
  • SSRF-based reconnaissance of internal networks may become possible using the browser as a pivot.
  • Business logic relying on tab-level isolation or navigation constraints can be circumvented.

General mitigation guidance

Effective mitigation focuses on enforcing consistent authorization and SSRF policies across all navigation-related endpoints:

  • Apply the same SSRF policy enforcement layer to all routes that can influence browser navigation or outbound requests, including helper or "action" endpoints.
  • Ensure every tab-related operation (open, select, close, navigate) performs explicit authorization checks based on the caller's identity and permissions.
  • Centralize navigation and SSRF decision logic in a single component or middleware so that no endpoint can bypass it.
  • Constrain what destinations tab navigation can reach using allowlists or strongly validated host patterns, rather than relying on implicit trust.
  • Design browser-control APIs following least privilege, exposing only the minimum necessary tab operations and parameters to external callers.

How teams detect issues like this

To detect this class of issue, organizations can combine code-level and behavioral approaches:

  • During code review, inspect all endpoints that influence browser navigation or outbound requests and verify that they invoke shared authorization and SSRF policy components.
  • Use static analysis or linter rules to flag navigation or HTTP request logic that is not wrapped by the standard authorization/policy-checking functions.
  • Implement policy-based tests or security unit tests that simulate attempts to reach blocked destinations via secondary or helper routes like /tabs/action.
  • Monitor logs for unusual tab navigation patterns, such as requests targeting internal IP ranges, metadata services, or domains outside the documented allowlist.
  • Incorporate automated API security testing to exercise indirect navigation paths and confirm that SSRF protections hold on all relevant routes.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/48c0347921b7e9438af0312968fc360ca88023f3
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-rj2p-j66c-mgqh
vulncheck.comvulncheck.com/advisories/openclaw-ssrf-policy-bypass-in-browser-tabs-action-routes

Frequently asked

questions

Yes, if an attacker can reach the /tabs/action endpoint over the network.

The exact exposure depends on your deployment and whether the endpoint is accessible from untrusted networks or only from authenticated users.

The attacker needs the ability to issue requests to the affected tab action routes.

In some environments this might require valid application credentials or a compromised user account; in others, misconfiguration could expose the endpoint more broadly.

The most robust fix is to route all tab-related operations through a centralized authorization and SSRF enforcement layer.

Every call that can influence browser navigation should explicitly verify the caller's permissions and confirm that the requested target complies with the configured SSRF policy.

Adopt a design where sensitive actions such as navigation, outbound requests, or resource access can only be performed via a small set of well-audited APIs that always apply authorization and policy checks.

Complement this with security-focused code reviews and automated tests that specifically verify SSRF policy enforcement and access control on all navigation-related endpoints.

Find out what's already
exploitable in your codebase.