Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to malicious/compromised HTTP server
-
DeliveryReturn tiny compressed response body
-
ExploitDecompress exceeds configured size limit
-
ExecutionDownstream handler throws in zlib callback
-
ImpactUncaught async exception crashes Node.js process
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 | Exploitation requires that the victim client application specifically compose undici's decompress interceptor with a downstream response handler that throws during response processing - the canonical example being the built-in dump interceptor configured with a maximum response size. This is NOT a default configuration: a client that does not use the decompress interceptor, or pairs it only with handlers that never throw, is not affected. The attacker must also control or compromise the HTTP server the client connects to (the client must initiate a request to attacker-influenced infrastructure). Given that composition, exploitation is otherwise unauthenticated and needs no user interaction; the limiting factors are the opt-in interceptor stacking (reflected as AC:H) and the requirement that the client reach an attacker-controlled endpoint. |
| Impact | This is a moderate-severity denial-of-service issue (CWE-248, Uncaught Exception) whose real-world priority is constrained by a non-default prerequisite rather than by low impact. The provided CVSS:3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, base 5.9) is internally consistent with the description: the attacker is a malicious or compromised HTTP server (AV:N, PR:N, UI:N), the impact is process termination only (C:N/I:N/A:H), and AC:H correctly reflects that exploitation is not universal - it fires only when the victim client composes the decompress interceptor with a downstream handler that throws during response processing (e.g., the dump interceptor's max-size throw). No EPSS score, KEV listing, POC reference, or SSVC decision data was supplied in the input, so exploitation likelihood cannot be quantified from the signals provided; per precision rules this is scored as 'no public exploit identified at time of analysis.' The amplification property is notable: because only the decompressed size matters, an attacker sends a tiny compressed body (a zip-bomb-style ratio) to crash the process, making exploitation cheap once the vulnerable composition exists. Net assessment: a genuine availability risk for Node.js services that use undici's decompress plus a throwing handler, but AC:H and the opt-in interceptor composition keep it well below a drop-everything priority; it is a real fix-on-schedule item, not a high-CVSS-but-illusory issue, and the absence of exploit-maturity data should be resolved before final triage. |
| Exploit ScenarioDerived | A Node.js application uses undici's decompress interceptor together with a size-limiting handler such as the dump interceptor and makes an outbound HTTP request to an attacker-controlled or compromised server. The server returns a small gzip/deflate body that decompresses to more than the configured maximum size; the handler throws from inside a zlib stream callback, and because the async throw is not caught, it propagates as an uncaught exception that terminates the entire Node.js process. No public exploit code was identified in the input, but the technique is trivial to reproduce given the documented condition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Process-terminating denial of service in the undici HTTP client library for Node.js (7.15.0 through 7.30.0 and 8.0.0 through 8.12.1) allows a malicious or compromised HTTP server to crash a connecting client by returning a small compressed body that expands past the client's configured response-size limit. The flaw only manifests when an application composes the decompress interceptor with a downstream handler that deliberately throws during response processing - most notably the built-in dump interceptor - because such exceptions are raised asynchronously from zlib stream callbacks, where undici's normal per-request error conversion does not apply, so the throw becomes an uncaught exception that terminates the Node.js process. Per the CVSS vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9) this is an unauthenticated remote crash with no confidentiality or integrity impact, and the AC:H rating reflects the non-default interceptor-stacking prerequisite rather than any authentication barrier; no public exploit code and no confirmed active exploitation were identified at time of analysis.
RemediationAI
Vendor-released patch: undici 7.30.1 for the 7.x line and 8.12.2 for the 8.x line - upgrade to one of those versions or later as the primary fix. Because undici is typically a transitive dependency, audit lockfiles (npm ls undici, or equivalent) and force resolution through npm overrides / yarn resolutions / pnpm overrides where an upstream dependency pins an affected range, then re-run tests to confirm no other package was relying on the buggy behavior. If an immediate upgrade is not possible, the vendor-endorsed workaround is to stop composing the decompress interceptor with a response handler that throws during response processing - for example, remove the dump interceptor's max-size throw path, perform decompression manually outside the interceptor chain, or sanitize/inspect decompressed bodies before handing them to a throwing handler; the trade-off is that you lose transparent decompression or the built-in oversize guard and must reimplement size limiting yourself, which risks memory pressure if done carelessly. Client-side network egress restrictions (allowing requests only to trusted origins, since the attacker must control the server the client contacts) reduce exposure but are a defense-in-depth measure, not a fix. Details and patch references are in GHSA-55wc-3pg8-jfw6 (https://github.com/nodejs/undici/security/advisories/GHSA-55wc-3pg8-jfw6) and the OpenJS CNA advisory page (https://cna.openjsf.org/security-advisories.html).
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 ships with and underpins much of Node.js's outbound networking. Its interceptor architecture lets callers wrap request pipelines - in this case the decompress interceptor, which transparently inflates gzip/deflate/br content through Node.js zlib streams. The root cause is CWE-248 (Uncaught Exception): decompressed chunks are forwarded to the downstream handler from inside zlib stream event callbacks, and undici's engine only converts a synchronous downstream throw into a per-request failure. When a handler throws asynchronously from a zlib callback, that safety net is bypassed and the exception propagates to the event loop as unhandled, killing the process. The canonical trigger is the built-in dump interceptor, which throws by design once a response exceeds its configured maximum size; because the limit is measured against decompressed bytes, a server can send a few hundred bytes of highly compressible payload (a 'compression bomb') that inflates past the threshold and detonates the uncaught throw. Version ranges 7.15.0-7.30.0 and 8.0.0-8.12.1 are affected per the advisory and matching CPE (cpe:2.3:a:undici:undici:*:*:*:*:*:*:*:*).
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:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Malicious server attacks over the network (AV:N, PR:N, UI:N); AC:H because the victim must compose decompress with a throwing handler; impact is process crash only, so C:N/I:N/A:H.
Primary rating from Vendor (openjs).
CVSS VectorVendor: openjs
Lifecycle Timeline
2DescriptionCVE.org
undici is an HTTP client library for Node.js. In versions 7.15.0 through 7.30.0 and 8.0.0 through 8.12.1, its decompress interceptor forwards decompressed response data to the downstream handler from zlib stream event callbacks without catching exceptions those callbacks may throw, and while undici's engine converts a synchronous throw from a downstream handler into a per-request failure, that protection is absent when the throw happens asynchronously from a zlib callback. As a result, a downstream handler that throws by design, such as the built-in dump interceptor which throws when a response exceeds its configured maximum size, escapes as an uncaught exception that terminates the Node.js process. A malicious or compromised HTTP server can crash any client that composes the decompress interceptor with such a handler by returning a small compressed body that decompresses to more than the configured limit, so only the decompressed size matters and the bytes on the wire stay tiny. The issue is fixed in undici 7.30.1 and 8.12.2, and users should upgrade to one of those versions or later. As a workaround, avoid composing the decompress interceptor with a response handler that throws during response processing until upgrading.
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-102347
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB