/

CVE-2026-43527

Severity:

HIGH RISK

(7.7)

SSRF in OpenClaw Browser SSRF Policy

CVE-2026-43527

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918, CWE-1188

Impact:

Unauthorized Access to Internal Services and Sensitive Metadata

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 before 2026.4.14 exposes a server-side request forgery (SSRF) weakness in its browser SSRF policy, which allows private-network navigation by default.

Under certain deployment conditions, an attacker can coerce the application to issue browser-driven requests to internal services or metadata endpoints that are not directly reachable from the public internet.

Affected context

This vulnerability affects deployments of OpenClaw where:

  • The browser SSRF policy is responsible for mediating or constraining outbound navigation.
  • The policy is configured (or defaults) to allow access to private or internal network ranges.
  • The application processes attacker-controlled or partially controlled URLs or navigation targets.

In such environments, internal infrastructure (e.g., internal APIs, admin panels, cloud metadata endpoints) may be reachable via browser-driven requests that appear legitimate to the application.

Exploit preconditions

  • Attack surface: Web-facing functionality that causes the application or a managed browser context to navigate to or fetch arbitrary URLs (e.g., URL previews, link unfurling, screenshot services, or headless browser automation).
  • Required access: Ability to supply or influence the target URL, navigation destination, or request parameters sent through OpenClaw's browser SSRF policy—typically achievable by any external user who can trigger the relevant feature.
  • Trigger point: Invocation of the feature that instructs the browser or backend component to perform network navigation or HTTP requests based on user-provided input.
  • Why exploitation is possible: The SSRF policy is misconfigured to allow private-network navigation by default, so standard safeguards (blocking internal IP ranges, metadata endpoints, or link-local addresses) are not enforced, enabling the attacker-controlled URL to be resolved and contacted.

Why this happens

The core issue stems from an incomplete or overly permissive SSRF policy that fails to treat internal addresses as sensitive, mapping to CWE-918: Server-Side Request Forgery (SSRF).

Instead of enforcing strict allowlists or blocking private and link-local ranges, the policy allows browser-driven navigation to internal network targets by default. This configuration error aligns with CWE-1188: Insecure Default Initialization of Resource, where a default setting is insecure and exposes sensitive resources. The abstract insecure pattern is: a component that issues HTTP requests on behalf of users accepts untrusted URLs and, by default, does not restrict access to non-public network locations.

Potential impact

  • Unauthorized access to internal HTTP-based services that are not exposed to the internet.
  • Discovery of internal network structure via response content, status codes, or timing differences.
  • Access to cloud provider metadata endpoints, which may expose credentials, tokens, or instance configuration.
  • Potential pivoting into internal admin endpoints, configuration dashboards, or management APIs.
  • Use of the application as a proxy to bypass IP-based access controls and firewall rules.

General mitigation guidance

Effective mitigation typically focuses on enforcing strict network boundary controls for any feature that issues server-side or browser-mediated requests:

  • Prefer deny-by-default SSRF policies: explicitly block private, link-local, loopback, and metadata IP ranges unless there is a documented, narrow business need.
  • Use allowlists for outbound destinations where feasible, limiting navigation to well-defined hostnames or domains rather than arbitrary URLs.
  • Normalize and validate URLs before request execution, resolving DNS and checking the final IP against blocked ranges to prevent DNS rebinding or hostname tricks.
  • Isolate request-performing components (e.g., headless browsers, fetchers) into restricted network segments with no direct route to sensitive internal services or metadata endpoints.
  • Apply least privilege network access in infrastructure: ensure that services performing navigation cannot reach control planes, databases, or management networks by default.

How teams detect issues like this

Organizations can look for this class of issue using a combination of static, dynamic, and configuration-focused approaches:

  • Static analysis / code review:
  • Identify code paths where user-controlled URLs are passed to navigation, HTTP client, or headless browser APIs.
  • Check SSRF policy configuration defaults, especially rules governing private IP ranges and metadata endpoints.
  • Flag any usage where outbound request components do not enforce explicit destination restrictions.
  • Configuration and policy audits:
  • Review default and environment-specific SSRF policies for allow-by-default behavior.
  • Validate that private, loopback, and metadata ranges are explicitly blocked at the application and/or network layers.
  • Dynamic testing:
  • Use security testing tools or custom scripts to supply URLs pointing to internal IPs (e.g., 127.0.0.1, 10.0.0.0/8) and cloud metadata endpoints to see if responses are relayed.
  • Monitor logs for unusual outbound requests from the application to internal or unexpected destinations.
  • Automated controls:
  • Integrate security scanners and CI checks that highlight potential SSRF sinks and insecure defaults in configuration files or code.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/024f4614a1a1831406e763adc40ef226e3d5e9ed
github.comgithub.com/openclaw/openclaw/commit/1dabfef28db523e7de81edeb3dd689e9171236a2
github.comgithub.com/openclaw/openclaw/commit/213c36cf51121ef6c05cfccd78037371f968f31a
github.comgithub.com/openclaw/openclaw/commit/7eecfa411df3d12e6b810e6ca5df47254fc3db3f
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-53vx-pmqw-863c
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-via-private-network-navigation

Frequently asked

questions

Yes. If an internet-exposed feature in OpenClaw allows an attacker to provide or influence URLs that are then navigated by the browser SSRF policy, a remote attacker can exploit this behavior without prior internal access.

Typically, the attacker only needs the ability to interact with any functionality that triggers browser-driven navigation or server-side URL fetching. In many deployments, this may be possible as an unauthenticated or low-privilege user, depending on how the feature is exposed.

The safest pattern is to adopt a deny-by-default SSRF policy: block private, loopback, link-local, and metadata-address ranges; then, selectively allow only the minimal set of external destinations that the application truly needs. Combine this with network-layer segmentation so that the component performing requests cannot reach sensitive internal services.

Treat any component that issues HTTP requests based on user input as a high-risk SSRF surface. Enforce secure defaults in configuration, add automated checks for SSRF sinks in code review and CI, maintain clear allowlists for outbound traffic, and validate that runtime environments and network topologies prevent request-performing components from accessing internal control planes or metadata endpoints.

Find out what's already
exploitable in your codebase.