CVE-2026-84947

Executive Summary

CVE-2026-84947 is an assertion-failure vulnerability in undici, the Node.js HTTP client library, affecting versions 7.1.0 through 7.29.1 and 8.0.0 through 8.10.2. The flaw resides in undici's dump interceptor, which reads and discards response bodies up to a configurable maximum size; when handling chunked responses (no Content-Length header), the interceptor signals completion early upon reaching the size limit without pausing the underlying parser, causing a second completion signal that trips an internal assertion and tears down the connection. Impact is limited to a low-severity integrity issue (CVSS 3.7): applications observe a misleading successful HTTP status with an empty or truncated body while the underlying connection has been terminated, potentially leading to incomplete data processing without error signals. No public exploit, PoC, or CISA KEV listing exists; patch confidence is 0/4, meaning no confirmed fix has been tracked.

Technical Analysis

The vulnerability resides in undici's "dump interceptor" — a mechanism designed to read and discard response body data up to a configurable maximum size threshold. The interceptor serves a resource-management purpose: it consumes response bodies that the application does not intend to process, bounded by an upper limit to prevent unbounded memory consumption.

The flaw's mechanism is a state-machine mismatch between the interceptor's accounting logic and the HTTP parser's delivery semantics, contingent on response framing:

1. Content-Length-framed responses: When a response declares a Content-Length header that exceeds the configured maximum dump size, the interceptor cleanly aborts the read operation. This is the intended/expected behavior — a bounded, controlled termination.

2. Chunked responses: When a response lacks Content-Length and uses chunked transfer encoding, the interceptor instead signals "completion" to the application as soon as the accumulated byte count reaches the configured maximum. Critically, it does not pause or abort the underlying HTTP parser's data delivery. The parser continues to receive body bytes from the network and delivers them to the interceptor's handlers. This second delivery triggers a second "completion" signal on the already-completed stream state.

The duplicate completion signal violates an internal invariant — an assertion in undici's state machine fires, indicating that a stream operation was attempted in an illegal state (e.g., completion emitted twice, or data delivered post-completion). The assertion aborts the request and tears down the underlying TCP/TLS connection.

From the application developer's perspective, the observable behavior is misleading: the request appears to have completed successfully (a successful HTTP status code is received), but the body is empty or truncated — and the connection has actually been forcibly closed due to the assertion-induced teardown. This creates a discrepancy between the logical success indicator (HTTP status) and the physical state (connection terminated, incomplete payload).

The vulnerability class is CWE-20 (Improper Input Validation) — the interceptor fails to correctly validate and handle the distinction between response framing types (Content-Length vs. chunked) when enforcing its size limit. The input that triggers the flaw is a malicious or anomalous HTTP response from a server — specifically, a chunked response whose total body size exceeds the configured dump maximum.

Attack surface: The affected component is client-side. Any Node.js application using undici as its HTTP client — whether directly (via the undici package API) or indirectly (via frameworks and libraries that wrap undici, such as Next.js, or fetch implementations built atop it) — that invokes the dump interceptor functionality on responses is exposed. The attacker-controlled input is the HTTP response received from a remote server. A malicious or compromised server, or a man-in-the-middle capable of modifying responses, can trigger the assertion and force connection teardown.

Technical detail depth: The NVD description provides the behavioral mechanism but does not expose internal function names, class names, or code paths beyond the generic "dump interceptor". Insufficient technical detail is available to identify the specific assertion location or the internal state machine transitions involved. The description is clear, however, on the trigger condition: chunked responses exceeding the configured dump size maximum cause premature completion signaling and subsequent assertion failure.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class and the NVD description.

Threat model: The attacker controls an HTTP server that the victim application connects to (either the application initiates outbound requests to attacker-controlled endpoints, or the attacker compromises/impersonates a server the application trusts). The victim application uses a vulnerable undici version and invokes the dump interceptor on responses.

Step 1 — Reconnaissance/target identification: An attacker operating a malicious server (or who has compromised a legitimate server) would first identify client applications using vulnerable undici versions (7.1.0 – 7.29.1, 8.0.0 – 8.10.2) that make outbound HTTP requests and apply the dump interceptor to responses. This could be determined by fingerprinting the application stack (e.g., identifying a specific Node.js service known to bundle vulnerable undici). No network-visible fingerprint exists for the library itself.

Step 2 — Flaw trigger: The attacker crafts an HTTP response that meets three conditions: (a) uses chunked transfer encoding (no Content-Length header), (b) declares no Content-Length while the total body size exceeds the victim's configured dump interceptor maximum, and (c) is delivered in multiple chunked frames such that the parser continues delivering bytes after the interceptor's accumulated size threshold is crossed.

