Node.js November 2026 Security Release: HTTP/2 and TLS
Node.js fixed 16 CVEs on 11 Nov 2026, seven rated high, mostly HTTP/2 and TLS. See which bugs hit your server, how to check exposure, and how to patch safely.
BY ASHLIN DARIUS GOVINDASAMY
If your Node.js service speaks HTTP/2 or terminates TLS itself, the security release of 11 November 2026 is a patch-this-week event. The Node.js November 2026 security release fixes 16 CVEs, seven rated high, and most of them live in the HTTP/2 and TLS code that sits directly on the internet. This post walks through what broke, which of your apps are actually exposed, and how to prove your fleet is on the fixed versions.
What the Node.js November 2026 security release fixed
The project shipped v22.23.5, v24.22.3 and v26.13.1. The advisory lists seven high, six medium and three low severity issues, plus dependency updates to llhttp, undici and sqlite. As always, end-of-life lines are affected and get no fix. The advisory gives no workarounds beyond upgrading.
- HTTP/2 (high): remote abort in session teardown, a session and file descriptor leak after a protocol error during shutdown, a use-after-free in stream teardown, and a use-after-free of Http2Stream when a respondWithFile() stream is reset mid-write.
- HTTPS (high): a re-entrant llhttp_execute() call causes a use-after-free and a heap leak into response bodies.
- TLS (high): TLS 1.2 renegotiation can change the servername and bypass client certificate policy; deferred handshake callbacks can throw an uncaught exception on destroyed sockets.
- TLS and agents (medium): CA-only SNI contexts fail open to the default CA, and https.Agent can reuse a TLS session across different trust policies.
- Resource and leak bugs (medium): inbound HTTP/2 data not charged to maxSessionMemory, proxy credentials printed in error messages, a one-byte overflow in session.altsvc(), and a NULL dereference in StreamPipe.
- Low: Permission Model wildcard over-grants, recursive fs.watch name leaks on macOS and Windows, and an uncatchable zlib assertion.
HTTP/2: the same bug family, again
Four of the seven highs are HTTP/2 lifetime bugs: an object is freed, but something still points at it. The abort bug is described as a variant of CVE-2024-27983 that the earlier fix did not cover. The advisory says a default HTTP/2 server that answers before the request body ends can be aborted by an unauthenticated client. The session leak is an incomplete fix for an earlier CVE: a peer sends GOAWAY(NO_ERROR) and then a protocol error, and the socket sits in CLOSE_WAIT with its state held forever.
The Http2Stream use-after-free needs only that you serve files with respondWithFile() or respondWithFD() under default settings. The related medium bug, a NULL dereference in StreamPipe, crashes the process when a file download is cancelled, and the advisory says a few cancelled requests against a default file handler are enough. Static file servers built on node:http2 are the obvious candidates.
QUICK CHECK
Which Node.js HTTP/2 usage does the advisory name as the precondition for the Http2Stream use-after-free?
TLS: mTLS policy is the real casualty
If you use mutual TLS with per-host policies, read this section twice. Two bugs let a client authenticated for one host reach a stricter one. First, in TLS 1.2 renegotiation a client can change the servername, so a client certificate accepted for a permitted host carries over to a protected host. Second, server.addContext(host, { ca: protectedCA }) with no server certificate creates a context that is rejected internally, and the code then keeps the default CA. A client trusted only by the default CA can complete mTLS to the protected host even with requestCert and rejectUnauthorized enabled.
The https.Agent bug is subtler: a request that omits ca and one with ca set to an empty array get the same agent key although their trust policies differ, so a TLS 1.3 session authenticated under the default policy can be resumed under the empty one and still report authorized as true. If you build agents with different ca options for different upstreams, this matters.
import tls from "node:tls";
import fs from "node:fs";
const server = tls.createServer({
key: fs.readFileSync("default.key"),
cert: fs.readFileSync("default.crt"),
ca: fs.readFileSync("default-ca.crt"),
requestCert: true,
rejectUnauthorized: true,
});
// Risky pattern from the advisory: a per-host context with a CA but
// no key/cert. Make sure every addContext call supplies both.
server.addContext("admin.example.com", {
key: fs.readFileSync("admin.key"),
cert: fs.readFileSync("admin.crt"),
ca: fs.readFileSync("admin-ca.crt"),
requestCert: true,
rejectUnauthorized: true,
});
server.on("secureConnection", (s) => {
console.log(s.servername, s.authorized, s.getPeerCertificate().subject);
s.end("ok\n");
});
server.listen(8443);The HTTPS heap leak and the memory budget
The HTTPS bug is the nastiest read. TLSWrap::DoWrite() calls ClearOut() directly for zero-byte writes, and from the on_body callback that re-enters llhttp_execute(). The advisory says triggering needs a handler that calls res.flushHeaders() before the request body ends and then res.end() with a non-empty chunk, and leaking data needs a route that echoes or stores request bodies. Cleartext node:http is not affected. Leaked data can include TLS private keys and other users' requests, according to the advisory.
Separately, queued inbound data on an undrained HTTP/2 stream was charged to no session budget, so maxSessionMemory neither bounded it nor refused new streams. The advisory reports about 10 wire bytes per one-byte data frame against about 114 bytes retained, a roughly elevenfold amplification. Patching fixes the accounting, but you should still set sane limits and drain streams.
import http2 from "node:http2";
import fs from "node:fs";
const server = http2.createSecureServer({
key: fs.readFileSync("server.key"),
cert: fs.readFileSync("server.crt"),
maxSessionMemory: 10, // megabytes per session
maxSessionInvalidFrames: 100,
maxSessionRejectedStreams: 100,
settings: { maxConcurrentStreams: 100 },
});
server.on("stream", (stream, headers) => {
stream.on("error", () => {}); // never let a stream error go unhandled
stream.respond({ ":status": 200 });
stream.end("hello\n");
});
server.listen(8443);Check your fleet and patch
The fixed floors are 22.23.5, 24.22.3 and 26.13.1. This script compares a version string against them, so you can run it over the output of a container inventory.
const floors = { 22: [22, 23, 5], 24: [24, 22, 3], 26: [26, 13, 1] };
function ok(version) {
const v = version.replace(/^v/, "").split(".").map(Number);
const floor = floors[v[0]];
if (!floor) return false; // other lines: not covered by this release
for (let i = 0; i < 3; i++) {
if (v[i] > floor[i]) return true;
if (v[i] < floor[i]) return false;
}
return true;
}
const input = process.argv[2] ?? process.version;
console.log(input, ok(input) ? "patched" : "NEEDS UPDATE");node check-node.mjs "$(node --version)"
for i in $(docker images --format '{{.Repository}}:{{.Tag}}' | grep -v '<none>'); do
v=$(docker run --rm --entrypoint node "$i" --version 2>/dev/null) && echo "$i $v"
done
docker build --pull --no-cache -t myapp:patched .
docker run --rm myapp:patched node --version›Prioritising when you cannot patch everywhere today
These are inferences from the advisory, not vendor guidance. Start with internet-facing services that use node:http2, respondWithFile(), respondWithFD(), server.addContext(), SNICallback, or per-host mTLS. Then HTTPS servers that flush headers early and echo bodies. Internal batch jobs that only act as HTTP clients are lower priority, apart from https.Agent users who mix ca settings. Leave nothing on an end-of-life line.
Takeaways
- Patch to 22.23.5, 24.22.3 or 26.13.1 and rebuild images with --pull --no-cache.
- Audit every addContext call: each per-host context needs its own key and cert.
- Do not trust the TLS handshake as your only authorization check.
- Set maxSessionMemory and stream limits explicitly, and handle stream errors.
- Two of the highs are described as incomplete fixes of earlier CVEs, so expect follow-up patches in this area.
SOURCES
Frequently asked questions
Which Node.js versions fix the November 2026 vulnerabilities?
v22.23.5, v24.22.3 and v26.13.1. End-of-life release lines are affected and receive no fix, so upgrade to a supported line.
Am I affected if I only run Node behind nginx or a load balancer?
Less exposed, but not immune. Bugs in HTTP/2 and HTTPS handling matter when Node terminates those protocols itself, while a proxy that speaks plain HTTP/1.1 to Node avoids several of them. Still upgrade, since other fixes apply regardless.
Is there a workaround if I cannot upgrade immediately?
The advisory offers none beyond upgrading. Reducing exposure, such as not serving files through respondWithFile() or putting a patched proxy in front, is a stopgap, not a fix.
How do I confirm a container is patched?
Run node --version inside the image you actually deploy and compare it with the fixed floors. Rebuild with a fresh base image, since a running or cached image keeps its old runtime.
NEWSLETTER
Get the engineering notes in your inbox.
Kernels, GPUs, networks, AI infrastructure — and the things we broke along the way. No spam, one click to leave.
We store only your email address, to send you new articles. See our privacy policy.
TAGS
RELATED
Node.js October 2026 Security Release, Explained
Node.js shipped ten CVE fixes on 21 October 2026, including a Brotli out-of-bounds write. Here is what each bug does, how to check your fleet, and how to patch.
Node.js Goes to One Major Release a Year
Node.js is dropping odd releases for one major every April, with a new Alpha channel and LTS for everything. What changes for servers and CI, with a script to track it.