How this bug class keeps getting shipped

CISA's Known Exploited Vulnerabilities catalog, which federal agencies track under BOD 26-04 (Prioritizing Security Updates Based on Risk), added two unchecked return value bugs in the same week: CVE-2026-111497 in Google's Brotli decoder (added 2026-10-27) and CVE-2026-76418 in Cisco Secure Firewall ASA and FTD software (added 2026-10-29). Different vendors, different languages, different impact (one yields memory corruption and potential code execution, the other collapses an SSL VPN head-end into a reboot loop), yet the root cause label is identical. This is a recurring failure mode that slips past code review, fuzzers, and SAST because the dangerous code looks ordinary on the page.

This post dissects the class with the Brotli bug as the lead case, then shows how the same pattern explains the Cisco DoS. By the end you should know what the flaw actually is, what an attacker needs to trigger it, and how to determine whether your estate is exposed without waiting for a vendor hotline.

The anatomy of an unchecked return

An unchecked return value vulnerability is a broken error-handling contract. A called function signals failure through a sentinel (-1, NULL, BROTLI_FAILURE, a negative errno); the caller must branch on that sentinel before touching any state the callee was supposed to populate. When it does not, three bad outcomes follow:

  1. State the callee never initialized is read as though valid.
  2. Partial writes made before the failure are treated as complete.
  3. Downstream code dereferences a pointer the callee set to NULL on the error path.

Each outcome maps to a different CWE, which is why the class is hard to grep for. The common shape in C looks like this:

/* Pattern that keeps shipping, abbreviated for clarity */
size_t out_len;
uint8_t *out_buf = decoder_state->scratch;

/* Caller trusts side effects even when the call fails. */
BrotliDecoderResult r = BrotliDecoderDecompressStream(
    state, &in_len, &in_ptr, &out_len, &out_ptr, NULL);

/* Missing: if (r == BROTLI_DECODER_RESULT_ERROR) goto fail; */

memcpy(dest, out_buf, out_len);   /* out_len may be stale or attacker-shaped */
state->next_block = out_ptr;      /* adjacent decoder state now corrupted  */

The compiler will not complain. A code reviewer scanning for strcpy or system( will not blink. The only reliable way to catch this pattern is to encode each consumed API's error contract into a lint rule and run it continuously.

Lead: CVE-2026-111497 in Brotli

CISA's KEV entry describes CVE-2026-111497 as an unchecked return value in Google Brotli that "allows a remote unauthenticated attacker to corrupt adjacent decoder state memory, disclose sensitive memory contents, cause a denial of service, or potentially execute arbitrary code using a crafted Brotli-compressed stream." The attacker's input is a compressed stream, so any surface that accepts a Content-Encoding: br is in scope: HTTP reverse proxies, API gateways, image optimizers, log shippers, service meshes, and anything embedding a Brotli decoder in a native extension.

The breadth of those embeddings is why this bug appears in multiple first-party advisories. Cisco published guidance on 2026-11-03 covering Node.js's inclusion of a vulnerable Brotli decoder across the 22.x, 24.x, and 26.x release lines, identifying traffic interception and remote code execution risk. Any Node service accepting Brotli-compressed request bodies must be rebuilt against a patched Node and redeployed. The underlying C library also ships inside dozens of other runtimes: browsers, CDNs, mobile SDKs, and language bindings that statically link libbrotli. A yum update brotli on the host does nothing for a statically linked copy inside a container image.

Exposure triage without an SBOM is painful but tractable. For a Linux fleet, start here:

# Find dynamically linked copies
find / -xdev -name 'libbrotli*' 2>/dev/null | xargs -I{} sh -c 'echo === {}; sha256sum {}'

# Statically linked symbols inside running binaries
for pid in $(pgrep -a . | awk '{print $1}'); do
  grep -lE 'BrotliDecoderDecompressStream|BrotliDecoderCreateInstance' \
    /proc/$pid/maps 2>/dev/null && echo "pid=$pid uses brotli statically"
done

# Node applications accepting br on ingress
grep -R --include='*.js' -nE "accept-encoding.*br|brotliDecompress" .

For HTTP-facing systems, the quickest compensating control while rollout is in flight is to strip Content-Encoding: br on request bodies at the perimeter and refuse to negotiate br on responses from untrusted upstreams. That is a measurable, enforceable configuration change verifiable with a packet capture.

Secondary: CVE-2026-76418 in Cisco Secure Firewall ASA and FTD

The second KEV entry carries the same root cause but a far narrower blast radius. Cisco's 2026-11-03 advisory describes "logic errors when secondary authentication is configured on a tunnel group" in the Remote Access SSL VPN service. CISA's KEV wording labels it an "unchecked return value to NULL pointer dereference." The failure path is textbook: the secondary authentication helper returns an error, the caller skips the check, and a pointer the helper would have populated is dereferenced moments later, crashing the data plane and triggering a reboot.

The attacker is unauthenticated and remote, over the SSL VPN listener. Exposure depends on whether the appliance has a tunnel group configured with secondary authentication and whether its SSL VPN is Internet-reachable. On ASA, verify both in two commands:

show running-config tunnel-group | include secondary-authentication-server-group
show running-config | include "webvpn|ssl trust-point|enable outside"

If both match on any Internet-facing interface, treat the appliance as exposed until the fixed train is deployed. This bug is not a code execution primitive, not an authentication bypass, and not a credential leak. Describing it as any of those will cost credibility with the people who must act on the fix. Scope it as the KEV catalog describes and move on.

Why the class keeps shipping

Three structural reasons, all addressable.

First, API error contracts are documented in prose, not in types. A function that returns BrotliDecoderResult could return a sum type the compiler forces the caller to destructure. Where you cannot change the library, wrap it: every call site goes through a thin adapter that asserts the success sentinel and aborts in debug builds.

Second, fuzzers find crashes, not missing branches. A decoder that silently corrupts an adjacent state struct will pass AFL for days. Differential fuzzing (feed the same input to the library and a reference oracle, flag divergence in observable state) catches these cases where crash-only fuzzing does not.

Third, SBOMs still misrepresent statically linked code. If your supply chain inventory is a list of OS packages, you will miss every embedded copy of libbrotli and every vendored httpd2. Build-time SBOM generation that walks link maps is the only approach that scales.

Patch, rebuild dependents, and verify at the perimeter. Then write the lint rule that would have caught the next one.

Verifiable security.