Description

undici's dump interceptor reads and discards a response body up to a configurable maximum size. When a response declares a Content-Length that exceeds the maximum, the interceptor aborts cleanly, but when a response has no Content-Length and is chunked, the interceptor instead signals completion early once the accumulated size reaches the maximum, without pausing or aborting the request. Because the underlying parser keeps delivering body bytes, a second completion signal fires and trips an internal assertion, which aborts the request and tears down the connection. The application is left observing a misleading successful status with an empty or truncated body while the connection has actually been disconnected. This affects undici versions from 7.1.0 up to 7.29.1 and from 8.0.0 up to 8.10.2. Users should upgrade to undici 7.29.1 or 8.10.2.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "3.7",
  "pubDate": "2026-09-04T17:17:02.103Z",
  "pubdate": "2026-09-04T17:17:02.103Z",
  "executiveSummary": "A flaw in the dump interceptor within the undici HTTP client library allows for the potential misinterpretation of response completion states.\nThe vulnerability occurs when processing chunked transfer-encoded responses that exceed a configured maximum body size limit, leading to an improper internal assertion failure.\nAffected products include undici versions 7.1.0 through 7.29.1 and 8.0.0 through 8.10.2.\nAn attacker can exploit this behavior by sending a malicious chunked response, resulting in a truncated body delivered to the application while the underlying TCP connection is forcibly aborted.\nThe primary risk lies in the application layer perceiving a successful request completion despite data truncation, which may lead to business logic errors, inconsistent state transitions, or incomplete data processing.\nExploitation requires the ability to influence or control the response body delivered to the client and does not necessarily require authentication.",
  "technicalDetails": "The vulnerability resides in the undici dump interceptor, a component designed to read and discard response bodies up to a predefined byte limit. The root cause of the issue is a divergence in how the interceptor handles boundary conditions between explicit Content-Length headers and chunked transfer encoding.\nWhen a Content-Length header specifies a size greater than the configured maximum, the interceptor correctly triggers an abort. However, when the response lacks a Content-Length header and utilizes chunked transfer encoding, the logic fails to enforce a proper abortion sequence. Instead, the interceptor signals completion prematurely upon reaching the accumulation limit.\nThe underlying HTTP parser remains active and continues to deliver body bytes even after this premature completion signal. Consequently, a secondary completion signal is emitted once further data is processed. This unexpected secondary signal triggers an internal assertion failure within the undici library, which forces the immediate termination of the request and the tearing down of the underlying network connection.\nThe attack flow involves an attacker acting as a malicious server or performing a man-in-the-middle intervention to provide an intentionally long chunked response. By exceeding the buffer limit, the attacker forces the client-side state machine into an inconsistent configuration. Because the library incorrectly reports an initial success before the fatal assertion occurs, the application logic may process the truncated data as valid, while the connection teardown is ignored or improperly handled by the caller.\nAffected versions are strictly constrained to undici versions 7.1.0 to 7.29.1 and 8.0.0 to 8.10.2. The vulnerability exists within the logic responsible for state management during body stream processing. Since this occurs at the protocol parsing level, it does not require authentication or specific privilege levels from the attacker, provided they can facilitate a network interaction with the vulnerable client. The post-exploitation impact includes the potential for silent data corruption or logic bypasses where the application assumes the full integrity of the received response body."
}