Security Approximate reading time: 14 minUpdated

Node.js November 2026 Security Release: Update Again?

On 11 November, Node.js issued security patches for release lines 22, 24 and 26, so even a Node.js installation updated in October needs updating again. We explain which versions are safe now, what to do with release lines 18 and 20, and why the patch does not take effect without a restart.

Desk with a monitor, warning symbol and padlock: Node.js November security patches

Yes, even if you updated Node.js in October, you need to update it again, because the Node.js November 2026 security release, issued on Wednesday, 11 November, provides security patches for all three long-term support (LTS) release lines, and the safe versions are now 22.23.5, 24.22.3 and 26.13.1 or later within the same release line. The versions patched in October, 22.23.4, 24.22.1 and 26.12.1, do not contain these patches, and every application process must be restarted after updating because a running process continues to use the old executable. We explained how to find out which version your application is actually running, how release line support cycles work and how to migrate from release line 18 or 20 in our article on the October security update, but here is what changed in November.

When we checked our hosting on 12 November, every release line available to customers had received the patches from this release: release lines 22 and 24 were already on patched versions 22.23.5 and 24.22.3, while release lines 16, 18 and 20, for which Node.js itself no longer issues patches, had received CloudLinux packages containing backports. The CloudLinux advisory states that patched packages have been released for all versions, including release lines that have reached end of life, but a backport is no substitute for a supported release line. The application only starts using the patch after a restart, so if it runs on our hosting, restart it under Setup Node.js App.

What the Node.js November 2026 security release fixes

The project's security advisory lists 16 vulnerabilities: the project rates seven as high severity, six as medium and three as low. The advisory gives no Common Vulnerability Scoring System (CVSS) score, describes no workarounds and says nothing about whether any of the flaws are already being exploited in attacks. That does not mean there are no attacks. It means that, this time, the urgency depends on the project's own assessment and what your application does. The release was expected: on 4 November, the project announced on the nodejs-sec mailing list that patches would be released on or shortly after 11 November.

The seven high-severity vulnerabilities affect three Node.js servers: four affect the HTTP/2 server, one the HTTPS server and two the TLS server. For each vulnerability, the table shows what it allows an attacker to do and when it can be exploited.

ServerWhat an attacker can doWhen it can be exploited
HTTP/2 servercrash the processan unauthenticated client, over either an encrypted TLS connection or an unencrypted connection
HTTP/2 servermake the process retain memory and file descriptors that it never releasesan unauthenticated client
HTTP/2 serverobtain memory contents that may include response data from other connectionsan unauthenticated client interrupts an HTTP/2 stream
HTTP/2 servercause memory corruption in the processthe application sends files using respondWithFile() or respondWithFD(), over either an encrypted TLS connection or an unencrypted connection
HTTPS server (CVE-2026-123864)read memory belonging to other connections, including TLS private keys and other users' requestsan unauthenticated client, with unencrypted node:http unaffected by this flaw
TLS servercrash the process remotelythe server uses SNICallback, OCSPRequest, newSession, resumeSession or server.addContext()
TLS serveruse authentication valid for one host to access a host with stricter client certificate requirementsthe application applies different client certificate requirements to different hostnames, and the client changes the hostname during TLS 1.2 renegotiation

Two medium-severity vulnerabilities do not concern accepting connections. https.Agent could allow TLS session reuse for a request with a stricter certificate policy even though the cached session had been validated under a different policy, and ERR_PROXY_INVALID_CONFIG error messages could expose proxy server credentials if the proxy server address specified in an environment variable was invalid. The advisory also names updates to bundled dependencies: llhttp in all three release lines, undici in release lines 24 and 26, and SQLite in release lines 22 and 24.

Which Node.js features the remaining patches affect

HTTP/2 streams and TLS settings

