Skip to main content

Elixir Plug EUVDEUVD-2026-30266

| CVE-2026-8468 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-05-14 EEF GHSA-468c-vq7p-gh64
8.2
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Recon
    Identify multipart upload endpoint
  2. Delivery
    Craft POST with malformed multipart boundary
  3. Exploit
    Stream body with incomplete headers
  4. Install
    Trigger unbounded buffer accumulation
  5. C2
    Open concurrent malicious connections
  6. Execute
    Exhaust BEAM VM memory
  7. Impact
    Crash application process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the target application to use Plug.Parsers.MULTIPART parser in its connection pipeline to handle multipart/form-data requests, typically indicating file upload functionality. The vulnerable code path is only reached when processing Content-Type: multipart/form-data requests against endpoints configured to parse multipart bodies. Applications using only Plug.Parsers.JSON, Plug.Parsers.URLENCODED, or custom parsers are not exposed. Network access to the upload endpoint is required (AV:N), but no authentication (PR:N) or user interaction (UI:N) is needed per CVSS vector. The CVSS AT:P (Attack Requirements:Present) flag reflects this: while the vulnerability is present in all affected Plug versions, real-world exploitability depends on deployment configuration enabling multipart parsing. Default Plug installations do not automatically parse multipart bodies without explicit Plug.Parsers configuration. Limiting factors: some deployments may front Plug applications with reverse proxies (nginx, HAProxy) that enforce their own request size limits, potentially blocking malformed uploads before they reach Plug. However, proxies configured to stream request bodies without buffering will pass malicious requests through unchanged.

Impact

CVSS 4.0 score of 8.2 (High) reflects network attack vector (AV:N), low complexity (AC:L), no privileges required (PR:N), and high availability impact (VA:H). The AT:P (Attack Requirements:Present) modifier indicates specific conditions must exist, which the description confirms: the application must process multipart/form-data uploads. EPSS data not provided, but risk signals are mixed: no CISA KEV listing and no public exploit code identified, suggesting limited observed exploitation despite the conceptual simplicity of the attack. However, the attack requires only basic HTTP tools to craft malformed multipart requests, making it highly automatable once discovered. Real-world risk depends heavily on deployment context: internet-facing file upload endpoints processing untrusted multipart data are high-priority targets, while APIs using only JSON or applications behind authentication have reduced exposure surface. The CVSS AT:P flag is critical here - not all Plug deployments parse multipart bodies, significantly narrowing the real attack surface compared to the raw score. Remediation priority is high for public-facing upload services, moderate for authenticated file handling, and low for JSON-only APIs. The availability of vendor patches across all affected branches since May 2026 makes delayed patching the primary residual risk.

Exploit ScenarioDerived

An unauthenticated remote attacker identifies a web application built with vulnerable Plug versions that accepts file uploads via multipart/form-data POST requests. The attacker crafts an HTTP request with Content-Type: multipart/form-data and a declared boundary string, then streams a request body that begins the boundary sequence but never includes the terminating \r\n\r\n delimiter required to complete the header section. The victim server's read_part_headers/2 function enters an unbounded accumulation loop, consuming 64KB per iteration as it waits for headers that never arrive. The attacker opens 5-10 concurrent connections sending such malformed bodies, each accumulating gigabytes of buffered data within minutes. The BEAM VM process exhausts available memory and crashes, causing denial of service to all users of that application instance. The attack requires no authentication, no special tools beyond curl or a basic HTTP client, and leaves minimal forensic evidence beyond memory exhaustion logs.

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

AnalysisAIv1 – May 14, 2026

Memory exhaustion in Elixir Plug 1.4.0 through 1.19.1 allows remote unauthenticated attackers to crash BEAM VM processes via unbounded buffer accumulation during multipart/form-data header parsing. The vulnerability mirrors CVE-2026-8466 in Cowboy: read_part_headers/2 recursively accumulates incoming bytes without size limits when parsing malformed multipart requests that never deliver complete header sections. Vendor-released patches available for all affected branches. No public exploit identified at time of analysis, but exploitation requires only basic HTTP client tools.

RemediationAI

