Skip to main content

SQLite CLI CVE-2026-119586

| EUVDEUVD-2026-113834 HIGH
Command Injection (CWE-77)
2026-10-30 VulnCheck GHSA-2h5x-4qp8-353h
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted .db file to victim
  2. Delivery
    Plant .shell/.system line in sqlite_schema.sql
  3. Exploit
    Victim runs .recover and pipes to sqlite3
  4. Execution
    Dot-command emitted verbatim
  5. Impact
    Execute arbitrary OS commands as victim

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Command injection prevention
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a specific multi-step local workflow, not a passive or default-config trigger: (1) the victim must obtain and open an attacker-crafted SQLite database whose sqlite_schema.sql value holds a syntactically valid CREATE statement immediately followed by a '.shell' or '.system' dot-command line; (2) the victim must run the sqlite3 CLI '.recover' command against that database; and (3) the victim must pipe the .recover output back into a sqlite3 process (e.g. 'sqlite3 evil.db .recover | sqlite3 out.db'), at which point the planted dot-command is re-interpreted and executed. Limiting factors that reduce real-world risk: the vector is local (AV:L), passive user interaction is required (UI:P - the victim must actively run the recovery/pipe workflow), execution occurs only with the victim's own privileges, and the specific .recover-into-sqlite3 pipeline is a non-default administrative/recovery operation rather than ordinary database use. No authentication is required (PR:N) because the trust boundary crossed is the untrusted database file itself.

Impact

This is a genuine but context-dependent integrity/execution risk rather than a mass-exploitation emergency. The authoritative CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H) scores 8.5 and makes the key constraint explicit: the attack vector is LOCAL and requires passive user interaction (UI:P) - the victim must process an attacker-crafted database with the sqlite3 shell. This is NOT remote unauthenticated code execution despite the high score; the high confidentiality/integrity/availability impact reflects full OS command execution on the victim, but only once the victim performs a specific .recover workflow. The vuln.today decision label is 'this_week' (not act_now/emergency), consistent with a serious-but-not-under-active-mass-exploitation issue. No EPSS score and no KEV listing were provided in the input, so there is no signal of confirmed active exploitation; absence of these is not evidence of safety but should not be read as active exploitation either. A public research write-up (abraxaslabs) and a VulnCheck advisory are referenced, so exploit detail is public even though the input does not mark working exploit code as confirmed. Net: prioritize for remediation this cycle for anyone who ingests untrusted .db files with the CLI, but it is not a drop-everything internet-facing RCE.

Exploit ScenarioDerived

An attacker distributes a malicious SQLite database file (e.g. as an email attachment, download, or shared forensic/recovery artifact) whose sqlite_schema.sql value contains a valid CREATE statement followed by a '.shell' or '.system' dot-command line. A victim attempting to recover or rebuild the database runs the sqlite3 CLI .recover command and pipes its output into a sqlite3 instance; the planted dot-command is emitted verbatim and executed, running arbitrary OS commands with the victim's privileges. A public PoC reference exists (abraxaslabs research and VulnCheck advisory); it is not verified as working exploit code in the provided input.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.8% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 30, 2026

Command injection in the SQLite command-line shell through 3.54.1 lets an attacker-planted dot-command hidden in a database's sqlite_schema.sql text be re-interpreted and executed as an OS command when a victim pipes .recover output back into sqlite3. Exploitation is not passive: it requires the victim to open a crafted database, run the .recover command against it, and feed the resulting script into another sqlite3 process, so commands run only with the victim's own privileges in a non-default administrative recovery workflow. No public exploit has been identified at time of analysis, but the flaw is rated 8.5 (assessed CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and, being a genuine context-dependent execution risk rather than a mass-exploitation emergency, is prioritized for remediation this week.

RemediationAI

No vendor-released patch is identified at time of analysis; the available references point only to the vulnerable version-3.54.1 source (https://github.com/sqlite/sqlite, https://github.com/sqlite/sqlite/blob/version-3.54.1/ext/recover/sqlite3recover.c#L1221-L1223, https://github.com/sqlite/sqlite/blob/version-3.54.1/src/shell.c.in#L7877-L7891) and the VulnCheck advisory (https://www.vulncheck.com/advisories/sqlite-cli-through-3.54.1-command-injection-via-recover-output), so track those channels for a fixed build. Until one is available, break the exploit chain described in the advisory: do not pipe .recover output directly into a sqlite3 process, and instead write the recovery script to a file, inspect it for lines beginning with .shell or .system (or any unexpected dot-command), and only then execute it - the trade-off is a manual review step in recovery workflows. Recover only database files from trusted sources, since the malicious payload lives in sqlite_schema.sql before any recovery command is run; per the reporting research (https://abraxaslabs.tech/research/sqlite-cli-recover), the risk is confined to that .recover-into-sqlite3 pipeline rather than ordinary database use.

Affected VersionsENISA

SQLite 0 ≤3.54.1

Affected Packages

euvd sqlite no fix

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

SQLite persists schema definitions as SQL text in the sqlite_schema table, and the .recover command reconstructs a database by replaying those stored values into an output script. In version 3.54.1 the recovery logic in ext/recover/sqlite3recover.c (lines 1221-1223) emits the stored sqlite_schema.sql values verbatim, while the shell's dot-command dispatcher in src/shell.c.in (lines 7877-7891) treats any output line beginning with a dot as a client meta-command, including .shell and .system, which spawn OS commands. The root cause is CWE-77 (command injection): untrusted data recovered from a database file crosses into a command interpreter without neutralization of leading dot-commands. The reported trigger is a schema value containing a syntactically valid CREATE statement immediately followed by a .shell or .system line; when .recover output is piped into sqlite3 (for example sqlite3 evil.db .recover | sqlite3 out.db), the planted line is executed. This is a data-to-interpreter boundary failure, not a memory-safety defect, and the sources do not describe any race, heap manipulation, or attacker-uncontrolled timing element.

Know when 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 (VulnCheck) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Local vector because exploitation needs the victim to process an attacker-supplied file (AV:L/UI:R); no privileges needed (PR:N); resulting OS command execution gives full C/I/A impact in the user's context (S:U).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

SQLite command-line shell through 3.54.1 contains a command injection vulnerability in the .recover command that emits attacker-planted dot-commands stored in sqlite_schema.sql values verbatim. Attackers can craft a database whose schema holds a valid CREATE statement followed by a .shell or .system line, executing OS commands when victims pipe .recover output into sqlite3.

Executive ViewAI

Why It Matters

CVE-2026-119586 is a high-severity command injection flaw in the SQLite command-line shell (through version 3.54.1) that could allow an attacker to execute arbitrary OS commands with the victim's privileges. The vulnerability requires a specific, non-default recovery workflow (.recover output piped back into sqlite3), so exploitation is not passive or widespread. Leadership should care because this affects data recovery and administrative processes, and a successful exploit could lead to data compromise or system integrity loss for users performing these operations.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: avoid piping .recover output into another sqlite3 process; run recovery operations only on trusted databases; enforce least privilege for users performing recovery; monitor for suspicious dot-commands in database schema text.

Threat Intelligence Overview

EPSS Score
0.8%
Top 42% exploitable
Prevalence
High
sqlite3 command-line shell bundled broadly across Linux distros and developer environments
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 HIGH
CISA KEV No
Public POC No
EPSS 0.8%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

More in Sqlite

View all
CVE-2015-5895 CRITICAL POC
10.0 Sep 18

Multiple unspecified vulnerabilities in SQLite before 3.8.10.2, as used in Apple iOS before 9, have unknown impact and a

CVE-2019-8457 CRITICAL
9.8 May 30

SQLite3 from 3.6.0 to and including 3.27.2 is vulnerable to heap out-of-bound read in the rtreenode() function when hand

CVE-2022-35737 HIGH POC
7.5 Aug 03

SQLite 1.0.12 through 3.39.x before 3.39.2 sometimes allows an array-bounds overflow if billions of bytes are used in a

CVE-2017-10989 CRITICAL
9.8 Jul 07

The getNodeSize function in ext/rtree/rtree.c in SQLite through 3.19.3, as used in GDAL and other products, mishandles u

CVE-2025-6965 HIGH POC
7.2 Jul 15

Memory corruption in SQLite versions before 3.50.2 allows network-based attackers with low privileges to manipulate aggr

CVE-2019-5018 HIGH POC
8.1 May 10

An exploitable use after free vulnerability exists in the window function functionality of Sqlite3 3.26.0. Rated high se

CVE-2025-71316 CRITICAL POC
9.2 Jun 04

Arbitrary DLL loading in SQLite's sqldiff.exe utility on Windows allows attackers to achieve code execution by abusing t

CVE-2026-11822 MEDIUM POC
6.8 Jun 09

Memory corruption in SQLite versions before 3.53.2 enables attackers to crash processes, exhaust memory, or potentially

CVE-2020-13871 HIGH POC
7.5 Jun 06

SQLite 3.32.2 has a use-after-free in resetAccumulator in select.c because the parse tree rewrite for window functions i

CVE-2020-11655 HIGH POC
7.5 Apr 09

SQLite through 3.31.1 allows attackers to cause a denial of service (segmentation fault) via a malformed window-function

CVE-2021-36690 HIGH POC
7.5 Aug 24

A segmentation fault can occur in the sqlite3.exe command-line component of SQLite 3.36.0 via the idxGetTableInfo functi

CVE-2026-87016 HIGH POC
8.1 Sep 09

OAuth and SCIM identity confusion in Open WebUI 0.6.41-0.10.x (SQLite-backed deployments only) allows unauthenticated re

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