Skip to main content

Angular SSR CVE-2025-62427

HIGH
Server-Side Request Forgery (SSRF) (CWE-918)
2025-10-16 security-advisories@github.com
8.7
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send request with path starting '//attacker-domain.com'
  2. Delivery
    createRequestUrl misresolves as schema-relative URL
  3. Exploit
    SSR virtual location set to attacker host
  4. Execution
    Relative HttpClient request during rendering
  5. Impact
    Server contacts attacker-controlled endpoint (SSRF)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires (1) the target to run @angular/ssr in a vulnerable range (>=19.0.0-next.0 and <19.2.18, >=20.0.0-next.0 and <20.3.6, or >=21.0.0-next.0 and <21.0.0-next.8), (2) the SSR application to actually issue relative HTTP requests during server-side rendering (e.g. HttpClient.get('assets/data.json') or 'api/data'), and (3) the request path beginning with '//' or '\\' to reach createRequestUrl without normalization. The key limiting factors: applications that make no relative server-side fetches have little to steal via this flaw, and any reverse proxy/load balancer that collapses leading double slashes to a single slash neutralizes the attack before it reaches Angular. No authentication or user interaction is required (PR:N/UI:N), so default vulnerable deployments behind a non-normalizing proxy are exposed to remote unauthenticated SSRF.

Impact

