/

CVE-2026-69205

Severity:

HIGH RISK

(8.7)

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

CVE-2026-69205

Deferred

Vulnerability type

Category:

HTTP Request Smuggling

CWE:

CWE-444

Impact:

Request smuggling and HTTP message-framing confusion

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 parsing inconsistency in Http4s Ember causes Transfer-Encoding values to be interpreted differently from RFC-compliant intermediaries. Under a proxy or gateway path, this disagreement may enable request smuggling, access-control bypass, cross-user request hijacking, or cache poisoning.

Affected context

The issue affects Http4s deployments using Ember before the relevant fixed releases, particularly where Ember processes HTTP requests behind intermediaries that apply different token, case, or character-set rules. It is most significant on server paths involving proxies, load balancers, caches, or access-control layers that do not interpret Transfer-Encoding and Content-Length consistently. Response smuggling through an ember-client gateway additionally depends on a malicious or compromised upstream service.

Exploit preconditions

  • Attack surface: HTTP request processing through an Ember server or gateway
  • Required access: Ability to send specially formed HTTP headers to the exposed service; response-side scenarios also require control or compromise of an upstream
  • Trigger point: Parsing of the Transfer-Encoding header and subsequent message-body framing
  • Why exploitation is possible: Ember uses case-sensitive substring matching and platform-default character decoding, while an intermediary may apply RFC-compliant token and charset interpretation, creating conflicting framing decisions

Why this happens

The vulnerability results from non-compliant parsing of the Transfer-Encoding header. A case-sensitive substring check can fail to recognize valid token forms such as Chunked, accept invalid substrings such as notchunked, and produce unexpected matches after platform-dependent character decoding and Unicode case folding. When different HTTP components derive different message boundaries from the same request, the behavior maps to CWE-444: Inconsistent Interpretation of HTTP Requests, commonly known as HTTP request smuggling.

Potential impact

  • An attacker could bypass access-control checks applied by an intermediary
  • Requests could be routed to or associated with another user
  • Caches could be poisoned with attacker-controlled responses
  • Backend services could process unintended or desynchronized requests
  • A gateway could experience response smuggling if its upstream is malicious or compromised

General mitigation guidance

Mitigation generally focuses on ensuring that every HTTP component applies the same strict, standards-aligned message-framing rules.

Common defensive patterns include:

  • Use a parser that performs exact, case-insensitive token matching for Transfer-Encoding values
  • Decode protocol headers with an explicitly defined, standards-appropriate character handling policy rather than the platform default
  • Reject ambiguous, malformed, contradictory, or duplicate framing headers
  • Normalize or validate requests consistently at trust boundaries
  • Configure intermediaries and backends to share compatible HTTP parsing and rejection policies
  • Minimize gateway privileges and isolate upstream services to limit the consequences of request desynchronization
  • Prefer secure-by-default HTTP components that reject ambiguous framing instead of attempting recovery

How teams detect issues like this

Detection can combine protocol-focused testing with source and configuration review:

  • Use static analysis to identify substring-based Transfer-Encoding checks, platform-default charset decoding, and inconsistent header normalization
  • Review code for separate or conflicting handling of Content-Length and Transfer-Encoding across proxies, gateways, and backends
  • Exercise staging paths with case variations, invalid token substrings, unusual encoded bytes, and conflicting framing headers, without exposing production systems
  • Monitor for malformed framing headers, backend requests that arrive out of sequence, unexpected connection reuse, and cache entries associated with anomalous requests
  • Enforce policies requiring standards-compliant HTTP parsing and consistent rejection behavior across all request-processing layers
  • Automated security testing and code-review tools may help identify parser differentials and unsafe header-handling patterns

Sources

SourceLink
github.comgithub.com/http4s/http4s/commit/5e88b2e7b4e6ea2f0c61040a4bc9de0d73e51217
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-9998-894r-fwvr

Frequently asked

questions

It may be remotely exploitable when an attacker can send HTTP requests through an affected Ember service and a parsing-different intermediary. The exact scope depends on the deployment topology and request-routing controls.

Not necessarily. An exposed HTTP endpoint may be sufficient, although authentication, network placement, proxy policy, and access-control configuration can limit reachable paths.

Use a standards-compliant HTTP parser with exact Transfer-Encoding token handling, explicit character decoding, and strict rejection of ambiguous message framing. Ensure intermediaries and backend services apply compatible rules.

Treat HTTP parsing as a security boundary, test proxy-to-backend parser differentials, prohibit platform-dependent header decoding, and enforce consistent framing policies across every component in the request path.

Find out what's already
exploitable in your codebase.