A path traversal vulnerability (CWE-22) exists in the systeminformation Node.js library prior to version 5.33.14. The Linux networkStats(iface) function improperly uses a caller-supplied interface name to build filesystem paths without validating that the input is a single segment or that the resolved path remains within the expected directory. This allows a local attacker who can control the iface parameter and set up symlinked directories to read the first line of arbitrary files accessible to the Node.js process. The package does not expose a network endpoint, so exploitation requires local filesystem access and setup. The issue is fixed in version 5.33.14.
The qs library version 6.7.0 through 6.16.0 has a vulnerability in its stringify function when using the arrayFormat 'comma'. If an array element has a non-callable own toString property, qs.stringify throws an uncaught TypeError. This can be triggered remotely by an unauthenticated attacker controlling input that is later serialized with this option, potentially crashing the Node.js process and causing a denial of service. There is no impact on confidentiality or integrity, and no prototype pollution occurs.
The undici WebSocket client, when using HTTP/2 (enabled by default with allowH2: true), crashes the Node.js process if it connects to a malicious server that responds with a failed WebSocket handshake over HTTP/2. This occurs because the client aborts the request too late, leaving an open HTTP/2 stream that emits an unhandled error when the server closes the connection, causing a denial of service. Versions 8.11.0 and 8.11.1 are affected. A fix is available in version 8.11.2. Workarounds include disabling HTTP/2 for WebSocket connections or avoiding untrusted servers until patched.
CVE-2026-117511 is an OS command injection vulnerability in the desmondmorris node-tesseract package up to version 0.2.7. The flaw exists in the process function of lib/tesseract.js within the Command Builder component, where manipulation of the image argument can lead to remote command injection. The vulnerability has been publicly disclosed with available exploit details, but the project has not yet responded or issued a fix.
Nodemailer versions from 3.0.0 up to but not including 10.0.13 contain a vulnerability in the SMTP client where certain regular expressions used to detect SMTP AUTH mechanisms cause quadratic backtracking. This leads to a denial of service by blocking the Node.js event loop during the EHLO response parsing if the server returns a crafted response with long whitespace runs and no matching mechanism. The vulnerability can be triggered pre-authentication by an attacker controlling or influencing the SMTP server or man-in-the-middling the connection before STARTTLS. A fix is available in Nodemailer version 10.0.13.
Nodemailer SMTP client versions from 3.0.0 up to but not including 10.0.10 contain a vulnerability in the SMTP response parser that allows a malicious or compromised SMTP server to cause a denial of service by sending a large number of continuation lines without a completion line. This triggers quadratic CPU usage in the Node.js event loop, freezing the entire process before authentication occurs. The vulnerability is fixed in version 10.0.10.
The Node.js qs library's stringify function with the allowEmptyArrays option set to true improperly encodes keys of empty arrays. This causes keys containing special characters like &, =, or # to be interpreted as query string syntax rather than data, enabling injection of additional parameters or truncation of the query string. The issue affects versions from 6.12.0 up to but not including fixed releases starting at 6.12.6 through 6.16.2, with fixes backported and included in 6.17.0 and later. The vulnerability arises when untrusted input keys are passed to qs.stringify with allowEmptyArrays enabled, potentially allowing parameter injection in the serialized query string. The default setting for allowEmptyArrays is false, so only explicit use of this option triggers the issue.
CVE-2026-111497, known as Brotli2Shell, is a critical out-of-bounds write vulnerability in Google's Brotli C decoder library. It affects many widely used software projects that decompress Brotli data, including Node.js, .NET, Bun, Envoy Proxy, Istio, Python HTTP clients, FFmpeg, Apache Arrow, ClickHouse, and PHP for Windows. The flaw can be triggered by decompressing crafted Brotli data, potentially leading to process crashes, memory leaks, or remote code execution. The vulnerability has a high CVSSv4.0 score of 9.2 assigned by Google. Patches have been released for the Brotli library and major runtimes, but some projects had not shipped fixed releases as of late October 2026. Applications bundling their own Brotli decoder require individual updates.
A resource exhaustion vulnerability exists in seroval versions from 1.4.1 up to but not including 1.6.8. The fromJSON and fromCrossJSON functions do not enforce that an array node's element list is an actual array, allowing an attacker to supply a crafted payload that controls memory allocation and processing iterations independently of payload size. This can lead to denial of service by exhausting process memory or blocking the thread. The issue is a residual bypass of a previous fix and is resolved in version 1.6.8.
CVE-2026-116581 is a vulnerability in the lxsmnsyc seroval library prior to version 1.6.8. The flaw involves improper validation of a sequence node's done index in the fromJSON and fromCrossJSON functions, which can lead to an infinite loop. An attacker can exploit this by sending crafted input to a service that deserializes untrusted data, causing the event loop to block, exhausting process memory, or making the service unavailable. The issue is fixed in version 1.6.8.
CVE-2026-116576 is an OS command injection vulnerability in the systeminformation Node.js library prior to version 5.33.16. The issue arises because the services() function improperly sanitizes input used in a PowerShell command filter on Windows, allowing crafted Unicode quotation marks to inject arbitrary PowerShell expressions. These expressions execute with the Node.js process permissions, potentially enabling unauthorized file access, data modification, or service disruption. The package itself does not expose a network service, so exploitation depends on an application forwarding attacker-controlled input to the vulnerable functions. The vulnerability is fixed in version 5.33.16.
The MongoDB Shell (mongosh) relies on Node.js as a third-party runtime that carries its own TLS root certificate store. This certificate store has the recoverable eMudhra intermediate CA certificates. This issue impacts MongoDB Shell (mongosh) versions prior to 2.14.0 and can be resolved by updating to mongosh 2.14.0 which bundles Node.js 24.22.1 or later. If mongosh is installed through npm, it uses the Node.js runtime installed on the host; update that runtime separately.
CVE-2026-111497, dubbed Node2Shell, is a critical out-of-bounds write vulnerability in Google’s Brotli decoder affecting versions 1.0.3 through 1.2.0. It impacts multiple platforms including Node.js, .NET, PowerShell, and Python packages, allowing unauthenticated attackers to cause memory corruption that can lead to process crashes, memory leaks, or arbitrary code execution. The flaw has been patched in Brotli versions 1.0.10, 1.1.1, and 1.2.1, with corresponding updates released by Microsoft, Node.js, and Python package maintainers. No exploitation in the wild has been reported, but proof-of-concept code demonstrates code execution on certain Linux arm64 Node.js builds. The vulnerability arises when attacker-controlled compressed data is processed by the affected Brotli decoder.
A vulnerability in the Node.js TLS stack allows improper normalization of hostnames containing fullwidth Unicode digits representing IPv4 addresses. This flaw can cause certificate hostname verification to accept a certificate that does not identify the intended peer, enabling potential TLS server impersonation. The issue affects Node.js 24.x and 26.x lines. Exploitation requires an attacker to influence the hostname used for the TLS connection and present a matching certificate, typically requiring privileged network positioning. The vulnerability impacts confidentiality and integrity but does not affect availability. Red Hat has released updated RPM packages to address this issue.
A flaw in Node.js HTTP Agent connection reuse can cause a client to accept as valid a response that was sent before the client has sent the request. This is an incomplete fix of CVE-2026-48931.
The guard that destroys idle keep-alive sockets when unexpected data arrives only runs when the event loop polls for I/O. If an unsolicited response has already reached the socket but has not been read yet when the socket is handed to a new request, for example because the event loop was busy with synchronous work, the guard is removed without seeing it and the data is parsed as the response to the new request.
This vulnerability affects Node.js **26.x**, **24.x**, and **22.x**.
A flaw in Node.js TLS hostname verification allows a certificate with only a DNS SAN to authenticate an IP endpoint when the client connects using a non-canonical IPv4 spelling, such as `0177.0.0.1`, `0x7f.0.0.1`, `2130706433` or `127.1`.
`tls.checkServerIdentity()` did not classify these hosts as IP addresses, but normalized them to their canonical form and matched the result against the certificate DNS names. A certificate containing `DNS:127.0.0.1` and no `IP Address:127.0.0.1` SAN was therefore accepted, while the same certificate is correctly rejected for `127.0.0.1`. Exploitation requires a certificate with a numeric DNS SAN issued by a CA trusted by the client, and a platform resolver that accepts these spellings, such as glibc.
This vulnerability affects Node.js **26.x**, **24.x**, and **22.x**.
A flaw in Node.js `crypto` causes the internal entropy caches used by `crypto.randomUUID()`, `crypto.randomUUIDv7()`, and `crypto.randomInt()` to be saved into user-land startup snapshots (`--build-snapshot`) and single executable applications built with `useSnapshot`.
If any of these functions, or an API that relies on them such as `URL.createObjectURL()`, is called while the snapshot is built, every process started from that snapshot returns the same values until the cache is refilled: up to 127 UUIDs and about 1,000 `randomInt()` values. Identifiers expected to be unique can collide across processes, and values issued by one process can be predicted by observing another.
This vulnerability affects Node.js **26.x**, **24.x**, and **22.x**.
A flaw in Node.js TLS hostname verification can cause a server certificate to be validated against a different IP address than the one the client connected to, when the host is a non-canonical IPv4 literal with a leading zero, such as `0127.0.0.1`.
`tls.checkServerIdentity()` normalizes the host following the WHATWG URL rules, which read a leading-zero octet as octal (`0127.0.0.1` becomes `87.0.0.1`), while the connection is made through the operating system resolver, which on some platforms such as macOS reads it as decimal (`127.0.0.1`). A server at the connected address can then be authenticated with a certificate issued for another IP address.
This vulnerability affects Node.js **26.x**, **24.x**, and **22.x**.