Skip to main content

undici CVE-2026-87029

| EUVDEUVD-2026-102347 MEDIUM
Uncaught Exception (CWE-248)
2026-10-15 openjs
5.9
CVSS 3.1 · Vendor: openjs
View

Attack ChainAIDerived

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

  1. Access
    Lure client to malicious/compromised HTTP server
  2. Delivery
    Return tiny compressed response body
  3. Exploit
    Decompress exceeds configured size limit
  4. Execution
    Downstream handler throws in zlib callback
  5. Impact
    Uncaught 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

undici 8.0.0 <8.12.2
undici 7.15.0 <7.30.1

Affected Packages

euvd undici fix: 7.30.1, 8.12.2

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

Vendor (openjs) PRIMARY 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 5.9 MEDIUM

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.

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

Primary rating from Vendor (openjs).

CVSS VectorVendor: openjs

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 15, 2026 - 20:03 EUVD
CVE Published
Oct 15, 2026 - 18:48 cve.org
MEDIUM 5.9

DescriptionCVE.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

EPSS Score
0.2%
Top 85% exploitable
Prevalence
High
undici is the HTTP client underlying Node.js fetch, very widely deployed
Data Quality
5 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Undici

View all
CVE-2022-35949 CRITICAL POC
9.8 Aug 12

undici is an HTTP/1.1 client, written from scratch for Node.js.`undici` is vulnerable to SSRF (Server-side Request Forge

CVE-2026-12151 HIGH POC
7.5 Jun 17

Memory exhaustion denial of service in the undici WebSocket client (versions 6.17.0 and later) allows a malicious or com

CVE-2026-14643 HIGH POC
7.5 Jul 29

Cross-user information disclosure in undici's cache interceptor allows authenticated users' responses to be served from

CVE-2026-16729 MEDIUM POC
6.5 Jul 29

Cookie attribute injection in undici's setCookie function allows attacker-controlled domain values or unparsed array ent

CVE-2022-31151 MEDIUM POC
6.5 Jul 21

Authorization headers are cleared on cross-origin redirect. Rated medium severity (CVSS 6.5), this vulnerability is remo

CVE-2022-32210 MEDIUM POC
6.5 Jul 14

`Undici.ProxyAgent` never verifies the remote server's certificate, and always exposes all request & response data to th

CVE-2026-15157 MEDIUM POC
5.4 Jul 29

CRLF injection in undici's HTTP/1.1 dispatcher enables HTTP header injection and potential request smuggling when applic

CVE-2023-23936 MEDIUM POC
5.4 Feb 16

Undici is an HTTP/1.1 client for Node.js. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable,

CVE-2022-35948 MEDIUM POC
5.3 Aug 15

undici is an HTTP/1.1 client, written from scratch for Node.js.`=< undici@5.8.0` users are vulnerable to _CRLF Injection

CVE-2026-13697 CRITICAL
9.1 Jul 29

Cross-user information disclosure and a parse-time denial of service in undici's HTTP cache interceptor affect versions

CVE-2026-84961 CRITICAL
9.1 Sep 04

TLS certificate validation bypass in undici's BalancedPool dispatcher silently discards function-valued options - includ

CVE-2026-6734 HIGH
8.8 Jun 17

Cross-origin request misrouting in undici's Socks5ProxyAgent (introduced in 7.23.0, affecting all releases through 8.1.0

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