Skip to main content

AshSqlite CVE-2026-77846

| EUVDEUVD-2026-68147 LOW
Improper Neutralization of Special Elements in Data Query Logic (CWE-943)
2026-08-30 EEF
2.1
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Identify API endpoint accepting user-controlled get_path field name
  2. Delivery
    Submit segment containing JSONPath metacharacters (e.g. 'nested.private_key')
  3. Exploit
    AshSqlite assembles unescaped json_extract path
  4. Execution
    SQLite descends multiple JSON levels
  5. Impact
    Read 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAI

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

ash_sqlite c12be48a5b6295593199b0e445b70a4aef81d1cd <2138480fceb654bec1845e691517ac409d0232c3
ash_sqlite 0.1.2-rc.0 <0.2.18

Affected Packages

euvd ash_sqlite fix: 0.2.18

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

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

Network-accessible endpoints are the realistic attack surface; confidentiality impact is partial (JSON sub-fields only), with no integrity or availability loss.

3.1 AV:N/AC:L/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
Local
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

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

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Rare
niche Elixir/Ash framework SQLite library, minimal production footprint
Threat Intel
1
1 source
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment NEWS GitHub VulDB

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 LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

10
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
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.

NoSQL injection exploits databases that don't use traditional SQL syntax-like MongoDB, CouchDB, or Redis-by manipulating queries through unsanitized user input.

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