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

  1. 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_inventory
    SELECT 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.

  2. 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_activity
    SELECT 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 ASC

    What a hit looks like. Rarely seen versions on a small number of hosts. These are the primary targets for remediation review.

  3. 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_activity
    SELECT 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.

  4. Agent triage

    Evaluate exposure and behavior

    Correlate the presence of vulnerable versions with the prevalence outliers and any suspicious behavioral signals.

  5. Decision

    Route by risk level

    Determine whether the evidence warrants an immediate remediation task or a standard close-out.

  6. Analyst task

    Prioritize patching and investigation

    Address the high-risk exposure identified by the hunt.

  7. Analyst task

    Finalize hunt report

    Document findings and identify remaining blind spots.

Coverage

2 of 3 stages covered

Stage and ATT&CK techniqueCoveredHow, 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

ParameterTypeDefaultWhat it is
affected_package_nameslist[string]node, nodejs, bun, brotli, brotlicffi, envoyPackage names associated with the vulnerable decoder.
lookback_daysnumber14Days of history to examine.
scope_hostslist[host]noneOptional list of hostnames to focus the hunt on.
suspicious_shellslist[string]sh, bash, cmd.exe, powershell.exe, zshShells that should not be spawned by a web server.

Data sources

SourceCategoryTelemetry
Endpoint telemetry (hb_ surfaces)endpointendpoint

Source

An open hunt.md file. It runs anywhere that reads the format.

hunt.md
---
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.

Content pack

Sign up to open

Pack contents open in Huntbase.