Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to http4s ember HTTP/2 endpoint
-
DeliveryCraft HPACK bomb with high-ratio indexed header references
-
ExploitSend concurrent HEADERS and CONTINUATION frames
-
ExecutionTrigger unbounded HPACK decoder expansion into JVM heap
-
PersistRepeat across ~5 concurrent connections
-
ImpactExhaust heap and crash server with OutOfMemoryError
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Compression ratio limits
|
| Exploitation Conditions | HTTP/2 must be explicitly enabled in the http4s ember backend - deployments using HTTP/1.1 only, or using backends other than ember (e.g., blaze, netty-client), are entirely unaffected. For server-side exploitation the endpoint must be reachable from untrusted network traffic. For client-side exploitation the ember HTTP/2 client must be directed to connect to an attacker-controlled server that returns HPACK bomb response headers. No authentication is required by either party. The existing maxHeaderSize configuration parameter does not limit exploitation in vulnerable versions because it excludes indexed headers from its accounting. Attack requires only approximately five concurrent connections against a 2 GB JVM heap, with no special tooling beyond HTTP/2 frame crafting capability. |
| Impact | The CVSS 4.0 score of 8.2 (AV:N/AC:L/AT:P/PR:N/UI:N/VA:H) correctly reflects that the attack is network-accessible and unauthenticated with high availability impact, while AT:P acknowledges a meaningful prerequisite: HTTP/2 must be explicitly enabled in the ember backend. No EPSS score was included in the source data, so exploitation probability cannot be independently quantified. The vulnerability is absent from CISA KEV and no public proof-of-concept has been identified, placing this in the theoretical-to-practical risk tier rather than confirmed active exploitation. Impact is purely availability - the JVM process crashes, denying service - with zero confidentiality or integrity exposure. The low concurrent-connection threshold (~5 connections on a 2 GB heap) makes the attack resource-efficient once a target is identified, so any deployment accepting untrusted HTTP/2 traffic should treat upgrade as urgent. The CVSS 4.0 AT:P signal is important: organizations that have not enabled HTTP/2 in ember are entirely unaffected and need not prioritize this finding. |
| Exploit ScenarioDerived | An unauthenticated remote attacker sends approximately five concurrent HTTP/2 requests containing crafted HPACK bomb payloads - small HEADERS and CONTINUATION frames that reference indexed header table entries - to a vulnerable http4s ember server. Each connection triggers the Hpack decoder to expand a compact wire payload into a very large Scala List held in JVM heap; across five simultaneous connections the heap is exhausted, causing an OutOfMemoryError that crashes the server process. The HPACK bomb technique is well-documented from prior HTTP/2 server disclosures, making independent exploit development straightforward for an attacker familiar with HTTP/2 framing. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 26, 2026
Denial of service via HPACK bomb in http4s ember-core's HTTP/2 implementation allows unauthenticated remote attackers to exhaust JVM heap memory and crash affected servers or clients. The flaw resides in the Hpack wrapper (Hpack.scala:L54), where HEADERS and CONTINUATION frames are concatenated and decoded wholesale into a Scala List before any size limit is enforced; the existing maxHeaderSize guard is bypassed entirely because it does not account for indexed headers. Approximately five concurrent malicious connections against a 2 GB heap suffice to trigger OutOfMemoryError; no public exploit code or CISA KEV listing has been identified at time of analysis.
Earlier versions of this analysis (1)
HTTP/2 HPACK bomb exploitation in http4s's ember backend (org.http4s:http4s-ember-core) allows remote unauthenticated attackers to crash JVM-based servers or clients by sending specially crafted compressed HTTP/2 headers that expand dramatically upon decoding. The ember Hpack wrapper concatenates HEADERS and CONTINUATION frames before invoking the decoder in one pass, loading the fully inflated header list into a Scala ListBuffer on the JVM heap with no early-abort path; critically, the pre-existing maxHeaderSize guard did not apply to indexed headers, allowing any declared limit to be bypassed entirely. No public exploit code or CISA KEV listing exists at time of analysis, but the advisory's own testing confirmed approximately five concurrent crafted connections against a 2 GB heap suffice to trigger OutOfMemoryError, placing this firmly in the category of exploitable availability threats for any ember HTTP/2 deployment reachable by untrusted traffic.
RemediationAI
The primary fix is to upgrade to http4s-ember-core 0.23.35 (0.23.x series) or 1.0.0-M47 (1.0.0 milestone series), available at https://github.com/http4s/http4s/releases/tag/v0.23.35 and https://github.com/http4s/http4s/releases/tag/v1.0.0-M47 respectively. The patch, committed at https://github.com/http4s/http4s/commit/6e8eccd64a6a74ab4811897881e95e0e1b3a818e, threads the maxHeaderSize setting into Hpack.Impl and propagates it from EmberClientBuilder and the server builder, so connections are terminated as soon as decoded header data exceeds the configured limit. For teams that cannot upgrade immediately, the vendor-confirmed workaround is to disable HTTP/2 in the ember backend entirely; this closes the attack surface but sacrifices HTTP/2 multiplexing and header compression, which may degrade throughput for high-concurrency workloads. No other configuration knob in current unpatched versions prevents the attack, as the advisory explicitly states that the existing maxHeaderSize parameter is ineffective against this payload class.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 10 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
The root cause is CWE-409 (Improper Handling of Highly Compressed Data - Data Amplification), a well-known class of attack against HTTP/2 HPACK header compression (RFC 7541). HPACK maintains static and dynamic header tables; an attacker can craft payloads that reference indexed table entries repeatedly, encoding a small wire-format frame that expands to megabytes of decoded data. In the vulnerable ember implementation, the H2Stream.receiveHeaders path concatenates HEADERS and CONTINUATION frames before invoking the HPACK decoder, which returns the fully expanded result as a single List held in JVM heap. The maxHeaderSize parameter exists in the server builder API but is not propagated into the Hpack.Impl constructor in vulnerable versions, so no runtime guard interrupts the expansion. Affected Maven artifacts are org.http4s:http4s-ember-core cross-compiled for Scala 2.12, 2.13, and 3 (GHSA-vmm3-xgcx-67hm). The 0.23.x series is affected through 0.23.34; the 1.0.0 milestone series is affected from 1.0.0-M1 through 1.0.0-M46.
Know when Java 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:N/VI:N/VA:H/SC:N/SI:N/SA:N
HTTP/2 must be explicitly enabled (non-default), warranting AC:H; no authentication or user interaction required; impact is availability-only JVM crash.
Primary rating from Vendor (https://github.com/http4s/http4s).
CVSS VectorVendor: https://github.com/http4s/http4s
Lifecycle Timeline
2DescriptionCVE.org
Summary
http4s 0.23.x and 1.0 servers running ember with http2 enabled are vulnerable to a denial of service attack using a HPACK bomb vulnerability recently disclosed as affecting other http2 servers.
Impact
Denial of Service:
- Affects any http4s server running the ember backend with HTTP/2 enabled that is exposed to untrusted traffic.
- Affects any http4s client running the ember backend with HTTP/2 enabled that can be directed to an untrusted server.
Details
The issue occurs in the Hpack wrapper. Ember concatenates the header and continuation frames before decoding all headers at once. When the code decodes the attack payload, the relatively small packets decode to a significantly larger amount of data which is returned as a single List which is then held in memory for further processing. With enough concurrent connections (~5 with a 2GB heap in testing) this leads to an OOM, eg:
java.lang.OutOfMemoryError: Java heap space
at scala.collection.mutable.ListBuffer.scala$collection$mutable$ListBuffer$$freshFrom(ListBuffer.scala:129)
at scala.collection.mutable.ListBuffer.addAll(ListBuffer.scala:147)
at scala.collection.mutable.ListBuffer.addAll(ListBuffer.scala:40)
at scala.collection.mutable.Growable.$plus$plus$eq(Growable.scala:69)
at scala.collection.mutable.Growable.$plus$plus$eq$(Growable.scala:69)
at scala.collection.mutable.AbstractBuffer.$plus$plus$eq(Buffer.scala:314)
at org.http4s.Header$.org$http4s$Header$ToRaw$$anon$10$$_$$lessinit$greater$$anonfun$2(Header.scala:192)
at org.http4s.Header$ToRaw$$anon$10$$Lambda/0x00001fe001239c50.apply(Unknown Source)
at scala.collection.immutable.List.foreach(List.scala:334)
at org.http4s.Header$ToRaw$$anon$10.<init>(Header.scala:192)
at org.http4s.Header$ToRaw$.scalaCollectionSeqToRaw(Header.scala:195)
at org.http4s.Headers$.apply(Headers.scala:220)
at org.http4s.ember.core.h2.PseudoHeaders$.headersToRequestNoBody(PseudoHeaders.scala:95)
at org.http4s.ember.core.h2.H2Stream.receiveHeaders$$anonfun$1$$anonfun$2$$anonfun$3$$anonfun$2(H2Stream.scala:248)
at org.http4s.ember.core.h2.H2Stream$$Lambda/0x00001fe001511fd8.apply(Unknown Source)
at cats.effect.IOFiber.runLoop(IOFiber.scala:429)
at cats.effect.IOFiber.autoCedeR(IOFiber.scala:1460)
at cats.effect.IOFiber.run(IOFiber.scala:129)
at cats.effect.unsafe.WorkerThread.run(WorkerThread.scala:935)Fix
The Hpack handling code has a configurable max header size parameter, but it does not include indexed headers in that accounting, allowing the attack to bypass the limit. There is not any configuration available in current http4s versions that can be enabled to prevent this attack short of disabling http2.
A fix has been tested locally that threads the maxHeaderSize setting from the server builder into the Hpack code. Using this, connections can be prematurely terminated once the decoded data size exceeds the maxHeaderSize that users can already configure.
Workarounds
If you can't upgrade immediately:
- Disable HTTP/2 in Ember backends
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.
Articles & Coverage 2
Executive ViewAI
http4s ember-core contains a vulnerability enabling unauthenticated remote attackers to crash affected applications and cause service outages (CVE-2026-54556). No public exploit identified at time of analysis. A patch is available per vendor advisory.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-66558
GHSA-vmm3-xgcx-67hm
NVD
CVE.org
EPSS
Exploit-DB