Node.js published a coordinated security release on November 11, 2026. The release is easy to summarize as “upgrade Node,” but that advice is incomplete for operators: the fixes cover several different runtime surfaces, and the practical risk depends on whether an application accepts HTTP/2 connections, serves files through the HTTP/2 API, uses SNI or mutual TLS, or emits proxy configuration errors into logs.
The patched release floors are 22.23.5, 24.22.3, and 26.13.1. The Canadian Centre for Cyber Security independently lists versions before those releases as affected. If a production process, container image, CI runner, or bundled tool uses an older active release line, update it and restart the process. Do not infer safety from a framework upgrade: these fixes are in the Node.js runtime and bundled dependencies.
What the release fixes
The official advisory describes a group of issues rather than one interchangeable vulnerability:
- HTTP/2 session and stream teardown bugs could terminate a process, retain memory and file descriptors, or expose response memory.
- An HTTPS parser re-entrancy flaw could disclose memory from other connections under a particular request-body and response pattern.
- TLS callback handling could let a remote client crash a server when hooks such as
SNICallback,OCSPRequest,newSession, orresumeSessionare configured. - TLS 1.2 renegotiation and session resumption fixes prevent a client from changing SNI or carrying authentication between different mTLS policies.
- Other fixes cover HTTP/2
Alt-Svcbuffer handling, inbound-data accounting, proxy credentials in error messages,https.AgentTLS-policy cache keys, recursive file-watch permissions, and related runtime behavior.
That list explains why a single “we put it behind a proxy” answer is not enough. A proxy may terminate TLS and prevent direct HTTP/2 access, but it does not patch Node processes used for internal services, workers, command-line tools, or health endpoints. It also does not correct a secret already written to a container log.
First identify the runtime that actually runs
Version managers and build hosts make it easy to check one Node binary while deploying another. Begin with the executable and image used by the service, not just the version on a laptop:
node --version
node -p "process.execPath"
node -p "process.versions"
In a container, run the check against the built image or the running workload. For example, adapt the following to your image name:
docker run --rm your-image:tag node --version
docker inspect your-container --format '{{.Config.Image}}'
These are inspection examples, not results from this article’s environment. Record the release line for every long-running Node process: web servers, background workers, SSR processes, scheduled jobs, and CI utilities. A dependency lockfile does not change the version of the Node executable that loads it.
Update to the patched release for your supported line, rebuild the image or deployment artifact, and restart every process. A rolling deployment is preferable where possible, but confirm that old replicas have actually drained; a patched image does not help while an old process continues serving traffic.
Triage HTTP/2 deployments
Node’s stable node:http2 module exposes both client and server APIs. Browser-facing secure HTTP/2 normally uses http2.createSecureServer(). The November fixes cover session teardown, stream lifetime, queued writes, cancellation, inbound memory accounting, and Alt-Svc handling.
Prioritize review if your service:
- creates an HTTP/2 server directly rather than leaving protocol handling to a front proxy;
- serves files with
respondWithFile()orrespondWithFD(); - streams request bodies or responses and has custom timeouts or cancellation handling;
- passes request-derived values to
session.altsvc(); or - accepts untrusted clients over cleartext or TLS HTTP/2.
Do not treat a clean application log as evidence that these paths are safe. Several issues are triggered during protocol teardown or backpressure, where the application handler may never receive a useful error. After upgrading, exercise ordinary health checks and representative upload, download, cancellation, and timeout flows in staging. Measure process restarts, open file descriptors, resident memory, and HTTP/2 error rates during the rollout.
If a front proxy terminates HTTP/2, verify the boundary rather than assuming it: confirm which hop speaks HTTP/2 to Node, whether internal traffic can reach the Node listener directly, and whether a worker or sidecar also uses node:http2. Disabling a protocol can be a temporary containment decision, but it is not a replacement for patching.
Review HTTPS, SNI, and mTLS configuration
The TLS fixes matter most to servers that use hostname-specific security policy. Node’s TLS documentation describes SNI as the mechanism for selecting host-specific contexts and ALPN as the mechanism for selecting protocols such as HTTP/2. That means a service with one certificate and one uniform policy is a different review case from a gateway that maps several hostnames to different client-certificate authorities.
Inspect code and configuration for:
SNICallback,server.addContext(),OCSPRequest,newSession, orresumeSession;requestCertandrejectUnauthorized;- per-host CA lists, especially SNI contexts that set a CA without their own certificate;
- TLS 1.2 support and renegotiation;
- custom
https.Agentinstances with differentcapolicies; and - TLS session reuse across requests or hostnames.
The release blocks clients from changing SNI during renegotiation or resumption and isolates TLS policy keys used by https.Agent. Do not “fix” an mTLS problem by making every hostname trust the broadest CA. Preserve the intended policy, deploy the patched runtime, and test that an allowed certificate reaches only its intended host while an untrusted certificate is rejected.
TLS callback failures can look like ordinary connection churn. During rollout, watch for process exits, uncaught exceptions, handshake failures, and unusual changes in SNI or client-certificate rejection metrics. Keep private keys and client certificates out of logs while collecting enough metadata to correlate a failed handshake with the selected hostname and protocol.
Check logs and proxy configuration
One medium-severity fix prevents proxy credentials from appearing in ERR_PROXY_INVALID_CONFIG messages. The proxy URL commonly comes from an environment variable, so the sensitive value may otherwise escape into stderr, a container runtime, a log aggregator, or crash-reporting service.
After upgrading:
- search historical logs for proxy URLs containing usernames or passwords;
- rotate a credential if it was exposed, rather than merely deleting the log line;
- redact environment variables and error objects at logging boundaries; and
- test invalid proxy configuration with a deliberately non-sensitive dummy value, never a real credential.
The https.Agent fix is a separate concern: cached TLS sessions must not be reused across requests whose CA policies differ. Review code that shares agents globally while varying ca, hostname, or authentication policy. The safest migration is to use the patched runtime and keep agents scoped to a consistent TLS policy.
Treat the Permission Model as defense in depth
Node’s Permission Model can restrict filesystem, network, child-process, worker, native-addon, and related access when started with --permission. The documentation explicitly describes it as a “seat belt” for trusted code, not a sandbox against malicious code.
The security release includes fixes for permission-model behavior, including recursive file-watch disclosure and a filesystem wildcard over-grant. If you use the model, check both the Node version and the command-line grants in the deployed artifact. Audit mode can help discover required permissions before enforce mode, but audit mode does not deny access.
Do not claim that enabling permissions makes an untrusted plugin safe. Keep untrusted code isolated with an appropriate process or service boundary, and grant only the resources the application needs.
A safe rollout checklist
Use this sequence for each Node deployment:
- Inventory the actual binary, image digest, release line, and process entrypoint.
- Upgrade to at least 22.23.5, 24.22.3, or 26.13.1, as appropriate for the supported line.
- Rebuild images and caches so an old base layer cannot restore the vulnerable runtime.
- Search the application for
node:http2,respondWithFile,respondWithFD,session.altsvc, TLS callbacks, SNI contexts, mTLS, customhttps.Agentpolicies, proxy environment variables, and Permission Model flags. - Deploy through staging and test normal HTTP/1.1, HTTP/2, TLS, mTLS, file-transfer, cancellation, and proxy-error paths that the application actually uses.
- Roll out and confirm that old replicas, workers, and scheduled processes have stopped.
- Verify the running version, restart/error metrics, open file descriptors, memory behavior, TLS rejection metrics, and logs.
- Document the version floor and the feature-specific review so the next image or runtime change does not silently reintroduce an older binary.
A version check proves only what executable answered the command. It does not prove that a load balancer routed traffic where you expected, that every worker restarted, or that a custom TLS policy is correct. Keep those checks separate.