/

CVE-2026-28476

Severity:

HIGH RISK

(8.3)

SSRF in OpenClaw Tlon Urbit Extension

CVE-2026-28476

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Potential Data Exposure via SSRF

Severity:

HIGH RISK

(8.3)

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's optional Tlon Urbit extension accepts user-controlled base URLs for authentication without sufficient validation, enabling server-side request forgery (SSRF).

An attacker who can influence the configured Urbit URL can cause the OpenClaw gateway to issue HTTP requests to arbitrary destinations, including internal services that are not directly exposed to the internet.

Affected context

This vulnerability occurs in OpenClaw deployments that enable and use the Tlon Urbit integration for authentication or related functionality.

The risk is present when:

  • The Urbit extension is enabled and reachable over HTTP(S)
  • The extension accepts or reads a user-controlled or loosely validated Urbit base URL
  • The OpenClaw gateway has network access to internal services (e.g., database admin panels, metadata services, or other internal HTTP endpoints)

Environments where the Urbit URL can be set through a web UI, configuration API, or otherwise influenced by untrusted parties are more exposed.

Exploit preconditions

  • Attack surface: The HTTP interface or configuration mechanism used to set or update the Urbit base URL in OpenClaw.
  • Required access: Ability to supply or modify the Urbit URL value (e.g., via a user profile, tenant configuration, or misconfigured admin endpoint). This could be authenticated or unauthenticated depending on deployment.
  • Trigger point: Any operation where OpenClaw's Urbit extension uses the configured base URL to initiate outbound HTTP requests (such as authentication flows, callbacks, or status checks).
  • Why exploitation is possible: The extension trusts the provided base URL and does not sufficiently validate or restrict target hosts, protocols, or IP ranges, allowing attackers to redirect the server's HTTP client to arbitrary endpoints, including internal IP addresses and metadata services.

Why this happens

The underlying issue is a classic server-side request forgery pattern as described in CWE-918.

The Urbit extension treats a user-influenced base URL as trustworthy, using it directly to construct outbound HTTP calls without:

  • Enforcing an allowlist of permitted hosts or domains
  • Blocking private or loopback IP ranges
  • Restricting protocols or ports

Because the server's HTTP client typically has broader network reach than external users, this design exposes internal network resources via the extension's outbound requests. The bug stems from missing or incomplete validation and normalization in URL handling logic, rather than in the HTTP client itself.

Potential impact

  • Attackers may coerce the OpenClaw gateway into accessing internal HTTP services that are otherwise not publicly exposed.
  • Sensitive internal data (e.g., configuration files, APIs, instance metadata) could be disclosed through SSRF responses.
  • Internal admin interfaces reachable over HTTP may be probed or interacted with, potentially leading to configuration tampering or privilege escalation if they lack strong authentication.
  • The gateway could be abused as a pivot point for reconnaissance of internal IP space and service discovery.
  • In some architectures, SSRF can be chained with other weaknesses (e.g., weak internal auth, exposed cloud metadata endpoints) to obtain credentials or perform further compromise.

General mitigation guidance

Effective mitigation focuses on hardening how URLs are accepted, validated, and used for outbound connections:

  • Restrict the Urbit base URL to a controlled, vetted set of allowed domains or host patterns (strict allowlist).
  • Implement robust server-side validation of any configured URL, including:
  • Normalization and re-parsing of URLs before use
  • Resolution of hostnames and verification that resulting IPs are not in private, loopback, link-local, or otherwise restricted ranges
  • Blocking of non-HTTP(S) schemes and unexpected ports
  • Decouple user input from direct network calls by mapping user-facing identifiers to pre-configured, trusted endpoints rather than raw URLs.
  • Apply network-level egress controls so that the OpenClaw gateway can only reach necessary external services and is not free to access arbitrary internal subnets.
  • Use least-privilege principles for service accounts and avoid exposing highly sensitive internal APIs on networks reachable by the gateway.

How teams detect issues like this

To detect and manage SSRF risks in similar components:

  • Use static analysis to flag code paths where untrusted URL components are passed directly into HTTP client libraries without validation, host allowlisting, or IP range checks.
  • During code review, look for:
  • Configuration options that accept arbitrary URLs
  • Direct concatenation of user input into request URLs
  • Absence of checks for private or loopback IP blocks and unapproved schemes
  • Implement centralized URL validation helpers and enforce their use via coding standards and review checklists.
  • Leverage dynamic testing and security scanning (e.g., DAST or integration tests) that attempt to supply internal IPs and unusual schemes as base URLs and observe whether outbound requests succeed.
  • Monitor network egress logs from the OpenClaw gateway for suspicious requests to internal IP ranges or unexpected destinations, and alert on such patterns.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/bfa7d21e997baa8e3437657d59b1e296815cc1b1
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-pg2v-8xwh-qhcc
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-in-tlon-extension-authentication

Frequently asked

questions

Yes, if an attacker can remotely influence or set the Urbit base URL (for example via a web UI, API, or misconfigured configuration endpoint), they can exploit SSRF from outside the network. If URL control is restricted to trusted admins, the practical exposure is reduced.

The attacker must be able to control or significantly influence the configured Urbit URL. This might require authenticated access, multi-tenant misconfiguration, or abuse of an integration endpoint depending on how OpenClaw is deployed.

Replace direct use of user-supplied URLs with a strict allowlist-based design, where the server only connects to predefined domains or IDs mapped to trusted endpoints. Complement this with rigorous URL parsing, IP range blocking, and network egress restrictions.

Establish secure design guidelines for outbound HTTP calls: never trust raw user-provided URLs, centralize URL validation logic, require host allowlists for integrations, and enforce these patterns through code review, static analysis rules, and automated tests targeting SSRF behavior.

Find out what's already
exploitable in your codebase.