Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify ember-server behind keep-alive proxy
-
DeliveryCraft request with both Transfer-Encoding and Content-Length
-
ExploitProxy frames by CL, Ember frames by chunked
-
ExecutionSmuggled prefix left on shared backend socket
-
PersistJoins next victim request / bypasses ACL
-
ImpactCache poisoning or cross-user request hijack
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Server-side exploitation requires ALL of: (1) ember-server (http4s-ember-core <= 0.23.34, or >= 1.0.0-M1 and <= 1.0.0-M46) acting as the origin; (2) a keep-alive intermediary/reverse proxy in front of it; (3) that intermediary forwarding a request carrying BOTH Transfer-Encoding and Content-Length headers rather than rejecting it (RFC 9112 permits rejection but many proxies forward); and (4) the intermediary framing the body by Content-Length while Ember frames by chunked (the CL.TE mismatch). Client-side desync additionally requires a malicious or compromised upstream server sending both headers to ember-client over a pooled connection. LIMITING FACTORS: a standalone Ember server with no fronting proxy is not exploitable; intermediaries that strictly reject dual-framed requests, buffer-and-re-encode bodies, or disable backend keep-alive fully mitigate (these are the documented workarounds). This deployment-topology dependency is exactly what the CVSS 4.0 AT:P (attack requirements) metric encodes. |
| Impact | This is a genuine but conditionally-exploitable HTTP request smuggling flaw (CWE-444) in http4s Ember. The vendor CVSS 4.0 score of 9.2 (VC:H/VI:H) reflects worst-case impact - front-end ACL bypass, cross-user request hijack, and cache poisoning - but the vector's AT:P (attack requirements present) is the critical qualifier: exploitation is NOT possible against a standalone Ember deployment. It requires ember-server to sit behind a keep-alive intermediary that itself forwards messages carrying both Transfer-Encoding and Content-Length AND frames the body by Content-Length while Ember frames by chunked (CL.TE desync). SSVC data corroborates the nuance: Exploitation=none (no observed exploitation), Automatable=no (each target's proxy chain must be probed), but Technical Impact=total. No EPSS score, no KEV listing, and no public exploit code are present in the input, so this is not confirmed actively exploited - it is a high-impact-if-preconditions-met issue rather than a mass-exploited emergency. The PR:N is legitimate (unauthenticated on the server path), but the AT:P requirement and 'no/none' SSVC signals mean real-world priority is moderate-to-high for organizations running Ember behind a permissive proxy, and low for those not matching that topology. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a single crafted HTTP/1.1 request containing both a Transfer-Encoding: chunked and a Content-Length header to a front-end proxy that forwards it over a keep-alive backend connection to ember-server. The proxy frames the body by Content-Length and treats part of the payload as one request, while Ember frames it as chunked, leaving a smuggled request prefix on the shared socket that concatenates with the next victim's request - bypassing the proxy's ACLs, capturing victim headers, or poisoning a downstream cache. No public exploit code is identified in the provided data, though request smuggling of this class is well-understood and straightforward to reproduce once the proxy/Ember framing mismatch is confirmed. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Request smuggling in the http4s Ember HTTP/1.1 parser lets an unauthenticated, remote attacker bypass front-end access controls, splice a victim request onto an attacker-controlled prefix, or poison a caching layer, but only where ember-server runs as an origin behind a keep-alive intermediary that forwards both Transfer-Encoding and Content-Length headers and frames the body by Content-Length while Ember frames by chunked (a CL.TE mismatch); a standalone Ember server with no fronting proxy is not exploitable, and the client path only desyncs when a malicious or compromised upstream sends both headers over a pooled ember-client connection. The flaw affects http4s-ember-core 0.23.34 and earlier in the 0.23.x line, plus 1.0.0-M1 through 1.0.0-M46, with a parser that fails to treat dual-framed messages as the framing error RFC 9112 §6.1 requires; the vendor-assessed CVSS 4.0 score is 9.2, with the topology dependency captured by the AT:P metric. Fixed in 0.23.35 and 1.0.0-M47 (vendor-released patch); no public exploit identified at time of analysis, and CISA SSVC records exploitation as none.
RemediationAI
Vendor-released patch: upgrade to http4s-ember-core 0.23.35 (for the 0.23.x line) or 1.0.0-M47 (for the 1.0.0 milestone line), updating the Maven dependency coordinates org.http4s:http4s-ember-core_2.12, _2.13 or _3 accordingly, or take the upstream commit 9feaf8677951a52af906ae9664ff6f0543d9d810, which makes the parser reject any message that sets both Transfer-Encoding and Content-Length. Where immediate upgrade is not possible, the documented workarounds are: configure the fronting intermediary to strictly reject requests carrying both headers (safest, but it will also reject any non-compliant client that legitimately sends both, which is extremely rare per RFC 9112 §6.1); have the intermediary buffer and fully re-encode request bodies (breaks streaming/duplex uploads and raises memory pressure on large bodies); or disable backend keep-alive between the intermediary and Ember so a smuggled prefix cannot be rejoined with the next victim request on a shared socket (incurs per-request TCP/TLS setup cost and reduced throughput). For client-side exposure, avoid pooled ember-client connections to upstreams you do not control or fully trust, since desynchronization there requires a malicious or compromised upstream. A standalone Ember deployment with no keep-alive intermediary in front is not exploitable and does not require emergency action. See the vendor advisory at https://github.com/http4s/http4s/security/advisories/GHSA-8h4c-x2wg-6xp8 and the release notes at https://github.com/http4s/http4s/releases/tag/v0.23.35 and https://github.com/http4s/http4s/releases/tag/v1.0.0-M47.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 5 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
This is a textbook CWE-444 (Inconsistent Interpretation of HTTP Requests, i.e. HTTP request smuggling) defect in http4s Ember, the pure-Scala HTTP/1.1 backend and client of the http4s stack (CPE cpe:2.3:a:http4s:http4s, Maven artifacts org.http4s:http4s-ember-core_2.12, _2.13 and _3). RFC 9112 §6.1 says a server that receives both a Transfer-Encoding and a Content-Length header must treat the message as a framing error and close the connection, because the two mechanisms describe the body length in different ways: Content-Length gives a fixed byte count, while Transfer-Encoding: chunked terminates the body with a zero-length chunk. Ember's parser accepted such messages, so when a front-end proxy strips or ignores Transfer-Encoding and frames by Content-Length while Ember honours chunked, the two disagree on where message one ends - the classic CL.TE desync. The residual bytes Ember reads as a new request are interpreted by the intermediary as part of the following (victim) request, enabling ACL/auth bypass, cross-user request hijacking, and cache poisoning. Notably, the same parser object is shared between the server request path and the client response path, so the identical disagreement can desynchronize a pooled ember-client connection when a malicious or compromised upstream replies with both headers. The upstream fix commit 9feaf8677951a52af906ae9664ff6f0543d9d810 introduces a ContentLengthAndTransferEncoding parse error that is raised whenever headerP.chunked is true and headerP.contentLength is defined, converting the ambiguous message into a connection-closing parse failure, and adds a regression test using the canonical 'POST / HTTP/1.1 / Content-Length: 0 / Transfer-Encoding: chunked' payload. Our independent assessment rates the issue CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:L, i.e. unauthenticated over the network but with high attack complexity and scope change, matching the CVSS 4.0 AT:P metric and cautioning against overstating real-world exploitability in deployments without the required proxy topology.
Know when Http4S gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
Network unauthenticated (AV:N/PR:N), but AC:H because success depends on a specific proxy/Ember framing mismatch topology; S:C as smuggling crosses the proxy security boundary to affect other users; C:H/I:H for header capture, ACL bypass and cache poisoning, A:L.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Http4s is a Scala interface for HTTP services. Prior to 0.23.35 and 1.0.0-M47, Ember HTTP/1.1 does not reject messages containing both Transfer-Encoding and Content-Length, so an intermediary and Ember can select different body framing rules. When ember-server is behind a keep-alive intermediary that forwards both headers and frames by Content-Length, an unauthenticated attacker can smuggle a second request, bypass intermediary access controls, poison caches, or cause a victim request to be joined to an attacker-controlled prefix. The shared response parser can also desynchronize an ember-client connection when a malicious or compromised upstream sends both headers. This issue is fixed in versions 0.23.35 and 1.0.0-M47.
Blast Radius
ecosystem impact- 3 maven packages depend on org.http4s:http4s-ember-core_2.12 (2 direct, 1 indirect)
Ecosystem-wide dependent count for version 0.23.35.
Technical POC Analysis
Class: CWE-444, Inconsistent Interpretation of HTTP Requests ("HTTP Request/Response Smuggling").
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
http4s Ember HTTP/1.1 parser request smuggling can enable attackers to bypass front-end access controls, splice requests, or poison caches in affected deployments where Ember runs as an origin behind a keep-alive intermediary or uses pooled client connections to untrusted upstreams. Organizations running affected http4s-ember-core versions (0.23.34 and earlier in the 0.23.x line, and 1.0.0-M1 through 1.0.0-M46) should prioritize patching because successful exploitation could cause unauthorized access, data integrity problems, and cache poisoning. Leadership should care because these outcomes can erode customer trust and undermine layered security, even though standalone Ember servers without a fronting proxy are not exploitable; no public exploit identified at time of analysis.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
XML External Entity (XXE) injection in http4s-scala-xml's EntityDecoder for scala.xml.Elem (all versions before 0.24.1 a
Http4s client applications that keep a cookie jar can leak stored cookies — including session and authentication cookies
Http4s is a Scala interface for HTTP services. Rated medium severity (CVSS 6.3), this vulnerability is remotely exploita
Http4s is a Scala interface for HTTP services. Rated medium severity (CVSS 5.3), this vulnerability is remotely exploita
Http4s is a minimal, idiomatic Scala interface for HTTP services. Rated critical severity (CVSS 9.1), this vulnerability
HTTP request smuggling in http4s Ember (all releases prior to 0.23.35 and 1.0.0-M47) lets an unauthenticated remote atta
Let me synthesize. CVE-2026-69205: http4s Ember HTTP parser request smuggling via Transfer-Encoding header case-sensiti
http4s is an open source scala interface for HTTP. Rated medium severity (CVSS 4.7), this vulnerability is remotely expl
A crafted WebSocket frame can pin a worker thread and exhaust memory in the http4s Scala HTTP library, causing denial of
Heap exhaustion in the http4s Ember backend (0.23.x before 0.23.35 and 1.0.0 milestones before 1.0.0-M47) allows a singl
Heap-exhaustion denial of service in the http4s DigestAuth server middleware: an inverted stale-nonce comparison in Nonc
Unbounded WebSocket fragment aggregation in http4s-blaze-server allows any client that completes a WebSocket handshake t
EUVD-2026-79025
GHSA-8h4c-x2wg-6xp8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB