/

CVE-2026-41361

Severity:

HIGH RISK

(7.1)

Server-Side Request Forgery (SSRF) Protection Bypass

CVE-2026-41361

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF) Protection Bypass

CWE:

CWE-184, CWE-918

Impact:

Bypass of SSRF Protections and Access to Internal IPv6 Resources

Severity:

HIGH RISK

(7.1)

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.3.28 contains an SSRF guard bypass where four IPv6 special-use ranges are not correctly blocked by its server-side request filtering logic.

An attacker who can influence target URLs may be able to send requests to internal or non-routable IPv6 addresses, undermining SSRF protections and reaching services that should not be exposed.

Affected context

The vulnerability occurs in deployments where OpenClaw acts as an HTTP client on behalf of users (for example, fetching remote resources, webhooks, or integrations) and relies on its built-in SSRF guard to restrict outbound destinations.

In affected versions, the guard does not cover four IPv6 special-use ranges, meaning that crafted URLs using those IPv6 forms may be treated as safe even when they actually point to internal or non-routable network locations.

This risk is most relevant in environments where internal services, metadata endpoints, or administrative panels are reachable over IPv6 from the OpenClaw host or container.

Exploit preconditions

  • Attack surface: Any OpenClaw feature that performs outbound HTTP/HTTPS requests based on user-supplied or indirectly controlled URLs.
  • Required access: Ability to submit or influence URLs or endpoints that OpenClaw will fetch (e.g., configuration fields, webhooks, import URLs, or API parameters).
  • Trigger point: OpenClaw's SSRF guard evaluates the destination and incorrectly treats certain IPv6 special-use ranges as allowed.
  • Why exploitation is possible: The SSRF defense implements incomplete or overly simplistic IP range checks that omit four special-use IPv6 ranges, allowing internal or non-routable IPv6 destinations to pass as if they were external and safe.

Why this happens

The core issue is an incomplete input validation and sanitization logic around outbound request destinations.

OpenClaw's SSRF guard appears to implement IP-based allow/deny checks that are correct for some IPv4 and IPv6 ranges but fail to include four IPv6 special-use ranges that should also be blocked.

This maps to CWE-184: Incomplete List of Disallowed Values, where a blacklist approach does not fully capture all unsafe patterns, and CWE-918: Server-Side Request Forgery, since the application can be coerced into making network requests to unintended internal locations.

Conceptually, the guard assumes that if an address is not on its disallowed list, it is safe, but the missing IPv6 ranges break this assumption and create an SSRF bypass.

Potential impact

  • Attackers may be able to reach internal IPv6-only services that are not directly exposed to the internet.
  • Sensitive configuration services, metadata endpoints, or admin panels reachable over IPv6 could be queried or interacted with.
  • Internal APIs that trust requests from OpenClaw's host or network segment might be abused for data exfiltration or state changes.
  • Network-level controls could be weakened if they rely on OpenClaw enforcing strict outbound destination policies.
  • In multi-tenant or hosted environments, attackers could potentially pivot to internal management services accessible via IPv6.

General mitigation guidance

Mitigation strategies should focus on hardening outbound request validation and not relying solely on partial blacklists.

Recommended patterns include:

  • Implement a default-deny outbound policy where only explicitly approved hostnames or CIDR ranges are allowed, rather than trying to enumerate all dangerous IP ranges.
  • Normalize and canonicalize all destination addresses (including resolving DNS and expanding IPv6) before applying policy decisions, to avoid evasion through alternate encodings.
  • Maintain a complete and regularly updated list of disallowed address ranges, including all private, loopback, link-local, multicast, and other special-use IPv6 networks, supplemented by configuration for environment-specific internal ranges.
  • Introduce an abstraction layer for outbound HTTP requests where all calls pass through a central policy enforcement component, making it harder for developers to accidentally bypass SSRF controls.
  • Use network-level controls such as egress firewalls, service meshes, or proxy policies that restrict which addresses and ports the OpenClaw process can contact.
  • Apply least-privilege to any credentials or tokens that might be reachable from internal resources, so that even successful SSRF attempts have limited impact.

How teams detect issues like this

Effective detection approaches combine code-level checks with runtime monitoring:

  • Static analysis and code review:
  • Look for custom SSRF guards or IP validation utilities and confirm they include comprehensive IPv4 and IPv6 special-use ranges.
  • Flag use of IP range blacklists that do not reference an authoritative registry for special-use networks.
  • Review all call sites that initiate outbound HTTP/HTTPS requests to ensure they route through the central SSRF protection logic.
  • Configuration and policy validation:
  • Periodically audit allow/deny lists against current IANA special-use registries for both IPv4 and IPv6.
  • Enforce policies that block direct socket connections to raw IP addresses where the SSRF guard is not applied.
  • Runtime and log analysis:
  • Monitor application logs or network telemetry for outbound requests to unusual IPv6 destinations (e.g., link-local, multicast, or reserved ranges).
  • Use network monitoring tools or egress firewall logs to detect connections from the OpenClaw host to internal addresses that should not be reachable.
  • Automated security testing:
  • Integrate SSRF-focused test suites into CI pipelines that probe known special-use IPv6 ranges to verify that they are correctly blocked.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-g86v-f9qv-rh6m
vulncheck.comvulncheck.com/advisories/openclaw-ssrf-guard-bypass-via-ipv6-special-use-ranges

Frequently asked

questions

Yes, if OpenClaw exposes features where external users or integrated systems can supply URLs or endpoints, a remote attacker can attempt to craft requests to internal IPv6 addresses through the application.

The attacker needs the ability to influence the URL or destination that OpenClaw will fetch—this might be through a user interface field, an API parameter, a configuration option, or any other mechanism that ends up being used as the target of an outbound request.

The most robust fix is to adopt a default-deny approach for outbound requests, normalize all addresses, and enforce a strict allowlist of permitted destinations, while ensuring that all known private, loopback, and special-use IPv6 ranges are treated as internal and blocked unless explicitly required.

Future prevention relies on centralizing outbound request logic, using well-maintained libraries or configuration for network range classification, regularly updating special-use IP lists, combining application-level checks with network-level egress controls, and incorporating SSRF-focused testing and code review into the development lifecycle.

Find out what's already
exploitable in your codebase.