On 21 October 2026, the same day PHP shipped its PHP2Shell fixes, Node.js published a security release that included CVE-2026-111497: an out-of-bounds write in the Brotli decoder that Node bundles. Google released fixed Brotli versions the same day. On 27 October CISA added it to the Known Exploited Vulnerabilities catalog. It has collected names - Node2Shell, HTTP2Shell, Broccoli2Shell, Brotli2Shell - because the bug is in a compression library, not in Node, and a great deal of software decompresses Brotli.

This article stays on the defender's side of it: what is affected, which fixed versions to install, how to check a running process, and - the part most write-ups skip - which ordinary code paths in a Node.js service feed outside data into the decoder. Two of those we checked against source ourselves, and one popular version check turns out to be useless.

[INFO]
Primary sources: the Node.js October 2026 security release post (21 October); Google's Brotli releases (21 October); CISA's KEV alert (27 October); ELLIO's analysis and first in-the-wild observation (25 and 26 October); Tenable's FAQ for the downstream version table. The fetch, body-parser and version-check findings are our own, from Node 24.22.0 and 24.22.2 and the published body-parser source, on 29 October.
◈ interactive artifact
Does Outside Data Reach the Decoder?
Pick a Node.js line, what the service does and what sits in front of it. See which paths hand untrusted Brotli to node:zlib, and how to confirm the running build is fixed.

//The Bug, in the Advisory's Words

From the Node.js release post: "A flaw in the Brotli decoder bundled with Node.js allows malformed compressed input to write past the end of an internal decoder buffer." An invalid block switch was treated as a temporary need for more input instead of a permanent format error, so the streaming decoder kept appending bytes to a small internal buffer. "An attacker who can supply Brotli data that an application decompresses with node:zlib can corrupt process memory, which can lead to a crash, disclosure of process memory, or remote code execution." Node rates it High. Google, as the CVE numbering authority, scores it 9.2 under CVSS v4.0, with "attack requirements present".

Per Tenable's timeline, Google committed the upstream fix in February, and Envoy and Istio shipped fixed releases in early October without naming the flaw. Node.js disclosure on 21 October was the first public description.

//Fixed Versions

Node.js: 22.23.4, 24.22.1, 26.12.1. Node 20, 23 and 25 are end of life and get no fix. The decoder is compiled into the node binary, so npm update changes nothing. You need a new Node build, a rebuilt container image, and a restart.
Brotli itself: affected 1.0.3 to 1.0.9, 1.1.0 and 1.2.0; fixed in 1.0.10, 1.1.1 and 1.2.1. Programs that link the system library pick up the fix when the distribution package is updated and the program restarts.

From Tenable's table, for the rest: Bun 1.4.4; .NET 8.0.33, 9.0.22, 10.0.14; Envoy 1.36.12, 1.37.8, 1.38.6, 1.39.3; Istio 1.29.9, 1.30.6, 1.31.2; the Python Brotli package 1.2.1 and brotlicffi 1.2.1.0, which matter wherever urllib3, requests, httpx or aiohttp have them installed; PHP for Windows 8.2.35-1, 8.3.36-1, 8.4.27-1, 8.5.12-1. JFrog, as cited by Tenable, also reached the bug through FFmpeg via JPEG XL, Apache Arrow via Parquet, and ClickHouse, which as of 26 October had merged a fix without a release.

//Paths Into the Decoder

The advisory says the risk is Brotli data "that an application decompresses". Few applications call the Brotli API on purpose. The question is what does it for them. We checked two common cases.

Node's built-in fetch() decodes Brotli responses. The bundled undici code in Node 24.22.2 adds zlib.createBrotliDecompress to its decoder chain whenever a response carries Content-Encoding: br. So any service that fetches a URL an outside party can influence - webhooks, link previews, image proxies, feed or file importers - lets that party pick the server, and the server picks the bytes. A reverse proxy in front of your inbound traffic does nothing for this path, because the Brotli arrives as a response to a request your service made.

Express 5 decodes Brotli request bodies by default. Express 5 depends on body-parser 2.x, whose read.js maps Content-Encoding: br to zlib.createBrotliDecompress(), and its inflate option defaults to true. Any client that can send a JSON or form body can send it Brotli-encoded. Express 4's body-parser 1.20.3 has no Brotli branch. That does not clear Express 4 apps - other middleware may decode it - but it removes the default path.

Those two cover a large share of real Node services. For inbound bodies, ELLIO's interim advice is to reject or drop Content-Encoding: br on inbound requests until patched; in Express 5, inflate: false on the body parsers does the same at the application. For outbound fetches, the fix is the Node upgrade.

//Checking a Running Process

A check circulating in several advisories reads a constant the fix added:

node -p "require('zlib').constants.BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH"

We ran it: undefined on Node 24.22.0, -17 on 24.22.2. Run it inside the container or with the same binary the service uses, not on the host. In the same test, process.versions.brotli reported 1.2.0 on both builds. The fixed build carries the fix without reporting a fixed Brotli version, so an inventory script that compares that string against Brotli's fixed releases will flag a patched Node as vulnerable, and tells you nothing either way. Use the Node version or the constant.

//Exploitation So Far

ELLIO reported the first in-the-wild attempt at 15:08 UTC on 26 October: a single Brotli-encoded request body of about 23 MB, built for the official Node.js 24.22.0 x86-64 build, from an address ELLIO had already seen carrying other exploitation attempts and scanning VPN and Kubernetes services. Before that, a tool identifying itself as node2shell-check had sent Brotli bodies to ELLIO's sensors to find hosts that decompress them. ELLIO's assessment is that the attempt was likely not successful: replayed against a vulnerable 24.22.0 target, the attacker's chain "scored zero hits in 50 attempts". CISA listed the CVE the next day.

Two findings from ELLIO and Imperva, as summarised by Tenable, shape the risk. Exploitation is build-specific: a chain tuned to one Node build produced nothing against others. And most failed attempts crash the worker rather than yield code. That is not much comfort. Attackers can tune once for a popular official build and reuse it on every host running it, and a process manager that restarts crashed workers hands them repeated tries. ELLIO adds one more cost of failed attempts: crashes can write process memory, session data included, to core dumps. Restrict who can read them and how long they are kept.

[IOC]
CVE: CVE-2026-111497 (Node2Shell / HTTP2Shell / Broccoli2Shell / Brotli2Shell), out-of-bounds write in the Brotli decoder; CVSS v4.0 9.2 (Google); KEV 27 October 2026
Node.js fixed: 22.23.4, 24.22.1, 26.12.1; 20, 23, 25 end of life, no fix
Brotli fixed: 1.0.10, 1.1.1, 1.2.1
Check: zlib.constants.BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH is -17 when fixed, undefined when not; ignore process.versions.brotli
Inbound signals (ELLIO): Content-Encoding: br on large POST bodies; user agent node2shell-check; repeated worker crashes on services that accept Brotli
Source address (ELLIO, 26 Oct): 94.154.43.7; request body SHA-256 7fcbdaaecd4419e2930927844f3b772668204737a4e7602a2290c991c93c5c4b

//Sourcing and Uncertainty

The bug description, affected lines, fixed Node versions, severity and credits are from the Node.js release post. Brotli's fixed versions are from Google's release page. The KEV listing is from CISA; CISA titles it "Google Brotli Unchecked Return Value Vulnerability", which describes the root cause differently from Node's "out-of-bounds write". The downstream version table, the February upstream commit, the early Envoy and Istio releases, the JFrog findings and the Imperva result are from Tenable's FAQ and were not checked against each vendor. The first in-the-wild attempt, the scanner, the 50-attempt replay, build specificity at the level described here, and the core dump advice are from ELLIO.

Our own checks. The fetch() path was read from the undici code bundled in Node 24.22.2. The body-parser paths were read from the published lib/read.js of body-parser 1.20.3, 2.0.0 and 2.4.0, and Express 4.21.2 and 5.1.0's declared dependencies. The constant and process.versions.brotli results are from running Node 24.22.0 and 24.22.2 on Linux x86-64. We did not test 22.x or 26.x builds.

What is unknown. Whether any real service has been compromised. As of ELLIO's update, the one documented in-the-wild attempt likely failed, and CISA has not said what evidence led to the listing. Who is behind the scanning or the attempt; ELLIO does not attribute it, and neither does this article.