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.

There are packages installed that are affected by a vulnerability referenced in the following CVE:

  - 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.
    (CVE-2026-87029)

It is, therefore, affected by multiple vulnerabilities as referenced in the ALAS2023-2026-3330 advisory.

    A vulnerability in Node.js HTTP Agent handling allows a keep-alive socket to process a response that was     written before the corresponding request was sent. This may cause incorrect response association and     potentially lead to HTTP response confusion or unintended data exposure. (CVE-2026-105481)

    A vulnerability in Node.js allows the `dns.resolve` function to improperly handle domain names containing     null bytes, potentially causing domain name truncation and inconsistent hostname validation. This could     allow applications relying on hostname validation to process unintended domain names. The issue affects     Node.js 22.x, 24.x, and 26.x release lines. Upgrade to a patched version to address the vulnerability.
    (CVE-2026-105482)

    TLS certificate hostname bypass when the IP is written fullwidth digits     (https://nodejs.org/en/blog/vulnerability/october-2026-security-releases#tls-certificate-hostname-bypass-     when-the-ip-is-written-fullwidth-digits-cve-2026-105483---high) (CVE-2026-105483)

    A vulnerability in Node.js TLS certificate hostname validation allows a hostname that loosely resolves to     an IP address to bypass hostname verification. This may enable an attacker to impersonate a trusted     endpoint and potentially facilitate man-in-the-middle attacks. (CVE-2026-106069)

    A vulnerability in Node.js TLS certificate validation allows non-canonical IPv4 hostnames to be     incorrectly matched against DNS Subject Alternative Name (SAN) entries in certificates. This may allow a     certificate issued for a DNS name to authenticate an IP endpoint, potentially bypassing intended hostname     validation. (CVE-2026-106072)

    A vulnerability in Node.js causes the entropy caches used by `crypto.randomUUID()` and     `crypto.randomInt()` to be preserved in user-land startup snapshots and Single Executable Applications     (SEAs). As a result, multiple processes initialized from the same snapshot may generate repeated values,     weakening randomness and potentially compromising security mechanisms that rely on unique or unpredictable     values. (CVE-2026-106073)

    A vulnerability in the Node.js Permission Model allows filesystem access restrictions to be bypassed     through `fs.realpathSync()`. This may enable an application to access filesystem paths that should be     restricted by the configured permission policies. (CVE-2026-106074)

    undici is an HTTP client library for Node.js. In versions 4.0.0 through 6.29.0, 7.0.0 through 7.30.0, and     8.0.0 through 8.12.1, its Agent dispatcher passes its constructor options through a JSON-based deep clone     before forwarding them to each per-origin pool, and because JSON cannot represent functions, a caller-     supplied tls option containing a checkServerIdentity callback is silently dropped before it reaches the     TLS layer. As a result, a TLS peer whose certificate a custom checkServerIdentity was written to reject,     but which passes Node's default hostname and chain checks, is silently accepted. Because Agent is the     default dispatcher behind request, fetch, and setGlobalDispatcher, this affects the path most applications     use, and EnvHttpProxyAgent is affected on its direct and no-proxy routes as well, while only applications     that pass a function-valued tls option such as a custom checkServerIdentity for certificate or public-key     pinning are at risk. The issue is fixed in undici 6.29.1, 7.30.1, and 8.12.2, which preserve the tls     option outside the JSON clone so custom verification callbacks are forwarded unchanged, and users should     upgrade to one of those versions or later. As a workaround, pass the TLS options through connect instead     of tls, or for proxied destinations use requestTls and proxyTls. (CVE-2026-109383)

    undici is an HTTP client library for Node.js. In versions 7.0.0 through 7.30.0 and 8.0.0 through 8.12.1,     when an originless Agent composes the redirect and cache interceptors in that order with a shared cache     store, the cache builds its key from the original request URL before the redirect handler changes the     origin, so a response produced after a cross-origin redirect is stored under the original key. An attacker     who controls the target of a redirect from a trusted URL can have their response cached under that trusted     URL and served to later callers, allowing persistent cache poisoning, and the same key confusion lets a     private, non-stored redirect response to a user-specific resource be stored under the original URL and     served to a later unauthenticated caller, disclosing private data. Applications are affected only when an     originless Agent, a shared cache store, and the redirect-then-cache composition are all used. The issue is     fixed in undici 7.30.1 and 8.12.2, which verify the producing origin still matches the cache key and     preserve each redirect hop's cache-control policy before storing, and users should upgrade to one of those     versions or later. As a workaround, compose the cache interceptor before the redirect interceptor, use     per-origin dispatchers and cache stores, or disable shared caching on redirect-capable requests.
    (CVE-2026-109829)

    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 fetch() implementation verifies Subresource Integrity metadata by matching the algorithm token against     a lowercase-only set, even though the SRI specification defines the token by its ASCII-lowercase form, so     a valid but non-lowercase token such as an uppercase or mixed-case SHA256 is treated as unknown and     skipped. When no recognized algorithm remains, undici treats the integrity list as empty and accepts the     response, so a server returning a body that does not match the pinned digest passes the check. An attacker     who controls only the response body can therefore deliver attacker-controlled bytes to an application that     pinned a valid uppercase or mixed-case SRI token, with no integrity error, affecting response integrity     only. The issue is fixed in undici 7.30.1 and 8.12.2, which normalize the algorithm token to ASCII     lowercase before validation, and users should upgrade to one of those versions or later. As a workaround,     use lowercase algorithm tokens such as sha256, sha384, or sha512 in integrity metadata. (CVE-2026-109841)

    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. (CVE-2026-109869)

    undici is an HTTP client library for Node.js. In versions 6.5.0 through 6.29.0, 7.0.0 through 7.30.0, and     8.0.0 through 8.12.1, its EventSource client can be driven to exhaust process memory by a malicious or     compromised Server-Sent Events peer. By sending millions of tiny completed data fields with no blank event     separator, or a single unfinished line split across many chunks, the parser retains a growing amount of     per-field and per-chunk state that the byte-based maxEventSize and maxResponseSize limits do not bound,     and because maxResponseSize is enforced on the compressed body before decompression, a small compressed     response can expand into enough retained memory to terminate the process. An application only needs to     maintain an EventSource connection to an untrusted peer, which controls only the response, and     availability is the only impact. The issue is fixed in undici 6.29.1, 7.30.1, and 8.12.2, which bound the     retained parser state independently of the byte limits, and users should upgrade to one of those versions     or later. There is no workaround. (CVE-2026-109924)

    undici is an HTTP client library for Node.js. In versions 5.15.0 through 6.29.0, 7.0.0 through 7.30.0, and     8.0.0 through 8.12.1, its WebSocket client, including the bundled WebSocket exposed by Node.js, can be     driven to exhaust process memory by a malicious or compromised WebSocket server. For every PING frame     received, the client automatically writes a PONG response and ignores the backpressure signal from the     socket write, so a server that streams small PING frames while never reading the client's PONGs makes the     outbound write queue and heap grow without bound until the Node.js process runs out of memory and     terminates. The attack is remote and unauthenticated, needs only a normal WebSocket connection, and is     asymmetric, since small inbound PINGs produce a much larger retained outbound queue, with availability the     only impact. The issue is fixed in undici 6.29.1, 7.30.1, and 8.12.2, which pause WebSocket frame parsing     when the automatic PONG response hits socket backpressure and resume on drain, bounding the outbound     queue, and users should upgrade to one of those versions or later. There is no workaround.
    (CVE-2026-109932)

    A vulnerability in the Node.js Brotli decoder can result in an out-of-bounds memory write when processing     crafted Brotli input. Successful exploitation may lead to memory corruption and remote code execution.
    (CVE-2026-111497)

    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. (CVE-2026-87018)

    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.
    (CVE-2026-87029)

Tenable has extracted the preceding description block directly from the tested product security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

The Linux/Unix host has one or more packages installed that are impacted by a vulnerability without a vendor supplied patch available.

  - 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.
    (CVE-2026-87029)

Note that Nessus relies on the presence of the package as reported by the vendor.

ID	Name	Product	Family	Type	Severity
477582	SCA: security update for undici (GHSA-55wc-3pg8-jfw6)	Tenable Cloud Security	SCA Checks	Local	high
477582	SCA: security update for undici (GHSA-55wc-3pg8-jfw6)	Tenable Self-Hosted Container Security	SCA Checks	Local	high
477510	Chainguard: node-gyp: security update to 13.1.0-r1	Tenable Cloud Security	Chainguard Local Security Checks	Local	high
477510	Chainguard: node-gyp: security update to 13.1.0-r1	Tenable Self-Hosted Container Security	Chainguard Local Security Checks	Local	high
371866	Amazon Linux 2023 : nodejs24, nodejs24-devel, nodejs24-full-i18n (ALAS2023-2026-3330)	Nessus	Amazon Linux Local Security Checks	Local	critical
366366	Linux Distros Unpatched Vulnerability : CVE-2026-87029	Nessus	Misc.	Local	high

Detections

Analytics

CVE-2026-87029

high

Tenable Plugins

high

high

high

high

critical

high