Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach unauthenticated HTTP/2 proxy port
-
DeliverySend crafted :path with protocol-relative //host
-
ExploitBypass targetOrigin check in URL resolver
-
ExecutionProxy fetches internal/localhost endpoint
-
ImpactFull internal response relayed to attacker
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 the operator to deploy the @happy-dom/server-renderer package in its reverse-proxy/SSR mode (ServerRendererServer with the required server.targetOrigin configured) and to have that HTTP/2 port reachable by the attacker. Against that configuration no further conditions apply: it is remote and unauthenticated (AV:N/PR:N/UI:N), there is no authentication guard on #onIncomingRequest, and the default behavior of the proxy is vulnerable - the attacker only needs to send a :path beginning with // (using --path-as-is and --http2-prior-knowledge to preserve the leading double slash). The limiting factor is purely deployment scope: the vulnerability is only exposed where this specific proxy component is run and network-reachable; it is not triggered by using happy-dom merely as a test/DOM library. Affected versions are <=21.0.1; 21.0.2 adds the origin check. |
| Impact | This is a genuine, actionable SSRF/open-proxy flaw rather than an inflated high-CVSS paper risk, but its real-world priority is bounded by how narrowly the affected component is deployed. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, 7.5) indicates remote, low-complexity, unauthenticated exploitation with high confidentiality impact and no integrity or availability impact, which is fully consistent with the source-code evidence: @happy-dom/server-renderer's ServerRendererServer resolves an attacker-controlled HTTP/2 :path against server.targetOrigin and fetches it with no post-resolution origin check, then relays the full response. The vuln.today decision label is this_week, signaling prompt but non-emergency remediation. No EPSS probability and no CISA KEV status are present in the supplied data, so there is no evidence of active exploitation; the exploitation signal here is PoC maturity, not in-the-wild use. A complete, working proof-of-concept (Dockerfile, curl invocation, and poc.py) is published directly in the GHSA advisory, which materially raises practical exploitability for anyone exposing the proxy. SSVC automatable/technical-impact fields were not supplied and cannot be asserted. Net: for operators actually running the server-renderer in proxy mode this is a real priority (internal/metadata endpoint exposure), but the aggregate population at risk is limited by the niche deployment of that specific component. |
| Exploit ScenarioDerived | An unauthenticated attacker who can reach the ServerRendererServer HTTP/2 port sends a request whose :path begins with a protocol-relative '//host:port/path' (e.g. //127.0.0.1:18081/secret), causing new URL() to switch origins away from the configured targetOrigin. The proxy then fetches that arbitrary internal/localhost endpoint (such as a cloud metadata service or internal API) and relays the full response headers and body back, enabling exfiltration from services never meant to be externally reachable. A full working proof-of-concept exploit is published in the GHSA advisory, and the low attack complexity with no authentication (AC:L/PR:N) makes exploitation trivial once the port is reachable. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Server-side request forgery in Happy DOM's @happy-dom/server-renderer package (versions <= 21.0.1) lets unauthenticated remote attackers redirect the proxy's outbound fetch to any HTTP or HTTPS endpoint the host can reach - including localhost and internal services - and read the relayed response headers and body. The flaw is limited to deployments that run ServerRendererServer in reverse-proxy/SSR mode with a configured server.targetOrigin and expose its HTTP/2 port; using happy-dom purely as a DOM or test library does not trigger it. Version 21.0.2 fixes the issue by rejecting any request whose resolved origin no longer matches targetOrigin, and the vendor advisory includes a complete proof-of-concept reproduction (Dockerfile plus poc.py) that demonstrates the bypass and the leaked internal response.
RemediationAI
Upgrade @happy-dom/server-renderer to 21.0.2, which is the version that introduces the origin check and the hardened redirect handling (vendor advisory GHSA-pmf4-3xr3-xjhg, fix commit 1f3ffdf634231361de1a2acb629b4fe8ee1bd85d, PR https://github.com/capricorn86/happy-dom/pull/2520, release https://github.com/capricorn86/happy-dom/releases/tag/v21.0.2); the patched code resolves targetOrigin once, returns 400 Bad Request when the resolved URL's origin differs or request.url is absent, and follows redirects manually only while each hop stays on the trusted origin, up to 20 hops. Be aware that this changes behaviour for deployments that relied on the proxy transparently following cross-origin redirects: those now surface as the raw 3xx response with its Location header instead of a followed fetch. If an immediate upgrade is not possible, the only effective interim control is to restrict who can reach the ServerRendererServer HTTP/2 listener - bind it to a loopback or management interface, or gate it behind firewall rules or an authenticating reverse proxy - accepting that this also blocks legitimate external clients of the SSR proxy while the vulnerable URL resolution remains in place.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The weakness is CWE-918 (server-side request forgery) arising from a URL-resolution trust failure rather than a parsing bug in HTTP. ServerRendererServer is an HTTP/2 reverse proxy built on Http2.createServer() that fetches an origin server's response, renders it through Happy DOM, and streams the result back to the caller; the configuration field server.targetOrigin is intended to pin all outbound fetches to one trusted origin, and it is validated as a well-formed URL at startup. In #onIncomingRequest the attacker-controlled HTTP/2 :path arrives as request.url and is resolved with new URL(request.url, targetOrigin), then handed straight to fetch(url.href) with no post-resolution comparison of url.origin against the configured origin. Per the WHATWG URL specification (and Node.js 20 behaves identically), a protocol-relative reference such as //127.0.0.1:18081/secret discards the base origin entirely, so the fetch goes to the attacker-named host and the resulting status, headers and body are written back verbatim to the requester. There is no authentication guard on the request handler, so reachability of the HTTP/2 port is the only precondition. The upstream fix in PR #2520 adds the missing origin equality check (returning 400 Bad Request), rejects requests with a missing URL, and additionally forces fetch to redirect: 'manual' with a per-hop origin check and a 20-redirect cap, because automatic redirect following was a second path to an off-origin fetch.
Know when Happy Dom 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Remote, no-auth, trivial protocol-relative path triggers SSRF (AV:N/AC:L/PR:N/UI:N); full internal response relayed verbatim gives C:H, with no integrity or availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Happy DOM is a JavaScript implementation of a web browser without its graphical user interface. Prior to 21.0.2, the Happy DOM server-renderer package's ServerRendererServer accepts unauthenticated HTTP/2 requests and resolves attacker-controlled :path values against server.targetOrigin in #onIncomingRequest in packages/@happy-dom/server-renderer/src/ServerRendererServer.ts without confirming that the resolved origin remains trusted before calling fetch. A protocol-relative path can change the destination to an arbitrary HTTP or HTTPS endpoint reachable by the server, including local and internal services, and the proxy relays the fetched response headers and body to the requester. This issue is fixed in version 21.0.2.
Technical POC Analysis
CWE-918 (Server-Side Request Forgery).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity SSRF vulnerability in Happy DOM's server-renderer package (versions ≤21.0.1) allows unauthenticated attackers to pivot into internal networks by abusing the reverse-proxy/SSR mode, potentially accessing sensitive internal services and data. While exploitation requires a specific deployment configuration (ServerRendererServer with targetOrigin and exposed HTTP/2 port), organizations using this mode for server-side rendering or proxying are at risk of internal network reconnaissance and data exfiltration. Leadership should prioritize remediation because the flaw could lead to unauthorized access to internal systems, data breaches, and compliance violations.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
Code injection in Happy DOM 17.0.0 through 21.0.3 allows attacker-supplied module source to execute in the Node.js host
Server-side request forgery in happy-dom (versions up to and including 20.14.6) lets a remote attacker force the Node.js
Cookie leakage in Happy DOM JavaScript library (all versions prior to 20.8.9) allows remote attackers to steal authentic
Cookie scope forgery in Happy DOM 20.14.5 and earlier lets an attacker-controlled origin plant a cookie that a victim or
EUVD-2026-112466
NVD
CVE.org
GitHub
Exploit-DB