In the HTTP/2 module, three further medium-severity flaws affect different operations. If the application passes an attacker-controlled value, such as the request's :authority header, to Http2Session.altsvc(), a memory write can exceed the allocated buffer's boundary by one byte. Another flaw causes incoming data to accumulate in an HTTP/2 stream that the application does not read, but this memory is not counted towards the session's usage, so maxSessionMemory neither limits its growth nor prevents new streams from opening. A client can also interrupt a file transfer using respondWithFile() or respondWithFD() in a way that crashes the process. A few cancelled requests are enough, with no specially crafted protocol frames required.

The medium-severity TLS flaw affects a server where the application uses server.addContext(host, { ca: protectedCA }) to set a different certificate authority (CA) for checking client certificates for a particular hostname, but does not specify a server certificate in that SNI context. Because of the flaw described in the advisory, the certificate authority intended for that hostname is not set, and the server checks the client certificate against the default authority. Your developer therefore needs to check the specific contexts that the application code creates with this method. The fact that a site uses HTTPS does not tell you whether the server checks client certificates against different authorities for different hostnames.

Permission Model and compression streams

The Node.js Permission Model can be enabled with --permission, and the advisory describes a low-severity flaw in its operation on macOS and Windows. fs.watch() or fs.promises.watch() in recursive mode can reveal the names of entries in subdirectories when read permission is granted only for the watched directory and another process or user creates files there. Event timing metadata may also be exposed, but file contents are not revealed. A second Permission Model flaw affects read or write permissions containing a wildcard: --allow-fs-read=/etc/passwd.* can also allow reads of /etc/passwd if this permission sits directly below the root of the permission tree, for example when it is the only read permission.

The low-severity flaw in the zlib compression library requires a call to deflate.params() while sending data. If the other side disconnects and the stream is destroyed with destroy(), as pipeline() does in this situation, the function that completes the params() operation ignores the error passed to it and checks for an internal resource that has already been disposed of. The result is an uncatchable ERR_INTERNAL_ASSERTION exception. It bypasses both the stream's error event and the functions the application passed to params() and pipeline(), and the process crashes. The advisory describes this use of deflate.params() as rare, so checking whether the application code calls this method is sufficient.

CVSS scores in CVE records

Unlike the project's advisory, the CVE records published by the OpenJS Foundation give CVSS 3.0 base scores for the seven high-severity flaws. CVE-2026-123863 has a score of 8.2, CVE-2026-123864 and CVE-2026-123872 have scores of 8.1, while CVE-2026-123865, CVE-2026-123866, CVE-2026-126051 and CVE-2026-123874 have scores of 7.5. We recommend reading these figures alongside the conditions for each flaw. Your developer needs to establish whether the application calls the specified API, what data it passes and whether its configuration meets the described condition, even for a flaw with a lower score.

CVEServerWhat an attacker can doCVSS 3.0 (in the CVE record)
CVE-2026-123863HTTP/2 servercrash the process8.2
CVE-2026-123864HTTPS serverread memory belonging to other connections8.1
CVE-2026-123872TLS serveruse authentication valid for one host to access a host with stricter requirements8.1
CVE-2026-123865HTTP/2 servermake the process retain memory and file descriptors7.5
CVE-2026-123866HTTP/2 serverobtain memory contents containing response data from other connections7.5
CVE-2026-126051TLS servercrash the process remotely7.5
CVE-2026-123874HTTP/2 servercause memory corruption in the process7.5

Does this affect your application?

All seven high-severity vulnerabilities are in the parts of Node.js that accept connections themselves: HTTP/2, HTTPS and other TLS servers. CloudLinux's advisory draws a clear conclusion from this: an application that runs none of these servers is unaffected by the seven high-severity flaws, but this only limits the risk rather than eliminating it, so all versions still need updating. In practice, the question for your developer is whether the application itself accepts connections through the http2, https or tls module. Each application needs its own answer, because two applications on the same hosting can be built very differently, and checking one tells you nothing about the others.

