Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious changeset repeating a table name
-
DeliveryDeliver changeset to session-enabled application
-
ExploitApplication invokes sqlite3changeset_apply()
-
ExecutionOversized column count triggers memset in sessionUpdateFind()
-
ImpactHeap buffer overflow corrupts adjacent memory
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires SQLite to be compiled with the session extension (SQLITE_ENABLE_SESSION), which is not enabled in default builds, and requires the target application to call sqlite3changeset_apply() (or apply_v2) on an attacker-controlled changeset. The precise trigger, per the vendor fix, is a changeset that repeats a table name in a second changeset block with a larger column count, driving sessionUpdateFind() to memset beyond the undersized aUpdateMask allocation. Limiting factors: only SQLite versions before 3.54.0 are affected; the attack vector is local (AV:L) and needs the application/user to process the malicious changeset (UI:P), so there is no direct remote-network path and no exposure for applications that do not ingest untrusted changesets. |
| Impact | This is a genuine memory-corruption bug (CWE-787 out-of-bounds write) in SQLite's session extension, confirmed and patched by the vendor at version 3.54.0, with the mechanism verified directly from the commit diff (64459c87) and a regression test (sessioncorrupt.test) that applies a crafted 242-byte changeset. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, VC:H/VI:H/VA:H, score 8.5) indicates a local attack vector with no privileges but requiring passive user/application interaction - i.e. an application must be induced to apply an attacker-supplied changeset - rather than remote unauthenticated network exploitation. The vuln.today decision label is 'this_week', which signals prompt but not emergency remediation; this is consistent with the absence of any CISA KEV listing and no EPSS score in the input (no active-exploitation or mass-exploitation signal is present). The dominant limiting factor, not captured by the CVSS score, is that the session extension must be compiled in (SQLITE_ENABLE_SESSION is not a default build option) and the application must process untrusted changesets, so real-world exposure is far narrower than SQLite's ubiquity would suggest. Net: a real, well-substantiated priority for the specific population of applications that apply untrusted changesets, but not a broad emergency for typical SQLite deployments. No EPSS and no KEV data were supplied, so widespread exploitation cannot be assessed from the input. |
| Exploit ScenarioDerived | An application built with SQLite's session extension (e.g. a sync or replication client) accepts a changeset from an untrusted source and passes it to sqlite3changeset_apply(). The attacker supplies a crafted changeset that repeats a table name in a second block declaring a larger column count, causing sessionUpdateFind() to memset past the undersized aUpdateMask allocation and corrupt the heap. A public PoC reference exists (the vendor regression test embeds a working trigger changeset and VulnCheck/Abraxas Labs published research); it is not verified in the input as a weaponized working exploit. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Heap memory corruption in SQLite's session extension can be triggered when an application calls sqlite3changeset_apply() (or apply_v2) on a crafted changeset, letting an attacker write past an undersized column-mask buffer, crashing the process or potentially achieving code execution under the privileges of the hosting application. Only SQLite builds earlier than 3.54.0 that were compiled with SQLITE_ENABLE_SESSION are affected; the vector is local (AV:L) with user interaction required, but no privileges are needed (PR:N) and there is no direct remote-network path, so exposure is limited to applications that ingest untrusted changesets. The vendor fixed the flaw in SQLite 3.54.0 (commit 64459c87cc702d600704fb77ee40ca1782398a52) and added a regression test that applies a 242-byte crafted changeset; no public exploit code has been identified at time of analysis.
RemediationAI
Upgrade to SQLite 3.54.0 or later, which contains the fix described at https://sqlite.org/releaselog/3_54_0.html; for vendors backporting instead of rebasing, the upstream fix is check-in https://sqlite.org/src/info/3f57024aecea0f3b and commit https://github.com/sqlite/sqlite/commit/64459c87cc702d600704fb77ee40ca1782398a52, which replaces the zTab/nTab name comparison in sessionChangesetApply() with the bNew flag from sessionChangesetNext() (the new ext/session/sessioncorrupt.test can be used as a regression check). Where an upgrade cannot be scheduled immediately, the most complete mitigation is to rebuild SQLite without SQLITE_ENABLE_SESSION if changeset replication is not actually used, which removes sqlite3changeset_apply() from the build entirely but breaks session-based synchronization features that depend on it; applications that do need the extension should ensure untrusted parties cannot supply the changeset consumed by sqlite3changeset_apply()/apply_v2() and should validate changesets before applying them, since the trigger is a malformed changeset whose repeated table name carries a larger column count than the original block. Fixing the bundled SQLite copy in applications that embed their own amalgamation is required as well, as system-level patching will not cover statically linked copies.
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
The session extension (ext/session, compiled only with SQLITE_ENABLE_SESSION) provides changeset-based change tracking: a changeset is a binary stream of table blocks, each carrying a table name, a column count, an opaque table header, and per-row records. When sqlite3changeset_apply() walks that stream in sessionChangesetApply(), it caches the previous table name (zTab/nTab) and treats a name change as the signal to open a new table, at which point it allocates the aUpdateMask array sized to that table's column count. The bug is a CWE-787 out-of-bounds write: because table identity was inferred from a string comparison rather than the changeset's own table boundaries, a changeset that repeats an already-seen table name inside a second block declaring a larger column count causes sessionUpdateFind() to memset more bytes into aUpdateMask than were allocated for the earlier, narrower declaration, corrupting adjacent heap metadata and data. The vendor's fix removes the string-based detection entirely, replacing the zTab/nTab bookkeeping in sessionChangesetApply() with a bNew flag returned by sessionChangesetNext(pIter, 0, 0, &bNew), so table boundaries come from the parser rather than from attacker-influenced name comparisons; the accompanying ext/session/sessioncorrupt.test exercises a 242-byte changeset that repeats table 't' with an inflated column count. The underlying technology is SQLite's C library and its binary changeset wire format, so any component that transports, stores, or replays changesets between database replicas is a potential attack surface.
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
AV:L and UI:R because an application must be induced to apply an attacker-supplied changeset; PR:N as no authentication is needed; C/I/A:H reflect heap corruption with potential for disclosure, code execution, and crash.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
SQLite before 3.54.0 built with the session extension contains a heap buffer overflow vulnerability in sqlite3changeset_apply() that allows attackers to corrupt heap memory by supplying crafted changesets. Attackers can repeat a table name in a second changeset block with a larger column count, causing sessionUpdateFind() to memset past the undersized aUpdateMask allocation.
Executive ViewAI
A heap memory corruption vulnerability in SQLite's session extension (CVE-2026-119379) could allow attackers to crash or potentially execute code within applications that process untrusted changesets. Only builds compiled with SQLITE_ENABLE_SESSION and versions earlier than 3.54.0 are affected; the threat requires local access and user interaction, limiting exposure but still posing a risk to products that ingest changesets from external sources. Leadership should prioritize patching affected systems to prevent potential service disruptions or security breaches.
Apply vendor patch.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
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-113790
GHSA-6w9f-4x4x-x559
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB