Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach unauthenticated SAML ACS/SLO endpoint
-
ExploitSubmit small highly compressed SAMLResponse
-
Executionzlib:unzip inflates unbounded to gigabytes of list heap
-
ImpactErlang VM memory exhausted, node crashes
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Compression ratio limits
|
| Exploitation Conditions | Exploitable only when the affected esaml binding handler is deployed as a SAML service provider with its assertion-consumer (ACS) and/or single-logout endpoints reachable by the attacker; these endpoints accept unauthenticated requests by design and the vulnerable zlib:unzip/1 inflation in esaml_binding:decode_response/2 executes before any signature validation, so no credentials, user interaction, or non-default configuration are required. The only meaningful limiting factors are that the target must actually run esaml 0.1.0 or later and expose these SAML endpoints to the attacker (e.g. internet-facing SP), and that each crash requires only a few crafted requests to exhaust the Erlang node's memory. No special feature toggle is needed - the behavior is present in default SAML response/logout processing. |
| Impact | This is a genuine, pre-authentication denial-of-service issue that warrants prompt patching for anyone actually running esaml, though its blast radius is bounded by product prevalence rather than by exploit difficulty. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) is internally consistent with the description: the vulnerable code path is reached on the SAML consume (ACS) and single-logout endpoints, which accept unauthenticated requests by design, and the unbounded zlib:unzip/1 inflation runs before any signature check - so the PR:N/UI:N/AC:L claims are well supported by the source-level evidence, not just the narrative. Impact is availability-only (VC:N/VI:N/VA:H), correctly reflecting a crash/resource-exhaustion bug with no confidentiality or integrity loss; this is not a code-execution flaw despite the 8.7 'high' score. On exploitation signals, there is no CISA KEV listing, no EPSS probability supplied, and no public exploit referenced in the inputs, so this is not confirmed as actively exploited; the score is driven by ease of exploitation and reliability of impact, not by observed attacks. The practical priority is therefore 'patch quickly where deployed': trivially triggerable, unauthenticated, and reliable (a ~1000:1 compression ratio means tens of KB of request body becomes gigabytes of Erlang list heap), but the real-world footprint of this specific Erlang SAML library is small. Note the supplied CVSS is 4.0 only - no 3.1 vector was provided - and no EPSS/KEV/POC data was provided at all; absence of those signals is not evidence of safety for an exposed, internet-facing SP. |
| Exploit ScenarioDerived | An attacker locates an internet-facing service provider that uses esaml and sends a small (tens of kilobytes) crafted, base64-encoded, DEFLATE-compressed SAMLResponse to its unauthenticated ACS or single-logout endpoint. esaml_binding:decode_response/2 base64-decodes and then inflates the stream with no output bound and converts it to an Erlang charlist, so a handful of such requests inflate to several gigabytes of list heap and exhaust memory, crashing the Erlang VM and taking the node offline. No public exploit is referenced in the inputs, but the technique is a well-understood decompression bomb and requires no authentication or user interaction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 22, 2026
Unauthenticated memory exhaustion in the Erlang esaml SAML library (version 0.1.0 and later) lets a remote attacker crash the hosting Erlang VM by posting a small, highly compressed SAMLResponse to a service provider's assertion-consumer (ACS) or single-logout endpoint. Because esaml_binding:decode_response/2 base64-decodes and inflates the attacker-supplied payload with zlib:unzip/1 before any signature check, a deflate stream with roughly 1000:1 amplification expands tens of kilobytes into hundreds of megabytes of binary and then gigabytes of charlist heap, so only a handful of requests are needed to take the node down. No public exploit code or confirmed active exploitation was identified at time of analysis, but the issue is trivially reachable on any internet-facing esaml service provider and upstream fix commits are already published.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - apply the patch commit deeb84378d5c82153b470e99d24f77c38afca14a from https://github.com/dropbox/esaml/commit/deeb84378d5c82153b470e99d24f77c38afca14a (equivalent commits exist in the arekinath and handnot2 forks) and rebuild/redeploy the dependency, then verify from the CNA advisory at https://cna.erlef.org/cves/CVE-2026-93471.html whether a tagged Hex/rebar release carries the change before pinning to a version number. Until the patched code is deployed, the most effective compensating control is to cap the size of the SAMLResponse before it reaches esaml_binding:decode_response/2 - enforce a strict HTTP request body limit (a few tens of kilobytes) at the reverse proxy or Cowboy listener in front of the ACS and single-logout endpoints, which shrinks the achievable expansion but will also reject legitimately large IdP responses carrying many attributes. A second option is to wrap or fork the binding call so the decoded payload is inflated through a bounded zlib stream (zlib:open/0 plus incremental inflate with a hard output ceiling) and rejected if it exceeds a configured maximum; the trade-off is maintaining a local patch. Running the SAML endpoints behind a rate limiter and limiting their exposure to known IdP networks reduces the number of requests an attacker can land but does not remove the underlying unbounded inflation, so it should be treated as defense in depth rather than a fix.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
esaml is a SAML 2.0 service-provider library for Erlang, originally authored by Alex Wilson (arekinath), with maintained forks under dropbox and handnot2 (all three appear as CPEs: cpe:2.3:a:dropbox:esaml, cpe:2.3:a:arekinath:esaml, cpe:2.3:a:handnot2:esaml). The root cause is CWE-409, Improper Handling of Highly Compressed Data (Data Amplification): the binding decoder accepts an untrusted, base64-encoded SAMLResponse, decodes it, and calls zlib:unzip/1 with no cap on the decompressed output size, then materializes the whole result in memory via binary_to_list/1 before handing it to the xmerl XML parser. Deflate permits extreme expansion ratios, and Erlang's per-character list representation multiplies the footprint roughly 8-16x over the binary, so a modest HTTP body balloons into multi-gigabyte heap allocations. Critically, this decompression path runs prior to any XML signature validation, on the ACS and single-logout handlers that by SAML design must accept unauthenticated browser POSTs, meaning the attack sits entirely in the pre-authentication phase. The published fix commit deeb84378d5c82153b470e99d24f77c38afca14a is shared across the arekinath, dropbox and handnot2 repositories.
Know when Esaml 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
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
Unauthenticated network request to endpoints exploitable before signature check gives AV:N/AC:L/PR:N/UI:N; impact is availability-only VM crash (A:H), no C/I impact, and the crashed node is the vulnerable component so S:U.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Improper Handling of Highly Compressed Data (Data Amplification) in esaml_binding in dropbox esaml allows an unauthenticated attacker to exhaust server memory and crash the Erlang VM via a crafted compressed SAMLResponse.
esaml_binding:decode_response/2 base64-decodes the attacker-supplied SAMLResponse, inflates it with zlib:unzip/1 with no bound on the output, then converts the result to a charlist with binary_to_list/1 before parsing. This runs on the SAML consume (ACS) and single-logout endpoints, which accept unauthenticated requests by design, and it runs before any signature check. A small deflate stream reaches a compression ratio near 1000 to 1, so a request body of tens of kilobytes inflates to hundreds of megabytes and then to several gigabytes of list heap, so a few requests exhaust memory and take the node down.
This issue affects esaml: from 0.1.0 onward.
Executive ViewAI
CVE-2026-93471 affects the Erlang esaml SAML library from version 0.1.0 onward, creating a memory-exhaustion risk for SAML service providers that can crash the hosting Erlang VM and interrupt login or logout availability for dependent applications. Internet-facing esaml deployments are the primary concern because a small number of crafted requests may be enough to disrupt service; no public exploit identified at time of analysis. Leadership should prioritize inventory and edge mitigation now, because no vendor-released patch identified at time of analysis and SAML outages can quickly affect workforce and customer access.
No vendor-released patch identified at time of analysis. Interim controls: enforce strict HTTP body-size and decompressed-size limits at the edge for ACS/SLO paths, reject or strip compressed SAMLResponse payloads unless explicitly required, rate-limit and monitor SAML endpoints, cap concurrency, disable unused single-logout endpoints, and isolate esaml service providers so an Erlang VM crash does not cascade; validate and selectively backport published upstream fix commits if operationally feasible.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Unauthenticated remote denial of service in the Erlang SAML library esaml (0.1.0 and later) allows an attacker to abort
A SSRF vulnerability (CVSS 6.3) that allows an attacker. Remediation should follow standard vulnerability management pro
EUVD-2026-108052
GHSA-3gv4-v3m4-w3vp
NVD
CVE.org
EPSS
Exploit-DB