On many Laravel and WordPress sites, Node.js does not handle requests at all: it runs Vite, which generates CSS and JavaScript files from source code, and then stops. This build process does not itself accept connections or handle requests, so according to CloudLinux's explanation, the seven high-severity flaws do not affect it. These installations still need updating, in the right order: first the systems where Node.js responds to requests from the internet, then developers' computers and continuous integration (CI) environments, because build tools download packages and connect to other servers.

How this applies to Express, Next.js, gRPC and other applications

According to CloudLinux's conclusion mentioned earlier, the seven high-severity flaws do not affect Express with app.listen(), Next.js with next start or the Inertia SSR server, because they run on node:http. For Express with HTTPS, @grpc/grpc-js and Vite servers with HTTPS, the conditions for the HTTP/2, HTTPS and TLS flaws need assessing. Updating is necessary in every case, because the November release also updates Node.js's bundled HTTP parser llhttp in all three release lines, and the advisory lists this update among the patches for publicly known vulnerabilities. The Express documentation distinguishes the http.Server created by app.listen() from an HTTPS server, which the application code creates with https.createServer(options, app). During your checks, establish which option your application uses and record it with the configuration, because the framework's name alone does not determine which Node.js module accepts connections. For gRPC, choosing an encrypted or unencrypted connection does not make this distinction, because @grpc/grpc-js uses node:http2 in both cases.

Application or modeServer creationHTTP/2, HTTPS and TLS server flaws
Express with app.listen()http.ServerDo not apply: this server does not itself use HTTP/2, HTTPS or TLS
Express with HTTPShttps.createServer(options, app)Assess the configuration conditions for the HTTPS and TLS flaws
Next.js with next startnode:httpDo not apply: this way of starting the application does not itself use HTTP/2, HTTPS or TLS
@grpc/grpc-jshttp2.createServer() or http2.createSecureServer()Assess the conditions for the HTTP/2 flaws both with and without TLS
Vite development server with HTTPSserver.https enables TLS and HTTP/2Assess the conditions for the HTTP/2 and TLS flaws
Vite preview with HTTPSpreview.https enables TLS and HTTP/2Assess the conditions for the HTTP/2 and TLS flaws
Inertia SSR servernode:httpDo not apply: this server does not itself use HTTP/2, HTTPS or TLS

Development modes and Inertia SSR

Check development modes separately: in Next.js, --experimental-https is only intended for the next dev command, while in Vite, preview.https inherits server.https by default, so check this inherited value in the preview configuration too. On a Laravel site, Inertia uses a separate Node.js process for server-side rendering (SSR), which your team starts with php artisan inertia:start-ssr and whose default port is 13714. The PHP version therefore tells you nothing about this process's Node.js version. Inertia's documentation gives node as this server's default runtime, so you need to update the Node.js used to start this process. If Node.js only builds files in your project, see the procedure in the October article's section on the build environment.

Which versions are safe now

The safe versions are 22.23.5, 24.22.3 and 26.13.1 or any later version within the same release line, and anything older within its release line is affected, including the versions released in October that were safe at the time. The advisory attributes some flaws only to release lines 24 and 26, but the 22.23.5 release notes also mention several of these fixes, so the project's two sources disagree on this point. We therefore do not give a vulnerability count for each release line here, but the action required is unchanged: release line 22 also needs updating to the patched version.

According to the project's release schedule, release lines 22 and 24 are in Maintenance LTS and will receive patches until 30 April 2027 and 30 April 2028 respectively. Release line 26 entered Active LTS on 28 October 2026 and will receive patches until 30 April 2029. If you are planning a migration to another release line now, these dates help you choose a target, but it is worth installing the security patch for your current release line today rather than waiting until the migration is complete.

Release lineNovember patched versionSupport phaseEnd of life
2222.23.5Maintenance LTS30 April 2027
2424.22.3Maintenance LTS30 April 2028
2626.13.1Active LTS30 April 2029

Node.js 20, 18, 16 and older release lines

