ThreatBeaconXSubscribe
CriticalRemote Code Execution · 15 min read

Beyond Node.js: The Hidden Risk in Brotli Decompression

A flaw in Google’s Brotli decoder can corrupt application memory when software unpacks specially crafted compressed data. The issue extends beyond Node.js to other runtimes, Python packages, proxies and file-processing tools. This article explains the different exposure paths, what researchers actually demonstrated, available fixes, and why updating one package or enabling a firewall rule may not complete remediation.

Written by Yedla Sai Geethika·Published Oct 28, 2026

A security flaw in Google’s Brotli decoder has become an important example of how a small shared software component can create risk across many different applications.

The issue, tracked as CVE-2026-111497, affects code responsible for unpacking Brotli-compressed data. Specially crafted input can corrupt the memory of the application performing that work. Possible consequences include a crash, exposure of sensitive memory, or execution of attacker-controlled code. 

The Hacker News initially reported the wider impact on October 24, 2026, and updated its article on October 26. The expanded reporting includes .NET updates and research into software that processes images and data files- not only web requests.

The key lesson is:

An application can inherit a serious vulnerability from a component hidden several layers below its own code.

However, the presence of that component does not automatically prove that a system was attacked. Security teams must establish whether untrusted data can actually reach the affected decoder.

Key Facts at a Glance

ItemExplanation
VulnerabilityCVE-2026-111497
Affected componentGoogle’s Brotli C decoder
Main weaknessWriting outside the intended memory buffer
Required conditionAn affected application decodes attacker-controlled Brotli data
Demonstrated code executionA specific official Node.js build and tested application configurations
Other demonstrated effectsCrashes, memory corruption and a CPU-consuming loop in additional software
Exploitation statusThe reviewed reporting does not identify a confirmed real-world attack campaign
Main responseReplace affected decoder copies and verify that deployed applications use the fix

These findings describe a vulnerability and research demonstrations. They are not evidence that every listed product has been remotely taken over. 

What Brotli Does

Brotli is a lossless compression format. Compression makes data smaller so that it takes less space or can be transferred more efficiently. “Lossless” means the original information can be restored without deliberately removing details. 

Imagine putting clothes into a compressed travel bag. The packed bag is smaller, but the clothes must be unpacked before they can be used.

Software follows a similar process:

Original data → Compression → Smaller data → Decompression → Original data restored

The software that packs the data is an encoder. The software that unpacks it is a decoder.

This vulnerability concerns the decoder. Simply compressing trusted content for a website is not the same operation as decoding attacker-controlled input. The vulnerable code must be used on the decoding path for this issue to become reachable. 

What Went Wrong Inside the Decoder?

The decoder processes a stream of compressed instructions and data.

According to the Node.js advisory, an invalid transition inside that stream was treated as though the decoder merely needed more input. It should instead have stopped and reported that the data was invalid.

Because processing continued in an invalid state, the decoder could write outside an intended buffer- a limited area of working memory. 

A simple analogy is a worker placing items into a small tray. When the instructions become impossible, the worker should stop. Instead, the worker keeps adding items and spills them into neighbouring workspaces.

In software, the “spill” can damage information that the program is using.

The result is called memory corruption. It does not always produce the same outcome: one application might crash, while another build or environment might allow more serious interference.

Why Node.js Is Only Part of the Story

The defect is in a reusable native library, not only in JavaScript application code.

Projects can include that library in several ways: directly inside a runtime, through a language package, through another native dependency, or as a system-installed shared library.

Therefore, one upstream fix does not automatically replace every copy already shipped inside other products. 

The names Node2Shell, HTTP2Shell and Brotli2Shell reflect different research perspectives on the same underlying CVE. They should not be presented as three unrelated vulnerabilities.

Also, the name HTTP2Shell should not be read as proof that this is a defect in the HTTP/2 protocol itself. The underlying issue is Brotli decoding. 

Three Different Ways Untrusted Data Can Reach the Bug

1. An Application Receives a Compressed Request

A service may accept a request whose body is Brotli-compressed.

Before the application can read the original content, a proxy, framework or middleware component may decompress it.

Incoming compressed request → Request decoder → Application memory

Express and body-parser provide request-body parsing features that can inflate compressed input, including Brotli in relevant versions and configurations. 

However, a basic Node.js HTTP server does not automatically decompress every request just because it arrives. The application must use a feature or dependency that reaches the decoder. 

That distinction matters when prioritising systems: a reachable decoding path is more informative than simply finding “Node.js installed.”

2. A Server Downloads a Compressed Response

A server is not always the receiver of incoming requests. It can also act as a client when it downloads information from another server.

