Skip to main content

Phoenix Framework CVE-2026-32689

| EUVDEUVD-2026-27339 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-05-05 EEF GHSA-628h-q48j-jr6q
8.7
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Obtain session token via unauthenticated GET
  2. Delivery
    Craft 8 MB POST with newline payload
  3. Exploit
    Send to /socket/longpoll endpoint
  4. Execution
    Trigger unbounded String.split allocation
  5. Persist
    Exhaust BEAM memory and schedulers
  6. Impact
    Crash node and terminate sessions

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 Phoenix application to expose the long-poll transport endpoint (typically /socket/longpoll) to the attacker's network. Applications using WebSocket-only transport or those with long-poll disabled in endpoint.ex socket configuration are not vulnerable. The vulnerable code path is triggered specifically by POST requests with Content-Type: application/x-ndjson; other content types bypass the vulnerable String.split call. A session token is required in the request but is obtained via an unauthenticated GET request to the same endpoint with a matching Origin header, effectively making the attack unauthenticated. No user interaction is required (UI:N in CVSS). The attack succeeds against default Phoenix configurations that include long-poll as a fallback transport, which is standard in Phoenix 1.7.x and 1.8.x scaffolded projects. Memory-constrained deployments (containers with <512 MB heap) crash faster than large instances, but all unpatched versions are exploitable regardless of hardware resources given sufficient payload size (8 MB body crashes typical production configurations). Network access to the endpoint is the sole prerequisite; authentication, privileges, and special client capabilities are not required.

Impact

Real-world risk is high for publicly exposed Phoenix applications using long-poll transport. CVSS:4.0 8.7 (AV:N/AC:L/PR:N/UI:N/VA:H) accurately reflects the unauthenticated network vector and high availability impact. Attack complexity is low: the vulnerability requires only a single HTTP POST with an 8 MB body of newlines. EPSS data not provided, but the attack primitive (send large request, crash service) is trivial to automate. No CISA KEV listing or public POC identified, suggesting exploitation has not yet been observed in the wild or widely weaponized. However, the advisory (GHSA-628h-q48j-jr6q) and patches are public since early 2025, so exploitation is technically feasible for any attacker monitoring Phoenix security advisories. The free availability of session tokens via unauthenticated GET (with matching Origin header) removes authentication as a barrier. The primary risk limiting factor is deployment configuration: only applications exposing the long-poll transport endpoint (typically /socket/longpoll) to untrusted networks are at risk. Modern deployments favor WebSocket over long-poll, reducing the attack surface, but legacy or fallback configurations remain vulnerable. Mitigation is straightforward (upgrade to patched version), but unpatched instances face immediate DoS risk. The server-side fix is incomplete (batching limit enforced client-side only), so defense-in-depth via reverse proxy rate limiting is advisable even after patching.

Exploit ScenarioDerived

An attacker crafts an HTTP POST to https://target.example/socket/longpoll with Content-Type: application/x-ndjson and an 8 MB body consisting entirely of newline bytes (0x0A). First, they obtain a session token by sending a GET request to the same URL with an Origin header matching the target domain, which returns a token without authentication. Using this token, they submit the malicious POST. The Phoenix server's publish/4 function calls String.split on the body, materializing approximately 8.4 million empty binaries in a list. Enum.map then walks this list, doubling the allocation. The BEAM VM exhausts memory within seconds, crashing the node and disconnecting all active WebSocket and long-poll sessions. The attack is repeatable and can be automated. If multiple application nodes exist behind a load balancer, the attacker can sequentially crash each node or send concurrent requests to crash the entire cluster.

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 – May 05, 2026

Unauthenticated remote denial-of-service in Phoenix Framework 1.7.0-1.7.21 and 1.8.0-1.8.5 allows attackers to crash Elixir BEAM nodes by sending multi-megabyte HTTP requests filled with newlines to the long-poll transport endpoint. A 1 MB payload of newline characters triggers allocation of approximately one million empty list elements, exhausting scheduler and memory resources. Session token required to trigger the vulnerability is obtainable via unauthenticated GET request, making exploitation trivial. Vendor-released patches (1.7.22, 1.8.6) enforce client-side batching limits. CVSS 8.7 (high availability impact) confirmed; no public exploit or CISA KEV listing identified at time of analysis.

RemediationAI

