Skip to main content

ash_cloak CVE-2026-81319

| EUVDEUVD-2026-68281 MEDIUM
Deserialization of Untrusted Data (CWE-502)
2026-08-30 EEF
5.9
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Recon
    Attacker authenticates to application and reads own AES.CTR-encrypted column
  2. Delivery
    XOR known plaintext against observed ciphertext to derive keystream
  3. Exploit
    Craft same-length ETF decompression bomb or atom-flood payload
  4. Install
    Write forged ciphertext to own record via application or direct DB
  5. C2
    Application loads column and invokes AshCloak.Calculations.Decrypt
  6. Execute
    non_executable_binary_to_term without :safe inflates bomb or interns atoms
  7. Impact
    BEAM node crashes, all tenants lose availability

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

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

Exploitation Conditions

The primary (network-reachable) attack path requires two conditions to both be true: (1) the application has configured Cloak's unauthenticated AES.CTR cipher for at least one encrypted column - this is a non-default cipher that must be explicitly selected in the Cloak configuration; and (2) the attacker holds application-layer credentials sufficient to read the ciphertext of their own encrypted column value and write a forged column value of the same byte length back to the datastore. The atom-flood and decompression-bomb payloads are equally viable once forged column bytes reach the decoder. If only authenticated ciphers (AES.GCM or similar) are deployed, the XOR-forgery path is blocked by vault.decrypt!() MAC verification, and exploitation is limited to adversaries with direct raw database write access, bypassing the application entirely. Limiting factors beyond cipher choice include: the attacker's column value must be of the same byte length as the intended forged payload for CTR-mode forgery to work; and the crash is triggered on the next column read, so timing is attacker-controlled but not instant.

Impact

The reported CVSS 4.0 score of 5.9 with AV:L models the conservative scenario requiring local or direct database write access, but the description explicitly documents a more accessible attack path: an application-layer user with AES.CTR-encrypted columns can forge ciphertext over the network without key material. AT:P (attack requirements present) correctly captures the conditional dependency on AES.CTR being configured. The impact is exclusively availability (VA:H): a node-wide BEAM crash affecting all tenants sharing the runtime - no confidentiality or integrity impact. EPSS data is not provided in the input; given the specific configuration prerequisite (AES.CTR must be deployed and the attacker must control a column), opportunistic mass exploitation is unlikely, suggesting a lower real-world exploitation probability than an unqualified DoS framing implies. Active exploitation is not confirmed - not in CISA KEV. However, once the attack path is understood, the XOR-forgery step requires only knowledge of one's own plaintext and is computationally trivial. The CVSS PR:N is potentially misleading: writing a forged column value almost certainly requires at minimum application-layer user credentials, suggesting PR:L better reflects real-world conditions. This is a moderate-priority finding for AES.CTR deployments; authenticated-cipher-only deployments face a substantially narrower attack surface.

Exploit ScenarioDerived

An authenticated user of an Ash Framework web application reads their own AES.CTR-encrypted column value, XORs the known plaintext against the returned ciphertext to recover the keystream, and constructs a same-length forged ciphertext encoding a compressed ETF decompression bomb. The user writes this forged value back to their own record via a normal application update endpoint. The next time any code path loads that column - by the attacker, an admin, or a background job - AshCloak.Calculations.Decrypt decodes the forged ETF, the BEAM node runs out of memory inflating the bomb, and the entire Elixir application crashes, taking all concurrent users offline. No publicly available exploit code was identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAI

Unsafe Erlang term deserialization in ash_cloak 0.1.0-0.3.x allows an attacker who can influence encrypted column bytes to crash the BEAM runtime node via unbounded atom table exhaustion or a decompression bomb. Applications configured with Cloak's unauthenticated AES.CTR cipher are the highest-risk targets: an authenticated application user who knows their own plaintext can XOR-derive the keystream and write a forged ciphertext of equal length without the encryption key, causing the deserialization to fire on any subsequent column read. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, but the patch commit confirms two distinct, low-skill attack primitives against unpatched deployments.