For example, an application might retrieve external content to generate a preview or perform an integration. These are illustrative workflows, not claims that every such product is affected.

Some HTTP clients automatically decompress responses. Bun’s advisory specifically identifies automatic Brotli response decoding through fetch() as an affected path. 

The sequence becomes:

Application requests external content → Remote server sends compressed data → Application decodes the response

The important point is that the dangerous input may arrive as a response to a request the application initiated itself.

3. A Worker Processes a File

HTTP is not required.

JFrog identified a route through FFmpeg’s JPEG XL support, involving the libjxl image library and compressed metadata. Apache Arrow’s issue tracker also identifies Brotli-compressed content in Parquet or Arrow IPC files as a relevant path in affected bundled builds. 

This expands the investigation to image-processing jobs, data-import services and background workers.

Untrusted file → File-processing library → Brotli decoder

A firewall rule looking for an HTTP compression header cannot cover a file that is later decoded by an offline or internal job.

What Researchers Actually Demonstrated

Imperva demonstrated code execution using the official Node.js 24.22.0 Linux ARM64 build. Its tests covered a fetched response and configured incoming request-body parsers.

The demonstration required multiple attempts. Imperva did not claim that it had tested every operating system, architecture or application. The same input was rejected by Node.js 24.22.1. 

The wider findings should be described separately:

Software or environmentPublished evidenceWhat should not be claimed
Tested Node.js buildAttacker-supplied code executed in the research setup.Every Node.js deployment was successfully exploited.
BunMaintainer confirmed the vulnerable bundled decoder and relevant input paths.Bun-specific successful RCE was demonstrated by its advisory.
FFmpeg with the relevant dependency pathJFrog demonstrated memory corruption and pointer-control evidence.Complete code execution was established on every FFmpeg build.
ClickHouseJFrog demonstrated a service crash.A crash proves successful code execution or data theft.
Apache Arrow / pyarrowJFrog demonstrated an endless decoding loop consuming CPU.The test demonstrated remote code execution.
.NET test applicationJFrog demonstrated a native process crash.Microsoft confirmed a working .NET RCE exploit.

The non-Node demonstrations come from JFrog’s research; Bun explicitly states it had not tested an attack against Bun. Microsoft lists memory disclosure, denial of service and possible privilege effects rather than claiming a demonstrated RCE chain. 

Affected Software and Published Fixes

The following are minimum fixes for this vulnerability, not a recommendation to stop updating afterward. Use a supported, vendor-approved release.

ComponentAffected scope or conditionPublished fix
Google Brotli C libraryAffected 1.0.x, 1.1.x and 1.2.x decoder releases1.0.10, 1.1.1 or 1.2.1, for the respective branch
Node.jsSupported 22.x, 24.x and 26.x before their fixes22.23.4, 24.22.1, 26.12.1
BunAdvisory range: 1.0.21 through 1.4.31.4.4
Python BrotliReleases covered by the advisory through 1.2.01.2.1
Python brotlicffiAffected releases through 1.2.0.x1.2.1.0
.NETAffected runtimes when untrusted Brotli is decoded8.0.33, 9.0.22, 10.0.14, .NET 11 RC3
EnvoyListed affected releases with Brotli decompression configured1.40.0, 1.39.3, 1.38.6, 1.37.8, 1.36.12
IstioAffected branches with Brotli decompression enabled1.31.2, 1.30.6, 1.29.9
Ruby brotli gemAffected bundled or system decoder used by the gem0.9.1
cdxgen standalone binaries and imagesAffected embedded runtimes13.5.0 or 12.8.9

The upstream branch ranges exclude the fixed releases: 1.0.3 before 1.0.10, 1.1.0 before 1.1.1, and 1.2.0 before 1.2.1. Distribution packages may contain backported fixes. 

Version information comes from the project advisories and maintainers. Unsupported Node.js branches should move to a supported release rather than be treated as safe because no new fix appears for them. 

Important Product-Specific Differences

Python applications can reach Brotli indirectly.
Requests documents automatic Brotli decoding when a supported Brotli backend is installed. An application may therefore use Brotli without directly importing it in its own source code. 

Installing a package alone is not proof of compromise. The application still needs to receive and decode untrusted input.

.NET does not enable these HTTP decompression paths by default.
Microsoft identifies exposure when applications enable the relevant Brotli request or response processing, or call Brotli APIs on untrusted data. .NET Framework is not affected, according to the advisory. 

Envoy and Istio require the relevant decompressor configuration.
Their advisories do not establish that every installation automatically processes Brotli. Check the actual filter and proxy configuration. 

Updating an application dependency may not update its runtime.
For example, changing an Express package does not itself replace the Node.js binary containing the vulnerable decoder. The runtime must be part of the remediation plan. 

Fixes Still Need Product-by-Product Verification

For ClickHouse, the project merged a Brotli update and recorded backport work. That is evidence of a source-code fix, but administrators must still confirm that their particular released package contains it. 

For Apache Arrow, the reported problem concerns builds using an affected bundled decoder. The issue states that builds linked to a patched system library are different. Do not invent a universally fixed Arrow version from the existence of an upstream Brotli release. 

For FFmpeg, the relevant dependency chain includes libjxl and the Brotli implementation it uses. Updating a separate Node.js installation would not repair that path.

The practical rule is to identify the decoder actually used by the deployed application- not a similarly named package elsewhere on the machine.

Timeline: A Source Fix Is Not the Same as a Deployed Fix

DateDevelopment
February 27, 2026The upstream correction appeared in Brotli’s source repository.
October 21Google published fixed Brotli releases; Node.js published its security releases.
October 22Imperva published its Node2Shell validation.
October 23Python advisory records documented the affected packages.
October 24The Hacker News published the wider-ecosystem article; the Ruby maintainer confirmed its fix.
October 25Microsoft published out-of-band .NET guidance; JFrog published broader research; Cloudflare announced emergency rules.
October 26The news article was updated with additional fixes and affected-software findings.

This is not a claim that every downstream product first received a fix on October 21. Different projects incorporated and disclosed changes on different schedules. 

The longer-term lesson is that a change in a source repository does not automatically protect software already installed on a server.

Why a Web Application Firewall Is Not the Complete Fix

A web application firewall, or WAF, examines traffic passing through its inspection point.

Vercel states that its protection covers relevant inbound traffic through its network, but does not cover responses fetched by application functions from other servers. It therefore directs users to update affected runtimes despite firewall protection. 

The same reasoning applies to file processing: a file opened by a background worker may never pass through the WAF’s relevant inspection path.

Cloudflare’s October 25 release added two broad rules associated with this vulnerability. Their default action was Log, not Block. One matches Brotli-encoded request bodies; the other matches the Next.js image-optimization path. Both can match legitimate activity. 

Consequently:

A rule being present does not prove that it blocks traffic, covers every input path, or repairs the vulnerable software.

Before changing a rule to blocking mode, review its scope and the effect on legitimate application functions.

Why Removing One HTTP Header Is Not Enough

These two headers have different meanings:

HeaderMeaning
Accept-EncodingThe compression formats a client says it can accept.
Content-EncodingThe compression applied to the actual message body.

Removing br from an advertised preference is not the same as preventing the application from decoding a Brotli response.

The cdxgen advisory gives a concrete example: its affected workflow could decompress a Brotli response even when it had not requested Brotli. 

A temporary control must stop the relevant data before the vulnerable decoding operation. Rejecting it afterward is too late.

There is no single header change that safely closes every request, response and file-processing path across all affected products.

A Useful Lesson From cdxgen’s Update

cdxgen’s advisory states that 12.8.8 was intended to ship the Node.js security update, but its standalone binaries still contained Node.js 24.18.0. The corrective release was 12.8.9.

The advisory also distinguishes standalone binaries from package installations that use the host’s Node.js runtime. 

This is an important additional lesson for defenders:

Do not close a vulnerability ticket only because a release announcement says “updated.” Verify the runtime inside the artifact actually deployed.

A build pipeline, container image or bundled executable can preserve an older component even after source files or dependency settings change.

Why a Scanner Can Miss the Real Exposure

There are at least three different questions:

Does the vulnerable component exist?
An inventory or version scanner may help answer this.

Can untrusted data reach it?
This requires checking application behavior, configuration and dependency paths.

Is the running workload using the fixed copy?
This requires deployment evidence, not only a source-code change.

Tools such as Trail of Bits’ Brotli Checker examine source and binary evidence, but their results still need interpretation. A potential call path is not automatically proof of practical exploitation, and absence of a match is not a guarantee that every embedded copy was found. 

Distribution backports create another complication. Debian’s fixed packages retain older upstream-looking version numbers with distribution-specific revisions. A simple comparison against “1.2.1” can therefore misclassify a patched system package. 

The opposite mistake is also possible: a patched system library does not necessarily repair an application carrying its own private copy.

What This Analysis Adds: Four Checks Before Declaring Recovery

The discovery belongs to the original researchers and maintainers. The following is a defensive framework built from their findings, not a claim of a new vulnerability.

CheckQuestionEvidence to retain
1. Find the copyWhich runtime or library performs Brotli decoding?Package, binary, container and dependency information.
2. Find the inputCan outside-controlled requests, responses or files reach it?Application configuration and input-flow review.
3. Replace the artifactHas the fixed component reached production?Released package, rebuilt image or republished executable.
4. Verify executionAre all active workers using the replacement?Running-version checks, restart records and deployment status.

For example, a team might update its public API but overlook an image worker or a scheduled data-import job. That hypothetical system would still have a separate exposure path.

The framework encourages teams to track each decoder copy and its workload, rather than marking the whole organization safe after updating one server.

Detection and Investigation Priorities

There is no single symptom that proves successful exploitation.

Investigators should correlate decoder errors, unexpected process crashes, worker restarts or sustained CPU use with the exact runtime, the data source and the operation being performed. A crash may be caused by an ordinary software problem, and malicious input may not always cause a visible crash. 

For a possible execution attempt, review unexpected child processes, new files and unusual network activity around the same event. For a possible denial-of-service event, look for repeated processing failures or workers that stop making progress.

MITRE’s application-exploitation detection guidance similarly emphasizes correlating suspicious input with failures and system behavior rather than relying on an isolated error. 

Preserve relevant timestamps, application logs, versions and request or file metadata. Handle collected inputs as untrusted evidence. Do not run a public exploit against production to “see whether it works.”

These are hunting priorities, not tested detection rules with claimed accuracy.

Recommended Remediation

Identify every affected workload.
Include production services, containers, serverless runtimes, developer tools, background jobs and software that embeds another runtime. Record an owner for each exposure path.

Apply the correct product fix.
Use vendor releases or verified distribution backports. Avoid assuming that updating the operating system, application framework or one language package updates every copy.

Rebuild embedded applications where required.
Bun says compiled executables containing an affected runtime need rebuilding. Microsoft requires self-contained and NativeAOT applications to be rebuilt or republished as appropriate; updating the machine’s shared runtime alone does not replace their embedded decoder. 

Restart or replace the running workload.
Deploying a new file does not necessarily replace code already loaded by an active process. Check all workers and container replicas, not only a command run in one administrator shell.

Use temporary restrictions carefully.
Where patching cannot happen immediately, stop untrusted Brotli from reaching the affected operation. Test the impact on legitimate traffic. Microsoft specifically warns against adding decompression features to applications that did not already use them merely to apply a workaround. 

Investigate credible signs of compromise.
If evidence suggests unauthorized execution or memory exposure, follow incident-response procedures and assess accessible secrets. Do not claim every unpatched installation requires a breach declaration, but do not treat patching as proof that earlier suspicious activity was harmless.

Verify closure.
Retain the fixed artifact version, deployment time, restart evidence and coverage of each decoding path. Least privilege, worker isolation and access restrictions are useful additional safeguards; they do not replace the decoder fix.

What This Means for Different Readers

For ordinary website visitors: This is primarily a software-maintenance problem for the application and infrastructure owners. A website using compression does not, by itself, mean that visiting it infected your device.

For developers: Review automatic behavior in HTTP clients and middleware, not only direct Brotli function calls. Optional dependencies can introduce decoding paths. 

For system administrators: Check the runtime inside each application or image. A patched host and an old embedded runtime can coexist.

For security teams: Prioritize systems that decode untrusted data and hold sensitive access or serve important workloads. Separate vulnerable software, reachable exposure and evidence of compromise.

For business owners: Ask whether the team has verified every deployed copy, including background services- not only whether someone has “installed the update.”

Severity and Remaining Uncertainty

The upstream advisory records CVSS 4.0 severity of 9.2, Critical. Node.js labels its issue High, while Microsoft’s .NET advisory uses CVSS 3.1, 8.1, High. These ratings come from different product contexts and scoring assessments. 

A Critical rating does not require confirmed mass exploitation. Equally, a serious theoretical impact does not prove that every installed application is remotely exploitable.

The reviewed reporting does not establish a named attacker, malware family, complete victim count or confirmed real-world exploitation campaign. 

Do not describe the issue as a malicious supply-chain insertion: the evidence concerns a shared vulnerable dependency, not proof that attackers intentionally poisoned Brotli’s distribution.

Conclusion

The Brotli flaw shows why a vulnerability report must look beyond the product named in the headline.

One shared decoder can be reached through an incoming web request, a downloaded response or a file-processing task. Those routes require different exposure checks, even though they ultimately depend on the same underlying fix.

The strongest response is:

Find the vulnerable copy, trace the untrusted input, deploy the correct fix and verify the running application.

A firewall rule can reduce some exposure. A package inventory can identify some affected software. Neither alone proves that every decoding path is safe.

MITRE ATT&CK Mapping

T1190- Exploit Public-Facing ApplicationT1203- Exploitation for Client ExecutionT1499.004- Endpoint Denial of Service: Application or System Exploitation