Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker holds valid subscription on affected 1.4.0-1.10.x instance
-
DeliveryBatcher backpressure or noproc triggers inline do_send/5 in caller process
-
ExploitResolver fires synchronous nested Ash notification
-
ExecutionInner do_send/5 reads outer run's :batch_resolved key
-
ImpactInner call publishes wrong tenant's records to attacker's topic
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V14 - Data Protection Exposure of data element to wrong session
|
| Exploitation Conditions | Two simultaneous conditions are required for exploitation. First, the AshGraphql.Subscription.Batcher process must be unavailable or under sufficient backpressure to trigger the |
| Impact | The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:L/UI:N/VC:L/VI:N/VA:N) scores 2.3, which accurately reflects the narrow exploitation window: AC:H and AT:P together capture that two independent conditions must coincide - the Batcher must be on a fallback path AND a re-entrant synchronous notification must fire during the publish cycle. The confidentiality impact is real but bounded (VC:L): resolved records from one subscription topic are delivered verbatim to a different subscriber, which in multi-tenant deployments could expose records across tenant or actor isolation boundaries - a meaningful privacy breach despite the low numeric score. No EPSS data was provided in the input, and this CVE is absent from the CISA KEV catalog, indicating no confirmed active exploitation at time of analysis. The practical risk is highest for multi-tenant applications using ash_graphql 1.4.0-1.10.x where the Batcher process may be intermittently unavailable under load, enabling the fallback path. Single-tenant or non-nested-notification deployments are unlikely to encounter the race condition in practice. |
| Exploit ScenarioDerived | A legitimate subscriber in a multi-tenant ash_graphql application sends a mutation that triggers a chained synchronous Ash notification while the Batcher is under backpressure, causing do_send/5 to execute inline in the caller's process. The inner publication run finds the outer run's |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAI
Cross-session record leakage in ash_graphql's subscription batcher allows one subscriber's resolved GraphQL records to be delivered to a different subscriber's topic, potentially crossing tenant and actor boundaries. Versions 1.4.0 through 1.10.x are affected when the Batcher process falls back to inline :backpressure_sync or :noproc execution paths and a subscription resolver triggers a nested synchronous Ash notification in the same caller process. No public exploit has been identified at time of analysis, and a vendor-released patch is available in version 1.11.0.
RemediationAI
Upgrade ash_graphql to version 1.11.0 or later, which resolves the issue via commit b798ef5288664a0261990b19765558f168b718fb (https://github.com/ash-project/ash_graphql/commit/b798ef5288664a0261990b19765558f168b718fb). The fix wraps each do_send/5 invocation in a try/after block that saves, deletes, and restores the ambient :batch_resolved process dictionary entry, ensuring run-level isolation even on re-entrant inline calls. If an immediate upgrade is not feasible, a partial mitigation is to ensure the AshGraphql.Subscription.Batcher supervision tree is configured to keep the Batcher process consistently available, reducing the likelihood of falling back to the :backpressure_sync or :noproc paths where the flaw is reachable - however, this does not eliminate the vulnerability under all load conditions and is not a substitute for patching. The vendor advisory is at https://github.com/ash-project/ash_graphql/security/advisories/GHSA-wm4m-cjmc-5v8c.
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_graphql is an Elixir library integrating the Ash framework with Absinthe's GraphQL subscription engine. The root cause (CWE-488: Exposure of Data Element to Wrong Session) resides in AshGraphql.Subscription.Batcher.do_send/5, which uses the Erlang/OTP process dictionary - a per-process mutable key-value store - to pass resolved batch data between pipeline stages via the un-namespaced :batch_resolved key. Under normal operation do_send/5 runs inside a library-owned OTP task, giving each invocation its own isolated process dictionary. On the :backpressure_sync and :noproc fallback paths, however, do_send/5 executes inline in the publishing caller's process. If a resolver inside the outer call triggers another synchronous Ash notification, the resulting inner do_send/5 invocation runs in the same process, finds the outer run's :batch_resolved value still present, adopts it as its own result, publishes it to the inner topic (a distinct subscription with a different actor and tenant), then deletes the key - leaving the outer run with nothing to publish. The CPE string cpe:2.3:a:ash-project:ash_graphql:*:*:*:*:*:*:*:* covers all affected builds from 1.4.0 onward.
Know when Ash Graphql 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:H/AT:P/PR:L/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Network vector via WebSocket subscription; AC:H requires backpressure fallback and re-entrant notification simultaneously; PR:L for authenticated subscriber; no integrity or availability impact.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Exposure of Data Element to Wrong Session vulnerability in ash-project ash_graphql can deliver one subscription's resolved records to a different subscriber's topic.
AshGraphql.Subscription.Batcher.do_send/5 reads the resolved batch from the process dictionary via Process.get(:batch_resolved) and then unconditionally deletes it. That is sound only inside a task the library owns. On the :backpressure_sync and :noproc fallbacks do_send/5 runs inline in the publishing caller's process, so if a resolver inside an outer do_send/5 triggers another synchronous Ash notification, the inner call finds the outer run's value still under :batch_resolved, adopts it as its own result, and publishes it to the inner topic, a different subscription document with a different actor and tenant. It then deletes the key, so the outer run publishes nothing. The key is not namespaced by run, so records cannot be told apart. The fix saves, clears, and restores :batch_resolved around each run.
This issue affects ash_graphql: from 1.4.0 before 1.11.0.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Ash Graphql
View allAshGraphql's Absinthe complexity calculator undercounts nested Relay connection and keyset pagination queries, allowing
Cross-tenant data disclosure in ash_graphql affects authenticated subscribers in multi-tenant deployments running versio
Internal Ash attribute and argument names leak through GraphQL error responses in ash_graphql 1.9.0 through 1.10.x, bypa
Relay node query crash in AshGraphql (ash_graphql 0.27.0 through 1.10.x) allows an unauthenticated remote caller to abor
GraphQL subscription payloads carrying unauthorized record data leak to authenticated subscribers in ash_graphql 1.4.0-1
EUVD-2026-68283
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB