/

CVE-2026-41912

Severity:

HIGH RISK

(7.6)

SSRF in OpenClaw Navigation Handling

CVE-2026-41912

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal or restricted network resources via SSRF policy bypass

Severity:

HIGH RISK

(7.6)

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.8 contains a server-side request forgery (SSRF) policy bypass that allows attackers to trigger navigations which evade the normal SSRF checks.

By abusing specific browser interaction flows, an attacker can cause the server to access internal or otherwise restricted resources that should be blocked by existing protections.

Affected context

The vulnerability appears in OpenClaw's navigation and request routing logic, specifically in how it handles browser-driven navigations relative to its SSRF protection layer.

It is most relevant in deployments where OpenClaw can initiate outbound HTTP(S) requests on behalf of users (e.g., URL previews, webhooks, proxying, or content fetching) and relies on internal SSRF policies to restrict which endpoints may be contacted.

The issue manifests when certain browser interaction patterns cause navigations or follow-up requests to be initiated through a code path that does not apply or fully enforce the configured SSRF checks.

Exploit preconditions

  • Attack surface: Web-facing OpenClaw endpoints that can trigger server-initiated HTTP(S) requests or navigations.
  • Required access: Ability to interact with the web interface or APIs that indirectly cause navigations (often as an unauthenticated or low-privileged user, depending on deployment).
  • Trigger point: Crafting browser interactions (such as specific links, redirects, or embedded resources) that cause OpenClaw to perform a navigation via a code path not covered by normal SSRF filtering.
  • Why exploitation is possible: The SSRF protection is enforced only on certain request flows. Browser-driven or indirect navigations can reach alternate code paths where host/URL validation, IP range checks, or protocol restrictions are incomplete or missing, allowing requests to prohibited internal endpoints.

Why this happens

This is fundamentally an SSRF policy enforcement gap, aligned with CWE-918: Server-Side Request Forgery.

OpenClaw's design appears to couple SSRF checks to specific request patterns, assuming all server-initiated outbound traffic flows through those guarded paths.

When browser interactions trigger alternative navigation logic—such as redirects, follow-on fetches, or UI-driven navigation helpers—the system initiates outbound requests without applying the same SSRF validation rules.

The insecure pattern is having multiple outbound request mechanisms with inconsistent or partial enforcement of network access policies, allowing an attacker-controlled URL or navigation target to be used to reach internal or restricted resources.

Potential impact

  • Access to internal services that are not directly exposed to the internet (e.g., admin panels, metadata services, internal APIs).
  • Bypassing network segmentation controls by relaying traffic through the OpenClaw server.
  • Exfiltration of sensitive information from internal endpoints accessible to the server.
  • Use of OpenClaw as a pivot point for further attacks against internal infrastructure (e.g., scanning, enumeration).
  • Potential abuse of trusted network position to interact with cloud provider or container metadata services, depending on environment configuration.

General mitigation guidance

Effective mitigation focuses on normalizing and centralizing SSRF controls and reducing trust in any user-influenced URL or navigation target.

Recommended design patterns include:

  • Centralized outbound request gateway: Route all server-initiated HTTP(S) traffic through a single, hardened component that consistently applies allowlists, DNS/IP validation, and protocol restrictions, regardless of how the navigation was initiated.
  • Strict allowlisting: Define explicit allowlists of hostnames, IP ranges, and schemes that OpenClaw is permitted to contact, and deny everything else by default.
  • Network-layer isolation: Place OpenClaw in a network segment with limited visibility into internal services, and use firewall rules or service meshes to prevent it from reaching sensitive internal endpoints by default.
  • Decoupled browser state from server navigations: Avoid designs where browser interactions directly drive arbitrary server-side navigations with attacker-controlled URLs; instead, map user actions to vetted, server-defined destinations.
  • Defense-in-depth validation: Perform DNS rebinding-safe checks (resolve-then-validate IPs), reject private/loopback/link-local ranges by default where not needed, and log violations for forensic analysis.

How teams detect issues like this

Detection strategies should focus on finding inconsistent outbound request handling and unexpected traffic patterns:

  • Static analysis: Search for all code locations where outbound HTTP(S) requests or navigations are created, and verify that each call site passes through centralized SSRF validation utilities or policies.
  • Code review signals: Look for multiple HTTP clients, ad hoc URL fetchers, or navigation helpers that bypass established network policy layers. Review redirect handling and UI-driven navigation code for missing validation.
  • Runtime monitoring: Instrument logging of outbound requests, including destination host/IP, scheme, and caller context, and alert on requests to internal address ranges or non-allowlisted hosts.
  • Policy enforcement: Use security scanners, WAF rules, or internal proxy policies to block unexpected outbound calls from OpenClaw to sensitive network ranges, and integrate these checks into CI/CD where possible.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/d7c3210cd6f5fdfdc1beff4c9541673e814354d5
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-vr5g-mmx7-h897
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-policy-bypass-via-interaction-triggered-navigation

Frequently asked

questions

In many deployments, yes. If an attacker can reach the OpenClaw interface or APIs that trigger server-initiated navigations, they may be able to exploit the SSRF policy bypass remotely, subject to authentication and rate-limiting controls that are in place.

The attacker generally needs the ability to influence URLs or navigation triggers processed by OpenClaw—often via standard web interactions. Depending on how OpenClaw is deployed, this may be possible for unauthenticated users, or it may require a basic authenticated account with access to the relevant functionality.

The most robust fix is to centralize all outbound request logic behind a single, well-audited SSRF protection layer that enforces allowlists and address validation, and to ensure that all navigation and HTTP client flows—regardless of how they are triggered—use this central mechanism.

Treat any user-influenced URL as untrusted, design outbound access as an explicit, allowlisted capability rather than a default, and incorporate SSRF-specific reviews in architecture, code review, and automated scanning. Additionally, limit the server's network reach so that even if SSRF occurs, accessible internal targets and resulting impact are minimized.

Find out what's already
exploitable in your codebase.