Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure app to attacker-controlled URL
-
DeliveryReturn response with >5 content codings
-
ExploitClose connection before body
-
ExecutionOrphaned stream raises unhandled error
-
ImpactNode.js process terminates (DoS)
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 | The vulnerable application must use undici's fetch() implementation (an affected 6.23.0-6.29.0, 7.18.0-7.30.0, or 8.0.0-8.12.1 release, including Node.js builds bundling these) to make an outbound HTTP(S) request to a server the attacker controls or has compromised - e.g. calling third-party APIs/webhooks or any user-influenced URL (SSRF-style redirection also qualifies). The attacker-as-server returns a response specifying more than five content-encoding codings and closes the connection before sending the body. Limiting factor: this is a client-side flaw, so the attacker cannot reach a victim that never initiates a request to a malicious/compromised endpoint; however, standard mitigation is ineffective because the crash occurs even when the fetch() promise rejection is correctly caught. There is no workaround other than upgrading to 6.29.1, 7.30.1, or 8.12.2 or later. |
| Impact | All signals point to a genuine, well-characterized availability risk. The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) describes a network-reachable, low-complexity, unauthenticated flaw with pure availability impact and no confidentiality or integrity loss (CWE-248, uncaught exception), which is fully consistent with the description: a single crafted response crashes the Node.js process. One important nuance the raw vector obscures is directionality - undici is an HTTP client, so the attacker is the SERVER, not a typical inbound network attacker; exploitation requires the victim application to issue a fetch() to an attacker-controlled or compromised endpoint. The description's note that the crash occurs 'even when the application correctly catches the fetch() rejection' elevates real-world severity, because the usual defensive pattern does not help. No EPSS score, KEV listing, POC, or SSVC data was supplied, so exploitation-probability and automatability signals are unavailable and cannot be used to rank this against other 7.5 issues. Net assessment: a credible, easy-to-trigger DoS whose priority is driven mainly by how widely undici/Node fetch is deployed rather than by any confirmed in-the-wild activity. |
| Exploit ScenarioDerived | A Node.js service that uses fetch()/undici to call an external API, webhook, or user-supplied URL is pointed at a server controlled by the attacker. That server returns one response declaring more than five content-encoding codings and then closes the connection before the body, triggering a content-length mismatch on an orphaned stream that Node treats as an unhandled error and terminates the process. No public exploit identified at time of analysis, but the trigger is a single trivially craftable HTTP response. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Denial of service in the undici HTTP client library for Node.js (6.23.0-6.29.0, 7.18.0-7.30.0, and 8.0.0-8.12.1) lets a malicious or compromised remote server terminate the entire Node.js process with a single crafted response. When the server advertises more than five stacked content codings and then closes the connection before sending the body, undici rejects the response over its content-encoding limit, but it has already created the internal response stream and returns without attaching an error listener or aborting the request; the early close then surfaces a content-length mismatch on the orphaned stream as an uncaught error that Node.js handles by aborting the process. The flaw is client-side and remote-triggerable without authentication (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), and - critically - the crash occurs even when the application correctly catches the fetch() rejection, so there is no public exploit identified at time of analysis and no vendor-provided workaround other than upgrading.
RemediationAI
Vendor-released patch: upgrade to undici 6.29.1, 7.30.1, or 8.12.2 (or any later release on the corresponding branch), as documented in GHSA-xjj6-f33q-929c (https://github.com/nodejs/undici/security/advisories/GHSA-xjj6-f33q-929c) and the OpenJS CNA advisory page (https://cna.openjsf.org/security-advisories.html); if the vulnerable undici is the copy vendored in a Node.js runtime, upgrading Node.js to a release that bundles a fixed undici resolves the issue, and the effective undici version can be confirmed at runtime via process.versions.undici. The advisory states there is no workaround, and because the process is killed by an uncaught stream error rather than an unhandled fetch() rejection, do NOT rely on try/catch, .catch(), or rejection handlers around fetch() - they demonstrably do not prevent the crash. Until patching is complete, the practical compensating controls are to stop using fetch() for attacker-influenced URLs and switch those call sites to node:https or another client on the fixed path, to constrain egress with an allowlist of trusted destinations and disable or tightly bound HTTP redirects so that SSRF-style redirection to a hostile host is not possible, and to isolate any workload that performs outbound fetches in its own container or process with restart supervision and CPU/memory limits so that a crash is contained to the fetcher rather than the whole application. Each of these has trade-offs: swapping the HTTP client requires code changes and may lose undici-specific features, egress allowlisting can break legitimate third-party integrations when destinations change, and process isolation adds operational overhead without removing the underlying defect.
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 client that powers Node.js's global fetch() implementation and is also vendored inside Node.js runtime releases, which broadens the blast radius well beyond applications that depend on undici directly (CPE cpe:2.3:a:undici:undici:*:*:*:*:*:*:*:*). The root cause is an ordering defect in the fetch() response path: undici enforces a limit of five chained Content-Encoding codings (e.g. repeated gzip/deflate/br layers) and rejects responses that exceed it, but the internal body stream is instantiated before that validation runs. On the rejection branch the code returns without wiring an 'error' listener onto that orphaned stream or aborting the underlying request, so when the attacker closes the TCP connection prematurely, undici's own content-length accounting fires an ERR_CONTENT_LENGTH_MISMATCH (or equivalent stream error) on a stream that has no error handler. Node.js treats an unhandled stream 'error' event as a fatal exception and terminates the process, mapping to CWE-248 (Uncaught Exception). This is an availability-only defect: there is no memory corruption, no code execution, and no data exposure, but because the failure is an uncaught event rather than a rejected promise, ordinary promise-level error handling cannot contain it.
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
Remote malicious server triggers process crash with a single response needing no auth or user interaction (AV:N/AC:L/PR:N/UI:N); pure availability loss, no C/I impact.
Primary rating from Vendor (openjs).
CVSS VectorVendor: openjs
Lifecycle Timeline
2DescriptionCVE.org
undici is an HTTP client library for Node.js. In versions 6.23.0 through 6.29.0, 7.18.0 through 7.30.0, and 8.0.0 through 8.12.1, its fetch() implementation crashes the Node.js process when a malicious server returns a response with more than five content codings and closes the connection before sending the body. undici rejects such responses because of a content-encoding limit, but it created the internal response stream before that check and returned without attaching an error listener or aborting the request, so the early close surfaces a content-length mismatch on the orphaned stream, which Node.js treats as an unhandled error and terminates the process. A remote, unauthenticated server can trigger this with a single response, even when the application correctly catches the fetch() rejection, resulting in a denial of service. The issue is fixed in undici 6.29.1, 7.30.1, and 8.12.2, and users should upgrade to one of those versions or later. There is no workaround.
Technical POC Analysis
Evidence base: the GHSA-xjj6-f33q-929c advisory only.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Any Node.js service that uses the undici HTTP client in versions 6.23.0-6.29.0, 7.18.0-7.30.0, or 8.0.0-8.12.1 can be terminated by a single crafted response sent by a remote server it connects to, and this occurs even when the application correctly handles the fetch() error. Because the crash kills the entire Node.js process rather than a single request, unauthenticated denial of service is achievable against every API gateway, background worker, or service that makes outbound HTTP calls on these versions, with no vendor-released patch identified at time of analysis. Leadership should treat this as an availability risk to customer-facing and internal services whose blast radius depends on how widely these undici versions are deployed across the estate.
No vendor-released patch identified at time of analysis. Interim mitigations: pin affected services to undici versions outside the vulnerable ranges where a validated non-vulnerable release exists; enforce strict egress allowlisting so Node.js workloads can only reach trusted servers; place a proxy or gateway in front of outbound requests that rejects responses advertising more than five stacked Content-Encoding headers; run Node.js processes under a supervisor or orchestrator restart policy (systemd, PM2, Kubernetes) to bound the duration of any crash; and monitor/alert on unexpected process restarts as a detection signal for exploitation attempts.
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-102240
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB