Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend concurrent requests to data-heavy ash endpoint
-
DeliveryApplication spawns async read tasks via AsyncLimiter
-
ExploitAll tasks still running; Task.yield(task, 0) returns nil for each
-
ExecutionTight recursive loop holds BEAM scheduler at 100% CPU
-
PersistMultiple concurrent request waves exhaust scheduler thread pool
-
ImpactApplication-wide throughput collapses
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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 ash version 2.19.0 through 3.32.2 to be deployed and for the application to execute concurrent asynchronous read operations that include at least one slow task - such as loading related resources backed by an external API call, a slow database query, or a long-running calculation. The busy-spin manifests only while all outstanding async tasks in a batch are still running; a fast application where all reads complete quickly will not exhibit scheduler exhaustion. The CVSS 4.0 AT:P flag confirms specific attack requirements are present. Limiting factors: the application must use ash's async read path (not purely synchronous reads), at least one async task must be slow relative to the polling cycle, and impact scales with the number of concurrent slow reads. There is no authentication requirement to trigger the condition if the vulnerable endpoint is publicly accessible, but the endpoint must be one that internally uses ash async reads. |
| Impact | The vendor-assigned CVSS 4.0 score of 2.1 (Low) reflects the narrow real-world impact: only availability is affected (VA:L), there is no confidentiality or integrity dimension, and the attack requires specific conditions (AT:P - concurrent slow async reads) to manifest at meaningful scale. The AV:L rating is debatable; in typical ash deployments, slow reads are initiated by HTTP request handlers, meaning a remote actor making many requests against a data-heavy endpoint could trigger the condition - this analysis rates AV:N independently (see assessed_cvss_vector). Attack Complexity is effectively High because scheduler exhaustion requires multiple concurrent slow operations, not a single crafted request. There is no KEV listing and no public exploit code, placing real-world exploitation risk very low. The EPSS signal is absent from the provided data. The practical risk profile is an internal performance regression under heavy or adversarially crafted load, not a classic availability-denial primitive. Defenders running ash 2.19.0-3.32.2 with data-intensive or slow relationship-loading operations (e.g., large aggregate queries or external-API-backed calculations) face the highest residual risk before patching. |
| Exploit ScenarioDerived | An operator runs an ash-powered Phoenix application with endpoints that load resource graphs involving slow external calculations or large related-dataset queries. An attacker - or simply a flood of legitimate users - issues many concurrent requests to those endpoints; each triggers an async read, and the AsyncLimiter busy-polls a BEAM scheduler thread for the full duration of every slow task. With enough concurrent slow reads, all scheduler threads are pinned at 100% CPU, starving other processes and causing application-wide latency spikes or unresponsiveness. No special exploit tooling is required beyond sustained concurrent HTTP traffic to a data-heavy endpoint. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 01, 2026
Scheduler exhaustion in ash Framework (Elixir) versions 2.19.0 through 3.32.2 allows any workload triggering concurrent slow async read operations to pin BEAM scheduler threads at 100% CPU. The root cause is a busy-polling loop in Ash.Actions.Read.AsyncLimiter.await_at_least_one/1 that called Task.yield(task, 0) repeatedly with zero timeout rather than sleeping until a task completed, keeping the calling scheduler thread active throughout the wait. Multiple concurrent slow related-data loads or calculations compound the impact by saturating additional scheduler threads, potentially degrading or denying service to the entire Elixir node. No public exploit identified at time of analysis; vendor-released patch ash 3.32.2 resolves the issue.
RemediationAI
Upgrade ash to version 3.32.2 or later, which replaces the busy-polling loop with a blocking Task.yield_many call; the patch commit is available at https://github.com/ash-project/ash/commit/0a5ecd2ffdfa848afdeb8827f02982ef2a63a1cd. If an immediate upgrade is not feasible, compensating controls should target reduction of concurrent slow async reads: limit the concurrency of background tasks per request at the application level using ash's async_limiter configuration or Elixir's Task.Supervisor with bounded pools, and enforce request timeouts to prevent long-running data loads from holding scheduler threads indefinitely. Restricting access to endpoints that perform heavy relationship loading (e.g., aggregate queries or external-API-backed calculations) via rate limiting or authenticated access controls reduces the window for adversarial load amplification. These mitigations reduce probability of scheduler saturation but do not eliminate the underlying busy-spin flaw; patching remains the only complete fix. The GHSA advisory at https://github.com/ash-project/ash/security/advisories/GHSA-33wq-x3q2-c92h should be consulted for any additional vendor guidance.
Affected VersionsENISA
Affected Packages
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 is an Elixir resource framework built on the BEAM (Erlang Virtual Machine), which uses a preemptive scheduler pool where each OS thread runs a BEAM scheduler. BEAM schedulers are cooperative/preemptive at reduction boundaries, meaning a process that loops without yielding holds a scheduler thread. The affected code in lib/ash/actions/read/async_limiter.ex used Task.yield(task, 0) - a zero-millisecond timeout poll - inside Enum.map over all outstanding async tasks. When all tasks are still running, every Task.yield returns nil immediately, the list passes through unchanged, and the recursive await_at_least_one call restarts instantly, creating a pure busy-wait spin. The fix replaces this with Task.yield_many(tasks, timeout: 0) to collect any already-complete tasks, and falls back to Task.yield_many(pending, limit: 1, timeout: :infinity) when nothing is ready - a blocking wait that releases the scheduler until at least one task finishes. CWE-400 (Uncontrolled Resource Consumption) accurately characterizes the flaw: CPU cycles are consumed without bound relative to the duration of the slow operation. CPE cpe:2.3:a:ash-project:ash:*:*:*:*:*:*:*:* covers all affected versions within the 2.19.0-3.32.2 range.
Know when Ash 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:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Network-reachable via HTTP endpoints; AC:H because concurrent slow async reads are required (AT:P equivalent); no C/I impact, only partial availability loss.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Uncontrolled Resource Consumption vulnerability in ash-project ash lets a slow asynchronous read spin a scheduler thread at full CPU while the framework waits for it.
Ash.Actions.Read.AsyncLimiter.await_at_least_one/1 (lib/ash/actions/read/async_limiter.ex) waited for concurrent async read tasks by polling each with Task.yield(task, 0) in a tight loop rather than blocking. While every outstanding task is still running (a slow related-data load or calculation), the loop returns immediately and repeats, busy-spinning and holding a BEAM scheduler at full CPU for the whole duration of the slow read; concurrent slow reads tie up further schedulers. The fix waits with Task.yield_many (a non-blocking sweep followed by a blocking wait with timeout: :infinity), so the process sleeps until a task completes instead of spinning.
This issue affects ash: from 2.19.0 before 3.32.2.
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.
Private argument injection in the Ash Elixir framework (versions 3.0.0 through 3.29.2) allows end users to set action ar
An issue was discovered in the ash crate before 0.33.1 for Rust. Rated critical severity (CVSS 9.8), this vulnerability
Atom table exhaustion in the Ash framework (Elixir) allows an unauthenticated remote attacker to crash a BEAM node by su
Cross-tenant record takeover in the Ash framework (Elixir) for versions 1.22.0 up to 3.37.2: when a resource uses attrib
An authorization bypass in the Ash framework (Elixir) lets authenticated, lower-privileged actors recover values they ar
Information disclosure in the Ash framework for Elixir (versions 2.6.0 up to but not including 3.34.6) lets an authentic
An incorrect authorization flaw in the Elixir Ash framework (versions 3.24.0 up to but not including 3.37.1) lets an aut
Persistent record-level denial of service in the ash Elixir resource framework (versions 3.6.3-3.32.1) lets any actor wh
Integer overflow in Ash Framework's vector encoding corrupts stored vectors in any Elixir application using Ash versions
CPU exhaustion in Ash Framework's string type constraint handler allows denial of service against Elixir applications th
Memory exhaustion via decompression bomb in Ash Framework's keyset pagination can terminate Erlang nodes running version
Unbounded string storage in Ash Framework versions 0.10.0 through 3.32.x allows unauthenticated attackers to bypass max_
EUVD-2026-68948
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB