Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted .db file to victim
-
DeliveryPlant .shell/.system line in sqlite_schema.sql
-
ExploitVictim runs .recover and pipes to sqlite3
-
ExecutionDot-command emitted verbatim
-
ImpactExecute 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
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
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).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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.
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
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Multiple unspecified vulnerabilities in SQLite before 3.8.10.2, as used in Apple iOS before 9, have unknown impact and a
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
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
The getNodeSize function in ext/rtree/rtree.c in SQLite through 3.19.3, as used in GDAL and other products, mishandles u
Memory corruption in SQLite versions before 3.50.2 allows network-based attackers with low privileges to manipulate aggr
An exploitable use after free vulnerability exists in the window function functionality of Sqlite3 3.26.0. Rated high se
Arbitrary DLL loading in SQLite's sqldiff.exe utility on Windows allows attackers to achieve code execution by abusing t
Memory corruption in SQLite versions before 3.53.2 enables attackers to crash processes, exhaust memory, or potentially
SQLite 3.32.2 has a use-after-free in resetAccumulator in select.c because the parse tree rewrite for window functions i
SQLite through 3.31.1 allows attackers to cause a denial of service (segmentation fault) via a malformed window-function
A segmentation fault can occur in the sqlite3.exe command-line component of SQLite 3.36.0 via the idxGetTableInfo functi
OAuth and SCIM identity confusion in Open WebUI 0.6.41-0.10.x (SQLite-backed deployments only) allows unauthenticated re
EUVD-2026-113834
GHSA-2h5x-4qp8-353h
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB