/

CVE-2026-27488

Severity:

HIGH RISK

(7.3)

SSRF in OpenClaw Cron Webhook Delivery

CVE-2026-27488

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal services and sensitive metadata via SSRF

Severity:

HIGH RISK

(7.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 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.

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/99db4d13e5c139883ef0def9ff963e9273179655
github.comgithub.com/openclaw/openclaw/releases/tag/v2026.2.19
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-w45g-5746-x9fp

Frequently asked

questions

It can be, if an external user or integration can define or influence cron webhook URLs. In that case, an attacker may leverage the cron subsystem to trigger SSRF from outside the network.

An attacker must be able to create, modify, or otherwise control the cron webhook target configuration. This may require authenticated access to OpenClaw or compromise of an integration that manages cron schedules.

Route all outbound HTTP requests, including from cron and background jobs, through a centralized, SSRF-aware HTTP client or proxy that enforces strict domain/IP allowlists and blocks access to internal and metadata endpoints.

Establish an architectural rule that no component may perform direct network calls; instead, enforce usage of common network utilities with SSRF protections, validate all user-controlled URLs, and add automated checks in CI to detect new direct fetch() or low-level HTTP client usage in server-side code.

Find out what's already
exploitable in your codebase.