/

CVE-2026-41914

Severity:

HIGH RISK

(8.5)

SSRF in OpenClaw QQ Bot Media Download Paths

CVE-2026-41914

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources via SSRF

Severity:

HIGH RISK

(8.5)

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.4.8 contain a server-side request forgery (SSRF) flaw in QQ Bot media download endpoints that can bypass existing SSRF protections.

By abusing unprotected media fetch paths, an attacker can coerce the server to initiate requests to internal services and resources, sidestepping configured allowlists and network access controls.

Affected context

The vulnerability appears in OpenClaw deployments that expose QQ Bot media download capabilities to external users or integrations.

It manifests when media fetch logic constructs outbound HTTP requests based on user-controlled URLs or identifiers but does not consistently apply SSRF filters, network segmentation rules, or URL allowlists.

The issue is most relevant where the OpenClaw server can reach internal HTTP services, metadata endpoints, or management interfaces that are not directly exposed to the public internet.

Exploit preconditions

  • Attack surface: Public or semi-public QQ Bot media download endpoints that accept user input influencing outbound requests
  • Required access: Ability to send crafted requests to the affected OpenClaw instance (e.g., being able to interact with the QQ Bot or API)
  • Trigger point: Submission of media download parameters (such as URLs, IDs, or paths) that cause the backend to fetch remote resources
  • Why exploitation is possible: Certain media download paths are not covered by the SSRF protection logic or allowlist checks, letting attacker-controlled input drive internal or arbitrary outbound requests from the server

Why this happens

The underlying issue is incomplete or inconsistent enforcement of SSRF protection on media retrieval logic.

Some QQ Bot media download handlers appear to construct server-initiated HTTP requests based on user-controlled values while bypassing central allowlist policies, URL normalization, or strict destination validation.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where the server is abused as a proxy to reach internal or otherwise restricted network locations because outbound request destinations are not tightly constrained or validated.

Potential impact

  • Access to internal HTTP(S) services that are not exposed externally
  • Bypassing existing SSRF allowlist policies and egress filters
  • Retrieval of sensitive configuration, metadata, or debugging endpoints reachable only from the server's network segment
  • Use of the server as a pivot point for further enumeration of internal network topology
  • Potential interaction with internal admin panels or service APIs, depending on authentication and network posture

General mitigation guidance

Effective mitigation generally focuses on centralizing and hardening outbound request validation for all server-initiated HTTP calls:

  • Route all media download and proxy logic through a single SSRF-safe client that enforces strict allowlists and blocks private/internal address ranges by default.
  • Normalize and parse URLs using trusted libraries and reject any that resolve to internal IP ranges, loopback, link-local, or non-HTTP(S) schemes.
  • Prefer identifier-based, server-side lookups (e.g., from a controlled registry of allowed media sources) rather than accepting arbitrary URLs from users.
  • Restrict the server's network egress through infrastructure controls (firewalls, service meshes, or egress policies) so it cannot directly access sensitive internal services.
  • Apply the principle of least privilege to the OpenClaw runtime, limiting which subnets and ports it can connect to, even if application-level validation fails.

How teams detect issues like this

Detection commonly combines code-level inspection with runtime monitoring:

  • Use static analysis or grep-based checks to identify outbound HTTP client usage (e.g., HTTP libraries or SDKs) that are not routed through a central SSRF-safe helper or allowlist enforcement layer.
  • During code review, flag any request-building logic that:
  • Accepts full URLs or hostnames directly from client input
  • Performs custom parsing or manual string concatenation for request targets
  • Skips or conditionally bypasses allowlist or validation routines
  • Enforce architectural policies that mandate a shared network access module where SSRF protections and allowlists are implemented and tested.
  • Monitor server logs for anomalous outbound connections, such as requests to internal IP ranges, localhost, or unexpected ports, and feed these into security alerting.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/d7c3210cd6f5fdfdc1beff4c9541673e814354d5
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-3fv3-6p2v-gxwj
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-in-qq-bot-media-fetch-paths

Frequently asked

questions

Exploitability depends on where the QQ Bot media endpoints are exposed. If attackers can interact with the bot or API and influence media download parameters, they may be able to exploit the issue, especially in internet-facing deployments.

Not necessarily. If media download endpoints are reachable without strong authentication or are indirectly reachable via bot messages, an unauthenticated or low-privileged actor may trigger SSRF. Strong authentication and rate limits can reduce exposure but do not fix the core issue.

The most robust fix is to centralize outbound HTTP requests through a hardened SSRF-safe client that enforces strict allowlists and blocks internal or non-approved destinations, ensuring all media download paths rely on this shared enforcement layer.

Design systems so user input never directly controls outbound request targets. Use identifier-based lookups, enforce strict network and URL validation policies, and incorporate SSRF-specific checks into code review, static analysis, and architectural guidelines.

Find out what's already
exploitable in your codebase.