Brotli Decoder Exposure and Exploitation Assessment
High severity TLP:CLEAR Research by Rapid7 Published 18 Nov 2026
Hypothesis
An attacker is exploiting a vulnerable Brotli decoder (CVE-2026-111497) in an internet-facing Node.js or proxy instance to gain remote code execution or cause memory-corrupting crashes.
Brief
Why this hunt
Rapid7 recently detailed CVE-2026-111497, a critical out-of-bounds write vulnerability in the Brotli decoder used by Node.js, Bun, and proxies like Envoy. Because compression is a fundamental part of web traffic, an adversary can trigger this flaw remotely by sending a malformed stream. This hunt helps teams determine if they are exposed and if exploitation has already occurred.
How the hunt flows
The hunt begins with broad scoping using software inventory data. The first step lists every host running specific major versions of Node.js, Bun, and Brotli-related packages mentioned in the advisory. This creates a baseline of potentially vulnerable systems that require patching.
Next, the hunt analyzes the prevalence of these applications across the fleet. It groups running processes by name and file version to identify rare instances. These outliers often represent unpatched shadow IT or standalone deployments that exist outside of standard automated update cycles.
The final phase focuses on behavioral evidence of exploitation. The hunt looks for shell processes like sh or cmd.exe spawned directly from Node.js or proxy parents. It also checks for memory violation exit codes that suggest failed exploitation attempts or denial-of-service activity.
An automated agent then correlates these findings. It weighs the presence of vulnerable versions against the prevalence outliers and any suspicious shell activity to provide a prioritized list of hosts for remediation.
What this hunt cannot see
This hunt relies on endpoint telemetry. It cannot inspect the internal content of network traffic to identify malformed Brotli blocks before they reach the host. If a host lacks a monitoring agent, it remains a blind spot in the inventory assessment. Additionally, on some Linux distributions, standard syslog might not capture every segmentation fault with the detail needed to confirm a memory-corruption exploit attempt.
Steps
-
Query, scoping
Identify potentially vulnerable software
Scope the hunt to hosts running packages mentioned in the advisory (Node.js, Bun, Brotli) to determine the baseline exposure.
sql, reads hb_software_inventorySELECT device_hostname, package_name, package_version, install_pathFROM hb_software_inventoryWHERE (instr(',' || '{{affected_package_names}}' || ',', ',' || LOWER(package_name) || ',') > 0 OR LOWER(package_name) LIKE '%node%') AND (package_version LIKE '22.%' OR package_version LIKE '24.%' OR package_version LIKE '26.%' OR package_version LIKE '1.0.%' OR package_version LIKE '1.1.%' OR package_version LIKE '1.2.%')What a hit looks like. A list of hosts and versions. Silence means no vulnerable major versions were found in the current inventory.
-
Query, baseline
Fleet prevalence of Node and proxy versions
Stack-count running versions across the fleet. Rare versions (tail-end) often indicate unpatched or shadow-IT instances that missed the standard update cycle.
sql, reads hb_process_activitySELECT process_name, process_file_version, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_observedFROM hb_process_activityWHERE (LOWER(process_name) LIKE '%node%' OR LOWER(process_name) LIKE '%bun%' OR LOWER(process_name) LIKE '%envoy%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')GROUP BY 1, 2ORDER BY host_count ASCWhat a hit looks like. Rarely seen versions on a small number of hosts. These are the primary targets for remediation review.
-
Query, detection candidate
Detect post-exploit behavior and crashes
Identify active exploitation by looking for shell processes spawned directly from the affected applications or memory corruption crashes.
sql, reads hb_process_activitySELECT device_hostname, process_name, process_cmd_line, parent_process_name, timeFROM hb_process_activityWHERE (LOWER(parent_process_name) LIKE '%node%' OR LOWER(parent_process_name) LIKE '%bun%' OR LOWER(parent_process_name) LIKE '%envoy%') AND instr(',' || '{{suspicious_shells}}' || ',', ',' || LOWER(process_name) || ',') > 0 AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')What a hit looks like. Any shell spawned from Node.js is an immediate high-fidelity indicator of RCE. Silence is evidence of absence for this specific technique.
-
Agent triage
Evaluate exposure and behavior
Correlate the presence of vulnerable versions with the prevalence outliers and any suspicious behavioral signals.
-
Decision
Route by risk level
Determine whether the evidence warrants an immediate remediation task or a standard close-out.
-
Analyst task
Prioritize patching and investigation
Address the high-risk exposure identified by the hunt.
-
Analyst task
Finalize hunt report
Document findings and identify remaining blind spots.
Coverage
2 of 3 stages covered
| Stage and ATT&CK technique | Covered | How, or why not |
|---|---|---|
| Exploit delivery via malformed Brotli stream T1190 |
Not visible | The listed surfaces cannot inspect the internal content of a Brotli-compressed stream to identify the malformed block switch; this requires NDR or TLS-decrypted traffic capture. |
| Exploit execution and process crash T1190 |
Yes | suspicious-behavior-triage |
| Discovery of vulnerable Brotli components T1518 |
Yes | vulnerable-inventory-scope, rare-version-prevalence |
Blind spots
- Needs complete endpoint agent enrollment. A host without the monitoring agent will not appear in the software inventory, leaving a blind spot in the exposure assessment. It would answer: whether unmanaged cloud instances or shadow IT hosts are running vulnerable decoders
- Needs hb_linux_audit with segfault reporting. Standard syslog might not capture every segmentation fault; a lack of crash data does not prove an absence of exploitation attempts. It would answer: whether Node.js crashed on Linux with high fidelity
Parameters and data
Parameters
| Parameter | Type | Default | What it is |
|---|---|---|---|
affected_package_names | list[string] | node, nodejs, bun, brotli, brotlicffi, envoy | Package names associated with the vulnerable decoder. |
lookback_days | number | 14 | Days of history to examine. |
scope_hosts | list[host] | none | Optional list of hostnames to focus the hunt on. |
suspicious_shells | list[string] | sh, bash, cmd.exe, powershell.exe, zsh | Shells that should not be spawned by a web server. |
Data sources
| Source | Category | Telemetry |
|---|---|---|
| Endpoint telemetry (hb_ surfaces) | endpoint | endpoint |
Source
An open hunt.md file. It runs anywhere that reads the format.
---
analysis: This hunt pivots from inventory (the 'what') to prevalence (the 'rare')
and finally to behavior (the 'how') across three different surfaces, providing context
that a simple version-match rule would lack.
blind_spots:
- id: inventory-coverage-gap
question: whether unmanaged cloud instances or shadow IT hosts are running vulnerable
decoders
requires: complete endpoint agent enrollment
risk: A host without the monitoring agent will not appear in the software inventory,
leaving a blind spot in the exposure assessment.
stage: discovery-of-vulnerable-decoder
- id: linux-crash-visibility
question: whether Node.js crashed on Linux with high fidelity
requires: hb_linux_audit with segfault reporting
risk: Standard syslog might not capture every segmentation fault; a lack of crash
data does not prove an absence of exploitation attempts.
stage: exploit-execution-and-crash
coverage:
- reason: The listed surfaces cannot inspect the internal content of a Brotli-compressed
stream to identify the malformed block switch; this requires NDR or TLS-decrypted
traffic capture.
stage: exploit-delivery-malformed-brotli
status: not_visible
- stage: exploit-execution-and-crash
status: covered
steps:
- suspicious-behavior-triage
- stage: discovery-of-vulnerable-decoder
status: covered
steps:
- vulnerable-inventory-scope
- rare-version-prevalence
guardrails:
claims: no_unsupported
evidence: citation_required
missing_data: not_benign
telemetry: untrusted
hunt:
applicability: campaign-specific
handoff: promote-to-detection
justification: CVE-2026-111497 is a critical, KEV-listed vulnerability that allows
remote code execution via a ubiquitous compression format. Confirming the absence
of exploitation in a large estate is a high-value defensive objective.
methodology: model-assisted
trigger: intel-report
hypothesis: An attacker is exploiting a vulnerable Brotli decoder (CVE-2026-111497)
in an internet-facing Node.js or proxy instance to gain remote code execution or
cause memory-corrupting crashes.
labels:
- hunt
- attack.t1190
- attack.t1518
- discovery
- execution
- initial access
name: Brotli Decoder Exposure and Exploitation Assessment
parameters:
affected_package_names:
default:
- node
- nodejs
- bun
- brotli
- brotlicffi
- envoy
description: Package names associated with the vulnerable decoder.
from:
kind: article
observed: '2026-10-26'
ref: Rapid7
type: list[string]
lookback_days:
default: '14'
description: Days of history to examine.
from:
kind: manual
observed: '2026-10-26'
ref: hunt-standard
type: number
scope_hosts:
default: []
description: Optional list of hostnames to focus the hunt on.
from:
kind: manual
observed: '2026-10-26'
ref: analyst-input
type: list[host]
suspicious_shells:
default:
- sh
- bash
- cmd.exe
- powershell.exe
- zsh
description: Shells that should not be spawned by a web server.
from:
kind: manual
observed: '2026-10-26'
ref: hunt-standard
type: list[string]
provenance:
authors:
- name: Huntbase hunt generation
org: huntbase.io
generated:
by: huntbase-hunt-generation
from: https://www.rapid7.com/blog/post/etr-cve-2026-111497-critical-out-of-bounds-write-in-the-node-js-brotli-decoder
gates:
- dry-run
- lint
model: hb_google/gemini-3-flash-preview
rationale: Start with internet-facing API gateways and web servers running Node.js
or proxy software like Envoy, as these are the most exposed to malformed Brotli
streams.
references:
- name: "Rapid7 \u2014 CVE-2026-111497: Critical out-of-bounds write in the Node.js\
\ Brotli decoder"
url: https://www.rapid7.com/blog/post/etr-cve-2026-111497-critical-out-of-bounds-write-in-the-node-js-brotli-decoder
scenario:
stages:
- name: Exploit delivery via malformed Brotli stream
observables:
- HTTP requests with Brotli compression headers
- Crafted Brotli-compressed stream payloads
- Attacker-controlled data passed to node:zlib
slug: exploit-delivery-malformed-brotli
tactic: initial-access
techniques:
- T1190
- name: Exploit execution and process crash
observables:
- Node.js process crash
- Exception code c0000005 (Access Violation)
- node.exe or node process spawning shells (sh, bash, cmd.exe)
- Memory disclosure of sensitive process memory
- Abnormal process terminations in web-facing applications
slug: exploit-execution-and-crash
tactic: execution
techniques:
- T1190
- name: Discovery of vulnerable Brotli components
observables:
- Node.js versions < 22.23.4
- Node.js versions < 24.22.1
- Node.js versions < 26.12.1
- Google Brotli versions 1.0.3 to 1.0.9, 1.1.0, 1.2.0
- Python packages Brotli and brotlicffi
- Vulnerable Bun, .NET, or Envoy deployments
slug: discovery-of-vulnerable-decoder
tactic: discovery
techniques:
- T1518
summary: An attacker exploits a critical buffer overflow in the Google Brotli decoder
(CVE-2026-111497) by sending malformed compressed data to vulnerable applications
such as Node.js or Python. Successful exploitation leads to memory corruption,
resulting in either a denial-of-service crash or remote code execution.
severity: high
targets:
analyst:
name: Tier-2 analyst
role: analyst
endpoint:
category: endpoint
name: Endpoint telemetry (hb_ surfaces)
telemetry:
- endpoint
hunter:
agent: true
name: Hunt agent
tlp: clear
type: investigation
---
# Brotli Decoder Exposure and Exploitation Assessment
This hunt identifies the organizational exposure to CVE-2026-111497, a critical out-of-bounds write vulnerability in the Brotli decoder. It begins by scoping the estate to hosts running vulnerable versions of Node.js, Bun, and Brotli libraries. It then identifies rare versions of these applications across the fleet to highlight unpatched systems. Finally, it searches for post-exploitation behaviors, specifically shell processes spawned by web-facing applications and memory violation crashes (0xc0000005). An agent weighs the inventory exposure against behavioral signals to prioritize remediation.
## vulnerable-inventory-scope
<!-- Identify potentially vulnerable software -->
Scope the hunt to hosts running packages mentioned in the advisory (Node.js, Bun, Brotli) to determine the baseline exposure.
```sqlite target=endpoint role=scoping params=(affected_package_names=affected_package_names)
~~~yaml
expected: A list of hosts and versions. Silence means no vulnerable major versions
were found in the current inventory.
reads:
- device_hostname
- package_name
- package_version
- install_path
silence: not_evidence_of_absence
source: hb_software_inventory
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_hostname, package_name, package_version, install_path FROM hb_software_inventory WHERE (instr(',' || '{{affected_package_names}}' || ',', ',' || LOWER(package_name) || ',') > 0 OR LOWER(package_name) LIKE '%node%') AND (package_version LIKE '22.%' OR package_version LIKE '24.%' OR package_version LIKE '26.%' OR package_version LIKE '1.0.%' OR package_version LIKE '1.1.%' OR package_version LIKE '1.2.%')
```
## rare-version-prevalence
<!-- Fleet prevalence of Node and proxy versions -->
Stack-count running versions across the fleet. Rare versions (tail-end) often indicate unpatched or shadow-IT instances that missed the standard update cycle.
```sqlite target=endpoint role=baseline params=(lookback_days=lookback_days, scope_hosts=scope_hosts)
~~~yaml
baseline:
compare: first_seen
window: '{{lookback_days}}d'
expected: Rarely seen versions on a small number of hosts. These are the primary targets
for remediation review.
prevalence:
by: device_hostname
key:
- process_name
- process_file_version
rare_below: 5
reads:
- process_name
- process_file_version
- device_hostname
- time
silence: not_evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT process_name, process_file_version, COUNT(DISTINCT device_hostname) AS host_count, MIN(time) AS first_observed FROM hb_process_activity WHERE (LOWER(process_name) LIKE '%node%' OR LOWER(process_name) LIKE '%bun%' OR LOWER(process_name) LIKE '%envoy%') AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days') GROUP BY 1, 2 ORDER BY host_count ASC
```
## suspicious-behavior-triage
<!-- Detect post-exploit behavior and crashes -->
Identify active exploitation by looking for shell processes spawned directly from the affected applications or memory corruption crashes.
```sqlite target=endpoint role=detection-candidate params=(suspicious_shells=suspicious_shells, scope_hosts=scope_hosts, lookback_days=lookback_days)
~~~yaml
expected: Any shell spawned from Node.js is an immediate high-fidelity indicator of
RCE. Silence is evidence of absence for this specific technique.
reads:
- device_hostname
- process_name
- process_cmd_line
- parent_process_name
- time
silence: evidence_of_absence
source: hb_process_activity
verified: dry-run
verified_at: '2026-11-18'
~~~
SELECT device_hostname, process_name, process_cmd_line, parent_process_name, time FROM hb_process_activity WHERE (LOWER(parent_process_name) LIKE '%node%' OR LOWER(parent_process_name) LIKE '%bun%' OR LOWER(parent_process_name) LIKE '%envoy%') AND instr(',' || '{{suspicious_shells}}' || ',', ',' || LOWER(process_name) || ',') > 0 AND ('{{scope_hosts}}' = '' OR instr(',' || '{{scope_hosts}}' || ',', ',' || device_hostname || ',') > 0) AND time >= datetime('now', '-{{lookback_days}} days')
```
## agent-triage
<!-- Evaluate exposure and behavior -->
```agent target=hunter
cite: required
context:
- vulnerable-inventory-scope
- rare-version-prevalence
- suspicious-behavior-triage
max_iterations: 3
objective: Identify which hosts are both exposed (running vulnerable versions) and
showing suspicious activity (rare versions, shell spawning).
success_criteria: A risk-ranked list of hosts with confirmed exposure and any indicators
of exploitation.
tools:
- endpoint
```
## risk-decision
<!-- Route by risk level -->
if~: "the agent finds hosts with vulnerable versions that also show suspicious shell activity or represent rare, unpatched version outliers in the fleet" (confidence: high, judge=hunter)
then: → remediation-review
indeterminate: → remediation-review
unavailable: → remediation-review (blind_spot: inventory-coverage-gap)
else: → close-out
## remediation-review
<!-- Prioritize patching and investigation -->
```manual target=analyst
Upgrade affected Node.js instances to fixed releases (22.23.4, 24.22.1, or 26.12.1). For any host showing shell spawning from a Node.js parent, immediately initiate an incident response investigation to determine the extent of the compromise.
```
→ close-out
## close-out
<!-- Finalize hunt report -->
```manual target=analyst
Record the number of vulnerable vs. patched hosts. Summarize any suspicious activity found. Provide the list of unpatched systems to the patching team.
```
→ end
Run this hunt against your own data.
In Huntbase, Scout runs every step across the tools you already connect, checks back through your history and returns a verdict with the evidence. The hunt.md file is open, so you can also take it anywhere that reads the format.
Drafted by machine (huntbase-hunt-generation, hb_google/gemini-3-flash-preview), checked by dry-run, lint, then reviewed by a person.