> ## Content Index
> Fetch the complete content index at: https://sudosecurity.org/llms.txt
> Use this file to discover other available public pages before exploring further.

# Node.js Fixed 16 Flaws in One Release. Most of Them Live in HTTP/2 and TLS.
- URL: https://sudosecurity.org/nodejs-november-2026-security-release-http2-tls/
- Published: 2026-11-16T15:00:00.000Z
- Updated: 2026-11-16T15:00:00.000Z
- Description: The November 11 Node.js security releases fix 16 CVEs across the 26, 24 and 22 lines, seven of them rated high. Nearly all sit in HTTP/2 and TLS, where a remote client can crash a server, leak memory, or get past per-host client-certificate checks.
- Author: Santhdium
- Tags: Cybersecurity, Node.js, CVE, Vulnerabilities, SSL/TLS, JavaScript, Backend Development, Server Security, Web Applications

Most Node.js apps don't terminate TLS themselves. There's an Nginx, a load balancer, or a CDN in front, and Node speaks plain HTTP/1.1 on a private port. That setup dodges most of this month's security release. The apps that don't are the ones that should patch first: anything serving HTTP/2 straight from `node:http2`, anything doing mutual TLS in Node, and anything using per-hostname TLS settings.

On November 11, Node.js shipped 26.13.1, 24.22.3, and 22.23.5\. Between them they fix 16 CVEs: seven rated high on the 26 and 24 lines, and six on 22\. Here's what's in it, who's actually exposed, and two fixes you can see for yourself.

## What the November 2026 Node.js Security Release Fixes

Grouped by where the bug lives, from the 26.13.1 and 24.22.3 changelogs:

| Area               | CVEs                                                   | Worst case                                                              | High |
| ------------------ | ------------------------------------------------------ | ----------------------------------------------------------------------- | ---- |
| HTTP/2 server      | 123863, 123865, 123866, 123874, 123828, 123868, 123875 | Remote crash, memory corruption, memory leaked to the client            | 4    |
| TLS and HTTPS      | 123864, 126051, 123872, 123867, 123877                 | Heap memory read by a client, crash, client-certificate checks bypassed | 3    |
| HTTP proxy support | 123871                                                 | Proxy password printed in error messages                                | 0    |
| Permission model   | 123829, 123873                                         | File names leaked or a write path not checked                           | 0    |
| zlib               | 123862                                                 | Process crash when a peer disconnects mid-compression                   | 0    |

The 22 line gets 15 of these. CVE-2026-126051, a TLS server crash, isn't in its changelog. The releases also update bundled dependencies. In the official Docker images I pulled:

| Image                 | llhttp | undici | SQLite |
| --------------------- | ------ | ------ | ------ |
| node:26.13.0 (before) | 9.4.3  | 8.12.2 | 3.54.0 |
| node:26.13.1          | 9.4.4  | 8.12.4 | 3.54.1 |
| node:24.22.3          | 9.4.4  | 7.30.2 | 3.54.1 |
| node:22.23.5          | 9.4.4  | 6.29.1 | 3.54.1 |

One bookkeeping note. The project's advisory page and the release changelogs don't list exactly the same set. The advisory includes CVE-2026-106071, which the 26.x changelog shows as fixed back in 26.12.1 on October 21, and leaves out CVE-2026-123873, a low-severity permission check that the changelogs include. Either way, the fix is the same: upgrade.

Several of the high-severity reports credit Chris Rohlf "in collaboration with Claude and Anthropic Research." Others came from Tim Perry and independent researchers. Matteo Collina wrote most of the fixes.

## The High-Severity Bugs, in Plain Terms

These come from the advisory, kept at the level you need to judge exposure.

**CVE-2026-123864, HTTPS heap read (all three lines).** The worst one on paper. Under a specific pattern of writes inside a request handler, Node's HTTPS server can re-enter its HTTP parser mid-request. The advisory says that lets "an unauthenticated client read memory belonging to other connections, including TLS private keys and other users' requests." It needs a handler that flushes response headers before the request body is finished, plus any route that echoes or stores a request body. Plain `node:http` without TLS isn't affected.

