/

CVE-2026-69217

Severity:

HIGH RISK

(8.7)

HTTP Request Smuggling (CWE-444) in Http4s Ember Parser

CVE-2026-69217

Deferred

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Request smuggling, control bypass, credential or header exposure, and cache poisoning

Severity:

HIGH RISK

(8.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A request smuggling vulnerability in Http4s Ember's HTTP/1.1 parser allows differing duplicate Content-Length headers to be interpreted inconsistently. An unauthenticated attacker may exploit this disagreement across keep-alive intermediaries to bypass front-end controls, expose another user's headers, or poison caches.

Affected context

The vulnerability occurs in Http4s Ember deployments that parse HTTP/1.1 messages containing duplicate Content-Length headers and operate behind intermediaries that may select a different header occurrence. The shared client-side parser may also be affected when it processes responses from an untrusted or compromised upstream while proxying traffic for multiple downstream consumers.

Exploit preconditions

  • Attack surface: HTTP/1.1 server or client parsing across a proxy, load balancer, or other keep-alive intermediary
  • Required access: Network access to submit HTTP requests; authentication may not be required
  • Trigger point: Processing a message containing conflicting duplicate Content-Length headers
  • Why exploitation is possible: The Ember parser uses the last Content-Length value while another intermediary may select a different occurrence, causing disagreement about message boundaries

Why this happens

The underlying bug is inconsistent handling of duplicate message-framing headers. Instead of rejecting conflicting Content-Length values, the parser accepts them and applies a single occurrence, allowing adjacent components to calculate different request or response boundaries.

This behavior maps to CWE-444: Inconsistent Interpretation of HTTP Requests, in which network components interpret the same HTTP message differently. The resulting parser differential can permit attacker-controlled data to be treated as a separate request or response by a downstream component.

Potential impact

  • An attacker may bypass controls enforced by a front-end intermediary.
  • A later user's headers or request data could be exposed to an attacker-controlled request.
  • Shared caches could be poisoned with attacker-controlled content.
  • Downstream requests may be routed or processed unexpectedly.
  • A client acting as a proxy could misframe upstream responses for multiple consumers.

General mitigation guidance

Mitigation generally focuses on ensuring consistent, strict HTTP message framing across every component in the request path.

Common defensive patterns include:

  • Rejecting messages with duplicate or conflicting Content-Length headers.
  • Applying one standards-compliant framing policy consistently across servers, clients, proxies, and gateways.
  • Preferring unambiguous transfer framing and disabling permissive parser behavior.
  • Normalizing or validating requests before they cross trust boundaries.
  • Avoiding reuse of ambiguous parsed messages across multiple downstream consumers.
  • Limiting proxy privileges, connection reuse, and access to sensitive downstream services where practical.

How teams detect issues like this

Detection approaches commonly include:

  • Static and dependency analysis for HTTP parsers with permissive duplicate-header handling.
  • Code review checks for "last header wins" or "first header wins" logic involving message-framing fields.
  • Integration tests that compare framing decisions across application servers, reverse proxies, load balancers, and clients.
  • Policy enforcement that rejects conflicting Content-Length headers at network boundaries.
  • Security monitoring for malformed requests, unexpected connection desynchronization, cache anomalies, and unusual downstream request sequences.
  • Automated application-security testing can help identify parser differentials in representative deployment topologies.

Sources

SourceLink
github.comgithub.com/http4s/http4s/commit/24e8d34e3ea89f8f23e0053ec9944f6467e8086d
github.comgithub.com/http4s/http4s/releases/tag/v0.23.35
github.comgithub.com/http4s/http4s/releases/tag/v1.0.0-M47
github.comgithub.com/http4s/http4s/security/advisories/GHSA-p83c-4wj9-p6w9

Frequently asked

questions

Yes. An unauthenticated network attacker may be able to trigger the issue by sending specially structured HTTP/1.1 traffic to an affected server or intermediary path.

The attacker generally needs network reachability to an affected HTTP endpoint. The risk is greater when the service is positioned behind a keep-alive proxy or when a client proxies upstream responses to multiple consumers.

Reject conflicting duplicate Content-Length headers and ensure every HTTP component uses the same strict message-framing rules.

Test complete proxy chains rather than isolated components, enforce boundary validation, monitor for desynchronization indicators, and avoid permissive parsing of security-sensitive protocol fields.

Find out what's already
exploitable in your codebase.