This is a genuine but moderate-priority issue, not a top-tier emergency. The CVSS 4.0 base score of 8.7 (High) is driven by a fully remote, unauthenticated, low-complexity vector (AV:N/AC:L/AT:N/PR:N/UI:N) with high confidentiality impact (VC:H) and no integrity or availability impact. However, several signals temper the urgency: EPSS is only 0.43% (35th percentile), indicating low modeled probability of near-term mass exploitation; the vulnerability is NOT listed in CISA KEV; and no public weaponized exploit code was identified - the advisory provides only a conceptual proof-of-concept request (http://localhost:4200//attacker-domain.com/...). The SSVC-style read is that technical impact is partial (SSRF/confidentiality only, no RCE), and automatability is limited because successful exploitation depends on the specific application actually issuing relative HttpClient requests during SSR and on front-end proxies forwarding unnormalized // paths. The high CVSS and the real confidentiality exposure (DOCUMENT/PlatformLocation poisoning leading to server-side requests toward attacker endpoints) make patching worthwhile, but the low EPSS and absence of KEV/public exploit suggest this is a prompt-patch item rather than a drop-everything incident. No conflicting-signal problems in the CVSS itself: the network vector is consistent with the description of a request-path-driven SSRF.

Exploit ScenarioDerived

An unauthenticated remote attacker sends a request to a vulnerable Angular SSR endpoint with a path beginning with a double slash, e.g. http://victim-app//attacker-domain.com/some-page. The URL constructor treats this as schema-relative, so the SSR engine adopts attacker-domain.com as the virtual host; any relative request the application makes during rendering (such as HttpClient.get('api/data')) is then resolved to http://attacker-domain.com/api/data, forcing the server to contact the attacker's endpoint. No public exploit code exists, but the GitHub advisory documents a concrete conceptual PoC request.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 09, 2026

Server-side request forgery in Angular's @angular/ssr package (all versions from 19.0.0-next.0 before 19.2.18, 20.0.0-next.0 before 20.3.6, and 21.0.0-next.0 before 21.0.0-next.8) lets a remote unauthenticated attacker redirect server-side relative HTTP requests to an arbitrary external host by submitting a request path beginning with a double forward slash (//) or backslash. The flaw lives in the createRequestUrl helper, where the native URL constructor interprets a leading '//' as a scheme-relative URL and silently replaces the trusted base host with an attacker-controlled hostname, so the page's virtual location (exposed via DOCUMENT/PlatformLocation) and any subsequent relative fetch such as HttpClient.get('assets/data.json') resolve against the attacker's domain. Exploitation is conditional: the SSR application must actually perform relative server-side fetches during rendering, and the request path must reach createRequestUrl without being normalized by an upstream proxy; no public exploit code has been identified and EPSS is low at 0.43% (35th percentile), though the flaw is remotely reachable and unauthenticated per the assessed vector (PR:N/UI:N).

RemediationAI

Vendor-released patches are available: upgrade @angular/ssr to 19.2.18, 20.3.6, or 21.0.0-next.8 (choose the branch matching your Angular major), which contains the createRequestUrl change from commit 5271547c80662de10cb3bcb648779a83f6efedfb and its regression tests. If you cannot upgrade immediately, add a middleware on the Node.js/Express server that hosts the SSR app and, before the Angular SSR handler runs, rewrite or reject any request whose path starts with a double slash - for example, in Express: app.use((req, res, next) => { if (req.originalUrl?.startsWith('//')) { req.originalUrl = req.originalUrl.replace(/^\/\/+/, '/'); req.url = req.url.replace(/^\/\/+/, '/'); } next(); }); this preserves single-slash routing but changes the effective path, and it will not help if a front-end proxy already forwards the leading double slash untouched or if the app constructs request URLs elsewhere. As a defense-in-depth compensating control with a clear trade-off, configure the reverse proxy or load balancer to collapse or reject leading duplicate slashes and to strip untrusted x-forwarded-host/x-forwarded-proto values before they reach the SSR node, since these headers also feed the trusted base-URL logic; this may break legitimate clients that rely on those headers and requires coordination with the proxy owner. Full details and the maintainer's own mitigation guidance are in the GitHub advisory GHSA-q63q-pgmf-mxhr (https://github.com/angular/angular-cli/security/advisories/GHSA-q63q-pgmf-mxhr) and the upstream commit (https://github.com/angular/angular-cli/commit/5271547c80662de10cb3bcb648779a83f6efedfb).

Affected Packages

npm @angular/ssr fix: 19.2.18, 20.3.6, 21.0.0-next.8

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Angular SSR (@angular/ssr) renders Angular applications on the server (Node.js/Express-style hosts). Its createRequestUrl function builds a request URL by combining the inbound request path (originalUrl or url) with a server-derived base of protocol, hostname and port. The original implementation called new URL(originalUrl ?? url, ${protocol}://${hostnameWithPort}), relying on the WHATWG URL parser's second-argument base semantics. Because strings beginning with '//' (or '\' after parser normalization) are treated as scheme-relative references, the base's path component is discarded and its scheme is combined with the attacker-supplied authority, overriding the security-intended hostname. The commit fix (5271547c80662de10cb3bcb648779a83f6efedfb) inverts the construction to interpolate the trusted base and the path into a single string (new URL(${protocol}://${hostnameWithPort}${originalUrl ?? url})) and adds request_spec.ts regression tests covering protocol-relative url/originalUrl values and x-forwarded-host/x-forwarded-proto handling. The root cause class is CWE-918 (Server-Side Request Forgery): attacker-influenced input controls the destination of a server-initiated request. Practically, the poisoned virtual location propagates through Angular's DOCUMENT and PlatformLocation tokens so relative API or asset fetches issued during SSR are routed to the attacker's host - exposing internal metadata, response bodies, or at minimum confirming SSRF reachability. Impact per the assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) is high confidentiality loss with no integrity or availability effect, and it is bounded by whether the app actually makes relative server-side requests and whether an intermediary normalizes leading double slashes.

Know when Angular gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Remote unauthenticated request-path trigger gives AV:N/AC:L/PR:N/UI:N; SSRF exposes confidential data (C:H) with no integrity or availability impact and no scope change in the base package.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

The Angular SSR is a server-rise rendering tool for Angular applications. The vulnerability is a Server-Side Request Forgery (SSRF) flaw within the URL resolution mechanism of Angular's Server-Side Rendering package (@angular/ssr) before 19.2.18, 20.3.6, and 21.0.0-next.8. The function createRequestUrl uses the native URL constructor. When an incoming request path (e.g., originalUrl or url) begins with a double forward slash (//) or backslash (\\), the URL constructor treats it as a schema-relative URL. This behavior overrides the security-intended base URL (protocol, host, and port) supplied as the second argument, instead resolving the URL against the scheme of the base URL but adopting the attacker-controlled hostname. This allows an attacker to specify an external domain in the URL path, tricking the Angular SSR environment into setting the page's virtual location (accessible via DOCUMENT or PlatformLocation tokens) to this attacker-controlled domain. Any subsequent relative HTTP requests made during the SSR process (e.g., using HttpClient.get('assets/data.json')) will be incorrectly resolved against the attacker's domain, forcing the server to communicate with an arbitrary external endpoint. This vulnerability is fixed in 19.2.18, 20.3.6, and 21.0.0-next.8.

Executive ViewAI

Why It Matters

CVE-2025-62427 is a high-severity server-side request forgery vulnerability in the @angular/ssr package that affects Angular applications performing relative server-side fetches during rendering. An attacker could redirect those requests to arbitrary external hosts, potentially exposing sensitive data or enabling further compromise of internal services. Leadership should care because production web applications using affected Angular SSR versions may face data leakage and reputational risk, though no public exploit has been identified at time of analysis.

Business Impact: High
Compensating Controls

Normalize request paths at reverse proxy or WAF to reject or strip leading double forward slashes (//) and backslashes; restrict outbound server-side requests to allowlisted hosts; disable or limit relative server-side fetches during SSR where possible; monitor vendor advisory for patch release.

Threat Intelligence Overview

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Medium
Angular is widely used, but SSR package is a specific deployment subset
Data Quality
4 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

CVE-2026-88060 HIGH POC
8.6 Sep 10

Cross-site scripting via Angular's server-side rendering package (@angular/platform-server) allows arbitrary JavaScript

CVE-2026-88058 HIGH POC
8.6 Sep 10

Cross-site scripting in Angular's server-side rendering engine (`@angular/platform-server`) allows arbitrary JavaScript

CVE-2026-88056 HIGH POC
8.6 Sep 10

Server-Side Rendering in Angular's @angular/platform-server leaks server-side credentials to attacker-controlled origins

CVE-2025-66412 HIGH
8.5 Dec 01

Stored XSS in the Angular Template Compiler (npm package @angular/compiler) allows an authenticated attacker who can per

CVE-2026-22610 HIGH
8.5 Jan 10

Cross-site scripting in Angular's Template Compiler allows attackers to inject arbitrary JavaScript through unsanitized

CVE-2026-101895 HIGH
8.7 Sep 28

An unauthenticated remote attacker can lock up an Angular server-side rendering process by submitting HTML that contains

CVE-2026-50178 HIGH
8.7 Jun 22

Command injection via untrusted Markdown rendering in the Angular Language Service VS Code extension (versions prior to

CVE-2026-49241 HIGH
8.7 Jun 22

Arbitrary code execution in the Angular Language Service VS Code extension prior to 21.2.4 allows attackers to silently

CVE-2026-41423 HIGH
8.7 May 08

Server-Side Request Forgery in Angular's @angular/platform-server (SSR) lets remote unauthenticated attackers hijack the

CVE-2026-101896 HIGH
8.2 Sep 30

Denial of service in the npm package @angular/router when Server-Side Rendering (SSR) is enabled on Node.js allows an un

CVE-2026-27970 HIGH
7.6 Feb 26

Cross-site scripting in Angular's internationalization (i18n) pipeline allows attacker-controlled JavaScript to execute

CVE-2026-104871 MEDIUM
6.3 Oct 02

Angular SSR's CommonEngine (in @angular/ssr/node, and in @angular/ssr for versions 17 through 18) can disclose a sibling

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy