/

CVE-2026-32019

Severity:

HIGH RISK

(7.4)

Server-Side Request Forgery (SSRF) in OpenClaw

CVE-2026-32019

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Bypass of SSRF network access controls and unauthorized access to restricted network ranges

Severity:

HIGH RISK

(7.4)

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 versions prior to 2026.2.22 implement incomplete IPv4 special-use range validation in the isPrivateIpv4() helper, allowing some RFC-reserved addresses to be treated as if they were public.

Under these conditions, attackers can abuse web_fetch SSRF protections to send requests to otherwise blocked non-global ranges such as 198.18.0.0/15 and other special-use networks.

Affected context

The vulnerability appears in OpenClaw deployments that:

  • Use the web_fetch or similar outbound HTTP functionality on behalf of user-supplied URLs or hostnames
  • Rely on the isPrivateIpv4() function or equivalent logic to enforce SSRF protections
  • Operate in environments where special-use or RFC-reserved IPv4 ranges (e.g., 198.18.0.0/15, test networks, benchmark ranges, or other non-global address space) are assumed to be unreachable from untrusted inputs

The issue arises because the validation logic does not fully cover all relevant special-use IPv4 ranges, leaving some non-global addresses incorrectly classified as safe for outbound access.

Exploit preconditions

  • Attack surface: Any feature in OpenClaw that performs outbound HTTP(S) or similar network requests (e.g., web_fetch) based on user-controlled or partially user-controlled URLs.
  • Required access: Ability to trigger web_fetch or related functionality, typically via a web UI, API endpoint, or integration that accepts external URLs.
  • Network topology: The OpenClaw instance must have network reachability to one or more special-use IPv4 ranges (such as 198.18.0.0/15 or other RFC-reserved networks) that are intended to be protected by SSRF filters.
  • Trigger point: Submission of a URL or hostname that ultimately resolves to an address within a special-use range that is not correctly identified as non-global by isPrivateIpv4().
  • Why exploitation is possible: The IPv4 classification logic is incomplete and fails to treat all relevant special-use ranges as restricted, allowing requests to be sent to addresses that SSRF policies are expected to block.

Why this happens

This vulnerability stems from an incomplete implementation of SSRF network filtering logic, mapping to CWE-918: Server-Side Request Forgery (SSRF).

The isPrivateIpv4() function is intended to distinguish public, routable IPv4 addresses from non-global or internal ranges, but it omits certain RFC-reserved address blocks (such as 198.18.0.0/15 and potentially other special-use networks).

As a result, some non-global ranges are misclassified as safe, and the SSRF protection layer incorrectly permits outbound requests to them.

Conceptually, this reflects a flawed security boundary model where "internal" and "external" networks are inferred from partial IP range lists rather than being derived from comprehensive, well-maintained definitions of private, link-local, documentation, benchmark, and other special-use address spaces.

Potential impact

  • Attackers may cause OpenClaw to initiate requests to restricted or non-global IPv4 ranges that should be blocked by SSRF protections.
  • Internal services, test/benchmark networks, or lab infrastructure reachable via affected special-use ranges could be probed or accessed indirectly.
  • Sensitive metadata, configuration, or debugging endpoints exposed only on non-global networks could be queried through OpenClaw's network context.
  • SSRF-based pivoting within the hosting environment may be possible, potentially assisting in further reconnaissance or lateral movement.
  • Monitoring and traffic controls relying on the assumption that special-use ranges are never accessed from user-driven requests may be bypassed.

General mitigation guidance

Effective mitigation focuses on strengthening how network destinations are evaluated and restricting the trust placed in user-supplied URLs:

  • Use a complete and canonical definition of non-global IPv4 ranges, including private, loopback, link-local, documentation, benchmark/testing, and other special-use networks defined by relevant RFCs.
  • Centralize IP range classification logic instead of scattering ad hoc isPrivateIpv4() style checks, reducing the risk of omissions.
  • Apply a default-deny egress policy for SSRF-prone functionality, explicitly allowing only well-known public endpoints or specific service domains needed for legitimate operation.
  • Resolve hostnames and apply SSRF validation after DNS resolution, ensuring checks operate on the final IP addresses (and re-check after redirects when possible).
  • Run OpenClaw components with least-privilege network access, limiting which subnets and address ranges they can reach even in the presence of logical filtering bugs.
  • Where feasible, decouple external fetch functionality into a dedicated, tightly controlled egress proxy that enforces its own allowlist independent of application logic.

How teams detect issues like this

Potential detection and assessment strategies include:

  • Static analysis and code review:
  • Search for custom IP classification helpers like isPrivateIpv4() and verify that they reference all relevant special-use ranges per current RFCs.
  • Flag manual IP range checks that hard-code only a subset of private ranges (e.g., just RFC1918) without considering other non-global or reserved blocks.
  • Configuration and policy checks:
  • Review SSRF protections around web_fetch or equivalent features to confirm that outbound requests are constrained to expected destinations or domains.
  • Ensure network egress policies at the infrastructure level prevent arbitrary access to internal or special-use ranges.
  • Runtime monitoring:
  • Instrument logs to record destination IPs and networks for requests made via SSRF-prone paths, alerting on traffic to special-use or unexpected ranges.
  • Use network telemetry (flow logs, firewall logs) to detect application-originated connections to non-global or RFC-reserved address space.
  • Security testing:
  • Perform targeted SSRF testing by supplying URLs that resolve to a variety of special-use IPv4 ranges to validate that protections operate as intended.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/333fbb86347998526dd514290adfd5f727caa6d9
github.comgithub.com/openclaw/openclaw/commit/44dfbd23df453e51b71ef79a148c28c53e89168c
github.comgithub.com/openclaw/openclaw/commit/71bd15bb4294d3d1b54386064d69cd0f5f731bd8
github.comgithub.com/openclaw/openclaw/commit/f14ebd743cfc73f667fae80af70043d0ab1f88bd
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-4rqq-w8v4-7p47
vulncheck.comvulncheck.com/advisories/openclaw-incomplete-ipv4-special-use-range-blocking-in-ssrf-guard

Frequently asked

questions

Yes, if an attacker can remotely reach an interface that exposes web_fetch or similar functionality and can supply URLs, they may exploit the incomplete validation to trigger SSRF to special-use IPv4 ranges, subject to the network topology.

The attacker typically needs only the ability to interact with the feature that performs outbound requests (for example, a web form, API endpoint, or plugin interface accepting URLs). Direct network access to the backend services themselves is not required; the attack leverages OpenClaw's own network access.

Replace ad hoc IP and hostname checks with a robust SSRF defense strategy that combines a comprehensive understanding of non-global address space, strict allowlists of permitted destinations, post-DNS resolution validation, and infrastructure-level egress controls, rather than relying solely on a single helper function.

Model SSRF as a first-class risk in design reviews, mandate the use of shared, vetted libraries for URL and IP validation, enforce outbound allowlists or proxy-based egress for high-risk features, and include SSRF-specific tests and automated checks in CI/CD pipelines to catch regressions and incomplete range coverage.

Find out what's already
exploitable in your codebase.