The project does not issue patches for release lines that have reached end of life. The advisory includes a statement repeated with every security release: end-of-life versions are always affected by a security release. The project's end-of-life page adds that these release lines will receive no new releases even when the same vulnerability affects them. According to the release schedule, release line 20 reached end of life on 30 April 2026, release line 18 on 30 April 2025 and release line 16 on 11 September 2023.

A patch may still come from the platform developer: CloudLinux, whose operating system also powers our hosting, backports fixes to its alt-nodejs packages even for end-of-life release lines, and at 23:46 UTC on 11 November, CloudLinux reported that patched packages were available for all alt-nodejs versions on CloudLinux OS 7, 8 and 9. The version number of such a package stays the same, so node --version shows the same result after the update as before. Only the package's release number changes: the CloudLinux advisory lists 20.20.2-17 or later as the patched package release for alt-nodejs20 on CloudLinux 7, 8, 9 and 10, and this is what you should ask your hosting provider about if your application is hosted elsewhere.

For businesses that maintain their own infrastructure, the project points to commercial support: OpenJS Ecosystem Sustainability Program partners HeroDevs and TuxCare offer security patches for end-of-life versions, while NodeSource helps assess migrations and provides expert support. Backports reduce risk but are no substitute for a supported release line, because they cover the runtime itself rather than the application's dependencies. We have explained what to do with a project still running an old version in our article on an old PHP or Node.js version.

What to do today

First, update Node.js to the patched version within its release line everywhere it responds to requests from the internet, then restart every process that uses it. CloudLinux reminds users of this after the package update: a running application continues to use the old executable until it is restarted. On hosting with cPanel, you can restart the application under Setup Node.js App, where each application has its own row, and that same row shows which version is selected for it. If it shows an end-of-life release line, the next step is a migration rather than another update.

Next, rebuild everything that embeds the runtime: Docker container images must be rebuilt with an updated base image, because a container image built before 11 November does not contain the patch, however many times the container has been restarted. A program distributed as a single executable application (SEA) contains the runtime itself, so it must be rebuilt with the patched version, and developers' computers and continuous integration environments come last. If you do not know which version your application is actually running, the checks for hosting, your own server and containers are described in the October article.

How to check that the running process uses the patch

After updating, check the process's process.version against the patched version in its release line, and use the checking procedure in the October article to locate the runtime. The process.versions property also shows bundled dependency versions. In the November releases 22.23.5, 24.22.3 and 26.13.1, llhttp is 9.4.4 and sqlite is 3.54.1. In 24.22.3 and 26.13.1, brotli is 1.2.1 and undici is 7.30.2 and 8.12.4 respectively. The 22.23.5 release notes do not mention a brotli or undici update. The documentation's process.versions example shows different numbers, so compare against the relevant release notes rather than the documentation.

Node.jsllhttpsqlitebrotliundici
22.23.59.4.43.54.1No update specifiedNo update specified
24.22.39.4.43.54.11.2.17.30.2
26.13.19.4.43.54.11.2.18.12.4

Restarting and checking the package release

Besides the Setup Node.js App section mentioned earlier, CloudLinux also lets you restart an application from the command line with cloudlinux-selector restart, specifying --interpreter nodejs and the application's --app-root. With PM2, pm2 restart stops and starts the process again, causing a brief interruption, while pm2 reload in cluster mode waits for the new worker processes to be ready to accept connections before stopping the old ones. After changing Node.js, the PM2 startup script must be regenerated with pm2 unstartup and pm2 startup so that it uses the new executable. Once these steps are complete, check the version reported by the application process.

Docker's official Node.js container image list includes tags 22.23.5, 24.22.3 and 26.13.1, so choose the appropriate base image and rebuild using the --pull option, which tells the build tool always to try downloading all specified images. After starting the new container, check its application process's version so that the result applies to the process now handling requests, and record it alongside the image tag and the date of the check.

For a release line with CloudLinux backports, the question is which package release is installed, because the Node.js version number stays the same, as explained in our article on backports. On our server, CageFS hides both rpm and the alt-nodejs package's release number from the customer account. Ask your hosting provider whether the patched package release specified by CloudLinux or a later one is installed. We describe what we checked on our server below. Restart the application and check its process separately, because checking the package does not tell you whether the running process is already using the new executable.

The November undici patch and your project's npm package

The November release updates undici in Node.js release lines 24 and 26. We explained the difference between built-in fetch and a package installed from npm in the October article's section on what the update covers. In four of the undici project's security advisories dated 5 November, the affected range starts at 7.0.0 and ends before 7.30.2, while in the next release line it starts at 8.0.0 and ends before 8.12.4. When checking your project, find the specific package version the application uses and compare it against the patched version in that release line.

The starting versions affected differ in the other advisories: one starts at 7.15.0 and 8.0.0, while the other starts at 7.30.1 and 8.12.2. Both give 7.30.2 and 8.12.4 as patched versions, so run npm ls undici in your project to see the installed versions of this package and their locations in the dependency tree. We recommend recording the Node.js version and the undici version found by npm separately in your check results. If npm shows an affected package, ask your developer to update that dependency, because confirmation of a runtime update does not answer the question about the project's package.

undici advisory (5 November)Affected versions start atPatched versions
GHSA-7xg3-fphp-28hg, GHSA-3g9m-rv3r-w5w2, GHSA-5rm8-gv32-r954, GHSA-9v6h-8rgp-m69f7.0.0 and 8.0.07.30.2 and 8.12.4
GHSA-r4pc-4jcp-7pqc7.15.0 and 8.0.07.30.2 and 8.12.4
GHSA-mqg3-3v4r-cm327.30.1 and 8.12.27.30.2 and 8.12.4

The order of the announcements and when to expect the next release

The date of the next security release is not yet known. The project's vulnerability advisories page lists six security releases in 2026 (13 January, 24 March, 18 June, 29 July, 21 October and 11 November), and no subsequent release had been announced by 20 November. This time, a week passed between the advance warning on 4 November and the release on 11 November. In the CloudLinux OS 8 source package list, the patched packages for release lines 22, 24 and 26 are dated that same day. Following the previously mentioned 23:46 UTC report, CloudLinux's status page announced at 00:33 UTC on 12 November that patched packages were available for all systems it builds them for. Our server check followed on 12 November, as described below.

A week passed between the warning and the release this time, but that is not a rule. The 72 hours mentioned in Node.js's security policy is the usual embargo period after a CVE is assigned, and it can vary depending on the flaw's severity or the complexity of fixing it. It therefore does not determine how far in advance the public warning will appear. Plan updates around each new warning rather than the timing of previous releases.

Node.js recommends the low-volume, announcement-only nodejs-sec mailing list. You can also follow the project's vulnerability news through its RSS feed, while CloudLinux reports on alt-nodejs packages on its security advisories page. We explained how to assign responsibility for monitoring these announcements in the October article.

Each country's computer emergency response team issues notices on its own timetable. The Node.js project's own announcements, including its 21 October 2026 security-release post and the 11 November post cited above, provide update information for every market. A national CERT warning cannot be relied on for every release. Do not make updating dependent on it, and follow the project and CloudLinux channels listed above.

What we checked on our hosting

Our managed hosting provides space on our own server, and each customer selects a Node.js version for each application in the hosting control panel. When we checked our server at 22:45 UTC on 12 November 2026, we found Node.js 22.23.5 and 24.22.3 executables, so release lines 22 and 24 are on patched versions, and both files were built on the evening of 11 November.

