Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify API endpoint accepting user-controlled get_path field name
-
DeliverySubmit segment containing JSONPath metacharacters (e.g. 'nested.private_key')
-
ExploitAshSqlite assembles unescaped json_extract path
-
ExecutionSQLite descends multiple JSON levels
-
ImpactRead unexposed nested field value
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Query language parameterization
|
| Exploitation Conditions | Exploitation requires that the application exposes at least one endpoint or query parameter where user-supplied string input is placed directly into a get_path/2 segment list without prior sanitization - the description characterizes this as 'a common pick-a-field pattern.' The attacker must additionally know (or be willing to enumerate) the nested key names present in the target JSON column. Exploitation is bounded to JSON sub-field disclosure within the single column already accessible via get_path; cross-table reads, data modification, and denial of service are not achievable. The CVSS PR:N indicates no authentication is required by the library itself, but actual exploitability depends entirely on whether the consuming application exposes the vulnerable endpoint without authentication; endpoints requiring authentication substantially reduce realistic risk. No non-default OS, platform, or database configuration is required beyond running ash_sqlite 0.1.2-rc.0 through 0.2.17 with a SQLite backend. |
| Impact | The overall risk is low but non-trivial for applications that expose user-controlled field selection over JSON columns. The CVSS 4.0 score of 2.1 reflects a read-only, partial confidentiality impact (VC:L) with no integrity or availability loss; AT:P acknowledges that a specific enabling condition must be present in the application. The AV:L designation in the provided CVSS 4.0 vector warrants scrutiny - the description explicitly frames the vulnerability as reachable through application endpoints that accept user input, which in most real deployments means network-accessible APIs; security teams should verify actual network exposure of their get_path endpoints rather than anchoring on AV:L. EPSS data was not provided, and the CVE is absent from the CISA KEV catalog, meaning no confirmed active exploitation exists at time of analysis. Impact is strictly bounded to JSON sub-field disclosure within the single column already targeted by the get_path call - no cross-table reads, data modification, or availability impact is possible. The patch is low-risk and localized. |
| Exploit ScenarioDerived | An attacker using an API endpoint that accepts a user-supplied field name parameter mapped to a get_path/2 call submits the value 'public_info.secret_token' as a single segment. AshSqlite assembles the path '$.public_info.secret_token', which SQLite interprets as a two-level descent, returning the value at json_column['public_info']['secret_token'] - a nested field the application intended to keep private. No public proof-of-concept code is known, but the attack is trivially constructable by anyone who can enumerate the target column's JSON schema. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAI
JSON path injection in AshSqlite (0.1.2-rc.0 through 0.2.17) allows any attacker who can supply user-controlled input to a get_path/2 query segment to read nested JSON sub-fields that the application never intended to expose. The vulnerable AshSqlite.SqlImplementation code naively concatenates user-supplied segments with periods into a SQLite json_extract path, so a segment containing a dot (e.g., 'private.secret') descends two JSON levels instead of matching a single literal key. No public exploit has been identified and the vulnerability is absent from the CISA KEV catalog; a vendor patch is available targeting version 0.2.18.
RemediationAI
Upgrade ash_sqlite to version 0.2.18 or later, which incorporates the fix in commit 2138480fceb654bec1845e691517ac409d0132c3 (https://github.com/ash-project/ash_sqlite/commit/2138480fceb654bec1845e691517ac409d0232c3). The patch is a localized change to the path-building function and carries no known functional side effects for correctly formed path segments. If immediate upgrade is not feasible, audit all application endpoints for user-controlled input flowing into get_path/2 segment lists and either validate segments against a strict allowlist of expected key names or remove user control over segment values entirely; this eliminates the attack surface without a library update but may restrict intended query flexibility. The vendor security advisory is at https://github.com/ash-project/ash_sqlite/security/advisories/GHSA-hrp2-5hgw-c83c.
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
AshSqlite (cpe:2.3:a:ash-project:ash_sqlite) is an Elixir data layer for the Ash framework backed by SQLite. The SqlImplementation module generates SQLite json_extract(column, path) calls for get_path/2 expressions. The vulnerable line - path = "$." <> Enum.join(right, ".") - concatenates user-supplied segments directly into the JSONPath string without escaping. SQLite's json_extract grammar assigns special meaning to '.', '[', ']', and '$', none of which are neutralized before path assembly. CWE-943 (Improper Neutralization of Special Elements in Data Query Logic) captures the root cause precisely: segments are correctly bound as SQL parameters, preventing SQL injection, but the JSONPath string itself is assembled in application code where metacharacters remain unescaped. The fix in commit 2138480 introduces encode_json_path/1, wrapping each string segment in double-quoted dot-bracket notation and handling integer segments as array indices, ensuring every segment is treated as a literal key name rather than a path expression.
Know when Ash Sqlite 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:L/VI:N/VA:N/SC:N/SI:N/SA:N
Network-accessible endpoints are the realistic attack surface; confidentiality impact is partial (JSON sub-fields only), with no integrity or availability loss.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Improper Neutralization of Special Elements in Data Query Logic vulnerability in ash-project ash_sqlite allows an attacker who controls a get_path/2 segment to traverse into nested JSON the application never exposed, disclosing private or sensitive? embedded fields.
AshSqlite.SqlImplementation builds the SQLite json_extract path with "$." <> Enum.join(right, "."), so a single segment containing ., [, ], or $ re-interprets the JSON path (for example "private.secret" descends two levels instead of naming one key). The path is bound as a parameter, so this is confined to the JSON-path grammar rather than SQL. Any endpoint that lets user input reach a get_path segment (a common pick-a-field pattern) can read nested values it never meant to expose.
This issue affects ash_sqlite: from 0.1.2-rc.0 before 0.2.18.
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.
NoSQL injection exploits databases that don't use traditional SQL syntax-like MongoDB, CouchDB, or Redis-by manipulating queries through unsanitized user input.
EUVD-2026-68147
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB