Skip to main content

ash_typescript EUVDEUVD-2026-68925

| CVE-2026-77950 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 crafted RPC request
  2. Delivery
    Trigger Ash error of unhandled shape
  3. Exploit
    FunctionClauseError raised in error handler
  4. Execution
    Pre-patch rescue clause returns raw error map
  5. Impact
    Client 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.

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

ash_typescript 0.8.0 <0.18.0
ash_typescript cb01cc8749e5a2a17fb45aedbe75df30a9f1126e <59d8e985a98cf2e01794dbe5b919b897a95311f4

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

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 because success depends on application-specific partial handler coverage gaps entirely outside attacker control; C:L bounds leakage to error var contents.

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

EPSS Score
0.3%
Top 76% exploitable
Prevalence
Rare
niche Elixir/Ash ecosystem library, limited production footprint
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