HTTP2Shell (CVE-2026-111497): Brotli Decoder Flaw, Detection, Fix
CVE-2026-111497 is an out-of-bounds write in the Brotli decoder bundled in Node.js, Python, .NET and Envoy. How it works, how to find every copy, what to do.
Zyberum Security Team · Published · 15 min read
CVE-2026-111497 is an out-of-bounds write in the decoder of Google’s Brotli compression library. The decoder reported one kind of malformed stream as “need more input” instead of as an error, kept running with inconsistent state and wrote outside an internal buffer. The library is compiled into Node.js, Bun, .NET, Envoy, Python packages and many other products, which is why the same bug is known as Node2Shell, HTTP2Shell, Brotli2Shell, Broccoli2Shell and Py2Shell.
The fixed releases shipped on 21 October 2026, and the entry has been in the CISA KEV catalogue since 27 October 2026. A system is exposed when it decompresses Brotli data that an attacker controls, and that includes responses your own servers fetch. This guide covers the mechanics, the detection and the actions. It is part of our series on the 2Shell vulnerabilities.
The facts in one table
| CVE-2026-111497 | |
|---|---|
| Component | Decoder of the Google Brotli C library (c/dec/decode.c) |
| Advisory | GHSA-9v8h-qqgm-4m35, plus one advisory per embedding product |
| Class | Unchecked return value (CWE-252) leading to an out-of-bounds write (CWE-787) |
| Affected | Brotli 1.0.3 to 1.2.0 and every product that embeds these versions |
| Fixed in | Brotli 1.0.10, 1.1.1, 1.2.1 |
| Trigger | A crafted Brotli stream that reaches a decoder |
| Authentication | None |
| Impact per advisory | Corruption of adjacent decoder state, memory disclosure, denial of service, potentially code execution |
| CISA KEV | Added 27 October 2026, due date 10 November 2026 |
The scores differ, and the difference is one judgement. Google as the upstream CNA and Envoy rate 9.2 on CVSS 4.0 (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H), NVD rates 9.8 on CVSS 3.1, Red Hat and Microsoft rate 8.1 on CVSS 3.1 with AC:H. Node.js gives no score and labels the issue “High”. The split is about attack complexity: triggering the write is simple, turning it into reliable code execution needs tuning per build.
The timeline has one detail that is often remarked on. The upstream fix was committed on 27 February 2026 under the title “Detect and report invalid stream earlier”, months before the coordinated disclosure on 21 October 2026. The flaw was found by Khai Tran and Sylvie Mayer of OpenAI Codex Security. The Istio bulletin is dated 15 October 2026, and according to Tenable, Envoy and Istio shipped their fixes without naming the flaw.
Why one bug has five names
There is one bug in one library, and each vendor or outlet named it after the product it looked at. The Node.js advisory calls it Node2Shell, Tenable Brotli2Shell, BleepingComputer HTTP2Shell, Wiz and Akamai Broccoli2Shell, and Py2Shell is the informal name for the impact on the Python packages. All of them are CVE-2026-111497.
What matters for you is the list of products that carry their own copy of the decoder:
| Product | Affected | Fixed in |
|---|---|---|
| Google Brotli (C library) | 1.0.3 to 1.2.0 | 1.0.10, 1.1.1, 1.2.1 |
| Node.js 22, 24, 26 | Before 22.23.4, 24.22.1, 26.12.1 | 22.23.4, 24.22.1, 26.12.1 |
| Node.js 20, 23, 25 | Vulnerable, end of life | No fix, move to a supported line |
| Bun (versions as reported by Tenable) | 1.0.21 to 1.4.3 | 1.4.4 |
| Envoy | 1.18.0 and later, before 1.40.0 | 1.36.12, 1.37.8, 1.38.6, 1.39.3, 1.40.0 |
| Istio | 1.29.0 to 1.29.8, 1.30.0 to 1.30.5, 1.31.0 to 1.31.1 | 1.29.9, 1.30.6, 1.31.2 |
| .NET 8 | 8.0.0 and later, before 8.0.33 | Runtime 8.0.33 (SDK 8.0.133, 8.0.427) |
| .NET 9 | 9.0.0 and later, before 9.0.22 | Runtime 9.0.22 (SDK 9.0.123, 9.0.320) |
| .NET 10 | 10.0.0 and later, before 10.0.14 | Runtime 10.0.14 (SDK 10.0.114, 10.0.403) |
Python brotli (PyPI) | 1.0.3 and later, before 1.2.1 | 1.2.1 |
Python brotlicffi (PyPI) | 1.0.3 and later, before 1.2.1.0 | 1.2.1.0 |
Go andybalholm/brotli | Before v1.2.7 | v1.2.7 |
| PHP for Windows (per Tenable) | Builds that bundle Brotli 1.0.3 to 1.2.0 | 8.2.35-1, 8.3.36-1, 8.4.27-1, 8.5.12-1 |
PHP extension kjdev/php-ext-brotli (per Tenable) | Before 0.21.1 | 0.21.1 |
| Linux distributions | brotli, libbrotli1, libbrotlidec before the fix | Package update of the distribution, as 1.2.1 or as a backport |
Some notes on the edges of this list:
- .NET Framework is not affected, according to Microsoft. .NET 11 previews are fixed in 11.0.0-rc.3.26522.148.
- The Bun advisory could not be retrieved as a public record when we checked. The Bun versions above come from Tenable, so confirm them against the Bun release notes.
- Browsers ship their own Brotli decoder for HTTP responses, and Mozilla tracks the CVE in its bug tracker. We found no release note that pins affected or fixed browser builds, so we do not state any.
- nginx with
ngx_brotlicompresses responses. A server that only compresses is not a decoding sink. We found no dedicated nginx advisory. - Siemens has published advisories for its products (ssa-898633, ssa-443410, ssa-045512). Expect more vendors of appliances and embedded products to follow.
How does it work?
A helper function in the decoder returned the same value for “this stream is invalid” and for “I need more input”, and its callers treated both as “need more input”. The decoder therefore did not stop on an invalid stream. It continued with state that was never validly set up and wrote past an internal buffer.
The function with the ambiguous return value
A Brotli stream is divided into blocks, and a block-switch command changes the current block type for literals, commands or distances and resets the block length counter. The function that decodes this command is DecodeBlockTypeAndLength in c/dec/decode.c. Before the patch it looked like this, shortened:
/* Decodes a command or literal and updates block type ring-buffer. Reads 3..54 bits. */
static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
int safe, BrotliDecoderState* s, int tree_type) {
brotli_reg_t max_block_type = s->num_block_types[tree_type];
...
if (max_block_type <= 1) {
return BROTLI_FALSE; /* invalid stream, reported as plain "false" */
}
... SafeReadSymbol(...) ... /* also returns BROTLI_FALSE on "need more input" */
}
The function returned a BROTLI_BOOL, and BROTLI_FALSE stood for two different situations:
- A malformed stream. A block switch is requested for a tree that declares only one block type (
max_block_type <= 1). There is nothing to switch to, so the stream is invalid. - A short read.
SafeReadSymbolorSafeReadBlockLengthran out of buffered bits. That is normal in streaming and recoverable: the caller supplies more bytes and decoding resumes.
The callers are DecodeLiteralBlockSwitch, DecodeCommandBlockSwitch and DecodeDistanceBlockSwitch, each wrapped in the BROTLI_SAFE(...) macro inside ProcessCommandsInternal. They could not tell the two cases apart. On the streaming path the macro turned every BROTLI_FALSE into BROTLI_DECODER_NEEDS_MORE_INPUT: save the state, return, wait for more bytes. On the fast path, where enough input is guaranteed, the boolean was ignored entirely. This is the unchecked return value of CWE-252.
- Step 1/5A crafted stream asks for a block switch on a tree that declares only one block type. There is nothing to switch to, so the stream is invalid.
- Step 2/5
DecodeBlockTypeAndLengthreturnsBROTLI_FALSE. The same value also means that the buffered bits ran out. - Step 3/5The
BROTLI_SAFEmacro reads the value asBROTLI_DECODER_NEEDS_MORE_INPUT. The decoder saves its state and waits for the next chunk. - Step 4/5Decoding resumes with a block type and block length that were never validly established. The error is swallowed.
- Step 5/5The fix returns a dedicated error code.
BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH, code -17, breaks processing and the stream is rejected.
Why memory is overwritten
With the error swallowed, the decoder goes on through its command loop with a block length and block type that do not match the stream. The Node.js advisory describes the consequence in one sentence: an invalid block switch was reported as a temporary need for more input instead of a permanent format error, so the streaming decoder kept appending input bytes to an eight-byte internal buffer.
- Step 1/5The streaming decoder has an internal buffer of eight bytes for input bytes that it cannot process yet. In normal operation only a few bytes sit there.
- Step 2/5The invalid block switch is reported as a need for more input. The decoder keeps its state and waits.
- Step 3/5More input arrives. The decoder appends the bytes to the internal buffer, because from its point of view it is still in the middle of the same read.
- Step 4/5The appending does not stop at the end of the buffer. Bytes from the stream land in the decoder state that lies behind it.
- Step 5/5A fixed decoder never gets this far: the block switch returns error -17, processing stops and the stream is rejected.
The figure is a simplification. ELLIO characterises the write as one with a signed 32-bit displacement: the corrupted length or position can reach roughly 2 GB in either direction from the buffer. This is not a one-byte overrun. The attacker chooses the trigger, has substantial influence on where and how much is written, and the written content is derived from the stream as well. The exact destination depends on the build and the allocator.
From the write to code execution
Imperva and ELLIO describe the path only schematically and have not released working exploits. An attacker arranges the heap so that a useful object lies next to the decoder state, triggers the write to overwrite a pointer or a length in that object, and converts that into control over execution. We leave it at this level.
How reliable this is in practice is where the sources disagree:
- Imperva demonstrated code execution on an unmodified Node.js 24.22.0 image on Linux arm64, through
fetch()and through request bodies in Express 5. It took multiple attempts. - ELLIO reports that an offset tuned for 24.22.0 gave no hit in 10,000 attempts against 22.23.3 and 26.12.0, and that most of 400 attempts against an Express application crashed the worker.
- Some researchers argued, according to SecurityWeek, that the bug supports denial of service only. Tenable reports that JFrog reached control of the instruction pointer through a different route but did not demonstrate code execution.
Denial of service needs none of the tuning. ELLIO measured Brotli 1.2.0 spinning through 44.4 million block-switch attempts in 25 seconds at 99.9% CPU on its denial-of-service test input.
What the patch changed
The fix makes the function say which of the two cases happened, and makes the callers act on it. Commit 0ed4268a was ported to 1.0.10, 1.1.1 and 1.2.1, and to the Go port in v1.2.7.
| Situation | Before | After |
|---|---|---|
Return type of DecodeBlockTypeAndLength | BROTLI_BOOL | BrotliDecoderErrorCode |
Invalid block switch (max_block_type <= 1) | BROTLI_FALSE | BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH (new, code -17) |
| Short read | BROTLI_FALSE | BROTLI_DECODER_NEEDS_MORE_INPUT |
| Success | BROTLI_TRUE | BROTLI_DECODER_SUCCESS |
Call sites in ProcessCommandsInternal | BROTLI_SAFE(...) | BROTLI_SAFE_WITH_STATUS(...): every status other than success saves the state and returns it to the caller |
The three block-switch wrappers now return and propagate the error code. The patch also adds a defensive assertion that the remaining meta-block length stays within BROTLI_BLOCK_SIZE_CAP. ELLIO measured the fixed 1.2.1 rejecting its test inputs in about 40 ms with error -17.
How does attacker data reach a decoder?
There are two directions, and the second one is the one that gets overlooked. A host is exposed only if it decompresses Brotli data that an attacker controls: either a request body sent to it, or a response it fetches itself.
- Inbound: a request with
Content-Encoding: brto a server that decompresses request bodies. - Outbound: a server-side HTTP client fetches a URL from a host the attacker controls or has compromised, the host answers with Brotli, and the client decompresses automatically. Typical places are webhooks, link previews, crawlers, image and metadata fetchers and anything that fetches a URL supplied by a user.
- Other routes: WebSocket and gRPC compression, file and upload processing, and formats that embed Brotli. Tenable names JPEG XL metadata, which reached FFmpeg through libjxl.
- Step 1/6Inbound: the attacker sends a request whose body is compressed with Brotli, marked with
Content-Encoding: br. - Step 2/6The proxy forwards the request. The runtime or a middleware decompresses the body before the application logic sees it.
- Step 3/6The bundled decoder processes the crafted stream. This is where the out-of-bounds write happens.
- Step 4/6Outbound: the application fetches a URL itself, for example for a webhook, a link preview or a crawler.
- Step 5/6The remote server answers with a Brotli response. This data never passes the inbound filter at the edge proxy.
- Step 6/6The HTTP client decompresses the response automatically. The same decoder runs, with the same bug.
What is on by default where
| Runtime | Inbound: request bodies | Outbound: fetched responses |
|---|---|---|
| Node.js | Express 5.0.0 to 5.3.0 with body-parser 2.0.0 to 2.3.0 decompress br bodies when their decompression is configured. Any code that calls brotliDecompress or createBrotliDecompress on request data | Built-in fetch() decompresses Brotli responses automatically, on by default |
| Python | Application code that calls the decoder on request data | urllib3, and with it requests, decodes br automatically as soon as Brotli or brotlicffi is installed. The same holds for httpx with its brotli extra and aiohttp with Brotli installed |
| .NET | ASP.NET Core request decompression with br, off by default | HttpClient automatic decompression with DecompressionMethods.Brotli or .All, off by default. Explicit use of BrotliStream or BrotliDecoder |
| Envoy, Istio | Only when the Brotli decompressor filter is configured, in Istio for example through an EnvoyFilter | The same filter in the response direction |
| PHP | Through the system libbrotli or the brotli extension | Per Tenable: cURL extension with automatic response decompression on the official Windows builds, off by default |
Two points follow from this table. The Express and body-parser versions are routes to the decoder and not the bug. And an application can be exposed without ever naming Brotli in its own code. In Python, installing the package is enough to switch on the outbound path for every HTTP client in that environment.
Why updating the system library does not fix bundled copies
Node.js, Bun, self-contained and NativeAOT .NET applications and Go binaries that use andybalholm/brotli carry the decoder inside their own binary. Updating libbrotli through the package manager and restarting changes nothing for them. Only a new runtime version or a rebuilt binary contains the fix.
Even within one distribution the answer differs. Red Hat notes that the nodejs:24 module on RHEL 8 and 9 uses the bundled Brotli, while nodejs:22 uses the system library. Where a process does link the system library dynamically, the patched package takes effect only after that process has been restarted.
How to identify it
Find every copy of the decoder, not every server that “uses Brotli”. That means runtimes with a bundled copy, Python packages, the system library and statically linked binaries, on hosts and inside container images. Then check which of them decompress untrusted data, and look at the logs.
1. Runtimes with a bundled copy
# Node.js: compare with 22.23.4, 24.22.1, 26.12.1
node --version
node -p process.versions.brotli # Brotli version compiled into this binary
# Bun: fixed in 1.4.4
bun --version
# .NET: compare runtimes with 8.0.33, 9.0.22, 10.0.14
dotnet --list-runtimes
dotnet --info
# Envoy and Istio
envoy --version
istioctl version
# Go binaries: is the Brotli port linked in, and in which version?
go version -m /path/to/binary | grep -i brotli
process.versions.brotli shows the library version inside that Node.js binary. We could not confirm which string each fixed Node.js line reports, so take the Node.js version as the deciding value. For self-contained and NativeAOT .NET applications the host runtime says nothing: check the build of the application itself.
2. Python packages
pip list 2>/dev/null | grep -i -E '^brotli'
pip show Brotli brotlicffi 2>/dev/null | grep -E '^(Name|Version)'
# Every virtual environment and image layer on the host
find / -type d \( -iname 'brotli-*.dist-info' -o -iname 'brotlicffi-*.dist-info' \) 2>/dev/null
pip-audit
Fixed are Brotli 1.2.1 and brotlicffi 1.2.1.0. Run the commands in every virtual environment, not only in the system Python. OpenSourceMalware reported that Dependabot and Safety did not flag the PyPI packages at the time of its post, so a silent scanner is no proof here.
3. System library
ldconfig -p | grep -i brotli
dpkg -l | grep -i brotli
rpm -qa | grep -i brotli
apt-cache policy libbrotli1
# Which running processes have the shared decoder loaded?
grep -l libbrotlidec /proc/[0-9]*/maps 2>/dev/null
# Which processes still map the old file after the update?
grep -l 'libbrotli.*(deleted)' /proc/[0-9]*/maps 2>/dev/null
Compare the package version with the advisory of your distribution, not with the upstream number: distributions ship 1.2.1 or backport the fix into their own version.
4. Containers and SBOM scanners
# Check the version inside the image, not the tag
docker run --rm IMAGE node --version
docker ps --format '{{.Names}}' | xargs -I{} sh -c 'echo {}; docker exec {} node --version 2>/dev/null'
# SBOM and vulnerability match
syft IMAGE -o cyclonedx-json > sbom.json
grype sbom:sbom.json
trivy image IMAGE
trivy fs .
An image such as node:22.23.3-alpine stays vulnerable until it is rebuilt on a fixed base. Coverage of the PyPI packages and of bundled copies lagged in the advisory databases at first, so a clean scanner run is not proof of safety for bundled Brotli. Verify the runtime version and the binary contents directly.
5. Where is untrusted data decompressed?
# Node.js
npm ls express body-parser
grep -R -n -E 'brotliDecompress|createBrotliDecompress' --include='*.js' --include='*.ts' --exclude-dir=node_modules .
# .NET
grep -R -n -E 'BrotliStream|BrotliDecoder|DecompressionMethods\.(Brotli|All)|UseRequestDecompression' --include='*.cs' .
# Envoy and Istio: is a Brotli decompressor configured?
grep -R -n -i 'brotli.decompressor' /etc/envoy 2>/dev/null
kubectl get envoyfilter -A -o yaml | grep -i -n brotli
For the outbound path there is nothing to grep for in Node.js and Python, because the decompression is automatic. List the features that fetch URLs instead: webhooks, previews, imports, crawlers, integrations.
6. Traces and indicators
Failed attempts are visible, because they usually crash the process:
dmesg -T | grep -i -E 'segfault.*(node|bun|python|dotnet|envoy)'
journalctl -k | grep -i segfault
# Indicators published by ELLIO
grep -F 'node2shell-check' /var/log/nginx/access.log
grep -F '94.154.43.7' /var/log/nginx/access.log
| Where | Indicator |
|---|---|
| Process supervision | Workers or processes that crash and restart without explanation, segmentation faults or aborts in the decompression path |
| Resource monitoring | A process pinned at full CPU after a small Brotli input. Tenable cites an infinite-loop case with an input of 534 bytes |
| Requests | POST requests with Content-Encoding: br to endpoints that never receive compressed bodies |
| Reconnaissance (ELLIO) | User-Agent Mozilla/5.0 (compatible; node2shell-check/1.0): one GET /, then 20 POSTs with Brotli bodies in two bursts, among them malformed bodies of 1032 bytes |
| Exploit attempt (ELLIO) | A Brotli request body of 23,069,983 bytes, SHA-256 7fcbdaaecd4419e2930927844f3b772668204737a4e7602a2290c991c93c5c4b, source IP 94.154.43.7 |
| After a decode event | Unexpected outbound connections or downloads from the affected process. The chain ELLIO captured redirected standard input only, which implies a follow-on stage |
These network indicators come from a single source and describe one actor. They are observations and not signatures. Most access logs do not record the Content-Encoding request header, so add it to the log format if you want to hunt for it. Imperva has added WAF rules for this CVE. We did not find a public, vendor-neutral IDS signature, and any rule on request bodies misses the outbound path.
What to do
Update every copy, rebuild what bundles one, and restart. A patched file on disk protects nothing until the process that loaded the old code is gone.
- Update the runtimes that bundle the decoder. Node.js to 22.23.4, 24.22.1 or 26.12.1, Bun to 1.4.4. Node.js 20, 23 and 25 are end of life and receive no fix: move to a supported line.
- Update the Python packages in every environment and restart the workers:
pip install -U "Brotli>=1.2.1" "brotlicffi>=1.2.1.0" - Install the fixed .NET runtime (8.0.33, 9.0.22, 10.0.14) and rebuild and redeploy self-contained and NativeAOT applications. Updating the shared runtime does not replace a decoder that is already linked into an executable.
- Upgrade Envoy and Istio to Envoy 1.36.12, 1.37.8, 1.38.6, 1.39.3 or 1.40.0 and Istio 1.29.9, 1.30.6 or 1.31.2.
- Rebuild static binaries. For Go, raise
andybalholm/brotlito v1.2.7 and rebuild every binary that links it. The same applies to any Rust or C program that links a Brotli decoder statically. - Patch the system library through the distribution and restart every process that links it dynamically. This does not cover the bundled copies above.
- Rebuild and redeploy container images. Restarting a container on an old image changes nothing. Update lockfiles and base images, then roll out.
- Verify what is loaded, not what is installed: the version the running runtime reports, the image digest in production, the process list after the restart.
- Review the logs with the indicators above. Where you find crash series together with outbound connections you cannot explain, treat the host as compromised: isolate it, rotate the credentials the process could read, rebuild from a known state.
If you cannot update today
Each of these measures closes one path. None of them replaces the update.
| Measure | Effect | Limit |
|---|---|---|
Reject request bodies with Content-Encoding: br at the proxy, load balancer or middleware. For nginx one form is if ($http_content_encoding ~* br) { return 415; }, verify it for your setup | Closes the inbound path | Does nothing against Brotli responses that server-side HTTP clients fetch |
Python: uninstall Brotli and brotlicffi until the fixed versions are deployed | HTTP clients fall back to gzip and deflate, the decoder is gone | Breaks code that calls the package directly |
Remove br from the Accept-Encoding header of outbound requests | None that you can rely on | A hostile server can answer with Brotli anyway. The client must not decode it |
.NET: make sure request decompression and AutomaticDecompression with Brotli are not enabled, keep BrotliStream and BrotliDecoder away from untrusted input | Closes the .NET paths | These are off by default, so this matters only where someone switched them on |
| Envoy, Istio: disable the Brotli decompressor filter in both directions | Removes the decoder from the data path | Changes what the backends receive, so test it before the rollout |
| Disable Brotli compression on the origin or the CDN | None | The bug is in the decoder, not in the encoder |
| WAF rules | Block known request shapes | Partial, and blind to the outbound path |
Hardening that limits the damage
None of this prevents the out-of-bounds write. It decides how far an attacker gets afterwards and how quickly you notice.
- Restrict outbound traffic. A service that fetches URLs should reach only the destinations it needs. Egress filtering shrinks the outbound path and hinders a follow-on stage that has to download something.
- Run decoders with few privileges. A separate low-privilege user, a read-only root filesystem in containers and no credentials in the environment that the process does not need.
- Keep exploit mitigations on, and do not count on them. Red Hat lists ASLR, NX, FORTIFY_SOURCE and SELinux as factors that make reliable code execution harder. ELLIO reports a test setup in which the public chain succeeded sooner with ASLR enabled than without. Hardening is not a substitute for the fix.
- Inventory every copy continuously. Generate an SBOM in CI and treat bundled and statically linked libraries as assets of their own, with an owner and an update path.
- Alert on crashing workers. A process that is restarted by its supervisor again and again is the most visible trace of this bug class.
What it means for a penetration test
This CVE shows that the attack surface of a web application includes the libraries inside its runtime and the requests the server sends out itself. In a web application penetration test we therefore ask which runtime in which build serves the application, which features fetch external URLs, and what a compromised worker could reach. For CVE-2026-111497 we verify exposure through versions and configuration: the runtime and package versions, the middleware and client settings, the proxy rules. We do not send triggering inputs to production systems, because the most likely outcome is a crashed worker and the result adds nothing that the version does not already tell.
FAQ
Frequently asked questions
We updated the libbrotli package of the operating system. Is Node.js fixed now?
No. Node.js compiles its own copy of the Brotli decoder into the runtime binary, and so do Bun, self-contained and NativeAOT .NET applications and Go binaries that use andybalholm/brotli. The system package only helps processes that load the shared library dynamically, and only after they have been restarted. For everything else you need a fixed runtime version or a rebuilt binary.
Our application never calls a Brotli function. Can it still be affected?
Yes. In Node.js the built-in fetch() decompresses Brotli responses automatically, and in Python urllib3, and with it requests, decodes Brotli as soon as the Brotli or brotlicffi package is installed. A server that fetches URLs, webhooks or link previews can therefore reach the decoder without a single Brotli call in its own code.
Is it enough to block Content-Encoding: br at the proxy?
No. That closes the inbound path through request bodies only. It does nothing when the server itself fetches a response from a host the attacker controls, because that data arrives as a response and never passes the inbound filter. Treat the block as a bridge until the update is deployed.
Is the vulnerability exploited in the wild?
CISA added it to the Known Exploited Vulnerabilities catalogue on 27 October 2026. ELLIO documented one attempt in the wild on 26 October 2026 that used a defective final stage. A successful compromise in the wild has not been publicly confirmed as of 19 November 2026, so treat the flaw as actively targeted and patch accordingly.