Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInduce victim client to open WebSocket over HTTP/2
-
ExploitFail the WebSocket handshake, leaving stream orphaned
-
ExecutionDestroy connection so orphaned stream emits unhandled error
-
ImpactNode.js process exits (denial of service)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling completeness
|
| Exploitation Conditions | Requires the victim Node.js application to use undici 8.11.0 or 8.11.1 AND to open a WebSocket connection, over HTTP/2, to a server the attacker controls or can manipulate. The experimental WebSocket client is enabled by default whenever HTTP/2 is allowed (allowH2 true is the default), so no special opt-in is needed on the client. Limiting factors that reduce real-world risk: the client must itself initiate the outbound WebSocket to an untrusted/attacker-influenced server (not a server-side listening flaw), only two undici releases are vulnerable, and the documented workarounds - setting allowH2 to false or never opening WebSockets to untrusted servers - fully mitigate it without upgrading. |
| Impact | This is a genuine but conditional availability risk rather than a top-tier emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) correctly captures a network-reachable, low-complexity, unauthenticated flaw with no confidentiality or integrity impact - purely a denial of service (CWE-248, uncaught exception crashing the Node.js process). The critical nuance the base score hides is directionality: this is a CLIENT-side vulnerability where the attacker is a malicious SERVER. Exploitation is only possible if the victim application itself opens a WebSocket connection to an attacker-controlled or untrusted endpoint over HTTP/2, so 'AV:N / PR:N' is technically accurate but the realistic attack surface is narrower than the score implies. No EPSS score, CISA KEV listing, or POC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation. The exposure is further bounded to exactly two releases (undici 8.11.0 and 8.11.1). Net assessment: a real, easily-triggered crash worth prompt patching for services that make outbound WebSocket connections to third parties, but not a mass-exploitation or spray-and-pray priority given its client-initiated nature and narrow affected-version window. |
| Exploit ScenarioDerived | An attacker stands up a malicious server (or compromises/MITMs one a victim client already connects to) that speaks HTTP/2 and WebSockets. When a vulnerable undici-based Node.js client opens a WebSocket to it over HTTP/2, the server deliberately fails the handshake and then destroys the connection, leaving an orphaned HTTP/2 stream with no error listener that emits an unhandled error and terminates the Node.js process. No public exploit code was provided in the input, but the trigger is trivial and requires no authentication from the server side. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Denial of service in undici 8.11.0 and 8.11.1 allows a malicious or attacker-controlled HTTP/2 WebSocket server to terminate the Node.js process of any client that connects to it. Because the experimental WebSocket client is enabled by default whenever HTTP/2 is permitted (allowH2 defaults to true), an unauthenticated remote server can abort a failed handshake, leave the underlying HTTP/2 stream orphaned without an error listener, and then destroy the connection so the stream emits an uncaught error that crashes Node.js. Severity is rated CVSS 3.1 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-248); there is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, and vendor-released patch 8.11.2 is available.
RemediationAI
Vendor-released patch: undici 8.11.2 - upgrade to 8.11.2 or later, which is the definitive fix per advisory GHSA-qq8j-7v2v-3rwp (https://github.com/nodejs/undici/security/advisories/GHSA-qq8j-7v2v-3rwp) and the openjs CNA listing (https://cna.openjsf.org/security-advisories.html). If upgrading cannot be done immediately, two documented workarounds fully remove the exposure: set allowH2 to false for WebSocket connections so the client negotiates HTTP/1.1 instead - an effective mitigation, with the trade-off that you lose HTTP/2 multiplexing and header compression and fall back to one connection per request semantics for those sockets - or simply avoid opening WebSocket connections to untrusted or attacker-influenceable servers, which is a policy control that costs nothing technically but requires inventorying every outbound WebSocket target. Standard hardening around the crash symptom, such as a process supervisor or cluster worker restart, reduces outage duration but does not prevent the unhandled-exception termination, so treat it as containment rather than a fix.
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
undici is the HTTP/1.1 and HTTP/2 client library maintained under the Node.js project; the flaw lives in its experimental WebSocket client, which is used whenever HTTP/2 support is allowed because allowH2 defaults to true. The root-cause class is CWE-248 (Uncaught Exception): in versions 8.11.0 and 8.11.1, when a WebSocket handshake over HTTP/2 fails, the request object is already marked completed, so the client-side abort becomes a no-op and the underlying HTTP/2 stream is left open and detached without an attached 'error' listener. If the remote server subsequently destroys the connection, that orphaned stream emits an 'error' event with no handler, and Node.js's default behavior for unhandled error events is to terminate the process. The CPE cpe:2.3:a:undici:undici:*:*:*:*:*:*:*:* labels the package broadly, but the description and advisory scope the defect specifically to the 8.11.0 and 8.11.1 releases of the experimental WebSocket-over-HTTP/2 path; the HTTP client and HTTP/1.1 WebSocket paths are unaffected.
Know when Undici 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:N/I:N/A:H
Server-side trigger needs no authentication (PR:N) and is network-reachable and trivial (AV:N/AC:L); impact is a process crash only, so C:N/I:N/A:H with no scope change.
Primary rating from Vendor (openjs).
CVSS VectorVendor: openjs
Lifecycle Timeline
2DescriptionCVE.org
undici is an HTTP client library for Node.js. In versions 8.11.0 and 8.11.1, its experimental WebSocket client, which is enabled by default when HTTP/2 is allowed, mishandles a failed WebSocket handshake over HTTP/2: the request is already marked completed, so the abort becomes a no-op and the underlying HTTP/2 stream is left open with no error listener. When a malicious server then destroys the connection, the orphaned stream emits an unhandled error and the Node.js process exits. A remote, unauthenticated server can therefore crash any client that opens a WebSocket to it over HTTP/2, resulting in a denial of service. The issue is fixed in undici 8.11.2, and users should upgrade to 8.11.2 or later. As a workaround, set allowH2 to false to disable HTTP/2 for WebSocket connections, or avoid opening WebSocket connections to untrusted servers.
Technical POC Analysis
Bug class: CWE-248 (Uncaught Exception), with CWE-754 (improper check for an unusual/exceptional condition) as the underlying defect.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
undici versions 8.11.0 and 8.11.1, a Node.js HTTP client library, contain a high-severity denial-of-service vulnerability that allows an unauthenticated remote attacker to crash the Node.js process by connecting to a malicious HTTP/2 WebSocket server. Organizations using these versions in applications that communicate with external or untrusted servers face service outages, potentially impacting customer-facing services and internal operations. According to current intelligence, no public exploit identified at time of analysis, but leadership should prioritize immediate patching to version 8.11.2 to mitigate risk.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
undici is an HTTP/1.1 client, written from scratch for Node.js.`undici` is vulnerable to SSRF (Server-side Request Forge
Memory exhaustion denial of service in the undici WebSocket client (versions 6.17.0 and later) allows a malicious or com
Cross-user information disclosure in undici's cache interceptor allows authenticated users' responses to be served from
Cookie attribute injection in undici's setCookie function allows attacker-controlled domain values or unparsed array ent
Authorization headers are cleared on cross-origin redirect. Rated medium severity (CVSS 6.5), this vulnerability is remo
`Undici.ProxyAgent` never verifies the remote server's certificate, and always exposes all request & response data to th
CRLF injection in undici's HTTP/1.1 dispatcher enables HTTP header injection and potential request smuggling when applic
Undici is an HTTP/1.1 client for Node.js. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable,
undici is an HTTP/1.1 client, written from scratch for Node.js.`=< undici@5.8.0` users are vulnerable to _CRLF Injection
Cross-user information disclosure and a parse-time denial of service in undici's HTTP cache interceptor affect versions
TLS certificate validation bypass in undici's BalancedPool dispatcher silently discards function-valued options - includ
Cross-origin request misrouting in undici's Socks5ProxyAgent (introduced in 7.23.0, affecting all releases through 8.1.0
EUVD-2026-101959
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB