/

CVE-2025-67647

Severity:

CRITICAL RISK

(9.1)

Server-Side Request Forgery (SSRF) and Availability Weakness

CVE-2025-67647

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF) and Availability Weakness

CWE:

CWE-248, CWE-918

Impact:

Denial of Service and Potential Server-Side Request Forgery

Severity:

CRITICAL RISK

(9.1)

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

Certain SvelteKit configurations prior to 2.49.5 allow crafted requests to abuse prerendered routes, leading to server-side request forgery (SSRF) and denial of service (DoS).

Applications with prerendered routes, especially when deployed with adapter-node and a missing ORIGIN configuration and without Host header validation, can be driven into resource exhaustion and unintended outbound requests by an attacker.

Affected context

This issue affects SvelteKit applications that:

  • Are running a version from 2.19.0 up to (but not including) 2.49.5, and
  • Have at least one prerendered route (export const prerender = true).

The risk is heightened when:

  • The app is deployed using adapter-node,
  • No ORIGIN environment variable is configured, and
  • The deployment is not placed behind a reverse proxy that enforces strict Host header validation.

In such setups, the server's handling of requests to prerendered routes can be influenced by attacker-controlled request metadata, allowing requests that overload the server or cause it to make unintended outbound connections.

Exploit preconditions

  • Attack surface: Public HTTP(S) endpoints serving a SvelteKit application, particularly prerendered routes.
  • Required access: Network-level ability to send crafted HTTP requests to the application (no prior authentication necessarily required).
  • Trigger point (DoS):
  • Version 2.44.0–2.49.4: At least one prerendered route is present.
  • Version 2.19.0–2.49.4: At least one prerendered route, deployment via adapter-node, missing ORIGIN env var, and no upstream reverse proxy enforcing Host header validation.
  • Trigger point (SSRF): The server's outbound request logic can be influenced by request headers (such as Host) or similar values derived from untrusted input, causing it to connect to attacker-chosen destinations.
  • Why exploitation is possible: The framework's handling of prerendered routes and origin-related metadata implicitly trusts aspects of client-controlled values, allowing an attacker to steer internal routing and/or repeated work, which can lead to both outbound requests and resource exhaustion.

Why this happens

The root cause combines:

  • CWE-918 (Server-Side Request Forgery): SvelteKit's prerendering and origin resolution logic implicitly relies on values influenced by client-controlled request headers (e.g., Host) or deployment configuration. When the ORIGIN is not explicitly defined and the environment lacks strict Host validation, the server can construct or follow URLs that originate from untrusted input, enabling SSRF-like behavior.
  • CWE-248 (Uncaught Exception / Uncontrolled Resource Consumption aspects): Under specific runtime conditions, the request handling for prerendered routes can be driven into failure states or loops that consume excessive resources, resulting in a denial of service. Attacker-controlled requests repeatedly trigger expensive processing or error-handling paths without appropriate throttling or constraints.

Conceptually, the insecure pattern is that the server:

  • Treats request-derived origin/Host information as trusted for constructing internal or outbound requests, and
  • Does not sufficiently bound the amount of work done per request or per client, allowing repeated triggering of heavy computation or error conditions.

Potential impact

  • Application may become unresponsive due to repeated triggering of costly prerendering logic (DoS).
  • CPU and memory usage could spike, degrading performance for all users.
  • The server could be induced to make outbound HTTP requests to attacker-controlled or internal network locations (SSRF).
  • Internal services or metadata endpoints reachable from the SvelteKit server's network environment could be probed or interacted with.
  • Logs and monitoring systems may be flooded with repeated error traces or high-volume requests.

General mitigation guidance

Effective mitigation typically combines framework-hardening with defensive deployment practices:

  • Explicitly define trusted origins: Configure a strict, explicit origin value for the application runtime rather than inferring it from client-supplied headers. This reduces the trust placed in the Host header or similar request metadata.
  • Harden HTTP ingress: Place the SvelteKit app behind a reverse proxy or load balancer that:
  • Enforces Host header validation against an allowlist.
  • Normalizes and strips unexpected headers where appropriate.
  • Constrain prerender behavior: Limit the amount of dynamic behavior tied to prerendered routes and avoid designs where prerendered paths depend on untrusted values for URL construction or internal routing.
  • Resource and failure bounding: Implement limits on request processing:
  • Timeouts and maximum work per request.
  • Rate limiting or connection throttling at the edge.
  • Graceful handling of invalid Host/Origin values without entering expensive fallbacks.
  • Network segmentation for outbound traffic: Where possible, restrict the server's ability to make arbitrary outbound HTTP requests using egress rules, service meshes, or firewall policies, especially to internal infrastructure and metadata endpoints.
  • Least-privilege deployment: Run the SvelteKit process with minimal privileges and within a tightly scoped network and container environment to reduce blast radius if SSRF is abused.

How teams detect issues like this

Identifying and monitoring for this vulnerability and similar patterns can involve:

  • Configuration review:
  • Confirm whether SvelteKit deployments with adapter-node define an explicit ORIGIN.
  • Check that reverse proxies or load balancers enforce strict Host header validation and do not blindly forward arbitrary Host values.
  • Static analysis and code review cues:
  • Look for server logic that constructs URLs or makes outbound HTTP calls based on request headers (e.g., Host, X-Forwarded-*).
  • Flag code that uses framework-provided origin values without verifying that they derive from a trusted configuration rather than from request input.
  • Runtime monitoring and logging:
  • Monitor for spikes in traffic targeting specific prerendered routes, particularly unusual patterns like repeated requests with varying Host values.
  • Track outbound HTTP requests from the application to unexpected domains or internal IP ranges.
  • Alert on recurring exceptions or high error rates tied to prerendered route handling.
  • Security testing:
  • Use internal tooling or application security scanners to send malformed or crafted Host/Origin headers and observe whether the server:
  • Makes unexpected outbound requests, or
  • Exhibits degraded performance or resource exhaustion.

Automated review tools and CI-integrated checks can be configured to flag untrusted use of Host/Origin headers and misconfigurations in deployment manifests.

Sources

SourceLink
github.comgithub.com/sveltejs/kit/commit/d9ae9b00b14f5574d109f3fd548f960594346226
github.comgithub.com/sveltejs/kit/security/advisories/GHSA-j62c-4x62-9r35

Frequently asked

questions

Yes. An attacker who can send HTTP(S) requests to the affected SvelteKit application can potentially exploit it, provided the application has at least one prerendered route and is deployed in a configuration that relies on unvalidated Host or origin metadata.

The attacker generally only needs network access to the application's public endpoint. No authenticated session is inherently required to trigger the DoS behavior or attempt SSRF, though additional access controls and network restrictions can significantly reduce exposure.

The safest pattern is to:

  • Treat Host and Origin as untrusted by default,
  • Configure a fixed, trusted origin in the application runtime,
  • Place the app behind a reverse proxy that strictly validates Host headers, and
  • Ensure prerender logic does not depend on untrusted input for constructing internal or outbound URLs.

Establish deployment and coding standards that:

  • Require explicit origin configuration for server frameworks,
  • Mandate reverse proxy frontends with strict header validation,
  • Prohibit constructing outbound requests directly from request headers without validation,
  • Include SSRF and DoS considerations in architectural reviews and automated security testing.
Find out what's already
exploitable in your codebase.