Skip to main content

ash Framework CVE-2026-82743

| EUVDEUVD-2026-68948 LOW
Uncontrolled Resource Consumption (CWE-400)
2026-09-01 EEF
2.1
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Send concurrent requests to data-heavy ash endpoint
  2. Delivery
    Application spawns async read tasks via AsyncLimiter
  3. Exploit
    All tasks still running; Task.yield(task, 0) returns nil for each
  4. Execution
    Tight recursive loop holds BEAM scheduler at 100% CPU
  5. Persist
    Multiple concurrent request waves exhaust scheduler thread pool
  6. Impact
    Application-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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

ash c48cb08026cf56b1ac33209203bc9c00061b40b8 <0a5ecd2ffdfa848afdeb8827f02982ef2a63a1cd
ash 2.19.0 <3.32.2

Affected Packages

euvd ash fix: 3.32.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

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

Vendor (EEF) PRIMARY 2.1 LOW
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
vuln.today AI 3.7 LOW

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/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
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Low
popular within Elixir ecosystem, niche outside it
Data Quality
6 sources
Confidence: High

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 LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

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

More in Ash

View all
CVE-2026-55736 MEDIUM POC
5.9 Jun 23

Private argument injection in the Ash Elixir framework (versions 3.0.0 through 3.29.2) allows end users to set action ar

CVE-2021-45688 CRITICAL
9.8 Dec 27

An issue was discovered in the ash crate before 0.33.1 for Rust. Rated critical severity (CVSS 9.8), this vulnerability

CVE-2026-94201 HIGH
8.2 Oct 05

Atom table exhaustion in the Ash framework (Elixir) allows an unauthenticated remote attacker to crash a BEAM node by su

CVE-2026-96581 HIGH
7.6 Oct 26

Cross-tenant record takeover in the Ash framework (Elixir) for versions 1.22.0 up to 3.37.2: when a resource uses attrib

CVE-2026-86338 MEDIUM
6.0 Sep 16

An authorization bypass in the Ash framework (Elixir) lets authenticated, lower-privileged actors recover values they ar

CVE-2026-101028 MEDIUM
6.0 Oct 09

Information disclosure in the Ash framework for Elixir (versions 2.6.0 up to but not including 3.34.6) lets an authentic

CVE-2026-114214 MEDIUM
6.0 Oct 25

An incorrect authorization flaw in the Elixir Ash framework (versions 3.24.0 up to but not including 3.37.1) lets an aut

CVE-2026-82738 MEDIUM
5.9 Sep 01

Persistent record-level denial of service in the ash Elixir resource framework (versions 3.6.3-3.32.1) lets any actor wh

CVE-2026-82737 MEDIUM
5.9 Sep 01

Integer overflow in Ash Framework's vector encoding corrupts stored vectors in any Elixir application using Ash versions

CVE-2026-82735 MEDIUM
5.9 Sep 01

CPU exhaustion in Ash Framework's string type constraint handler allows denial of service against Elixir applications th

CVE-2026-69659 MEDIUM
5.9 Aug 09

Memory exhaustion via decompression bomb in Ash Framework's keyset pagination can terminate Erlang nodes running version

CVE-2026-82752 MEDIUM
5.9 Sep 05

Unbounded string storage in Ash Framework versions 0.10.0 through 3.32.x allows unauthenticated attackers to bypass max_

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