RemediationAI

Upgrade ash_cloak to version 0.4.0 or later, which closes both attack primitives: the fix rejects all compressed ETF payloads outright (matching magic bytes <<131, 80>>) before deserialization, and passes the :safe option to binary_to_term to prevent interning of attacker-supplied atoms. The patch commit is https://github.com/ash-project/ash_cloak/commit/1690f0a436efe3e7c11d70d74ff5a8ac0fdf6608. If immediate upgrade is not possible, the most effective compensating control is to replace the Cloak AES.CTR cipher with an authenticated cipher such as AES.GCM for all encrypted columns; this eliminates the XOR-forgery path and causes vault.decrypt!() to reject tampered ciphertexts before they reach the deserializer. Note that column re-encryption is required after the cipher change, and read compatibility during migration must be managed carefully. Applications that cannot change cipher or upgrade should restrict column write access at the database layer to application service accounts only, reducing (but not eliminating) the direct-DB-write attack surface. The advisory is at https://github.com/ash-project/ash_cloak/security/advisories/GHSA-rc26-mrm2-6pf9.

Affected VersionsENISA

ash_cloak 0.1.0 <0.4.0
ash_cloak f1595a77fdfa9bfc672f84c2f77feb9e7bf895fc <1690f0a436efe3e7c11d70d74ff5a8ac0fdf6608

Affected Packages

euvd ash_cloak fix: 0.4.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

ash_cloak is an Elixir library for the Ash Framework that encrypts resource columns using the Cloak encryption library. The defect resides in AshCloak.Calculations.Decrypt, which passes decrypted bytes to Ash.Helpers.non_executable_binary_to_term/1 - a thin wrapper around Erlang's built-in binary_to_term/1 - without the :safe flag. In the BEAM runtime, atoms created via binary_to_term are permanently interned in a finite global table (default ~1 million entries); feeding a stream of novel atom terms exhausts this table and crashes the node. Separately, the Erlang External Term Format (ETF) supports zlib-compressed payloads identified by the magic bytes <<131, 80>>; binary_to_term transparently inflates these regardless of :safe, so a kilobyte-compressed payload can expand to gigabytes of heap, triggering OOM. The CWE-502 root cause is the direct application of a powerful, unrestricted deserialization primitive to attacker-controlled bytes. The unauthenticated Cloak cipher AES.CTR in stream mode leaks keystream to any user who can observe their own plaintext-ciphertext pair, enabling bit-exact ciphertext forgery without the key. Authenticated ciphers (e.g., AES.GCM) block this path at vault.decrypt!(). Affected CPE: cpe:2.3:a:ash-project:ash_cloak:*:*:*:*:*:*:*:* covering all releases from 0.1.0 to pre-0.4.0.

Know when Ash Cloak 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 5.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 5.3 MEDIUM

Network-reachable via AES.CTR forgery path; AC:H because AES.CTR must be explicitly configured; PR:L because attacker requires application user credentials to read and write encrypted columns.

3.1 AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:H/AT:P/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Local
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

Deserialization of Untrusted Data vulnerability in ash-project ash_cloak allows an attacker who can influence the bytes of an encrypted column to crash the BEAM node, by triggering unbounded atom creation or a decompression bomb during decryption.

AshCloak.Calculations.Decrypt decodes the decrypted binary with Ash.Helpers.non_executable_binary_to_term/1 without the :safe option, so atoms in the payload are interned during the decode and never garbage collected, and the term format's compressed form is inflated transparently. vault.decrypt!() is the only barrier and stops tampering only for an authenticated cipher. Cloak also ships the unauthenticated AES.CTR, whose ciphertext an attacker who knows their own plaintext can XOR into any same-length payload without the key, so an ordinary read of the forged column reaches the decoder. A few hundred kilobytes of distinct atoms exhausts the atom table, or a small compressed payload inflates to gigabytes.

This issue affects ash_cloak: from 0.1.0 before 0.4.0.

Threat Intelligence Overview

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Low
niche Elixir plugin limited to Ash Framework adopters
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.

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