/

CVE-2026-41302

Severity:

HIGH RISK

(7.6)

SSRF in OpenClaw Marketplace Plugin Downloader

CVE-2026-41302

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network pivoting and unauthorized access to internal or external services via the vulnerable server

Severity:

HIGH RISK

(7.6)

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 before 2026.3.31 contain a server-side request forgery (SSRF) flaw in the marketplace plugin download feature, where unguarded fetch() calls allow user-controlled URLs to be requested by the server.

A remote attacker can abuse this behavior to make arbitrary network requests, potentially probing internal services or invoking external APIs using the affected system's network identity.

Affected context

The vulnerability occurs in OpenClaw deployments that expose the marketplace plugin download functionality and allow user input to influence the URL or endpoint that fetch() will contact.

It is most relevant when:

  • The OpenClaw server can reach internal services not directly exposed to the public internet (e.g., databases, admin panels, metadata services, internal APIs), or
  • The server's outbound identity (IP, auth context, firewall position) grants it privileged access to third-party services.

The issue appears when URL inputs are accepted without strict validation, normalization, and allowlisting before being passed into the server-side fetch() logic.

Exploit preconditions

  • Attack surface: Publicly or internally accessible OpenClaw instances exposing the marketplace plugin download mechanism.
  • Required access: Ability to invoke the plugin download or related endpoints and control or influence the target download URL (e.g., via parameters, headers, or crafted plugin metadata).
  • Trigger point: The server-side code issues a fetch() call to retrieve plugin content based on attacker-influenced input, without robust validation or restriction of the destination.
  • Why exploitation is possible: The server trusts user-provided URLs and forwards them directly to fetch(), allowing the attacker to coerce the server into initiating arbitrary HTTP(S) requests to internal or external hosts using its network privileges.

Why this happens

The root cause is a classic server-side request forgery pattern: user-controllable input is used to construct backend HTTP requests without adequate validation or policy enforcement.

In the marketplace plugin download functionality, the unguarded use of fetch() treats attacker-supplied URLs as trusted destinations, failing to:

  • Enforce an allowlist of approved domains or paths,
  • Block access to private network ranges and loopback addresses,
  • Normalize and re-validate URLs after redirects or encoding tricks.

This behavior corresponds to CWE-918: Server-Side Request Forgery (SSRF), where the server becomes an unwitting proxy that can reach endpoints the attacker could not directly contact.

Potential impact

  • Unauthorized access to internal HTTP services that are otherwise not exposed to the internet.
  • Discovery and enumeration of internal network structure and services (e.g., via response behavior and timing).
  • Interaction with sensitive cloud or metadata endpoints (where reachable), which may expose credentials, tokens, or configuration.
  • Abuse of the server's IP and privileges to call external APIs or third-party services, potentially bypassing IP-based ACLs or rate limits.
  • Use of the application server as a stepping stone for broader lateral movement within the network.

General mitigation guidance

Effective mitigation focuses on constraining where server-initiated HTTP requests are allowed to go and minimizing trust in user-supplied URLs:

  • Prefer a strict allowlist of approved domains or repository endpoints for marketplace plugin downloads; reject any URL outside these domains.
  • Normalize and parse URLs using robust libraries, then re-validate host, scheme, and port against policy before performing any request.
  • Disallow or heavily restrict access to private IP ranges, loopback addresses (e.g., 127.0.0.0/8, ::1), link-local ranges, and internal hostnames.
  • Enforce protocol restrictions (e.g., only HTTPS with standard ports) and disable or carefully handle redirects to prevent redirect-based bypasses.
  • Where possible, separate the plugin download function into a network-constrained component (e.g., egress-filtered service) with minimal privileges.
  • Complement application-level controls with network-layer safeguards such as egress firewalls, proxy policies, and segmentation that limit where application servers can connect.

How teams detect issues like this

Detection typically involves a combination of code-level analysis and behavioral monitoring:

  • Static analysis and code review:
  • Flag server-side fetch(), HTTP client, or URL handling code where destination URLs are derived from request parameters, headers, or plugin metadata without allowlists.
  • Look for missing checks on hostname, IP range, and scheme, or the absence of a centralized URL validation/normalization helper.
  • Review redirect-handling logic to ensure post-redirect URLs are re-validated.
  • Configuration and policy review:
  • Verify that outbound firewall rules and proxies restrict access to internal networks and sensitive cloud endpoints from application servers.
  • Ensure logging is configured for outbound requests initiated by the marketplace components.
  • Runtime and log analysis:
  • Monitor logs and network telemetry for unusual outbound requests from the OpenClaw server, especially to internal IP ranges, uncommon ports, or unexpected domains.
  • Use automated security testing tools or SSRF-focused scanners in a controlled environment to exercise plugin download endpoints and observe outbound traffic patterns.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/8deb9522f3d2680820588b190adb4a2a52f3670b
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-9q7v-8mr7-g23p
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-via-unguarded-fetch-in-marketplace-plugin-download

Frequently asked

questions

Exploitability depends on how the plugin download interface is exposed and what the server can reach. If an attacker can control the download URL and the server has access to sensitive internal services or privileged external endpoints, the SSRF can be leveraged to perform meaningful attacks; if outbound connectivity and URL inputs are already tightly constrained, practical impact is reduced.

That depends on how your OpenClaw instance is configured. If the marketplace plugin download feature is available to unauthenticated users or low-privilege accounts that can influence the target URL, then unauthenticated or minimally authenticated exploitation may be possible. If access to this functionality is restricted to trusted administrators and their accounts are well protected, the risk is more constrained but still present if those accounts are compromised.

The safest pattern is to avoid accepting arbitrary URLs for server-side requests. Instead, implement a strict allowlist of known-good domains or repository endpoints and centralize URL validation and normalization. All plugin downloads should pass through this gatekeeper logic, which enforces permitted schemes, hosts, ports, and blocks internal or private address ranges.

Treat any user-influenced URL as untrusted, and design APIs so that clients reference logical identifiers (e.g., plugin IDs) rather than raw URLs. Apply a shared validation layer that canonicalizes and validates destinations, and back it with network-level egress controls. Incorporate SSRF checks into code review guidelines, static analysis rules, and security testing so that new server-side HTTP calls are automatically evaluated for SSRF risk.

Find out what's already
exploitable in your codebase.