Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted RPC request
-
DeliveryTrigger Ash error of unhandled shape
-
ExploitFunctionClauseError raised in error handler
-
ExecutionPre-patch rescue clause returns raw error map
-
ImpactClient receives unredacted vars containing runtime secrets
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Error message sanitization
MITRE ATT&CK
1 technique across 1 tactic: Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires two specific conditions to be simultaneously true: first, the application must have configured a custom error_handler in its Ash domain typescript_rpc block - applications using only the default error path are not affected; second, that handler must be a partial pattern-matching function that does not cover the specific Ash error shape triggered by the attacker's request. The attacker must be able to send network requests that cause the application to generate an Ash error of an unhandled type; any input causing a validation failure, query error, or runtime Ash exception can serve as a trigger. Exploitation is further limited to deployments where those error vars actually carry sensitive runtime values - applications that generate errors with only safe or empty vars fields face information disclosure of low practical consequence. Authentication is not required per CVSS PR:N. The original vulnerability did not cover handler throws or exits; the fix closes both paths simultaneously. |
| Impact | The CVSS 4.0 score of 6.3 with AT:P accurately captures that exploitation is conditional: the application must have a custom error handler that does not cover all possible Ash error shapes, which is the common but not universal Elixir pattern-matching idiom. Applications with no custom error handler or with exhaustive catch-all clauses are unaffected. The AV:N/PR:N metrics indicate that any unauthenticated client capable of triggering application errors could extract internal state wherever the handler gap exists. The severity of leaked data depends entirely on what Ash errors carry in their vars at runtime - in worst-case deployments, this includes production database credentials or API tokens. No EPSS data was provided, and the absence of a CISA KEV listing suggests no confirmed widespread active exploitation, though the ease of triggering diverse error shapes through normal API fuzzing makes opportunistic discovery plausible without dedicated tooling. The CVSS 4.0 vector is consistent with the description; no conflicting signals are present. |
| Exploit ScenarioDerived | An attacker sends crafted API requests to an ash_typescript RPC endpoint, deliberately triggering Ash error types - such as query or authorization errors - that the application's partial error handler does not pattern-match. The FunctionClauseError propagates to the pre-patch rescue clause, which returns the raw error map including its vars field in the JSON response. If that error's vars contains a production secret such as a backend service token or database URI, it is returned to the unauthenticated caller. No public proof-of-concept code has been identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 01, 2026
Sensitive internal error data - including runtime secrets potentially carried in Ash error vars fields - leaks to unauthenticated network clients in ash_typescript 0.8.0 through 0.17.x when a configured error handler raises a FunctionClauseError on an unmatched error shape. The rescue clause in apply_error_handler/3 was intended as a safety net but fell back to returning the original, unredacted error map rather than a safe generic response, inverting the intended suppress-on-failure semantics. No public exploit code has been identified and there is no CISA KEV listing; a patched release (0.18.0) is available from the Ash Project.
RemediationAI
Upgrade ash_typescript to version 0.18.0 or later, which replaces the fail-open rescue clause with the fail-closed generic_internal_error/2 path; the patch commit is https://github.com/ash-project/ash_typescript/commit/59d8e985a98cf2e01794dbe5b919b897a95311f4 and the vendor advisory is at https://github.com/ash-project/ash_typescript/security/advisories/GHSA-mjr7-r3rf-x963. If immediate upgrade is not possible, add an exhaustive catch-all clause to every configured error handler - for example, a final def handle_error(_error, _context), do: nil clause that returns nil to suppress unmatched errors entirely - so that no error shape reaches the unpatched rescue path; note this suppresses all unmatched errors rather than sanitizing them, which may degrade client-visible error reporting. Also audit all Ash error types that the application can generate and the runtime values they may carry in vars, to understand the realistic exposure window until patching.
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_typescript is an Elixir library that extends the Ash framework to expose TypeScript-typed RPC endpoints. The vulnerability resides in AshTypescript.Rpc.Errors.apply_error_handler/3 in lib/ash_typescript/rpc/errors.ex, which is the sole pre-client hook for redacting or suppressing error data before it reaches the API response. Per CWE-209, the root cause is that error detail intended only for server logs reaches the client. In Elixir, error handlers are idiomatically written as multi-clause functions pattern-matched over anticipated error shapes; any unrecognized shape raises a FunctionClauseError at runtime. The pre-patch rescue clause caught this exception but then returned the original error map to the caller - including the vars field, which Ash populates with runtime values at exception creation time and which can hold database URIs, authentication tokens, internal hostnames, or other secrets. The fix (commit 59d8e985) replaces the fail-open fallback with a call to a new private generic_internal_error/2 function, which emits a UUID-keyed opaque message to the client and logs the full details server-side only. It also adds a catch block to handle handler throws and exits, closing both the raise and throw escape paths. CPE: cpe:2.3:a:ash-project:ash_typescript.
Know when Ash Typescript 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:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
AC:H because success depends on application-specific partial handler coverage gaps entirely outside attacker control; C:L bounds leakage to error var contents.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Generation of Error Message Containing Sensitive Information vulnerability in ash-project ash_typescript allows an unauthenticated attacker to receive unredacted internal error data by provoking an error shape the configured error handler does not match.
apply_error_handler/3 in lib/ash_typescript/rpc/errors.ex is the only hook an application has for redacting or suppressing errors before they reach the client, with a nil return dropping the error entirely. Its rescue clause logs a warning and then returns the original, pre-handler error map. Error handlers are conventionally written as pattern-matching functions over expected error shapes, so an unmatched shape raises FunctionClauseError and the raw transformed error, including any secrets carried in vars, is emitted instead. An intent to suppress an error becomes an intent to publish it. The rescue catches exceptions only, so a handler that throws or exits still propagates.
This issue affects ash_typescript: from 0.8.0 before 0.18.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.
EUVD-2026-68925
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB