undici's dump interceptor reads and discards a response body up to a configurable maximum size.

CVE-2026-84947 affects undici's optional interceptors.dump() feature, which reads and discards HTTP response bodies up to a configurable maxSize (default 1 MiB). When an upstream server sends a chunked transfer-encoded response without a Content-Length header that exceeds maxSize, the interceptor terminates early but fails to properly abort the underlying request. The downstream application receives a misleading HTTP 200 status with a silently truncated body. Affected versions are v7.1.0 through v7.29.0 and v8.0.0 through v8.10.1, fixed in v7.29.1 and v8.10.2.

The vendor rated this LOW at CVSS 3.7, and that rating is accurate. The dump interceptor is explicitly opt-in — developers must manually compose it into their dispatcher chain. The attack requires a *malicious or compromised upstream server* sending specially crafted chunked responses, which already assumes significant attacker positioning. The impact is purely integrity-related: a truncated response body. There is no confidentiality breach, no remote code execution, and no denial of service. For the narrow population of Node.js applications that both use interceptors.dump() AND consume bodies from untrusted upstreams, this is a real but bounded concern.

Why this verdict

• Opt-in gating: The dump interceptor must be explicitly composed into the dispatcher chain. This is not a default behavior of undici or Node.js's built-in fetch(). The reachable population is a small subset of undici's ~150M weekly downloads.
• Attacker positioning: Exploitation requires the attacker to *be* or *control* the upstream HTTP server, or perform a network-level MITM. This is a server-side positioning requirement that dramatically narrows real-world exploitability.
• Integrity-only, bounded blast radius: The impact is a silently truncated response body. There is no path to code execution, privilege escalation, or data exfiltration. Applications with any form of response validation (JSON parsing, checksums, schema validation) will detect the truncation immediately.
• Role multiplier: undici is a general-purpose HTTP client library. In high-value roles (CI/CD pipelines fetching artifacts, API gateways proxying traffic), the dump interceptor could cause corrupted data to propagate — but only if explicitly enabled AND the upstream is malicious. In proxy/gateway deployments, dump is atypical because those applications *forward* response bodies rather than discard them. The blast radius even in worst-case scenarios is limited to a single truncated response per request, not fleet-scale or identity-scale compromise. No high-value role floor is triggered.

Why not higher?

There is no path to remote code execution, privilege escalation, or confidentiality breach. The feature is opt-in, requiring explicit developer action to enable the vulnerable code path. The attacker must already control an upstream server — a position that typically implies the attacker already has more impactful options than sending a truncated response.

Why not lower?

The vulnerability is real and can cause silent data corruption in applications that trust response integrity without secondary validation. In proxy or gateway patterns where the dump interceptor is used (however rarely), a truncated response forwarded downstream could cause application-level logic errors. Dismissing it entirely would be inappropriate for the narrow set of affected deployments.

1. Validate response body integrity at the application layer — Add JSON schema validation, content-length checks, or checksum verification on responses from untrusted upstreams. This catches any truncation regardless of the underlying HTTP client behavior. No SLA deadline — this is a LOW-severity backlog item.
2. Pin or upgrade undici to v7.29.1+ or v8.10.2+ — The patch enforces proper abort semantics when maxSize is exceeded. Since this is a library dependency, update via npm update undici or pin the version in package.json. Treat as backlog hygiene per noisgate LOW SLA.
3. Restrict dump interceptor usage to trusted upstreams only — If you use interceptors.dump(), ensure it is only composed on dispatchers that communicate with internal, trusted services — not arbitrary external endpoints. Review your dispatcher composition to confirm.

Run this on any host where Node.js applications are deployed. It checks the installed undici version via npm. Requires read access to the project's node_modules. Example: bash check_cve_2026_84947.sh /path/to/your/node/app

#!/usr/bin/env bash
# CVE-2026-84947 — undici dump interceptor response truncation
# Usage: bash check_cve_2026_84947.sh /path/to/node/project
# Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN

set -euo pipefail

PROJECT_DIR="${1:-.}"
PKG_JSON="$PROJECT_DIR/node_modules/undici/package.json"

if [ ! -f "$PKG_JSON" ]; then
  echo "UNKNOWN — undici not found in $PROJECT_DIR/node_modules"
  exit 2
fi

VERSION=$(grep '"version"' "$PKG_JSON" | head -1 | sed 's/.*"version": *"\([^"]*\)".*/\1/')

if [ -z "$VERSION" ]; then
  echo "UNKNOWN — could not parse undici version from $PKG_JSON"
  exit 2
fi

echo "Found undici version: $VERSION"

# Parse major.minor.patch
IFS='.' read -r MAJOR MINOR PATCH <<< "$VERSION"

# Affected: v7.1.0–v7.29.0, v8.0.0–v8.10.1
# Fixed: v7.29.1+, v8.10.2+
# Not affected: v6.x and below, v9.x and above (if exists)

if [ "$MAJOR" -lt 7 ]; then
  echo "PATCHED — undici $VERSION is not in the affected range (pre-v7)"
  exit 0
elif [ "$MAJOR" -eq 7 ]; then
  if [ "$MINOR" -lt 1 ]; then
    echo "PATCHED — undici $VERSION is before the affected range (v7.0.x)"
    exit 0
  elif [ "$MINOR" -lt 29 ]; then
    echo "VULNERABLE — undici $VERSION is in the affected range (v7.1.0–v7.28.x)"
    exit 1
  elif [ "$MINOR" -eq 29 ]; then
    if [ "$PATCH" -lt 1 ]; then
      echo "VULNERABLE — undici $VERSION is affected (v7.29.0)"
      exit 1
    else
      echo "PATCHED — undici $VERSION contains the fix (v7.29.1+)"
      exit 0
    fi
  else
    echo "PATCHED — undici $VERSION is above the affected range"
    exit 0
  fi
elif [ "$MAJOR" -eq 8 ]; then
  if [ "$MINOR" -lt 10 ]; then
    echo "VULNERABLE — undici $VERSION is in the affected range (v8.0.0–v8.9.x)"
    exit 1
  elif [ "$MINOR" -eq 10 ]; then
    if [ "$PATCH" -lt 2 ]; then
      echo "VULNERABLE — undici $VERSION is affected (v8.10.0–v8.10.1)"
      exit 1
    else
      echo "PATCHED — undici $VERSION contains the fix (v8.10.2+)"
      exit 0
    fi
  else
    echo "PATCHED — undici $VERSION is above the affected range"
    exit 0
  fi
else
  echo "PATCHED — undici $VERSION is above the affected major version range"
  exit 0
fi

Sources

1. GitHub Security Advisory GHSA-2gqq-gqf2-x968
2. undici Interceptors Documentation
3. undici npm Package
4. undici GitHub Releases
5. nodejs/undici Security Advisories Index
6. undici on Socket.dev (Security Analysis)
7. Node.js undici Tenable Plugin