/

CVE-2026-31989

Severity:

HIGH RISK

(7.4)

SSRF in OpenClaw Web Search Citation Redirects

CVE-2026-31989

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access via SSRF

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.3.1 contain a server-side request forgery (SSRF) vulnerability in the web_search citation redirect resolution logic, which operates under a policy that permits access to private networks.

When an attacker can influence citation redirect targets, they may coerce the OpenClaw host into making HTTP requests to loopback, private, or otherwise internal destinations that are not directly exposed to the attacker.

Affected context

This vulnerability occurs in OpenClaw's web_search feature that resolves citation redirects on behalf of users.

It is relevant when:

  • The application accepts or derives redirect target URLs from user-controlled or indirectly user-influenced data, and
  • The backend HTTP client is configured with a policy that permits requests to loopback (127.0.0.1, ::1), RFC1918 private IP ranges, or other internal endpoints.

In such deployments, the OpenClaw server effectively becomes a network proxy, bridging untrusted user input to sensitive internal services that would normally be unreachable from the public internet.

Exploit preconditions

  • Attack surface: The citation redirect resolution endpoint or workflow in the web_search subsystem.
  • Required access: Ability to supply or influence citation redirect target URLs (e.g., by crafting citations, metadata, or references that the application later resolves).
  • Trigger point: Invocation of the citation resolution logic that fetches the targeted URL from the OpenClaw host.
  • Why exploitation is possible: The HTTP client used by OpenClaw:
  • Trusts redirect targets derived from user-influenced data,
  • Uses an SSRF policy that explicitly allows requests to loopback and private-network addresses,
  • Lacks robust host/URL validation and network egress restrictions for this particular feature.

Why this happens

The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF).

The web_search citation resolver takes a URL-like target, which may be influenced by untrusted input, and instructs the server to fetch it.

Instead of enforcing a deny-by-default egress policy or restricting requests to a known-safe set of domains and address ranges, the underlying policy explicitly permits access to loopback and private network addresses.

This breaks the expected trust boundary between external users and the internal network, effectively converting a metadata-resolution feature into a general-purpose internal HTTP client that attackers can steer.

Potential impact

  • Access to internal web services that are not exposed publicly (e.g., admin panels, management APIs).
  • Probing of internal IP ranges and hosts, enabling network mapping and service discovery.
  • Interaction with cloud metadata services (where present) that may expose credentials or configuration data.
  • Abuse of internal APIs to read or modify data, subject to the OpenClaw host's network position and permissions.
  • Use of the server as a stepping stone for further attacks within the internal network.

General mitigation guidance

Effective mitigation focuses on restoring a strict network boundary and constraining outbound requests made on behalf of users:

  • Restrict the HTTP client used for citation resolution to a fixed allowlist of domains or URL patterns that are required for the feature.
  • Deny or strictly filter requests to:
  • Loopback addresses (127.0.0.0/8, ::1),
  • Private and link-local ranges (e.g., 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 169.254.0.0/16),
  • Direct IP addresses except those explicitly required.
  • Normalize and validate URLs before use, ensuring that redirects and DNS resolution cannot be abused to reach internal destinations.
  • Where possible, route outbound requests through a controlled egress proxy with network-layer policies that block internal and metadata endpoints.
  • Apply the principle of least privilege to the OpenClaw host's network access, limiting which internal segments it can reach.

How teams detect issues like this

Detection strategies can combine code-centric and runtime approaches:

  • Static analysis and code review:
  • Flag code paths where user-controlled or derived URLs are passed into HTTP clients or redirect resolution logic.
  • Look for URL validation routines that do not check for private, loopback, or numeric IP addresses, or that only perform superficial string checks.
  • Identify any configuration or client policies that explicitly allow access to private networks without compensating controls.
  • Configuration and policy enforcement:
  • Define organizational policies requiring outbound egress allowlists for all server-initiated HTTP requests.
  • Use automated checks (e.g., in CI/CD) to detect disallowed network ranges or missing validations in new features.
  • Runtime and logging:
  • Log outbound requests made by the citation resolution component, including destination host, IP, and headers.
  • Monitor logs for patterns indicative of SSRF attempts, such as requests to 127.0.0.1, 169.254.169.254, or RFC1918 ranges.
  • Employ network monitoring or firewalls that alert when application servers attempt to reach atypical internal endpoints.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-g99v-8hwm-g76g
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-via-web-search-citation-redirect

Frequently asked

questions

Yes. In typical deployments, any remote user who can influence citation redirect targets may attempt to exploit the SSRF behavior, subject to application-specific authentication and permission checks.

The attacker generally needs only the ability to submit or control citation data or references that the web_search feature later resolves.

They do not need direct network access to internal services; the OpenClaw server issues requests on their behalf.

The most robust pattern is to adopt a deny-by-default egress model:

  • Restrict citation resolution to a tightly controlled allowlist of external domains or endpoints.
  • Block loopback, private, and metadata address ranges at both application and network layers.
  • Ensure URL validation and resolution occur before any outbound request is initiated.

Treat any server-initiated HTTP requests based on user-influenced data as high-risk:

  • Design features assuming that all URLs from users are untrusted.
  • Centralize outbound HTTP logic behind vetted helper libraries or services with built-in SSRF protections.
  • Incorporate SSRF-specific checks into code review guidelines, threat models, and automated security testing.
Find out what's already
exploitable in your codebase.