Upgrade Phoenix to version 1.7.22 or 1.8.6 immediately. Patches are available from the official GitHub repository at commits 1a67c61ff9ce0a7711662ac7354861917a7c80f7 (v1.7.22) and 912ea181fd247c21dbcc49fb97d0053b947d81bf (v1.8.6). Update mix.exs dependency and run 'mix deps.update phoenix'. If immediate upgrade is not feasible, implement reverse proxy rate limiting on the /socket/longpoll endpoint: limit request body size to 1 MB and enforce rate limits of 10 requests per minute per source IP (adjust based on legitimate client behavior). Be aware that rate limiting reduces attack impact but does not eliminate the vulnerability, as even a 1 MB payload can trigger memory exhaustion on under-resourced nodes. Another compensating control is disabling long-poll transport entirely if WebSocket is supported by all clients: remove or comment out the LongPoll transport configuration in endpoint.ex socket declarations. This breaks compatibility with clients in restrictive network environments (corporate proxies blocking WebSocket) but eliminates the attack vector. Monitor BEAM memory and scheduler utilization via :observer or external APM tools; set alerts for sustained >80% memory usage as an early warning signal. The patch enforces client-side batching (100 messages per POST) and replaces eager String.split/2 with lazy String.splitter/2, but server-side validation remains a TODO per commit comments, so layered defenses are prudent. Full advisory and patch details at https://github.com/phoenixframework/phoenix/security/advisories/GHSA-628h-q48j-jr6q.

Affected VersionsENISA

phoenix 1.8.0 <1.8.6
phoenix 1.7.0 <1.7.22
phoenix 2674c6ea30634667f9b09966b90269393b445953 <*

Affected Packages

euvd phoenix fix: 1.7.22, 1.8.6

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

Phoenix is an Elixir web framework built on the Erlang BEAM VM. The vulnerable code path is in Phoenix.Transports.LongPoll, which implements a fallback transport for WebSocket connections. When handling POST requests with Content-Type: application/x-ndjson, the publish/4 function calls String.split/2 without a limit argument to parse message batches. Elixir's String.split/2 materializes the entire result into a list in memory before returning. An attacker sending a body composed entirely of newline bytes (e.g., 0x0A repeated eight million times in an 8 MB request) causes 1:1 memory amplification: each newline produces one empty binary in the resulting list. Enum.map then walks every element, materializing a second list of equal size. The cumulative allocation exhausts BEAM's heap and scheduler queues, triggering an out-of-memory crash that terminates all active sessions on the node. This is a classic resource exhaustion attack (CWE-770: Allocation of Resources Without Limits or Throttling). The fix introduced MAX_LONGPOLL_BATCH_SIZE=100 on the client side and replaced String.split/2 with String.splitter/2 on the server, which returns a lazy stream instead of eagerly building a list. The server-side TODO comment in the patch indicates the 100-message cap is currently client-enforced only; future versions will validate batch size on the server.

Know when Phoenix 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.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
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

1
CVSS changed
May 05, 2026 - 16:22 NVD
8.7 (HIGH)

DescriptionCVE.org

Allocation of Resources Without Limits or Throttling vulnerability in phoenixframework phoenix allows a denial of service via the long-poll transport's NDJSON body handling.

In 'Elixir.Phoenix.Transports.LongPoll':publish/4, when a POST request is received with Content-Type: application/x-ndjson, the request body is split on newline characters using String.split/2 with no limit on the number of resulting segments. An attacker can send a body consisting entirely of newline bytes, causing a 1:1 amplification into a list of empty binaries - a 1 MB body produces approximately one million list elements, an 8 MB body approximately 8.4 million. Each element is then walked by Enum.map, materializing another list of the same size. This exhausts BEAM memory and schedulers, crashing the node and terminating all active sessions.

A session token required to reach the vulnerable endpoint is freely obtainable by any client via an unauthenticated GET request to the same URL with a matching Origin header, making this attack effectively unauthenticated.

This issue affects phoenix: from 1.7.0 before 1.7.22 and 1.8.6.

Executive ViewAI

Why It Matters

Phoenix Framework versions 1.7.0-1.7.21 and 1.8.0-1.8.5 contain a remote denial-of-service vulnerability (CVSS 8.7) that allows unauthenticated attackers to crash Elixir application servers by sending oversized HTTP requests to the long-poll endpoint, causing memory exhaustion. Organizations running affected Phoenix versions face immediate risk of service unavailability; attackers require no authentication and can obtain necessary session tokens through standard web requests.

Business Impact: High
Compensating Controls

Apply vendor patch. If immediate patching is not feasible, implement Web Application Firewall (WAF) rules to reject HTTP requests exceeding 50 KB to the long-poll transport endpoint (/phoenix/live/websocket or equivalent paths) and rate-limit requests from single IP addresses to mitigate attack volume.

Threat Intelligence Overview

EPSS Score
0.0%
Top 86% 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 Vendor 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 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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

64
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
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.

Vendor StatusVendor

SUSE

Severity: High
Product Status
SUSE Linux Enterprise Module for SAP Applications 15 SP7 Fixed
SUSE Linux Enterprise Server for SAP Applications 15 SP7 Fixed
SUSE Linux Enterprise Server for SAP applications 16.0 Fixed
SUSE Linux Enterprise Server for SAP applications 16.1 Fixed
SUSE Linux Enterprise Server for SAP Applications 15 SP6 Fixed

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