Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInduce client request to attacker HTTPS endpoint
-
DeliveryNegotiate TLS 1.2 connection
-
ExploitRenegotiate with mismatched CA-trusted certificate
-
ExecutionNode raises certificate-altname error
-
Persistundici assertion fails as uncaught exception
-
ImpactNode.js process crashes, all requests dropped
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 the undici/fetch client to establish an HTTPS connection to an endpoint the attacker controls or has compromised, and that connection must use TLS 1.2 - TLS 1.3 is explicitly unaffected because it does not support renegotiation. The malicious server must perform a post-handshake renegotiation presenting a second CA-trusted certificate whose hostname does not match the requested host; two ordinary valid certificates suffice and no CA compromise is needed. Both HTTP/1.1 and HTTP/2 paths are affected. The principal limiting factor is that the victim must send a request to the attacker-influenced endpoint, so impact concentrates on applications that fetch attacker-controllable URLs; the documented mitigation is to restrict outbound connections to TLS 1.3 where endpoints support it, or upgrade to undici 6.29.1 / 7.30.1 / 8.12.2 or later. |
| Impact | This is a genuine availability risk whose practical severity depends heavily on deployment context, not a purely theoretical high-CVSS issue. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) correctly captures a network-reachable, unauthenticated, availability-only impact (CWE-248, uncaught exception). The crash is a full Node.js process termination - not a single dropped request - so a single server-initiated TLS 1.2 renegotiation takes down all in-flight requests and background work in the process, which amplifies the real-world impact of an 'availability-only' bug. No EPSS score was provided in the input, and there is no CISA KEV listing and no public exploit referenced, so exploitation status is 'no public exploit identified at time of analysis.' The key mitigating factor absent from the raw CVSS score is directional: the victim client must initiate (or be induced to initiate) an HTTPS request to an endpoint the attacker controls or has compromised, over TLS 1.2. That makes mass, untargeted exploitation less likely than the AV:N/AC:L vector alone suggests, but it is highly relevant to systems that fetch attacker-influenceable URLs (webhooks, SSRF-reachable targets, link previews, outbound proxies). Note the vector does not fully express the dependency on reaching a malicious endpoint; verify applicability against your outbound-request patterns. |
| Exploit ScenarioDerived | An application uses undici (or Node's global fetch, which is backed by undici) to make outbound HTTPS requests to a URL an attacker can influence or host - for example a webhook target, link-preview fetcher, or SSRF-reachable endpoint. The malicious server negotiates TLS 1.2, completes the handshake, then renegotiates and presents a second, CA-trusted certificate whose hostname does not match the request, causing Node to emit a certificate-altname error that trips undici's assertion and crashes the entire Node.js process. No public proof-of-concept is referenced, but the attack requires only two ordinary valid certificates and no CA compromise. |
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 allows any attacker-controlled or compromised HTTPS endpoint to terminate the client process by performing a TLS 1.2 renegotiation. When a server renegotiates after the connection is established and presents a different CA-trusted certificate whose hostname does not match the requested host, Node.js re-runs hostname verification and destroys the socket with a certificate-altname error; undici's established-socket error handler treated that error code as impossible, so the peer-controlled condition became an uncaught assertion (CWE-248) that crashes Node.js and kills all in-flight requests and background work. The flaw affects undici 4.2.1 through 6.29.0, 7.0.0 through 7.30.0, and 8.0.0 through 8.12.1 on both the HTTP/1.1 and HTTP/2 paths, and is reachable through Node's global fetch() as well as direct library use; it is remotely triggerable without authentication or a CA compromise (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), though only TLS 1.2 connections are exploitable since TLS 1.3 removed renegotiation. No public exploit code was identified at time of analysis and there is no indication of confirmed active exploitation, but exploitation is trivial for any adversary who can serve an endpoint the victim fetches from, and patched releases 6.29.1, 7.30.1, and 8.12.2 are available.
RemediationAI
Upgrade to a fixed release: undici 6.29.1, 7.30.1, or 8.12.2, or any later version on the corresponding line (vendor-released patches, per GHSA-qrxm-fqhp-jwvm at https://github.com/nodejs/undici/security/advisories/GHSA-qrxm-fqhp-jwvm). Teams that cannot patch immediately should force outbound connections to TLS 1.3 so server-initiated renegotiation cannot occur - for example by setting minVersion and maxVersion to 'TLSv1.3' on the client TLS options (or the equivalent agent/tls configuration used by fetch) - accepting the trade-off that any endpoint which only negotiates TLS 1.2 will become unreachable; the OpenJS advisory notes this workaround applies only where target endpoints support TLS 1.3. As a narrower compensating measure, constrain the set of hosts the client will fetch from via an allowlist (or proxy-level egress filtering) so requests cannot be steered to attacker-controlled endpoints, which reduces exposure without changing TLS behaviour but does nothing for already-allowlisted hosts that are compromised. Installing a process-level uncaughtException handler can keep the process alive, but this is a weak control: the exception unwinds from undici's socket handling and leaves in-flight request and connection state in an undefined condition, so it should be treated only as a last-resort stopgap. Note that neither disabling HTTP/2 nor restricting TLS versions other than 1.3 mitigates the issue, since both the HTTP/1.1 and HTTP/2 paths are affected and only TLS 1.3 eliminates renegotiation.
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 library maintained under the Node.js project and also backs the global fetch() implementation in modern Node.js runtimes, which is why a fault inside its socket error handling translates into a process-wide outage rather than a per-request failure. The root cause is assigned CWE-248 (Uncaught Exception): undici's handler for errors on an already-established socket contained an assertion that the code ERR_TLS_CERT_ALTNAME_INVALID could never be surfaced at that stage, so when Node.js did deliver it the assertion went uncaught and aborted the Node.js process. The trigger sits in TLS 1.2's renegotiation feature, which lets a server restart a handshake mid-connection and supply a new certificate; Node.js re-validates that certificate, including hostname matching, and tears down the socket when the new certificate's altnames do not match the requested host. The attacker therefore needs only to control (or compromise) the endpoint and hold two ordinary, CA-issued valid certificates - one matching the requested host for the initial handshake and one for a different host for the renegotiated handshake - with no private-key or CA compromise required. TLS 1.3 is not affected because it does not permit post-handshake renegotiation, and the same defect is present on both the HTTP/1.1 and HTTP/2 code paths, so switching protocol version does not evade it. The affected package is captured by CPE cpe:2.3:a:undici:undici for the version ranges 4.2.1-6.29.0, 7.0.0-7.30.0, and 8.0.0-8.12.1, reported by the OpenJS Foundation as CNA.
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
Network-reachable and unauthenticated with a single server-initiated renegotiation (AC:L), causing a full-process crash (A:H) with no confidentiality or integrity impact.
Primary rating from Vendor (openjs).
CVSS VectorVendor: openjs
Lifecycle Timeline
2DescriptionCVE.org
undici is an HTTP client library for Node.js. In versions 4.2.1 through 6.29.0, 7.0.0 through 7.30.0, and 8.0.0 through 8.12.1, the client process crashes when a TLS 1.2 server renegotiates after the connection is established and presents a different, CA-trusted certificate whose hostname does not match the requested host. Node.js re-runs hostname verification on the renegotiated handshake and destroys the socket with a certificate-altname error, but undici's established-socket error handler asserted that this error code could never occur, so the peer-controlled error became an uncaught assertion that terminates the Node.js process, affecting both the HTTP/1.1 and HTTP/2 paths. A malicious or compromised HTTPS endpoint reached through undici or the global fetch() can crash the client with a single server-initiated renegotiation, taking down all in-flight requests and background work in the process, and exploitation needs no CA compromise because the attacker controls the endpoint and can present two ordinary valid certificates. Only TLS 1.2 is affected, since TLS 1.3 does not support renegotiation. 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. As a workaround, restrict outbound connections to TLS 1.3 so renegotiation cannot occur, when the target endpoints support it.
Technical POC Analysis
Evidence note: the supplied material is the GitHub advisory GHSA-qrxm-fqhp-jwvm only.
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 availability flaw in undici, the HTTP client library bundled with Node.js and used by the global fetch() API, allows any external or compromised HTTPS server to crash a Node.js process during a TLS 1.2 renegotiation. Any product or service that makes outbound HTTPS calls-including to third-party APIs, partner endpoints, or customer-supplied URLs-is exposed without authentication, and a single trigger terminates all in-flight requests and background jobs in that process. Leadership should care because this is a remotely reachable, unauthenticated denial-of-service against production Node.js workloads with no vendor patch available at time of analysis, making service disruption a matter of when, not if, for internet-facing integrations.
No vendor patch available. Interim mitigations: restrict outbound HTTPS egress to an allowlist of trusted hosts so attacker-controlled or compromised endpoints cannot reach the undici client; avoid passing user- or partner-supplied URLs to fetch()/undici without strict validation; isolate outbound-fetch workloads into separate supervised processes (with auto-restart) to limit blast radius to a single worker rather than the whole application; terminate or cap connection lifetime at an egress proxy to reduce TLS renegotiation exposure; log and alert on certificate-altname errors and Node.js assertion crashes to detect exploitation attempts early; and track the Node.js/undici security advisory for the fixed release.
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-102318
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB