---
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
