Skip to main content

hackney EUVDEUVD-2026-109837

| CVE-2026-97200 HIGH
Improper Handling of Highly Compressed Data (Data Amplification) (CWE-409)
2026-10-26 EEF GHSA-wpmp-4grc-56ph
8.2
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Induce hackney client to request attacker-controlled server
  2. Delivery
    Server returns oversized or highly-compressed response body
  3. Exploit
    hackney buffers every chunk unbounded (HTTP/1.1/2/3)
  4. Execution
    auto_decompress inflates whole body in one zlib call
  5. Impact
    Client Erlang VM memory exhausted (denial of service)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Compression ratio limits
Exploitation Conditions

The victim application must use hackney to issue a request whose full body is buffered - the default hackney:request/5 result or hackney:body/1 - to a server the attacker controls or can influence the response of (reachable directly, via redirect, or via a client-supplied/SSRF URL). The oversized-body path requires no special configuration: before 4.9.0 the HTTP/1.1, HTTP/2 and HTTP/3 accumulators had no size limit, so default deployments are affected. The compression-amplification path additionally requires the {auto_decompress, true} option, under which the entire body is inflated in a single zlib:gunzip/1 or zlib:inflate/2 call. Limiting factors: exploitation yields only availability loss (no data exposure), the client must actually initiate the connection to the hostile server, and installing 4.9.0 (or setting max_body_size) caps buffering and returns {error, body_too_large}.

Impact

This is a client-side memory-exhaustion (CWE-409 data-amplification) denial-of-service in the hackney HTTP client, and the available signals point to a moderate-but-real priority rather than an emergency. The input CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) and the availability-only impact (VC:N/VI:N/VA:H) are internally consistent with the description: no authentication, network-reachable, no confidentiality or integrity loss, and an attack requirement (AT:P) reflecting that the victim client must actually issue a request to a server that then returns the hostile body. The vuln.today decision label is 'this_week' and a vendor patch (4.9.0) is confirmed available, which aligns with a serious-but-non-critical DoS. No EPSS score, no CISA KEV listing, and no proof-of-concept exploit reference are present in the input - so there is no public exploit identified at time of analysis, and the realistic threat is a malicious or compromised server (or one reachable via SSRF/redirect) degrading or crashing the client's Erlang VM, not mass remote compromise. The one data-quality conflict to flag explicitly: the input Tags label this 'Information Disclosure', which contradicts the CVSS vector (VC:N, VA:H) and the description - this is an availability/DoS issue, not disclosure, so treat the tag as mislabeled.

Exploit ScenarioDerived

An application using hackney makes an HTTP request (directly, or via a redirect / user-supplied URL) to a server the attacker controls or has compromised. That server replies with an endless or highly gzip-compressed body; hackney buffers the entire response via hackney_conn:read_full_body/2 (or the HTTP/2 / HTTP/3 accumulators) with no size cap, and with {auto_decompress, true} inflates the whole payload in one zlib call, exhausting the client process's memory. No public exploit code is referenced in the input, but the trigger is trivial for any server that answers the client's request.

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

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

Alert me

AnalysisAIv1 – Oct 26, 2026

Memory exhaustion in the Erlang hackney HTTP client (2.0.0-beta.1 through 4.8.x) lets any server the client requests force the connection process to buffer an entire response body with no size bound; when {auto_decompress, true} is set, a small compressed body is additionally inflated in one zlib call, multiplying the allocation. The default hackney:request/5 and hackney:body/1 paths buffer the full body, so unauthenticated remote attackers who control or influence the target server (directly, via redirect, or via an SSRF-style URL) can crash or stall the calling BEAM process, giving availability-only impact. No public exploit code was identified at time of analysis and there is no KEV confirmation; 4.9.0 introduces a max_body_size option (default 512 MiB) that caps buffering and returns {error, body_too_large}.

RemediationAI

Vendor-released patch: upgrade to hackney 4.9.0, which introduces the max_body_size request option (default 512 MiB, also accepts the 1.x name max_body, and disabling the cap requires explicitly setting infinity) and returns {error, body_too_large} once a buffered body exceeds it on HTTP/1.1, HTTP/2 and HTTP/3 - see https://github.com/benoitc/hackney/releases/tag/4.9.0, https://github.com/benoitc/hackney/pull/980 and the fix commit https://github.com/benoitc/hackney/commit/493e8bf83a391548e5101792276ab3fc428fa76c. If upgrading immediately is not possible, the trade-off options are to pass a bounded max_body_size/max_body-equivalent cap at the application layer by avoiding hackney:body/1 and instead streaming via hackney:stream_body/1 with your own byte counter that closes the response and the connection after an application-defined threshold (this changes response handling code but bounds memory), or to leave {auto_decompress, true} disabled so the decompression-amplification path is not reachable, accepting that callers then must handle compressed payloads themselves. Since exploitation requires the client to actually issue a request to a hostile or attacker-influenced endpoint, restricting user-supplied or SSRF-derived URLs to an allowlist of trusted hosts, and disabling automatic redirect following to untrusted hosts, reduces exposure without changing the library; the 4.9.0 release notes also cover related redirect credential-handling, CA-pinning and proxy fixes in the same upgrade.

Affected VersionsENISA

hackney dc41b79339ca0c41e16d3f2dd17172bc2de855d6 <493e8bf83a391548e5101792276ab3fc428fa76c
hackney 2.0.0-beta.1 <4.9.0

Affected Packages

euvd hackney fix: 4.9.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

hackney is an Erlang/OTP HTTP client library, and the flaw sits in its connection layer: hackney_conn:read_full_body/2 and the HTTP/2 and HTTP/3 accumulators appenden every chunk received until the body terminates, with nothing constraining the total buffered size - the CWE-409 data-amplification angle compounds this because the {auto_decompress, true} option deflates the accumulated body in a single zlib:gunzip/1 or zlib:inflate/2 call, which returns the whole decompressed output at once rather than streaming it in bounded windows. Practically, a hostile or compromised origin can therefore turn a modest response (or a very small but highly compressed one) into an arbitrarily large heap allocation inside the client's connection process. CPE data identifies the affected package as benoitc:hackney across the version range from 2.0.0-beta.1 up to, but not including, 4.9.0. The assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms this is unauthenticated over the network with high availability impact and no confidentiality or integrity impact; the CVSS 4.0 AT:P metric reflects that the attacker must be the entity supplying the response (a malicious, compromised, or redirect-reachable server). The trigger requires no unusual client configuration for the oversized-body path; only the decompression-amplification path needs auto_decompress enabled.

Know when Hackney 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 (EEF) 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 7.5 HIGH

Network-reachable, no authentication or user interaction, availability-only impact (memory exhaustion); the victim merely connecting to a responding malicious server keeps AC:L and scope unchanged.

3.1 AV:N/AC:L/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 (EEF).

CVSS VectorVendor: EEF

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

DescriptionCVE.org

Allocation of Resources Without Limits or Throttling vulnerability in hackney_conn in benoitc hackney allows a malicious HTTP server to exhaust client memory via an oversized or highly compressed response body. hackney:request/5 and hackney:body/1 return the whole response body, and nothing bounds how much the connection process buffers. Any server the client requests can trigger it.

hackney_conn:read_full_body/2 and the HTTP/2 and HTTP/3 accumulators append every chunk until the body ends. With {auto_decompress, true} the buffered body is then inflated in one step with zlib:gunzip/1 or zlib:inflate/2, which return the whole output at once.

This issue affects hackney: from 2.0.0-beta.1 before 4.9.0.

Executive ViewAI

Why It Matters

A memory exhaustion flaw in the widely used Erlang hackney HTTP client (versions 2.0.0-beta.1 through 4.8.x) allows any server the client contacts to force excessive buffering and crash or stall the calling BEAM process, with amplification when auto-decompression is enabled. However, no public exploit code and no confirmed active exploitation were identified at time of analysis. Leadership should care because availability-impacting failures in Erlang-based services that rely on hackney for outbound requests could interrupt dependent applications, though the risk is currently contained and a vendor fix exists.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 53% exploitable
Prevalence
Medium
widely-used HTTP client, but confined to the niche Erlang/Elixir ecosystem
Social Media
2
Sightings
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.6%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
Medium
Technical Impact
Partial

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +41
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0
CVE-2026-47073 HIGH POC
8.7 May 25

Denial of service in benoitc hackney (Erlang HTTP client) versions 2.0.0 through 4.0.0 allows a malicious WebSocket serv

CVE-2026-47067 HIGH POC
8.7 May 25

Denial of service in benoitc hackney (Erlang HTTP client) 2.0.0 through 4.0.0 allows remote unauthenticated attackers to

CVE-2026-47066 HIGH POC
8.7 May 25

Denial-of-service in benoitc's hackney Erlang HTTP client (versions 2.0.0-beta.1 through 4.0.0) allows any HTTP origin s

CVE-2026-47077 HIGH POC
8.2 May 25

Remote denial of service in benoitc hackney 2.0.0 through 4.0.0 lets a malicious HTTP/3 server exhaust a client's BEAM p

CVE-2026-47071 HIGH POC
8.2 May 25

Denial of service in benoitc hackney (Erlang HTTP client) versions 0.10.0 through 4.0.0 lets a hostile SOCKS5 or HTTP CO

CVE-2026-47072 MEDIUM POC
6.9 May 25

CRLF injection in hackney (Erlang HTTP client, versions 2.0.0-4.0.1) enables header injection into outbound WebSocket up

CVE-2026-47076 MEDIUM POC
6.9 May 25

SSRF allowlist bypass in hackney (Erlang HTTP client) versions 0.13.0 through before 4.0.1 allows attackers who control

CVE-2026-47075 MEDIUM POC
6.8 May 25

HTTP Request Splitting via CRLF injection in hackney, the Erlang/Elixir HTTP client library, allows an attacker who cont

CVE-2026-47070 MEDIUM POC
6.0 May 25

Credential leakage in the hackney Erlang HTTP client library (versions 3.1.1 through before 4.0.1) allows a malicious or

CVE-2026-115693 CRITICAL
9.1 Oct 26

Improper certificate validation in the Erlang HTTP client hackney (1.24.0 through 4.8.x) lets an on-path attacker impers

CVE-2026-115700 MEDIUM
6.9 Oct 26

Server-side request forgery in the Erlang hackney HTTP client (versions 4.0.1 up to but not including 4.9.0) lets an att

CVE-2026-47069 LOW POC
2.1 May 25

CRLF injection in the hackney Erlang HTTP client library's hackney_cookie:setcookie/3 function enables HTTP response spl

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