Step 3 — Payload/execution: The response is served to the victim application during a routine outbound request. As the interceptor accumulates body bytes and crosses the configured maximum, it signals completion. The parser continues delivering the remaining chunked body bytes, generating a second completion signal. This trips the internal assertion, which aborts the request and forcibly closes the connection.

Step 4 — Post-exploitation impact: The application observes a successful HTTP status code (e.g., 200 OK) but receives an empty or truncated body, unaware that the connection was torn down. This creates an integrity failure: the application may process incomplete data as if it were complete, or proceed with logic that depends on the full response body. In scenarios where the dump interceptor is used to consume and discard bodies (e.g., draining connections for reuse, or discarding unwanted content), the connection pool state may also be corrupted — the torn-down connection may be erroneously returned to the pool, potentially causing subsequent requests to fail or misbehave. The CVSS vector (C:N/I:L/A:N) confirms the impact is limited to low integrity loss; no confidentiality impact (no data exfiltration or information disclosure mechanism is described) and no direct availability impact beyond the single-connection teardown.

Practical exploitation likelihood: Limited. Triggering requires: (1) the use of a deprecated dump-interceptor feature, (2) a server that emits chunked responses larger than the configured threshold, and (3) precise chunk-framing behavior to ensure the parser delivers bytes after the interceptor has already signaled completion. The CVSS Attack Complexity of High (AC:H) reflects these requirements. No exploit code exists, and no in-the-wild activity has been reported.

Impact Assessment

CVSS analysis: The base score of 3.7 (Low severity) breaks down as follows:

• Attack Vector: Network (AV:N) — remotely triggerable via HTTP responses.
• Attack Complexity: High (AC:H) — requires specific framing conditions and application configuration.
• Privileges Required: None (PR:N) — unauthenticated attacker can trigger if conditions are met.
• User Interaction: None (UI:N) — no victim interaction beyond automated request handling.
• Scope: Unchanged (S:U) — the impact stays within the vulnerable component.
• Confidentiality: None (C:N) — no information disclosure mechanism exists in the described flaw.
• Integrity: Low (I:L) — applications may process truncated/empty bodies as valid, leading to incorrect data handling.
• Availability: None (A:N) — the connection teardown is a single request; no sustained denial-of-service is described.

Affected systems: Node.js applications using undici 7.1.0–7.29.1 or 8.0.0–8.10.2 that exercise the dump interceptor. This includes direct users of the undici API and indirect users through frameworks such as Next.js (which historically bundled undici) or custom fetch implementations. Server-side components making outbound HTTP requests with response-body draining logic are the primary at-risk surface.

Business impact: Low-to-moderate. The primary risk is silent data corruption: applications relying on the dump interceptor to validate or drain responses may believe a request succeeded when the body was never fully received, potentially leading to inconsistent state, incorrect database writes, or flawed business logic execution based on truncated data. In connection-pool reuse scenarios, a torn-down connection returned to the pool could cause cascading request failures. However, the absence of confidentiality impact and lack of sustained availability impact keep the overall severity low.

Blast radius: Confined to the individual Node.js process and its outbound connection handling. No server-side data compromise, no lateral movement potential, and no cross-tenant impact within shared hosting environments. The attack requires the victim application to actively connect to a malicious or compromised server, limiting the attacker's ability to target specific victims.

Detection Guidance

Detection of this vulnerability is challenging because the trigger is a client-side assertion failure caused by server-controlled response framing. The observable artifacts occur locally on the victim host: process logs showing assertion failures, connection resets, or truncated-body errors. Network-level detection of the trigger is feasible only by inspecting response framing (chunked responses exceeding size thresholds) which is non-trivial at scale.

Sigma Rule

title: Undici Dump Interceptor Assertion Failure - CVE-2026-84947
id: 6a8c3f2e-9b41-4c7d-8e5a-1b2c3d4e5f6a
status: experimental
description: Detects undici assertion failures and connection teardown events consistent with CVE-2026-84947 exploitation. Triggers on internal assertion logs and abrupt connection closure following chunked response handling.
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-84947
author: Valters IT - Threat Intelligence
date: 2026/02/01
logsource:
    category: application
    product: nodejs
detection:
    selection_assertion:
        message|contains:
            - 'Assertion failed'
            - 'assertionError'
            - 'undici'
    selection_dump_term:
        message|contains|all:
            - 'dump'
            - 'abort'
            - 'connection'
    selection_proxy:
        message|contains:
            - 'ERR_HTTP2_ERROR'
            - 'ECONNRESET'
            - 'Client network socket disconnected'
    condition: selection_assertion and (selection_dump_term or selection_proxy)
    timeframe: 1h
level: medium
falsepositives:
    - Genuine undici assertion failures from internal bugs or resource exhaustion
    - Legitimate connection resets from network issues unrelated to this CVE

YARA Rule

rule undici_dump_interceptor_assertion_CVE_2026_84947
{
    meta:
        author = "Valters IT - Threat Intelligence"
        description = "Detects source code or log fragments referencing undici dump interceptor assertion failures consistent with CVE-2026-84947"
        cve = "CVE-2026-84947"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-84947"
        date = "2026-02-01"
        severity = "low"
    strings:
        $a = "dump" ascii wide
        $b = "interceptor" ascii wide
        $c = "Assertion failed" ascii wide nocase
        $d = "body exceeds" ascii wide nocase
        $e = "chunked" ascii wide nocase
        $f = "content-length" ascii wide nocase
        $g = "Connection closed" ascii wide nocase
    condition:
        uint16(0) == 0x5A4D or uint32(0) == 0x464C457F or filesize < 2MB and
        2 of ($a, $b, $c, $d) and 1 of ($e, $f, $g)
}

Suricata IDS Rule

Note: This vulnerability is triggered by server-framed chunked responses handled by a client-side library. Network detection is limited to observing responses that could trigger the flaw — specifically, chunked responses whose cumulative size exceeds normal application thresholds. The following rule detects anomalous chunked responses with excessive total body size that may be used to trigger the assertion.

alert http any any -> $HOME_NET any (msg:"Potential CVE-2026-84947 trigger - oversized chunked HTTP response"; flow:to_client; http.response_body; content:"%"; http.header; content:"Transfer-Encoding: chunked"; nocase; http.header; content:"!"; http.header; reference:cve,2026-84947; classtype:attempted-dos; sid:10084947; rev:1; metadata:created_at 2026_02_01, updated_at 2026_02_01;)

Detection caveat: This rule triggers on any oversized chunked response and may generate substantial false positives. Thresholds must be tuned to the application's expected dump-interceptor maximum. The rule is indicative only — Suricata cannot reliably correlate response size with client-side configuration without substantial state tracking.

Elastic Detection

// EQL query for Elastic SIEM - detect undici assertion failures and connection teardowns
sequence by host.name with maxspan=1h
  [ process where event.category == "process" and process.name == "node" and message like "*Assertion failed*" and message like "*undici*" ]
  [ network where event.category == "network" and event.type == "end" and network.direction == "egress" and network.protocol == "http" and network.bytes > 10000 ]

Note: The assertion failure and connection teardown occur nearly simultaneously in the same process, making event correlation challenging. SOCs should prioritize log-based detection from the Node.js runtime output over endpoint network telemetry.

Splunk SPL Query

index=nodejs OR index=application sourcetype=nodejs:log
("Assertion failed" OR "assertionError")
AND ("undici" OR "dump" OR "interceptor")
| eval cve_84947 = if(match(_raw, "(?i)(assertion|undici).*dump.*(chunked|content-length|abort)") OR match(_raw, "(?i)(dump|interceptor).*abort.*connection"), "suspicious", "normal")
| where cve_84947 == "suspicious"
| stats count by host, source, message
| sort - count

// Alternative: detect recurring connection resets following chunked response handling
index=network sourcetype=cisco:asa OR index=proxy sourcetype=proxy:http
error="ECONNRESET" OR error="Client network socket disconnected"
| join type=inner host [search index=nodejs OR index=application sourcetype=nodejs:log "undici" "dump" | table host]
| stats count by host, dest_ip, dest_port
| where count > 5

Wazuh OSSEC Rule

<group name="nodejs,undici,vulnerability,">
  <!-- CVE-2026-84947: undici dump interceptor assertion failure -->
  <rule id="100847" level="7">
    <decoded_as>json</decoded_as>
    <field name="message">Assertion failed</field>
    <field name="message">undici</field>
    <field name="message">dump</field>
    <description>Undici dump interceptor assertion failure - possible CVE-2026-84947 exploitation</description>
    <group>vulnerability,undici,nodejs,</group>
    <mitre>
      <id>T1190</id>
    </mitre>
    <options>no_full_log</options>
  </rule>

  <!-- CVE-2026-84947: Connection teardown after chunked response -->
  <rule id="100848" level="5">
    <decoded_as>json</decoded_as>
    <field name="message">Client network socket disconnected</field>
    <field name="message">ECONNRESET</field>
    <description>Unexpected connection teardown after undici request - may indicate CVE-2026-84947</description>
    <group>vulnerability,undici,nodejs,</group>
    <options>no_full_log</options>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. No patch evidence has been identified from any tracked source. The NVD description identifies undici 7.29.1 and 8.10.2 as targets users should upgrade to, implying these versions contain a fix, but no patch source, advisory, or commit reference has been confirmed. Treat these versions as potentially fixed but verify before relying on them.

Immediate mitigations (before a confirmed patch is available):

1. Avoid the dump interceptor: If the application does not strictly require response-body draining, refactor to use standard response handling (request.body consumption or explicit body reading) instead of the dump interceptor. This eliminates the vulnerable code path entirely.
2. Validate response framing: If the dump interceptor must be used, add application-level checks to reject or handle chunked responses with no Content-Length that exceed the dump size threshold before invoking the interceptor, or implement a wrapper that enforces a hard abort on chunked responses over the threshold.
3. Increase dump maximum: If feasible, raise the configured dump size maximum beyond the largest legitimate response the application expects to receive — this reduces the probability of tripping the size threshold on routine chunked responses. This is a stopgap, not a fix; malicious responses can still exceed any finite threshold.
4. Connection-pool hygiene: Monitor for unexpected ECONNRESET errors and assert-failure logs. Restart Node.js processes when such events occur to clear corrupted connection-pool state.
5. Network-layer filtering: If the application connects to a known set of servers, restrict outbound HTTP requests to trusted endpoints via firewall/egress rules to reduce the attack surface of malicious servers.

Patch/upgrade steps:

1. Continuously monitor the undici GitHub repository (github.com/nodejs/undici) for a security advisory referencing CVE-2026-84947.
2. When a confirmed fixed version is released (the advisory nominates 7.29.1 and 8.10.2), upgrade:
   • For direct dependency: npm update undici or pnpm update undici / yarn upgrade undici — target the nominated version or later.
   • For indirect dependency (e.g., via Next.js or another framework): run npm audit to identify the dependency chain and upgrade the parent package once it bundles a fixed undici version, or use npm overrides to force undici to a patched version.
3. After upgrade, verify the dump interceptor no longer triggers assertion failures on oversized chunked responses via regression testing.
4. Update application dependency manifests and lockfiles, then redeploy. Validate in a staging environment before production rollout.

Long-term hardening:

1. Dependency hygiene: Implement automated dependency scanning (Dependabot, Snyk, or equivalent) to surface vulnerable library versions at commit time rather than after discovery. Subscribe to Node.js security release notifications.
2. Runtime assertion monitoring: Enable structured logging for Node.js processes and alert on assertion-failure patterns. Route these logs to a SIEM (Elastic, Splunk, etc.) for centralized visibility.
3. Error semantics review: Audit application code for patterns where HTTP status codes are treated as the sole success indicator. Implement body-completeness validation (checking consumed byte counts against declared or expected lengths) for critical outbound requests.
4. Framing-aware response handling: Adopt HTTP client usage patterns that explicitly handle both Content-Length and chunked responses uniformly, avoiding premature completion logic based on body-size thresholds.
5. Supply-chain risk evaluation: Given the 0/4 patch confidence, conduct broader risk assessment of undici as a critical dependency. Evaluate whether alternative HTTP client libraries (e.g., native Node.js http/https, axios with compatible behavior) could serve as a fallback for critical services.

References

1. NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-84947 — Official CVE record with the full NVD description, CVSS vector, and CWE classification.
2. Node.js undici GitHub Repository: https://github.com/nodejs/undici — Monitor for the security advisory, patched release tags (7.29.1, 8.10.2), and commit history referencing the dump interceptor fix.
3. NVD CVSS Calculator: https://nvd.nist.gov/vuln-metrics/cvss/v3-calculator?vector=CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N — For independent verification of the CVSS v3.1 score (3.7).
4. CISA Known Exploited Vulnerabilities Catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog — CVE-2026-84947 is NOT listed (as of report date); re-check periodically for updates to KEV status.
5. FIRST.org EPSS: https://www.first.org/epss/ — EPSS score not yet assigned as of this report; check for future scoring updates to assess exploitation likelihood in the wild.

Threat actor activity: No known threat actor campaigns or exploit-in-the-wild evidence has been identified for CVE-2026-84947 as of this report date. Exploitation requires specific application configurations (dump interceptor in use) and is not amenable to broad automated scanning, which limits its attractiveness to commodity threat actors. State-sponsored or targeted actors interested in data-integrity attacks against Node.js backend services could theoretically weaponize this flaw, but no such activity is currently documented.