**HTTP/2 crashes and leaks (123863, 123865, 123866, 123874).** One remote client can abort the process through a failed assertion during session teardown, leak sessions and file descriptors until the server runs out, or cause freed memory to be written back to the peer. The advisory describes the triggers as reachable against "default HTTP/2 servers," over TLS and cleartext. 123874 needs a server that sends files with `respondWithFile()` or `respondWithFD()`.

**CVE-2026-126051, TLS server crash (26 and 24).** Servers using `SNICallback`, OCSP stapling hooks, session resumption hooks, or `server.addContext()` can be crashed by an unauthenticated client.

**CVE-2026-123872, client-certificate bypass (all three lines).** If you apply different client-certificate rules per hostname, a client authorized for one host could switch hostnames during TLS 1.2 renegotiation, or session resumption, and carry its authorization to a stricter host.

> **We recommend reading** [Node 26 Is LTS and Temporal Is Finally On by Default](https://sudosecurity.org/nodejs-26-lts-upgrade/) to continue reading our selection of content. If this release is your push to move off Node 22, that piece covers what breaks when you jump to 26.

[Node 26 Is LTS and Temporal Is Finally On by Default](https://sudosecurity.org/nodejs-26-lts-upgrade/) Node.js 26 is LTS as of October 28\. Temporal enabled by default, V8 14.6, legacy stream modules removed. What breaks on upgrade. SudoSecurity · Santhdium

## Who's Actually Exposed

| Your setup                                                             | Priority                                                                                     |
| ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Node serves HTTP/2 directly (http2.createServer or createSecureServer) | Patch now. Four high-severity bugs are remotely reachable with default settings.             |
| Node terminates TLS itself (https.createServer, tls.createServer)      | Patch now, especially with mTLS, SNI contexts, or OCSP hooks.                                |
| Node makes outbound HTTPS calls with custom ca settings                | Patch soon. CVE-2026-123877 affects https.Agent session reuse.                               |
| Node sits behind a proxy that terminates TLS and speaks HTTP/1.1 to it | Lower risk for the server bugs, but still upgrade. The proxy and agent fixes apply anywhere. |
| You use \--permission                                                  | Low-severity fixes, but upgrade if you rely on it as a boundary.                             |

That third row is easy to miss. CVE-2026-123877 is in the client side. `https.Agent` built the same cache key for a request with no `ca` option and a request with `ca: []`, even though the second one means "trust nothing by default." So a TLS session authenticated under the normal trust store could be reused for a request whose own policy would have rejected that server.

You can see the fix through the public `agent.getName()` method. This is my own check:

```js
// CVE-2026-123877: does https.Agent give "no ca" and "ca: []" the same cache key?
const https = require('node:https');
const agent = new https.Agent();
const opts = { host: 'example.com', port: 443 };
const a = agent.getName({ ...opts });
const b = agent.getName({ ...opts, ca: [] });
console.log(process.version, a === b ? 'same key (shared TLS sessions)' : 'different keys');

```

```
v26.13.0 same key (shared TLS sessions)
v26.13.1 different keys

```

## The One That Ends Up in Your Logs

CVE-2026-123871 is rated medium, but it's the one most likely to bite a sysadmin. With `NODE_USE_ENV_PROXY=1`, Node reads `HTTP_PROXY` and `HTTPS_PROXY` from the environment. If that URL is malformed, Node throws an error that includes the URL, password and all. The advisory's point is that this lands somewhere much wider than the environment: "`stderr`, container logs, log aggregation, and crash reporting services."

I set a proxy URL with an invalid port and a throwaway password, and started Node in each image:

```bash
docker run --rm --network none -e NODE_USE_ENV_PROXY=1 \
  -e 'HTTP_PROXY=http://deploy:hunter2@proxy.internal:99999' \
  node:26.13.0 node -e 'console.log("never reached")'

```

| Image        | Error printed                                                 |
| ------------ | ------------------------------------------------------------- |
| node:26.13.0 | Invalid proxy URL: http://deploy:hunter2@proxy.internal:99999 |
| node:26.13.1 | Invalid proxy URL: http://\[redacted\]@proxy.internal:99999   |

On both, the process exits before running any code, so this is a startup failure that gets logged right where your container platform keeps restart output. If you've ever had a bad proxy variable in a deployment, search your old logs for it and rotate that credential.

> **We recommend reading** [Next.js Shipped Seven Advisories and Six of Them Are the Cache](https://sudosecurity.org/nextjs-november-2026-cache-components-advisories/) to continue reading our selection of content. If your Node app is a Next.js app, this month has a second set of patches, and that piece covers them.

[Next.js Shipped Seven Advisories and Six of Them Are the Cache](https://sudosecurity.org/nextjs-november-2026-cache-components-advisories/) Next.js patched seven advisories in November 2026: six in Cache Components, three hitting self-hosted next start. Versions and fixes. SudoSecurity · Santhdium

## How to Check and Upgrade

The fixed versions are 26.13.1, 24.22.3, and 22.23.5\. Check what's actually running, not what's in your `package.json`:

```bash
node -p "process.version + ' llhttp ' + process.versions.llhttp"

```

Anything older than those versions on the same line needs updating. A few places it hides:

- **Docker images.** A `FROM node:26` tag picks up the fix on your next pull and rebuild. A pinned tag like `node:26.13.0`, or a digest, stays vulnerable until you change it.
- **Distro packages.** Ubuntu, Debian and RHEL ship their own Node builds and backport fixes on their own schedule. Check your vendor's advisory, not just the version number.
- **Bundled runtimes.** Electron apps and some CLIs ship their own Node. They need their own updates.

If you can't upgrade today and you serve HTTP/2 or TLS directly from Node, putting a reverse proxy in front that terminates TLS and talks HTTP/1.1 to Node takes most of the high-severity server bugs out of reach. It does nothing for the agent, proxy, or permission-model bugs.

## What This Doesn't Cover

I didn't reproduce the memory-safety bugs, and this article deliberately leaves out how to trigger them. What's here comes from the advisory and changelogs. The two checks I ran, the `https.Agent` key and the proxy error, only show that a fix is present. They don't attack anything.

End-of-life lines, like 20.x, get no fix. The Node project's standing note is that "End-of-Life versions are always affected when a security release occurs." It also doesn't cover npm packages. If your HTTP/2 server comes from a framework, the framework still runs on this same `node:http2` code, so the Node version is what matters.

For the client-side risk from your dependencies, the [axios SSRF and supply chain attack](https://sudosecurity.org/cve-2025-62718-the-axios-crisis-a-critical-ssrf-vuln-a-north-korean-supply-chain-attack-and-why-every-node-js-developer-needs-to-act-right-now/) is the recent example worth revisiting.

## The Actual Point

If Node faces the network directly over HTTP/2 or TLS, this is a patch-today release. If it sits behind a proxy on plain HTTP/1.1, it's still a patch-this-week release, because the agent and proxy fixes apply everywhere.

Upgrade to 26.13.1, 24.22.3, or 22.23.5, check the version inside the running container, and search your logs for proxy URLs that might have leaked a password.

*CVE details and quotes are from the Node.js project's* [*November 11, 2026 security release advisory*](https://nodejs.org/en/blog/vulnerability/november-2026-security-releases?ref=sudosecurity.org) *and the* [*26.x*](https://github.com/nodejs/node/blob/main/doc/changelogs/CHANGELOG%5FV26.md?ref=sudosecurity.org)*,* [*24.x*](https://github.com/nodejs/node/blob/main/doc/changelogs/CHANGELOG%5FV24.md?ref=sudosecurity.org) *and* [*22.x*](https://github.com/nodejs/node/blob/main/doc/changelogs/CHANGELOG%5FV22.md?ref=sudosecurity.org) *changelogs. The `https.Agent` check is original code using Node's documented `agent.getName()` method. It and the proxy test were run on November 16, 2026 in the official `node:26.13.0` and `node:26.13.1` images with networking disabled, and the dependency versions are from `process.versions` in each image. The outputs are reproduced from those runs, and the proxy password is a throwaway.*