Yaamlabs
Vulnerabilities

Node.js patched 16 flaws: upgrade your runtime

Node.js shipped security fixes on 11 November 2026 across the 22, 24 and 26 lines. Seven High flaws, mostly HTTP/2 and TLS. What to upgrade and why.

By Yaali. November 16, 2026, 6 min read, Vulnerabilities, Patching.

Cover illustration of a server runtime behind a protective shield made of hexagons, with the Yaamlabs logo and the text: Node.js patched 16 flaws across three release lines, 16 fixed, 7 high

On 11 November 2026 the Node.js project shipped coordinated security releases for its three supported lines: version 26.13.1, 24.22.3 and 22.23.5. The releases fix 16 vulnerabilities (CVE, Common Vulnerabilities and Exposures, the public identifier each flaw gets), 7 of them rated High. Most of the serious ones sit in the HTTP/2 server (the second major version of the web's HyperText Transfer Protocol), with the rest in the TLS (Transport Layer Security, the encryption behind HTTPS) layer and the permission model. Some early reporting counted 17 issues; the official nodejs.org advisory lists 16, which is the number we use here.

If you run anything on Node.js that faces a network, this affects you, because the worst flaws need no login. An unauthenticated client can crash a server or make it leak memory from one connection into another. The fix is the same for everyone: upgrade to the patched build for your line, then rebuild the container and serverless images that carry the old runtime. If you are still on Node.js 20.x or an odd-numbered line such as 23.x, those are past end-of-life (EOL, no longer receiving fixes) and got nothing this round, so the task there is to migrate.

Table of Node.js release lines showing the fixed version for 26.x, 24.x and 22.x and the end-of-life status of 20.x and 23.x

How the top High-severity flaws work

Seven flaws are rated High, and five of those are in HTTP/2. HTTP/2 lets many requests share one connection, which means the server tracks a lot of state per connection: streams, buffers and callbacks that are created and torn down as requests come and go. Several of this month's bugs are mistakes in that teardown, where a client can make the server free memory and then use it again, or never free it at all.

CVE-2026-123874 and CVE-2026-123866 are both use-after-free bugs (UAF, where the program keeps using a chunk of memory after it has been released and possibly reused for something else). In CVE-2026-123874, a stream serving a file with respondWithFile() is reset by the client while a write is still pending, and Node.js frees the Http2Stream object while code still points at it. In CVE-2026-123866, tearing down a stream can hand the peer response memory that has already been freed. A use-after-free crashes the process at best, and at worst lets an attacker read leftover data or steer execution, so both are the kind of flaw worth patching first.

CVE-2026-123863 and CVE-2026-123865 turn HTTP/2 edge cases into a denial of service (DoS, making a service unavailable). In CVE-2026-123863 a remote client can abort a session in a way that trips an internal consistency check (CHECK_EQ(current_nghttp2_memory_, 0) in the session destructor) and kills the process. In CVE-2026-123865 a protocol error during connection shutdown leaves the session object around forever, so repeated connections leak memory until the server falls over. A related medium-severity issue, CVE-2026-123868, lets inbound HTTP/2 data queued on a stream that is not being read escape the maxSessionMemory accounting, so the per-session memory limit you rely on does not hold.

The remaining two High flaws are not HTTP/2. CVE-2026-123864 is an HTTPS request-smuggling-style memory leak: a zero-length TLS write re-enters the HTTP parser (llhttp_execute()) and the server copies a slice of its own heap into the request body, meaning one client can read memory that belonged to the server or another request. CVE-2026-123872 is an authentication bypass: during a TLS 1.2 renegotiation a client can change the server name (SNI) after presenting its certificate, and the check that ties the client certificate to the right host does not re-run, so client-certificate authentication can be sidestepped. If you use mutual TLS (mTLS, where both sides present certificates) to gate access, treat this one as a priority. Two lower-severity permission-model bugs round out the set: CVE-2026-106071 over-grants filesystem access through a wildcard lookup, and CVE-2026-123829 leaks the names of denied files through recursive fs.watch, both only relevant if you run with the --permission flag.

Cards summarising the seven High-severity Node.js CVEs with component, flaw and effect

What to do

Upgrading the runtime is the real fix, and a mitigation only narrows the window until you get there. Work through these in order.

  1. Find out what you run. Check each service with node -v at the shell, or read process.version from inside a running app. Both print the exact build, so you can tell a patched 24.22.3 from a vulnerable 24.22.2.
  2. Upgrade to the patched build for your line: 26.13.1, 24.22.3 or 22.23.5, or later. Pick the patched release that matches the line you are already on rather than jumping major versions in the same change.
  3. Rebuild and redeploy your images. The runtime usually ships inside a container, so a host upgrade alone does nothing. Pull fresh node:22, node:24 or node:26 base images, rebuild, and redeploy. Do the same for serverless runtimes (set the function's Node version to a patched one) and for the Node image your CI pipeline uses to build and test.
  4. Prioritise HTTP/2 servers. Five of the seven High flaws are in HTTP/2, and they need no authentication. Any service that terminates HTTP/2 directly in Node.js, rather than behind a reverse proxy, should go first.
  5. If you genuinely cannot upgrade today, some reporting suggests putting Node.js behind a proxy that terminates HTTP/2 and TLS for it, or tightening request and connection limits. That narrows exposure to the HTTP/2 and TLS bugs but does not remove them, and it does nothing for the permission-model issues. Schedule the upgrade regardless.
  6. Migrate off end-of-life lines. Node.js 20.x reached end-of-life on 30 April 2026, and odd-numbered lines such as 23.x were never promoted to long-term support and are long retired. They did not receive these fixes and never will. The advisory is explicit that EOL versions are affected whenever a security release ships, so plan the move to 22.x or a newer supported line.

To find the bugs across a whole estate, inventory every place a Node version is pinned: the FROM node: lines in Dockerfiles, the engines field and lockfiles in your repositories, the runtime setting on each serverless function, and the Node image tag in CI config. Those four lists are where stale runtimes hide after the obvious production servers are patched.

The wider lesson

Node.js now ships security releases on a regular cadence, and this is the third batch in recent months. A runtime patch only reaches production through the images built on top of it, so the teams that stay current are the ones that rebuild base images on a schedule. If a base image tag is pinned once and never rebuilt, a fix that shipped this month never reaches the containers that run it, which is how a patched CVE still turns up in production a year later.

If you want help working out which services and images carry a vulnerable runtime, or building a pipeline that rebuilds and redeploys them without a scramble each time, our platform and cloud engineering and red team and code review teams do exactly this. Open the chat and Yaali, our AI agent, will pass your question to the engineer who would do the work.


Sources: Node.js November 2026 security releases advisory, oss-security announcement, securityonline.info, secnews.gr, Node.js release schedule, endoflife.date for Node.js.

Read next

Back to the blog, or tell us about your system in the chat. Yaali, our AI agent, answers first and brings in an engineer.