/

CVE-2026-35629

Severity:

HIGH RISK

(7.4)

SSRF in OpenClaw Channel Extensions

CVE-2026-35629

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Access to Internal Network Resources

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 before 2026.3.25 contains a server-side request forgery (SSRF) vulnerability in multiple channel extensions that do not adequately validate or constrain configured base URLs.

An attacker who can influence these endpoints can abuse unprotected fetch() calls to redirect server-originated requests to internal services, potentially accessing otherwise restricted network resources.

Affected context

The vulnerability appears in OpenClaw channel extensions that perform outbound HTTP requests via server-side fetch() calls using configurable base URLs or endpoints.

It is most relevant when:

  • Extensions allow administrators or integrators to configure remote endpoints or base URLs, and
  • These configurations are not strongly validated, normalized, or constrained to approved domains, and
  • The OpenClaw server has network-level visibility into internal or otherwise restricted services.

In such deployments, the OpenClaw server effectively becomes a proxy that attackers can steer toward internal network locations.

Exploit preconditions

  • Attack surface: HTTP endpoints in OpenClaw channel extensions that trigger server-side fetch() requests.
  • Required access: Ability to supply or modify the configured base URL or request path, or to influence parameters that are concatenated into those URLs. This may occur through:
  • Misconfigured or overly-permissive admin/config interfaces
  • Tenant or integration configuration options
  • User-controlled query parameters or payload fields that feed into endpoints.
  • Trigger point: An API call or workflow that causes the channel extension to execute fetch() against the configured endpoint (e.g., message delivery, webhook processing, data synchronization).
  • Why exploitation is possible: The implementation does not sufficiently restrict or verify the destination of outgoing requests. As a result, user-influenced URLs can bypass intended domain or network boundaries, allowing requests to be rebound from "safe" external endpoints to internal or blocked addresses (e.g., 127.0.0.1, metadata services, intra-cluster services, admin panels).

Why this happens

This issue maps to CWE-918: Server-Side Request Forgery (SSRF).

At a design level, the channel extensions trust configured base URLs and user-influenced URL components without strong validation or allowlisting. The extensions build outbound requests (often by simple string concatenation) and pass them directly to fetch() or equivalent HTTP client APIs.

The underlying insecure pattern is:

  • Treating configuration- or user-supplied URLs as fully trustworthy destinations.
  • Failing to enforce hard boundaries around where the server is allowed to send requests.
  • Relying on coarse-grained network controls or blocklists instead of strict validation and canonicalization.

This lack of destination validation permits attackers to steer server-side HTTP requests toward internal resources, causing the application server to act as an unintended network proxy.

Potential impact

  • Access to internal HTTP services that are not exposed to the public Internet.
  • Reading sensitive data from internal APIs, admin interfaces, or cloud metadata endpoints.
  • Interacting with intra-cluster services (e.g., databases, message queues, control panels) that assume only trusted callers.
  • Using the OpenClaw server as a pivot point for further internal reconnaissance.
  • Potentially triggering state-changing actions on internal services if HTTP endpoints support unsafe methods (e.g., POST/PUT/DELETE).

General mitigation guidance

Effective mitigation focuses on constraining outbound destinations and reducing trust in configured URLs:

  • Prefer strict allowlists of hostnames or service identifiers for any outbound HTTP calls, and block all other destinations by default.
  • Normalize and parse URLs using robust URL parsers before validating, avoiding plain string operations for domain checks.
  • Enforce scheme, port, and host restrictions (e.g., only HTTPS, no loopback or link-local IPs, no raw IP addresses, limited set of ports).
  • Introduce a dedicated outbound request abstraction that applies centralized SSRF protections for all channel extensions.
  • Apply a least-privilege network posture, isolating OpenClaw from highly sensitive internal control planes and metadata endpoints where feasible.
  • Treat admin or integration configuration interfaces as semi-trusted input; validate endpoints even if only administrators are expected to configure them.

How teams detect issues like this

Organizations can use a mix of code-centric and environment-centric approaches to detect similar SSRF risks:

  • Static analysis and linters to flag direct use of fetch() or HTTP clients where URL components are derived from configuration or user input without validation or allowlisting.
  • Code review checklists that require reviewers to verify outbound request destinations, including:
  • Presence of a central URL validation/allowlisting function.
  • Explicit checks against localhost, private IP ranges, and metadata service addresses.
  • Configuration audits for channel extensions to identify endpoints pointing to internal IPs or non-approved domains.
  • Runtime monitoring and logging of outbound HTTP requests, with alerts for patterns such as:
  • Requests to loopback, link-local, or internal CIDR ranges.
  • Sudden spikes of outbound traffic to unusual or previously unseen destinations.
  • Optional use of application security scanners or SSRF-focused testing tools that attempt to coerce the application into calling controlled callback URLs or well-known metadata endpoints, helping to surface weak validation.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/f92c92515bd439a71bd03eb1bc969c1964f17acf
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-rhfg-j8jq-7v2h
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-via-unguarded-configured-base-urls-in-channel-extensions

Frequently asked

questions

Yes, if an attacker can reach the affected OpenClaw endpoints and influence the configured base URLs or URL parameters, they can trigger SSRF from outside the organization, subject to any authentication or tenancy controls that guard those interfaces.

Exploitation typically requires the ability to supply or alter configuration or request data that feeds into the channel extensions' outbound URLs. This might be via authenticated admin or integration panels, tenant configuration, or crafted user inputs—depending on how the deployment exposes these features.

Introduce a central, reusable outbound HTTP client layer that:

  • Enforces strict allowlisting of destination hosts.
  • Normalizes and validates all URLs prior to making requests.
  • Rejects any destination that does not match a known-safe set of domains, schemes, and ports.

Then update all channel extensions to use this protected abstraction instead of calling fetch() directly.

Treat all URLs—whether from users, tenants, or administrators—as untrusted input. Use design-time patterns such as:

  • Fixed, code-defined destination lists for outbound calls.
  • Centralized SSRF protection utilities.
  • Code review and static analysis rules focused on outbound network access.

Combined with conservative network segmentation, these practices significantly reduce the likelihood and impact of SSRF vulnerabilities.

Find out what's already
exploitable in your codebase.