Introduction

Node.js developers have another security issue to check: CVE-2026-111497, a vulnerability affecting the Brotli decoder included with Node.js.

The Node.js project published security updates on October 21, 2026, addressing this and several other vulnerabilities. The Brotli issue is classified as high severity because specially crafted compressed data can cause an out-of-bounds memory write, potentially resulting in a crash, memory disclosure, or remote code execution.

The risk depends on how an application handles compressed input. Simply running a Node.js application does not mean an attacker can automatically exploit it, but developers should check their runtime and update affected installations.

In this guide, you'll learn what the vulnerability means, which Node.js versions are affected, how to check your installation, and what steps to take to protect your application.

Official advisory: Node.js security releases — October 21, 2026

What Is CVE-2026-111497?

CVE-2026-111497 is a vulnerability in the Brotli decoder bundled with Node.js.

Brotli is a data compression algorithm used to reduce the size of data transferred or stored by applications. Smaller data can mean faster transfers and reduced bandwidth usage. Node.js supports Brotli compression and decompression through its built-in node:zlib module.

The problem is that the vulnerable decoder can mishandle certain malformed compressed input.

According to the Node.js security advisory, an invalid block switch can be incorrectly treated as a temporary request for more input instead of an invalid data format. In the affected code, the streaming decoder may continue appending input to a small internal buffer, allowing data to be written beyond that buffer's intended boundaries.

This is known as an out-of-bounds write.

What does an out-of-bounds write mean?

Programs use memory to store data while they run. Each memory buffer has a defined size, and software must ensure that it does not write beyond the allocated space.

An out-of-bounds write happens when a program writes data outside the intended boundaries of a memory buffer. Depending on the circumstances, this can corrupt other data or affect the stability and security of the process.

For this vulnerability, the potential consequences include:

  • Application crashes: Corrupted memory can cause a Node.js process to terminate unexpectedly.

  • Memory disclosure: Under certain conditions, process memory could be exposed.

  • Remote code execution: In some circumstances, memory corruption can potentially allow an attacker to execute code.

These are potential impacts described by the Node.js project. They do not mean that every vulnerable installation can necessarily be exploited in the same way.

How Could This Vulnerability Affect a Node.js Application?

The main concern is an application that receives compressed data from an untrusted source and passes that data to the vulnerable Brotli decoder.

For example, a backend application might accept compressed uploads, process compressed messages, or decompress data received from another system. If attacker-controlled Brotli data reaches the vulnerable functionality, the decoder may encounter the malformed input that triggers the flaw.

A simplified example of Brotli decompression in Node.js looks like this:

import { brotliDecompress } from 'node:zlib';

brotliDecompress(compressedData, (error, result) => {
  if (error) {
    console.error('Decompression failed:', error.message);
    return;
  }

  console.log('Decompression completed');
});

This example illustrates the API involved; it is not an exploit or a test for the vulnerability.

The security issue is in the affected Node.js runtime, so applications using the built-in decoder can be exposed when the relevant code path is reached. The exact risk depends on the application, its inputs, and its deployment.

Developers should pay particular attention to services that decompress data supplied by users or other untrusted systems.

Important: Updating application dependencies alone may not fix this issue. The Node.js runtime itself must include the security patch.

Which Node.js Versions Are Affected?

The official advisory identifies the Node.js 22.x, 24.x, and 26.x release lines as affected.

The following versions contain the published fix for this vulnerability:

Node.js release line Fixed version
Node.js 22.x 22.23.4
Node.js 24.x 24.22.1
Node.js 26.x 26.12.1

These are the fixed versions listed in the October 21 security release. When updating, check the official Node.js downloads page for the latest available patch in your supported release line.

If you use an older, unsupported Node.js release, do not assume it is safe. The Node.js project warns that end-of-life versions are also affected when security releases address vulnerabilities.

For unsupported versions, the safer approach is to migrate to a supported Node.js release and test your application for compatibility.

How to Check Your Node.js Version

Before updating, identify the version running in your development environment and on your server.

Open a terminal and run:

node -v

You might see output similar to:

v22.23.3

Compare the output with the fixed version for your release line. For example, Node.js 22.23.3 is older than the listed fixed version, 22.23.4.

You can also check npm:

node -v

However, the npm version does not tell you whether the Node.js runtime is patched. The node -v command is the relevant first check.

Check the runtime used by your deployed application

Be careful when checking a production server. The version shown in your local terminal may differ from the version used by your hosting account, Docker container, process manager, or production service.

If your application runs in Docker, for example, check the Node.js version inside the running container rather than relying only on the version installed on your computer.

If your hosting provider manages Node.js for you, use its control panel or deployment instructions to identify and update the actual runtime.

How to Update Node.js and Apply the Fix

The exact update procedure depends on how Node.js was installed. The goal is to move to a supported release that contains the security fix, then verify that the application actually uses that version.

Step 1: Record your current environment

Before changing the runtime, record the existing Node.js version and deployment configuration.

Review your application's dependencies, environment variables, and startup commands. For production applications, make sure you have an appropriate backup and a rollback plan.

Step 2: Install a fixed Node.js release

If you use a Node Version Manager (NVM), you can install a fixed version for your release line.

For example, to install the fixed Node.js 22 release listed in the advisory

nvm install 22.23.4
nvm use 22.23.4
node -v

For Node.js 24 or 26, select the corresponding fixed release shown in the table above, or a newer patched release in that supported line.

If you installed Node.js through an operating system package manager, hosting control panel, or container image, follow the update process for that environment instead.

Step 3: Rebuild or restart the application

Installing a new Node.js version does not automatically guarantee that every running application uses it.

Depending on your setup, you may need to:

  • Select the new runtime in your hosting control panel.

  • Update the Node.js version used by your Docker image.

  • Reinstall dependencies if your application requires it.

  • Rebuild your application.

  • Restart the relevant service or process manager.

For Docker deployments, use an updated, appropriately pinned Node.js base image and rebuild and redeploy the container. Avoid assuming that updating Node.js on the host also updates the runtime inside an existing container.

Step 4: Verify the running version

After updating, run:

node -v

Confirm that the result is the patched version you intended to use.

Also verify the runtime inside the actual deployment environment. If your application uses a process manager, container, or hosting platform, check that environment rather than relying exclusively on a local terminal.

Step 5: Test your application

Run your automated tests and verify the main application features. If your application processes compressed data, test the relevant functionality with valid inputs and appropriate error handling.

Monitor application logs after deployment and confirm that the service starts correctly.

Finally, review the official security advisory for the other vulnerabilities included in the same release. Updating to a patched version can address more than one security issue.

What If You Cannot Update Immediately?

Updating to a fixed runtime is the recommended solution. If you cannot update immediately, take temporary steps to reduce exposure while preparing the upgrade.

Consider the following measures:

  • Restrict untrusted compressed input. Review whether your application needs to accept Brotli-compressed data from external users.

  • Review decompression endpoints. Limit access to functionality that processes untrusted compressed input wherever practical.

  • Apply input and resource limits. Enforce sensible request-size, processing-time, and resource limits as part of your application's general defensive design.

  • Review logs and unusual failures. Investigate unexpected process crashes, malformed-input errors, and suspicious traffic around affected functionality.

  • Plan the runtime upgrade. Test the patched version in a staging environment, then deploy it as soon as practical.

These steps can help reduce exposure, but they are not a replacement for installing a fixed Node.js release. Application-level input validation also cannot be relied on as a complete fix for a vulnerability in the decoder itself.

Frequently Asked Questions

Is CVE-2026-111497 a critical vulnerability?

The Node.js project classifies CVE-2026-111497 as high severity in its October 21, 2026 security advisory. The potential impact includes memory corruption, crashes, memory disclosure, and remote code execution under relevant conditions.

Can this vulnerability lead to remote code execution?

Potentially, yes. The official advisory states that an attacker who can supply Brotli data that an application decompresses with node:zlib may trigger memory corruption that could lead to remote code execution. The practical exploitability depends on the affected application and its environment.

Does every Node.js application need to be updated?

Developers running affected release lines should update to a fixed release. The likelihood of exploitation depends on whether untrusted input can reach the vulnerable decoder, but this should not be used as a reason to leave an affected runtime unpatched.

Will updating npm fix the vulnerability?

Not by itself. npm manages JavaScript packages, while this issue affects the Brotli decoder bundled with the Node.js runtime. Update Node.js itself and verify the runtime used by your application.

How do I check the Node.js version on my server?

Run node -v in the environment where the application runs. For managed hosting, containers, or process-managed applications, make sure you check the runtime actually used by the deployed service.

Where can I find the official fix?

Read the Node.js October 21, 2026 security release and use the official Node.js downloads page to obtain an appropriate patched release.

Conclusion

CVE-2026-111497 highlights why keeping server runtimes up to date is an important part of application security.

The vulnerability affects the Brotli decoder included with Node.js and can cause memory corruption when specially crafted compressed data reaches the vulnerable code. Depending on the circumstances, the consequences can include crashes, memory disclosure, or remote code execution.

If you use Node.js 22.x, 24.x, or 26.x, check your runtime against the fixed versions listed in the official advisory. Update to a patched release, verify the version used in production, and test your application after deployment.

The key takeaway: Do not rely on updating npm packages alone. Check and patch the Node.js runtime itself.

For the latest technical details and release information, consult the official Node.js security advisory.


Editorial note: This article is for informational purposes. Always check the official Node.js advisory for the latest affected versions, fixes, and security guidance.

 

ST

Sifted Tech Editor

Sifted Tech contributor · Technology, thoughtfully considered.