An infinite loop vulnerability (CWE-835) exists in digitalbazaar's forge library versions prior to 1.4.1. The issue occurs in the BigInteger.prototype.modInverse() function when it receives a negative value or modulus, causing the Node.js event loop to block at full CPU. This can be triggered if an attacker controls the RSA public exponent passed to key generation or directly controls the modInverse() operand. Commonly parsed cryptographic formats like DER, PEM, JWK, PKCS#12, X.509, and TLS are not affected as they use unsigned values. The vulnerability is fixed in version 1.4.1.
Forge (also called node-forge) is a native implementation of Transport Layer Security in JavaScript. Prior to 1.4.1, the affected implementation used pem.decode(), lib/pem.js, missing END line to process the relevant input or security decision. node-forge used polynomial-time regular expressions in pem.decode(), including when searching for a matching END line and parsing encapsulated headers. An unauthenticated attacker able to supply PEM input to any high-level parser could consume excessive CPU with a long malformed message and cause denial of service. This issue is fixed in version 1.4.1.
Forge (also called node-forge) is a native implementation of Transport Layer Security in JavaScript. Prior to 1.4.1, asn1.oidToDer() in lib/asn1.js did not range-check the first two arcs of an OID. An application that accepted an untrusted OID string, checked or authorized that string, and then encoded it with asn1.oidToDer() could emit DER representing a different, trusted OID from the one that was checked. DER parsing is not affected. This issue is fixed in version 1.4.1.
A vulnerability in the hapijs joi library versions from 16.0.0 up to 17.1.1 and from 18.0.0 up to but not including 18.3.1 allows inefficient regular expression processing in the Joi.string().email({ multiple: true }) validation rule. This causes quadratic time complexity during string splitting on long whitespace runs without separators, potentially blocking the Node.js event loop for seconds when processing attacker-controlled input. The issue is fixed in version 18.3.1.
CVE-2026-111497 is a critical out-of-bounds write vulnerability in Google's Brotli decompression library that allows specially crafted compressed data to corrupt application memory and potentially enable remote code execution. It affects Brotli versions 1.0.3 through 1.2.0 and multiple platforms including Node.js, Bun, Python, and .NET frameworks. Exploitation attempts were observed shortly after patches were released, with proof-of-concept code demonstrating remote code execution via malicious HTTP requests and responses. The vulnerability can be triggered through various vectors such as HTTP requests with Brotli-compressed bodies, malicious server responses, and file processing workflows. Enterprise products from Palo Alto Networks and VMware are also impacted, broadening the attack surface. CISA added this vulnerability to its KEV catalog on October 27, 2026.
The decode-uri-component package has a denial of service vulnerability due to quadratic time complexity when processing malformed inputs with many distinct percent-encoded runs. An attacker can craft a payload of about 224 KB that causes the Node.js event loop to block for approximately 20 seconds, making the application unresponsive. This affects version 0.5.0 and earlier. The issue arises because the fallback decoding function performs multiple regex replacements proportional to the number of distinct encoded runs, leading to O(K·L) complexity. The vulnerability impacts availability only, with no confidentiality or integrity effects. It is fixed in version 0.5.1.
Red Hat has issued an important security advisory for the nodejs:24 module in Red Hat Enterprise Linux 8, addressing multiple vulnerabilities including denial of service, TLS certificate hostname bypass, authentication bypass, and out-of-bounds write issues. These vulnerabilities affect various components such as ip-address parsing, brace-expansion patterns, Brotli decoder, DNS resolution, and filesystem permission checks. The update rebases Node.js 24 to the latest upstream release, incorporating fixes for these security flaws and other bug fixes and enhancements.
flat versions up to and including 6.0.1 contain a vulnerability in the unflatten() function that allows attackers to allocate resources without limits by creating huge sparse arrays using unbounded numeric keys. This can cause blocking of the Node.js event loop during iteration methods such as forEach, spread, or JSON.stringify.
Node open versions from 7.2.0 up to but not including 11.0.0 contain an OS command injection vulnerability. This flaw allows attackers to execute arbitrary PowerShell code on Windows and Windows Subsystem for Linux (WSL) by supplying crafted URLs containing $(...) subexpressions. The vulnerability arises because the index.js component passes these crafted URLs unescaped to the powershell -EncodedCommand, enabling code execution.
A flaw in Node.js crypto affects the internal entropy caches used by crypto.randomUUID(), crypto.randomUUIDv7(), and crypto.randomInt() when user-land startup snapshots or single executable applications are built. If these functions are called during snapshot creation, processes started from that snapshot return identical UUIDs and random integers until the cache is refilled, causing collisions and predictability across processes. This impacts Node.js versions 22.x, 24.x, and 26.x prior to specific fixed releases.
A flaw in the Node.js Permission Model filesystem enforcement causes fs.realpathSync() to bypass required read permission checks. This incomplete fix of CVE-2026-21715 allows code running with restricted --allow-fs-read permissions to use fs.realpathSync() to access filesystem paths outside permitted directories. The vulnerability affects Node.js versions 22.x, 24.x, and 26.x prior to specific fixed releases.
A vulnerability in Node.js TLS hostname verification allows a certificate with only a DNS Subject Alternative Name (SAN) containing a numeric IP address to authenticate an IP endpoint when the client connects using non-canonical IPv4 address formats. This occurs because the function tls.checkServerIdentity() normalizes non-canonical IP addresses to their canonical form and matches them against DNS names in the certificate, incorrectly accepting certificates with DNS SANs for numeric IPs. The flaw affects Node.js versions 22.x, 24.x, and 26.x prior to specific fixed releases.
A flaw in the Node.js Permission Model for filesystem enforcement allows access to filesystem paths that do not exactly match a wildcard permission rule. Specifically, when a requested path is shorter than the prefix of a wildcard grant, the permission check incorrectly treats it as a match, potentially granting unintended access. This affects Node.js versions 25.0.0 up to but not including 26.12.1 and is fixed in version 26.12.1.
A vulnerability in the Node.js zlib.ZipFile API allows it to return bytes not belonging to the requested ZIP entry when local and central header validation fails. This occurs because the parsed local header is cached without a content offset, causing subsequent reads to return attacker-controlled bytes from the start of the file. The CRC-32 check still passes due to attacker control of the central directory CRC. This can cause Node.js-based ZIP scanners to approve different content than other ZIP implementations extract. The flaw affects Node.js versions 25.0.0 up to but not including 26.12.1 and is fixed in 26.12.1.
A vulnerability in Node.js TLS hostname verification allows a server certificate to be validated against a different IP address than the one the client connected to when the host is specified as a non-canonical IPv4 literal with a leading zero. This occurs because Node.js normalizes the host using WHATWG URL rules interpreting leading-zero octets as octal, while some operating systems interpret them as decimal. This mismatch can cause a server at one IP to be authenticated with a certificate issued for another IP. The flaw affects Node.js versions 22.x, 24.x, and 26.x prior to their respective fixed releases.
A vulnerability in Node.js TLS hostname verification allows a certificate without a matching IP address Subject Alternative Name (SAN) to authenticate a connection to an IPv4 address when the host is represented with non-ASCII characters such as fullwidth digits. This occurs because the tls.checkServerIdentity() function fails to recognize such hosts as IP addresses and instead matches them against DNS names and Common Name fields in the certificate. This flaw affects Node.js versions 24.x and 26.x and was introduced as a regression after a previous fix. Fixed versions are 24.22.1 and 26.12.1.
A vulnerability in Node.js DNS resolution functions allows hostnames containing a NUL byte to be silently truncated by dns.resolve*() and dns.reverse(). This can cause applications that validate hostnames but then resolve them using these functions to act on DNS records for a different hostname than intended. The flaw affects Node.js versions 22.x, 24.x, and 26.x prior to specific fixed releases.