End-of-life release lines 16, 18 and 20 also remain available to select. On our server, Node.js release lines 16, 18 and 20 had CloudLinux packages containing backports installed, rebuilt on 11 November. Their executables were built between 21:35 and 22:39 UTC, but the version numbers stayed the same, exactly as CloudLinux describes for a package containing a backport. We established that the packages had been updated from the executables' build times. These patches reduce risk but do not restore support for these release lines, so for a project using any of them, updating still means migrating to a supported release line. Release line 26 was not available to select on our hosting on 12 November, so we recommend release line 24 in most cases. We checked the installed files rather than each application's process: an application that has not been restarted since the evening of 11 November may still be running the old executable, so restart it under Setup Node.js App.

Our managed hosting starts at €45 per month and includes runtime maintenance. If your application still runs on Node.js 16, 18 or 20, contact us and we will agree on a migration to a supported release line, because backports do not cover the application's dependencies or extend the release line's support.

FAQ

Frequently asked questions.

Which versions fix the vulnerabilities in the Node.js November 2026 security release?

The safe versions are 22.23.5, 24.22.3 and 26.13.1 or later within the same release line, and anything older within its release line is affected, including the versions patched in October, 22.23.4, 24.22.1 and 26.12.1. Node.js does not issue patches for end-of-life release lines, so only a platform package can contain a patch for them, and the Node.js version number does not reveal that patch. On our hosting, release lines 22 and 24 received 22.23.5 and 24.22.3, while release lines 16, 18 and 20 received CloudLinux packages containing backports. Restart your application under Setup Node.js App so that it uses them.

We updated Node.js in October. Do we need to do it again?

Yes. The 11 November release fixes 16 vulnerabilities. The project had already reported one low-severity flaw in the Permission Model on 21 October, stating that it affects release line 26. The remaining 15 vulnerabilities were announced in November, and the project rates seven of them as high severity. Update to 22.23.5, 24.22.3 or 26.13.1 depending on your release line, then restart every application process. If the application runs in a Docker container image or is distributed as a single executable application (SEA), it must be rebuilt with the patched version because Node.js itself is embedded in it.

Our application runs on Node.js 18 or 20. What does the November release mean for it?

Plan a migration to a supported release line and try it in a test environment first. On our hosting, where release line 26 was not available to select when we checked on 12 November, we recommend release line 24 in most cases because release line 22 will only receive patches until 30 April 2027. Elsewhere, if the project's dependencies allow it, you can also choose release line 26, which will receive patches until 30 April 2029. Node.js release lines 18 and 20 have reached end of life: release line 18 on 30 April 2025 and release line 20 on 30 April 2026, and Node.js no longer issues patches for them. On our hosting, both release lines received CloudLinux packages containing backports, which the application starts using after a restart, but elsewhere you should ask your hosting provider: on CloudLinux 7, 8, 9 and 10, they are available from package release 18.20.8-28 (alt-nodejs18) and 20.20.2-17 (alt-nodejs20). This is still a temporary measure rather than a substitute for migrating to a supported release line.

We only use Node.js to generate CSS and JavaScript files. Are we affected?

Less than an application that handles requests itself. All seven high-severity vulnerabilities are in HTTP/2, HTTPS and TLS servers run by Node.js itself, and the build process does not run these servers. Node.js still needs updating on developers' computers and in continuous integration environments, because build tools also communicate with other servers, for example when downloading packages. One of the medium-severity vulnerabilities affects these outgoing connections. The order is straightforward: servers first, then build environments.

Is updating Node.js without restarting enough?

No. A running process continues to use the Node.js executable it started with, and replacing the package on disk does not affect it, so every application process must be restarted after updating. On cPanel hosting, you can do this under Setup Node.js App. Restarting is not enough for a Docker container image or a single executable application (SEA), because Node.js itself is embedded in them and they must be rebuilt with the patched version.

RELATED SERVICE
Managed hosting and servers

Servers, hosting and maintenance in the EU — Frankfurt, Helsinki or Riga, with 24/7 monitoring. Full management: updates, security and performance, automated backups with tested restores, SSL certificates, CDN and DDoS protection. We migrate you from your current host with no downtime and scale with the load.

Learn more