/

CVE-2026-43526

Severity:

HIGH RISK

(8.2)

SSRF in OpenClaw QQBot Media URL Handling

CVE-2026-43526

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal and external resources via SSRF, with potential data exfiltration and pivoting

Severity:

HIGH RISK

(8.2)

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 QQBot reply media handling performs server-side HTTP requests to attacker-controlled URLs, enabling server-side request forgery (SSRF).

When crafted media URLs are supplied, the server may fetch arbitrary remote content and then re-upload the retrieved bytes through the bot channel, potentially exposing internal resources or enabling pivot attacks.

Affected context

The vulnerability appears in OpenClaw deployments using the QQBot integration where reply messages can embed or reference external media URLs.

When the bot receives a media URL, the backend fetches that URL server-side and then re-uploads the fetched payload back to the QQ channel.

Instances that allow untrusted or user-controlled sources to supply media URLs, and that run the bot in an environment with network access to internal services (e.g., intranet APIs, metadata endpoints, or other protected hosts), are particularly exposed.

Exploit preconditions

  • Attack surface: QQBot reply interfaces or any feature that accepts user-supplied media URLs for processing.
  • Required access: Ability to send or influence messages handled by the QQBot that contain media URLs (e.g., being a participant in a channel or having access to an upstream integration).
  • Trigger point: Server-side processing of the media URL, where the backend performs an HTTP(S) request to fetch the resource.
  • Why exploitation is possible: The application trusts and directly dereferences user-controlled URLs without sufficient network-layer restrictions, allowlists, or protocol filtering, enabling the bot server to act as a blind or reflected proxy to arbitrary targets.

Why this happens

This vulnerability stems from treating user-supplied URLs as trustworthy fetch targets in server-side media handling logic.

When the QQBot receives a reply containing a media URL, the backend issues an outbound HTTP request using high-privilege network vantage (e.g., data center, VPC, or internal cluster).

Because there is no robust validation or restriction on the destination host, IP range, protocol, or response size, attackers can direct these requests toward internal services or other protected endpoints.

This matches CWE-918: Server-Side Request Forgery (SSRF), where the server becomes an unintended proxy to arbitrary locations due to unsafe use of user-controlled URLs.

Potential impact

  • Access to internal HTTP services that are not directly reachable from the public internet
  • Discovery of internal network structure and reachable endpoints via timing and error behaviors
  • Exfiltration of data from internal web services when responses are re-uploaded through the bot channel
  • Abuse of the bot server's IP and trust relationships to interact with third-party services as if it were a legitimate internal client
  • Potential leverage toward further compromise (e.g., querying cloud metadata services, hitting admin panels, or interacting with internal APIs)

General mitigation guidance

Effective mitigation focuses on constraining where and how server-side URL fetches are performed:

  • Introduce strict allowlists for outbound destinations, limiting media fetching to vetted domains or storage providers.
  • Block or carefully restrict access to private IP ranges, link-local addresses, metadata service endpoints, and internal hostnames from media fetch components.
  • Normalize and validate URLs before fetching, rejecting ambiguous or unsafe schemes, redirects to internal addresses, and malformed host headers.
  • Run the media fetcher in a segregated network segment or dedicated egress proxy with tight firewall rules.
  • Apply size, content-type, and timeout limits to fetched responses to reduce abuse and resource exhaustion risks.
  • Default to treating all user-controlled URLs as untrusted inputs and avoid reflecting raw responses back without scrutiny.

How teams detect issues like this

Organizations can look for SSRF patterns and exploit attempts using:

  • Static analysis rules that flag direct HTTP client calls using unvalidated, user-controlled URLs.
  • Code review checklists that explicitly question any server-side fetching of URLs derived from chat messages or external inputs.
  • Centralized egress logging and monitoring for unusual outbound patterns, such as requests to internal IP ranges, metadata endpoints, or unexpected ports originating from the bot service.
  • WAF or egress-proxy policies that block known-sensitive destinations and enforce domain allowlists for media retrieval components.
  • Periodic security testing (including internal red teaming) focused on features that dereference external URLs.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/08ae021d1f4f02e0ca5fd8a3b9659291c1ecf95a
github.comgithub.com/openclaw/openclaw/commit/ddb7a8dd80b8d5dd04aafa44ce7a4354b568bb2d
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-2767-2q9v-9326
vulncheck.comvulncheck.com/advisories/openclaw-server-side-request-forgery-via-qqbot-reply-media-url-handling

Frequently asked

questions

Yes. Anyone who can cause the QQBot to process a reply with a crafted media URL can potentially trigger SSRF, subject to how messages are authenticated and routed in a given deployment.

Typically, the attacker needs the ability to send or influence messages that the QQBot will process—such as being a member of a QQ channel the bot participates in or controlling an integration that feeds messages into the bot.

The safest pattern is to restrict outbound requests to a narrow set of allowed domains through an allowlist, combined with network-level egress controls that prevent access to internal IP ranges and sensitive endpoints, and to validate and normalize URLs before dereferencing them.

Treat all user-controlled URLs as untrusted, subject to both application-level validation and network-layer policy. During design and code review, explicitly identify any feature that fetches remote resources and ensure it uses allowlists, segmented network contexts, and robust safeguards against SSRF.

Find out what's already
exploitable in your codebase.