Vulnerabilities in node.js Affecting Cisco Products: October 2026
Cisco has published a bundled advisory, "Vulnerabilities in node.js Affecting Cisco Products: October 2026," covering the Node.js project's security release across the 22.x, 24.x, and 26.x supported lines. The advisory identifies defects in three critical runtime surfaces: the Brotli decoder, DNS resolution, and TLS certificate validation. In Cisco's words, the issues "pose risks for remote code execution and traffic interception," and each carries a Security Impact Rating of High.
The analysis centers on CVE-2026-111497 (Brotli decoder out-of-bounds) because it is the most reachable from the untrusted edge of a typical web application and the most urgent to triage before the CVE appears in CISA's Known Exploited Vulnerabilities (KEV) catalog. The TLS certificate validation defect appears only where it affects exposure modelling. The DNS resolver defect is deferred pending full publication of the Node.js advisory text.
What CVE-2026-111497 actually is
Brotli is a general-purpose compression format standardised in RFC 7932. Node.js exposes Brotli encode and decode primitives through the zlib module (zlib.createBrotliDecompress, zlib.brotliDecompressSync, and the streaming variants). The HTTP client and server reuse these for Content-Encoding: br handling, fetch() reuses them for response decoding, and many user-space libraries that accept compressed payloads pull them in transitively.
Cisco's advisory describes CVE-2026-111497 as a Brotli decoder out-of-bounds condition. Out-of-bounds defects in native decoders follow a well-understood exploitation pattern: an attacker-controlled, malformed compressed stream drives the decoder into a state where it reads or writes outside the bounds of a sliding window, ring buffer, or output slice. An OOB write is a plausible path to memory corruption and, downstream, to remote code execution. OOB reads lend themselves to information disclosure (adjacent heap contents, pointers useful for an ASLR break) and are often chained with a second primitive to reach code execution.
Node.js's Brotli bindings run in-process, so a successful corruption primitive executes with the privileges of the Node.js process. In Cisco product contexts, host privilege ranges from a web UI daemon up to appliance root, which is why the SIR of High maps to concrete, severe outcomes on specific products.
The precondition an attacker needs
To exploit this defect, an attacker needs one thing: the ability to make a vulnerable Node.js process decode a Brotli stream they control. In order of decreasing commonality:
- The Node.js process is an HTTP or HTTPS server that accepts
Content-Encoding: bron request bodies. Any public endpoint that callsreq.bodyafter an Express body parser, Fastify content-type parser, or similar is a candidate. - The Node.js process is an HTTP client that fetches arbitrary URLs on behalf of users (webhooks, SSRF-adjacent features, link previews, OAuth discovery, OpenAPI/Swagger ingestion, SBOM pulls). A hostile upstream returns
Content-Encoding: brwith a crafted body. - The process is a WebSocket server using
permessage-deflate-style negotiation, a GraphQL gateway, or an SMTP/IMAP handler feeding compressed MIME parts into a Node.js decoder. - The process ingests files uploaded by users and runs them through a parser that calls into Brotli.
Authentication is often not required. In the HTTP server case, if the body parser decompresses before auth middleware runs, the vulnerable code path is reachable pre-auth. In the client case, exploitation requires only that your Node.js service fetch a URL under the attacker's control.
The companion TLS certificate validation defect in the same advisory widens case 2. If a product's Node.js client treats an invalid chain as valid, an on-path attacker can inject a crafted Brotli response into traffic the client expected to be authenticated, expanding the attacker set from the owner of a hostile upstream to any adversary on the network path.
How to determine exposure
Treat this as a two-pass inventory.
Pass one: runtime inventory. Enumerate every Node.js runtime your estate runs, not just the ones you intend to run. In Cisco product environments, that means Cisco's own bundled Node.js, not an OS package. The Node.js lines that received fixes are 22.x, 24.x, and 26.x. Any running process on an older or unpatched point release in those lines is suspect until the Cisco product-level advisory confirms otherwise; Cisco's bulletin ties specific product versions to fixed releases.
A quick walk of a Linux host:
# Running Node.js processes and their binaries
sudo ss -lntp 2>/dev/null | awk '/node/'
for pid in $(pgrep -x node); do
echo "pid=$pid exe=$(readlink -f /proc/$pid/exe) ver=$($(readlink -f /proc/$pid/exe) -v 2>/dev/null)"
done
# Container images in use
sudo crictl images 2>/dev/null | awk 'NR>1 {print $1":"$2}' \
| xargs -I{} sh -c 'echo "== {} ==" ; docker run --rm --entrypoint node {} -v 2>/dev/null'
# Static sweep for bundled runtimes
sudo find / -xdev -type f \( -name node -o -name 'node-v*' \) 2>/dev/null \
| while read f; do printf "%s\t%s\n" "$f" "$("$f" -v 2>/dev/null)"; done
Pass two: reachability of the Brotli surface. For each Node.js workload under your control, confirm whether request-body or response-body Brotli decoding is reachable from an untrusted principal. Grep is a reasonable first filter:
rg -n "brotliDecompress|createBrotliDecompress|BROTLI_DECODE|accept-encoding.*br|content-encoding.*br" \
--type js --type ts --type json
For Cisco appliances you lack source access to, exposure depends on the product version listed in the bulletin and whether the exposed interfaces support Brotli. Probe a representative endpoint (use your inventory host, not example.com in production) to see whether the server advertises or accepts br:
curl -skI -H 'Accept-Encoding: br' https://appliance.example.com/ \
| grep -i -E 'server|content-encoding|vary'
Note: absence of Content-Encoding: br on a cached response does not prove the server cannot decode an inbound Brotli body. Where the vendor confirms the product bundles a vulnerable Node.js, treat the surface as reachable until the fixed image is deployed.
What to do before this reaches the exploited-in-the-wild lists
The Node.js project has shipped fixed releases on the 22.x, 24.x, and 26.x lines; Cisco's advisory enumerates the product rebuilds that consume them. Three actions, in order of value:
- Patch the Node.js runtime wherever you control it. For services you build, pin to the fixed minor on the line you run and rebuild images.
- For Cisco-managed products, map each affected product to its fixed train in the vendor bulletin and schedule the upgrade. Where no fix is yet available for a specific product, record the gap and compensate with network controls that remove untrusted Brotli reachability from the device.
- Where immediate patching is infeasible, strip or reject
Content-Encoding: brat an upstream reverse proxy for request paths that do not require it, and restrict outbound HTTP clients inside Node.js services from fetching arbitrary user-supplied URLs.
Under CISA's current KEV remediation directive, BOD 26-04 (Prioritizing Security Updates Based on Risk), federal civilian agencies must remediate KEV-listed vulnerabilities on the schedule the directive sets once a CVE is added to the catalog. CVE-2026-111497 is not on KEV at the time of writing; two PHP CVEs added on 2026-10-26 (CVE-2026-109618, CVE-2026-109619) are a reminder that native-decoder and runtime-level RCEs do not sit idle for long. Prioritise accordingly.
Verifiable security.