Summary
OpenClaw's cron webhook delivery logic forwards outbound HTTP requests using a raw fetch() call, bypassing the application's SSRF protection layer.
If an attacker can control cron webhook targets, they may coerce the server into making requests to internal, metadata, or otherwise restricted endpoints, potentially exfiltrating sensitive information or abusing internal services.
Affected context
This vulnerability affects OpenClaw deployments that use cron-based webhook delivery implemented in src/gateway/server-cron.ts.
The issue manifests when user- or configuration-controlled webhook URLs are invoked by the server using a direct fetch() call, rather than a central HTTP client or proxy that enforces SSRF policies.
In such environments, internal network addresses, cloud provider metadata endpoints, or other sensitive internal HTTP services may become reachable through the cron job execution path.
Exploit preconditions
- Attack surface: HTTP(s) interface or configuration channel that allows defining or influencing cron webhook target URLs.
- Required access: Ability to create, modify, or indirectly control cron webhook configurations (e.g., via application UI, API, or compromised configuration).
- Trigger point: Execution of the scheduled cron job that performs the outbound webhook using
fetch(). - Why exploitation is possible: The cron handler bypasses centralized SSRF policy checks and performs direct HTTP requests, allowing attacker-controlled URLs to target internal or otherwise restricted endpoints.
Why this happens
The root cause is an architectural bypass of SSRF protections: the cron webhook delivery logic uses a raw fetch() call rather than the SSRF-hardened request path used elsewhere.
This design choice means user-influenced URLs are sent directly over the server's network interface without hostname/IP allowlisting, blocklisting, or scheme validation.
Conceptually, this aligns with CWE-918: Server-Side Request Forgery (SSRF), where an attacker induces the server to initiate arbitrary network requests, leveraging its trust relationships and network position to reach internal or sensitive resources.
Potential impact
- Access to internal HTTP services that are not exposed externally.
- Interaction with cloud provider metadata endpoints, which may reveal temporary credentials or instance details.
- Probing of internal network topology and host availability (port scanning via HTTP).
- Abuse of internal administrative APIs that trust traffic originating from inside the network.
- Potential data exfiltration from internal services reachable over HTTP(S).
General mitigation guidance
Mitigation centers on ensuring all outbound HTTP calls, including cron-driven webhooks, pass through the same SSRF protection layer:
- Route cron webhook delivery through a centralized HTTP client or proxy that enforces SSRF policies (allowlists, blocklists, and scheme restrictions).
- Apply strict allowlisting of destinations for scheduled webhooks (e.g., only pre-approved domains or service names).
- Normalize and validate URLs before requests, rejecting private IP ranges, link-local addresses, and metadata service endpoints.
- Limit the network privileges of the component performing cron webhooks (e.g., network segmentation, dedicated egress rules).
- Treat webhook configuration as untrusted input and restrict who can define or modify cron webhook targets.
How teams detect issues like this
Detection efforts can focus on both code and runtime behavior:
- Static analysis: Search for direct
fetch()or low-level HTTP client usage in backend or cron code paths that do not pass through the standard SSRF-safe client or policy enforcement layer. - Code review signals: Look for outbound request logic implemented outside established HTTP utility modules, especially in scheduler, worker, or background job components.
- Policy enforcement: Introduce linting or architectural rules that forbid direct network calls from cron handlers and require using approved network abstraction layers.
- Runtime monitoring: Analyze outbound traffic from cron or worker services, flagging connections to internal IP ranges, metadata services, or unexpected domains.