Upgrade to patched Plug versions: 1.15.4, 1.16.3, 1.17.1, 1.18.2, or 1.19.2 per vendor advisory at https://github.com/elixir-plug/plug/security/advisories/GHSA-468c-vq7p-gh64. Patches introduce size limits via the existing :length option (defaults to 64KB) that now applies to accumulated header buffers, causing read_part_headers/2 to return {:error, :too_large, conn} when exceeded. Verify patches in commits 2cb7958d, aa69c5ec, d5dfffe2, df812a15, and 33858427 at https://github.com/elixir-plug/plug/. For applications unable to upgrade immediately, implement compensating controls: (1) Deploy reverse proxy rate limiting on multipart upload endpoints (trade-off: may block legitimate large uploads; tune limits to application requirements). (2) Set aggressive timeouts on request body reads via Plug.Conn read_timeout option, typically 5-30 seconds for file uploads (trade-off: terminates slow but legitimate uploads on poor connections). (3) If upload functionality is non-essential, disable Plug.Parsers.MULTIPART parser in plug pipeline and accept only JSON/urlencoded (trade-off: eliminates file upload capability). These workarounds reduce but do not eliminate risk - prioritize vendor patching.

Affected VersionsENISA

plug 1.18.0 <1.18.2
plug 1.17.0 <1.17.1
plug c52b2f32c90bccd718202bafccb5f95594e30183 <*
plug 1.4.0 <1.15.4
plug 1.19.0 <1.19.2
plug 1.16.0 <1.16.3

Affected Packages

euvd plug fix: 1.15.4, 1.16.3, 1.17.1, 1.18.2, 1.19.2

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

Elixir Plug is a composable web middleware library for the BEAM VM ecosystem, providing HTTP connection primitives used by Phoenix Framework and other Elixir web applications. The vulnerability exists in src/plug_multipart.erl and lib/plug/conn.ex, specifically in the read_part_headers/2 function that parses multipart/form-data request bodies. This code was forked from the cow_multipart module in the Cowboy HTTP server (which has the identical flaw tracked as CVE-2026-8466). The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling): when parse_headers/2 returns 'more' or {more, Buffer}, the function reads up to 64KB chunks from the socket and recursively accumulates them into a growing binary with no upper-bound check. Unlike the sibling function read_part_body/8, there is no byte_size(acc) > length guard. The BEAM VM's memory management cannot reclaim this accumulated buffer until the request completes, making it trivial to exhaust process memory. The vulnerability affects CPE cpe:2.3:a:elixir-plug:plug:*:*:*:*:*:*:*:* across six release branches spanning from the 1.4.0 introduction of multipart parsing through 1.19.1.

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

3
CVSS changed
May 14, 2026 - 11:22 NVD
8.2 (HIGH)
CVE Published
May 14, 2026 - 10:29 nvd
UNKNOWN (no severity yet)
CVE Published
May 14, 2026 - 10:29 nvd
HIGH 8.2

DescriptionCVE.org

Allocation of Resources Without Limits or Throttling vulnerability in plug_project plug allows denial of service via unbounded buffer accumulation in multipart header parsing.

plug_multipart in src/plug_multipart.erl is a fork of the cow_multipart module from ninenines cowboy (CVE-2026-8466). The same unbounded accumulation pattern is present in 'Elixir.Plug.Conn':read_part_headers/2 in lib/plug/conn.ex: it accumulates incoming request bytes into a growing binary with no upper-bound check. When plug_multipart:parse_headers/2 returns more or {more, Buffer}, the function reads up to 64 KB from the underlying socket and recurses with the enlarged buffer. There is no equivalent of the byte_size(acc) > length guard present in the sibling function read_part_body/8. An unauthenticated attacker can send a multipart/form-data request whose body never yields a complete header section - for example, a body that never contains the advertised boundary delimiter, or one whose header lines never contain \r\n\r\n - and force the server process to accumulate memory linearly with the bytes the protocol layer is willing to deliver. A handful of concurrent such uploads is sufficient to exhaust BEAM memory.

This issue affects plug from 1.4.0 before 1.15.4, 1.16.3, 1.17.1, 1.18.2, and 1.19.2.

Executive ViewAI

Why It Matters

Elixir Plug versions 1.4.0 through 1.19.1 contain a memory exhaustion vulnerability allowing unauthenticated remote attackers to crash BEAM VM processes through malformed multipart form requests, impacting all applications using affected Plug versions and resulting in service unavailability without authentication requirements.

Business Impact: High
Compensating Controls

Apply vendor patch. If patching cannot be completed immediately: implement HTTP request filtering at reverse proxy/WAF to enforce multipart Content-Length limits and request timeouts; configure BEAM VM memory limits and process restart policies; deploy rate limiting on multipart form endpoints.

Threat Intelligence Overview

EPSS Score
0.3%
Top 49% exploitable
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

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.

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