Skip to main content

ash_typescript CVE-2026-82733

| EUVDEUVD-2026-68928 MEDIUM
Error Message Information Leak (CWE-209)
2026-09-01 EEF
6.3
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Send HTTP request to vulnerable typed-controller route
  2. Delivery
    Handler returns non-conn error tuple
  3. Exploit
    dispatch/3 routes to unexpected_return/2
  4. Execution
    inspect(value, limit: 50) serializes full Elixir struct
  5. Persist
    Sensitive fields embedded in JSON 500 response
  6. Impact
    Attacker 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

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

ash_typescript 0.15.0 <0.18.0
ash_typescript 546a15e1a2d7dbf1df2d5a6ee4404bc3da87852e <dec80e29543f96e43eeece8501376562f17ac638

Affected Packages

euvd ash_typescript fix: 0.18.0

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

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

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.3%
Top 76% exploitable
Prevalence
Rare
niche Elixir library for Ash Framework TypeScript generation
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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