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
sendMediaFeishuand 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
sendMediaFeishuor 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.

