Skip to main content

Req (Elixir) EUVDEUVD-2026-35098

| CVE-2026-49755 HIGH
Improper Handling of Highly Compressed Data (Data Amplification) (CWE-409)
2026-06-08 EEF GHSA-655f-mp8p-96gv
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 Req client to fetch attacker URL
  2. Delivery
    Return Content-Type/Content-Encoding bomb headers
  3. Exploit
    Req invokes decode_body/decompress_body with no size cap
  4. Execution
    Recursive decompression inflates body to multi-GB
  5. Persist
    BEAM process exhausts memory and crashes
  6. Impact
    Service 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 Req (versions 0.1.0-0.6.0) and issue an HTTP request whose final response is served by an attacker-controlled host - directly via an attacker-supplied URL or indirectly via Req's automatic redirect following. No authentication, user interaction, or non-default configuration is required on the Req side: decode_body/1 and decompress_body/1 are enabled by default, and the attacker controls both Content-Type (to trigger :zip/:erl_tar extraction) and Content-Encoding (to chain :zlib/:brotli/:ezstd decoders). Exploitation is limited to availability impact (BEAM process crash); it cannot be used for code execution or data disclosure, and applications that pass raw: true, that never fetch attacker-influenced URLs, or that have already upgraded to 0.6.1 are not exposed.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) reflects a network-reachable, unauthenticated, low-complexity issue with high availability impact (VA:H) and no confidentiality or integrity loss - consistent with a denial-of-service primitive that crashes the BEAM rather than achieving code execution. The AT:P (Attack Requirements: Present) qualifier captures the real-world constraint that the victim must actually issue an HTTP request to a server the attacker controls or can influence (including via Req's automatic redirect following). EPSS and KEV data were not provided, and no public exploit is identified at this time, so this is best treated as a credible but not yet actively-weaponized DoS bug. Risk is highest for services that use Req to fetch arbitrary user- or third-party-supplied URLs (webhook delivery, link unfurling, RSS/feed fetchers, SSRF-style proxy endpoints, server-side previews), where attacker URL control is realistic; closed-world, fixed-endpoint usage is materially lower risk.

Exploit ScenarioDerived

A service uses Req to fetch a URL supplied by an untrusted user - for example, a webhook target, an OAuth callback metadata URL, or an open-graph preview fetcher. The attacker either points the service at their own host or sets up a redirect chain Req will follow; the malicious server responds with a ~500 KB payload and Content-Encoding: gzip, gzip, gzip (or Content-Type: application/zip wrapping a deeply nested bomb), causing the Req client to inflate the body to multiple gigabytes in memory and crash the BEAM VM, taking down the host service. No public PoC is referenced in the available data, but the technique is well-known and trivially reproducible from the advisory's description.

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

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

Alert me

AnalysisAIv1 – Jun 08, 2026

Memory exhaustion in wojtekmach Req (Elixir HTTP client) versions 0.1.0 through 0.6.0 allows attacker-controlled HTTP servers to crash the BEAM process via decompression-bomb response bodies. Because Req enabled automatic body decompression and archive decoding by default with no size caps, a sub-megabyte response advertising gzip/zip/tar content can expand to multiple gigabytes in memory. No public exploit identified at time of analysis, but the fix and root cause are documented in the upstream advisory GHSA-655f-mp8p-96gv.

RemediationAI

Vendor-released patch: upgrade Req to 0.6.1 or later (commit 84977e5b1a83f26e749d55ad06e3625464af4e8d), which changes the default of the :compressed option from true to false and only runs decompress_body/1 when the caller explicitly opts in with compressed: true - see https://github.com/wojtekmach/req/commit/84977e5b1a83f26e749d55ad06e3625464af4e8d and the advisory at https://github.com/wojtekmach/req/security/advisories/GHSA-655f-mp8p-96gv. If immediate upgrade is not possible, callers should pass raw: true to Req.get!/Req.request to bypass decompress_body/1 and avoid decoding application/zip, application/x-tar, application/gzip, or .tgz responses, accepting the trade-off that the application must handle compressed bytes itself; alternatively, disable Req's automatic redirect following (redirect: false) and restrict outbound fetches to allowlisted, trusted hosts to shrink the attacker-controlled-server exposure. Resource ceilings on the BEAM (e.g., +MMscs, container memory limits, or process-level supervision) reduce blast radius but do not address root cause.

Affected VersionsENISA

req e37753741cbdc725e6aba3d977b380163bfc0ecb <84977e5b1a83f26e749d55ad06e3625464af4e8d
req 0.1.0 <0.6.1

Affected Packages

euvd req fix: 0.6.1

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

Req is a widely used Elixir HTTP client built on top of Finch and the BEAM standard library. The vulnerability lives in lib/req/steps.ex, where decode_body/1 dispatches on the server-supplied Content-Type (or URL extension) and calls Erlang/OTP primitives :zip.extract/2, :erl_tar.extract/2 with the [:memory] option, materializing the entire decompressed archive as an in-memory [{name, bytes}] list. decompress_body/1 likewise chains :zlib, :brotli, and :ezstd decoders driven by the Content-Encoding header, allowing a layered encoding such as gzip, gzip, gzip to inflate without bound. This is a classic CWE-409 (Improper Handling of Highly Compressed Data / decompression bomb) issue, made worse because Req also follows redirects automatically - so a benign-looking initial request can land on an attacker-controlled host that returns the bomb.

Know when Req 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

Primary rating from Vendor (EEF) · only source for this CVE.

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

Lifecycle Timeline

2
CVSS changed
Jun 08, 2026 - 16:22 NVD
8.2 (HIGH)
CVE Published
Jun 08, 2026 - 15:20 nvd
UNKNOWN (no severity yet)

DescriptionCVE.org

Improper Handling of Highly Compressed Data (Data Amplification) vulnerability in wojtekmach Req allows attacker-controlled HTTP servers to exhaust memory in a Req client via decompression-bomb response bodies.

Req's default response pipeline includes Req.Steps.decode_body/1 and Req.Steps.decompress_body/1 in lib/req/steps.ex. decode_body/1 dispatches on the server-supplied content-type (or URL extension) and calls :zip.extract(body, [:memory]) for application/zip, :erl_tar.extract({:binary, body}, [:memory]) for application/x-tar, and :erl_tar.extract({:binary, body}, [:memory, :compressed]) for application/gzip / .tgz. Each returns the full decompressed archive contents as a [{name, bytes}] list in memory, with no per-entry or total size cap. decompress_body/1 walks the content-encoding header and chains :zlib/:brotli/:ezstd decoders, so a response advertising content-encoding: gzip, gzip, gzip inflates through multiple layers without bound.

Both steps are enabled by default, no caller opt-in is required, and the attacker controls the content-type and content-encoding headers on their own server (or on any host reached via Req's automatic redirect following). A sub-megabyte response can expand to multiple gigabytes on the victim, crashing the BEAM process.

This issue affects req: from 0.1.0 before 0.6.1.

Executive ViewAI

Why It Matters

Elixir applications using the wojtekmach Req HTTP client (versions 0.1.0-0.6.0) face a high-severity Denial of Service vulnerability that allows remote attackers to crash application instances through specially crafted HTTP responses. Any organization relying on affected versions risks service outages and operational disruption.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.0%
Top 87% exploitable
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub VulDB

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 Yes
EPSS 0.0%
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
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

61
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
PoC: +20
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.

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