Skip to main content

http4s Ember CVE-2026-54556

| EUVDEUVD-2026-66558 HIGH
Improper Handling of Highly Compressed Data (Data Amplification) (CWE-409)
2026-08-26 https://github.com/http4s/http4s GHSA-vmm3-xgcx-67hm
8.2
CVSS 4.0 · Vendor: https://github.com/http4s/http4s
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Connect to http4s ember HTTP/2 endpoint
  2. Delivery
    Craft HPACK bomb with high-ratio indexed header references
  3. Exploit
    Send concurrent HEADERS and CONTINUATION frames
  4. Execution
    Trigger unbounded HPACK decoder expansion into JVM heap
  5. Persist
    Repeat across ~5 concurrent connections
  6. Impact
    Exhaust 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv2 – 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)
v1 Aug 26, 2026 - 14:34

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

http4s-ember-core_2.12 < 0.23.35
http4s 1.0.0-M1, < 1.0.0-M46
http4s-ember-core_3 < 0.23.35
http4s-ember-core_3 1.0.0-M1, < 1.0.0-M46
http4s < 0.23.35
http4s-ember-core_2.13 < 0.23.35
http4s-ember-core_2.13 1.0.0-M1, < 1.0.0-M46

Affected Packages

maven org.http4s:http4s-ember-core_2.12 fix: 0.23.35
maven org.http4s:http4s-ember-core_2.13 fix: 0.23.35, 1.0.0-M47
maven org.http4s:http4s-ember-core_3 fix: 0.23.35, 1.0.0-M47
euvd http4s fix: 0.23.35
euvd http4s_1_0_0_m1 fix: 1.0.0-M46
euvd http4s_ember_core_2_12 fix: 0.23.35
euvd http4s_ember_core_2_13 fix: 0.23.35
euvd http4s_ember_core_2_13_1_0_0_m1 fix: 1.0.0-M46
euvd http4s_ember_core_3 fix: 0.23.35
euvd http4s_ember_core_3_1_0_0_m1 fix: 1.0.0-M46

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

Vendor (https://github.com/http4s/http4s) PRIMARY 8.2 HIGH
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
vuln.today AI 5.9 MEDIUM

HTTP/2 must be explicitly enabled (non-default), warranting AC:H; no authentication or user interaction required; impact is availability-only JVM crash.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/http4s/http4s).

CVSS VectorVendor: https://github.com/http4s/http4s

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
CVSS changed
Aug 26, 2026 - 15:52 NVD
8.2 (HIGH)
CVE Published
Aug 26, 2026 - 14:10 cve.org
HIGH

DescriptionCVE.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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 78% exploitable
Prevalence
Low
niche Scala functional HTTP library, limited enterprise footprint
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

41
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Java

View all
CVE-2012-4681 CRITICAL POC
9.8 Aug 28

Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m

CVE-2015-7450 CRITICAL POC
9.8 Jan 02

Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti

CVE-2013-2465 CRITICAL POC
9.8 Jun 18

Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent

CVE-2011-3544 CRITICAL POC
9.8 Oct 19

Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug

CVE-2010-1871 HIGH POC
8.8 Aug 05

JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to

CVE-2012-1723 CRITICAL POC
9.8 Jun 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up

CVE-2013-0422 CRITICAL POC
9.8 Jan 10

Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using

CVE-2012-0507 CRITICAL POC
9.8 Jun 07

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up

CVE-2015-4852 CRITICAL POC
9.8 Nov 18

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

CVE-2012-5076 CRITICAL POC
9.8 Oct 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow

CVE-2017-3066 CRITICAL POC
9.8 Apr 27

Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla

CVE-2012-0391 CRITICAL POC
9.8 Jan 08

The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy