Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP request to vulnerable typed-controller route
-
DeliveryHandler returns non-conn error tuple
-
Exploitdispatch/3 routes to unexpected_return/2
-
Executioninspect(value, limit: 50) serializes full Elixir struct
-
PersistSensitive fields embedded in JSON 500 response
-
ImpactAttacker reads hashed passwords and tokens from response body
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 that at least one typed-controller route handler in the target application returns a value other than %Plug.Conn{} - for example, an error tuple such as {:error, %SomeStruct{}} or a bare map or atom. This condition arises from application-layer coding patterns (incomplete handlers, error-branch fallthrough) and is not attacker-controllable unless the attacker can also influence handler logic through request inputs. The CVSS AT:P (Attack Requirements: Present) formally encodes this precondition. Exploitation is further scoped to ash_typescript versions 0.15.0-0.17.x and only affects routes processed by the TypedController request handler. No authentication is required (PR:N) and no user interaction is needed (UI:N). Applications where all typed-controller handlers are guaranteed to return a %Plug.Conn{} on every code path - including error branches - are not exploitable regardless of version. |
| Impact | The CVSS 4.0 score of 6.3 (AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N) reflects two competing signals: network-reachable with no privileges or user interaction required (PR:N, AV:N), but AT:P (Attack Requirements: Present) indicating a deployment-specific precondition - a route handler must return a non-conn value. This precondition is outside attacker control and is the primary risk limiter. Applications whose handlers always return a %Plug.Conn{} are not exploitable regardless of version. The confidentiality impact is rated Low in CVSS 4.0 terms, though practically the exposed data (hashed passwords, tokens) can be high-value depending on the application's domain model. No CISA KEV listing and no public exploit code identified; the vulnerability is not confirmed as actively exploited. Real-world risk is meaningful for applications in rapid development or those with error-handling branches that return error tuples to typed-controller dispatch, and negligible for applications with complete handler coverage. |
| Exploit ScenarioDerived | An unauthenticated attacker sends an HTTP request to a typed-controller endpoint whose handler returns {:error, %User{hashed_password: "$2b$12$...", token: "...", tenant_id: "..."}} rather than a %Plug.Conn{}. The unpatched dispatch/3 calls unexpected_return/2, which serializes the full struct via inspect/2 and embeds it in the JSON 500 response body; the attacker reads the hashed password and session token directly from the response with no further steps required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 01, 2026
Sensitive application data leaks from HTTP 500 responses in ash_typescript versions 0.15.0 through 0.17.x due to an ungated code path that serializes handler return values verbatim using Elixir's inspect/2. Any unauthenticated caller who can trigger a typed-controller route whose handler falls through with a non-conn term - such as {:error, %User{}} - receives the full Elixir struct inspection, potentially including hashed passwords, session tokens, and tenant identifiers, in the JSON error body. No public exploit identified at time of analysis, but the disclosure is trivially reproducible with a standard HTTP client given the right application-layer condition.
RemediationAI
Upgrade ash_typescript to version 0.18.0 or later, which gates the unexpected-return detail behind the typed_controller_show_raised_errors configuration flag (defaulting to false), matching the behavior of the existing exception rescue path. The authoritative patch commit is dec80e29543f96e43eeece8501376562f17ac638 at https://github.com/ash-project/ash_typescript/commit/dec80e29543f96e43eeece8501376562f17ac638, and the advisory is at https://github.com/ash-project/ash_typescript/security/advisories/GHSA-ghhw-qh7p-55xr. If an immediate upgrade is not feasible, audit all typed-controller route handlers to ensure every code path explicitly returns a %Plug.Conn{} struct - eliminating handler fallthrough removes the exploitable condition, though this requires a complete handler audit with associated regression risk. Do not set typed_controller_show_raised_errors: true in any production environment; doing so explicitly re-enables the leaking behavior even on patched versions.
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 Hex package (CPE: cpe:2.3:a:ash-project:ash_typescript:*:*:*:*:*:*:*:*) within the Ash Framework ecosystem that generates TypeScript client types for Phoenix/Plug-based web applications. The flaw resides in AshTypescript.TypedController.RequestHandler.dispatch/3, which routes non-conn handler returns through unexpected_return/2. That function calls inspect(value, limit: 50) and interpolates the result directly into the JSON 500 response body. The limit: 50 option caps the number of elements per collection, not the overall term depth, so a struct like %User{hashed_password: ..., token: ...} serializes its full field set. CWE-209 (Generation of Error Message Containing Sensitive Information) precisely describes the root cause: an error path that emits internal runtime data without sanitization or gating. The same module's rescue clause for raised exceptions is correctly gated behind AshTypescript.typed_controller_show_raised_errors?/0 with a safe default of false - the unexpected-return path simply lacked this identical gate.
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 reflects the AT:P precondition (handler fallthrough required); PR:N as no credentials needed; C:L since only specific struct fields are exposed rather than full system confidentiality.
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 read internal application data from an HTTP 500 response body.
When a typed-controller route handler returns anything other than a %Plug.Conn{}, dispatch/3 in lib/ash_typescript/typed_controller/request_handler.ex passes the value to unexpected_return/2, which interpolates inspect(value, limit: 50) directly into the response message. The limit option bounds elements per collection rather than the term as a whole, so a handler falling through with a term such as {:error, %User{}} or a changeset serialises its full field set, including hashed passwords, tokens, and tenant identifiers, into the JSON error returned to the caller.
This contradicts the module's own posture elsewhere: the rescue clause gates Exception.message/1 behind AshTypescript.typed_controller_show_raised_errors?/0 and otherwise returns a generic message, while this path is ungated and always echoes.
This issue affects ash_typescript: from 0.15.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-68928
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB