/

CVE-2026-28451

Severity:

HIGH RISK

(8.3)

SSRF in OpenClaw Feishu Extension

CVE-2026-28451

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Internal Service 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 Feishu extension prior to version 2026.2.14 contains a server-side request forgery (SSRF) flaw where the application can be tricked into fetching attacker-controlled URLs via the sendMediaFeishu function and markdown image handling.

When an attacker can influence tool calls—either directly or via prompt injection—they can coerce the server to contact internal services and then re-upload retrieved content as Feishu media.

Affected context

The vulnerability appears in OpenClaw deployments that:

  • Have the Feishu extension enabled and reachable through automation or tool-calling flows
  • Allow user-provided input or model-generated content to influence URLs used in sendMediaFeishu and markdown image resolution
  • Do not enforce strict SSRF protections such as URL allowlists, internal address blocking, or protocol restrictions

In such environments, the OpenClaw server effectively becomes an HTTP client that can be abused to reach otherwise non-public endpoints.

Exploit preconditions

  • Attack surface:
  • Feishu extension features that send or embed media via external URLs
  • Markdown or content processing that automatically resolves image URLs
  • Required access:
  • Ability to supply or influence content used by OpenClaw tools
  • This can be direct (user-controlled URLs, configuration) or indirect (prompt injection into LLM calls that select URLs)
  • Trigger point:
  • Invocation of sendMediaFeishu or markdown image processing with attacker-controlled or attacker-influenced URLs
  • Why exploitation is possible:
  • The URL fetching logic lacks robust SSRF defenses (e.g., no strict allowlist, no blocking of internal IP ranges, no hostname/IP re-validation), allowing arbitrary destinations to be requested from the server's network context.

Why this happens

The core issue aligns with CWE-918: Server-Side Request Forgery (SSRF).

OpenClaw's Feishu extension exposes functionality that fetches remote resources based on dynamic URLs. These URLs can be influenced by external input, including user-controlled data or content generated via prompt injection.

Because the implementation does not sufficiently restrict which hosts, IP ranges, or protocols can be accessed, the server trusts the provided URL and issues outbound requests on behalf of the attacker. This conflates user input with trusted network operations, allowing attackers to pivot into internal networks or protected services that only the server can reach.

Potential impact

  • Discovery and probing of internal HTTP services that are not directly exposed to the internet
  • Exfiltration of sensitive data from internal endpoints by fetching responses and re-uploading them as Feishu media
  • Abuse of internal APIs to perform unintended operations under the server's identity
  • Bypassing firewall or network segmentation controls by using the application server as a proxy
  • Potential chaining with other vulnerabilities (e.g., internal service RCE) to escalate to full environment compromise

General mitigation guidance

Mitigations generally focus on strict network egress controls and hardened URL handling:

  • Introduce a robust SSRF protection layer for all outbound HTTP requests made by the Feishu extension, including:
  • Denying access to private and link-local IP ranges by default (e.g., RFC1918, 169.254.0.0/16, localhost/loopback)
  • Enforcing a domain or URL allowlist for external media fetching
  • Re-resolving hostnames and validating the final IP to prevent DNS rebinding
  • Separate untrusted URL handling from privileged network paths; route external fetches through a controlled egress proxy with filtering.
  • Treat LLM-generated content, markdown, and tool arguments as untrusted input; apply the same validation and sanitization as for direct user input.
  • Apply the principle of least privilege to the network: restrict the Feishu extension's ability to reach internal services that are not necessary for its function.

How teams detect issues like this

Organizations can look for SSRF indicators and patterns through:

  • Static analysis and code review:
  • Identify code paths that construct outbound HTTP requests from user or model-influenced URLs without validation.
  • Flag direct use of generic HTTP clients in integration layers (e.g., extensions, webhooks) that lack explicit allowlists or IP-range checks.
  • Configuration and policy checks:
  • Enforce centralized policies for outbound HTTP access, such as mandatory proxies or network-level egress filters.
  • Verify that markdown and media-handling components do not automatically fetch external resources without SSRF safeguards.
  • Runtime monitoring:
  • Monitor outbound traffic from the application for unusual destinations, particularly internal address ranges.
  • Use anomaly detection on egress logs to catch repeated or unexpected calls to non-public endpoints.
  • Automated tooling:
  • Leverage security scanners or custom linters to detect SSRF-prone patterns (unrestricted URL fetching) in CI pipelines before deployment.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/5b4121d6011a48c71e747e3c18197f180b872c5d
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-x22m-j5qq-j49m
vulncheck.comvulncheck.com/advisories/openclaw-ssrf-via-feishu-extension-media-fetching

Frequently asked

questions

Yes. If an attacker can provide content or influence prompts that feed into the Feishu extension's URL parameters or markdown processing, they can exploit the SSRF remotely through the normal OpenClaw interfaces or integrated LLM flows.

The attacker needs the ability to control or significantly influence the inputs that determine which URLs are fetched. This can be via direct configuration or content submission, or indirectly via prompt injection affecting tool calls and markdown content.

Centralize and harden outbound HTTP handling with strict SSRF protections: enforce allowlists, block internal address ranges by default, validate resolved IPs, and route all extension-based fetches through a controlled egress mechanism instead of allowing arbitrary direct requests.

Treat any URL that originates from users or model output as untrusted; design integrations so that they can only access a narrow set of approved endpoints, incorporate SSRF checks into shared HTTP client utilities, and include SSRF-focused reviews and automated checks in development and deployment pipelines.

Find out what's already
exploitable in your codebase.