/

CVE-2026-30118

Severity:

CRITICAL RISK

(9.8)

SSRF in Scalar Proxy scalar_url Parameter

CVE-2026-30118

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Sensitive Data Exposure and Potential Privilege Escalation via Backend HTTP Requests

Severity:

CRITICAL RISK

(9.8)

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

A server-side request forgery (SSRF) vulnerability in scalar/astro v0.1.13 allows unauthenticated users to control outbound HTTP requests made by the Scalar Proxy endpoint via the scalar_url query parameter.

By directing the backend server to attacker-controlled URLs, an attacker can potentially capture authentication cookies and headers intended for internal services and leverage them for privilege escalation.

Affected context

This vulnerability affects deployments of scalar/astro v0.1.13 that expose the Scalar Proxy endpoint over HTTP(S) without strict network egress controls or URL validation.

The issue emerges when the scalar_url query parameter is used to construct outbound HTTP requests from the backend, and the application forwards cookies or authorization headers automatically.

Environments where the server has network access to internal APIs, metadata services, or administrative interfaces are particularly at risk.

Exploit preconditions

  • Attack surface: Publicly or internally accessible Scalar Proxy endpoint that accepts the scalar_url query parameter.
  • Required access: No authentication required; any party capable of sending HTTP requests to the vulnerable endpoint can attempt exploitation.
  • Trigger point: Supplying a crafted scalar_url value that points to an attacker-controlled or internal target URL, causing the backend to initiate an HTTP request.
  • Why exploitation is possible: The server constructs and sends outbound requests based on user-provided URLs without sufficient validation, normalization, or restriction of the target host and path. Cookies and headers associated with the backend context may be included in these proxied requests.

Why this happens

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

The Scalar Proxy endpoint trusts the scalar_url query parameter to define the destination of a server-side HTTP request, effectively allowing user input to control where the backend connects.

Without robust allowlisting, scheme/host validation, or segmentation of internal resources, an attacker can coerce the application to reach arbitrary endpoints, including internal services not otherwise exposed.

When authentication cookies or authorization headers are forwarded or reused automatically by the proxy logic, these sensitive values can be observed or abused, enabling lateral movement or privilege escalation.

Potential impact

  • Exposure of authentication cookies or authorization headers in requests made to attacker-controlled endpoints.
  • Unauthorized access to internal APIs, admin panels, or management interfaces reachable from the backend network.
  • Enumeration of internal network structure and services by probing internal hosts and ports.
  • Potential compromise of cloud or container metadata services if reachable, leading to access token leakage.
  • Use of captured credentials or tokens to escalate privileges within the target environment.

General mitigation guidance

Mitigation strategies typically focus on constraining outbound connections and reducing trust in user-supplied URLs:

  • Introduce strict allowlists for target hosts, domains, or paths that the proxy is permitted to contact, and reject all other destinations by default.
  • Enforce robust URL parsing and normalization, including scheme checks (e.g., limit to HTTPS) and rejection of IP literals, localhost, or private address ranges where appropriate.
  • Avoid automatically forwarding user cookies or highly privileged authentication headers through proxy endpoints; use separate, scoped credentials when proxying is necessary.
  • Segment internal networks so that web-facing services have minimal reach to sensitive internal components and metadata endpoints.
  • Apply least-privilege principles to backend roles and tokens so that, even if an SSRF occurs, the reachable resources and accessible data are limited.

How teams detect issues like this

Effective detection approaches combine code-focused and operational techniques:

  • Static analysis & code review: Flag patterns where user-controlled parameters directly influence HTTP client destinations (e.g., constructing URLs from query parameters) without allowlisting or robust validation.
  • Configuration and policy checks: Enforce development policies requiring host allowlists or network egress controls for proxy features; ensure sensitive headers are explicitly filtered before forwarding.
  • Runtime monitoring: Inspect outbound HTTP traffic from the affected service for unusual destinations, such as unexpected external domains, internal IP ranges, or metadata service endpoints triggered via proxy routes.
  • Automated security testing: Use dynamic scanners or SSRF-specific test suites during QA to detect endpoints that accept arbitrary URLs and relay server-side responses.

Sources

SourceLink
github.comgithub.com/prassan10/ssrf-zero-click-ato-scalar

Frequently asked

questions

Yes. Because the vulnerability is in a query parameter of a publicly accessible Scalar Proxy endpoint and does not require authentication, a remote attacker can exploit it by sending crafted HTTP requests to the affected server.

No. The issue, as described, is exploitable by unauthenticated users. The main requirement is the ability to reach the vulnerable endpoint over the network.

The most robust pattern is to decouple user input from arbitrary outbound connections by enforcing strict allowlists or fixed backends, performing comprehensive URL validation, and blocking all destinations outside explicitly approved hosts or paths. Additionally, avoid forwarding sensitive cookies and headers through generic proxy mechanisms.

Treat all user-influenced URLs as untrusted, require secure-by-default proxy designs (fixed destinations or well-defined allowlists), implement network egress restrictions for web-facing services, and incorporate SSRF-specific checks into code review, static analysis, and automated testing pipelines.

Find out what's already
exploitable in your codebase.