Skip to main content

mem0 EUVDEUVD-2026-108126

| CVE-2026-115324 CRITICAL
SQL Injection (CWE-89)
2026-10-22 VulnCheck GHSA-7587-9684-52r6
9.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted memory text or metadata to agent
  2. Delivery
    mem0 stores content via Databricks vector store
  3. Exploit
    Payload reaches unescaped insert()/update() interpolation
  4. Execution
    Injected SQL executes on Databricks warehouse
  5. Impact
    Read, modify, or destroy warehouse data

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Parameterized queries, prepared statements
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Persistence

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

Exploitation Conditions

The deployment must be running mem0 (versions 0.1.117 up to but not including 1.0.8) configured to use the Databricks vector store backend (mem0/vector_stores/databricks.py) - this is a non-default backend choice and is the central prerequisite. The attacker must be able to influence stored memory content, specifically memory text, metadata values, or message names, which flow into the unescaped insert() and update() string interpolation. Limiting factors beyond the Databricks backend requirement: the CVSS AC:H/AT:P indicates exploitation is not deterministic, consistent with attacker text passing through mem0's memory-ingestion pipeline before storage; the exact trigger mechanics for reliably preserving a payload through that pipeline are not detailed in the available sources. The complete fix is upgrading to v1.0.8; the vendor diff provides no alternative mitigation.

Impact

The CVSS 4.0 base score of 9.2 (Critical) reflects high confidentiality, integrity, and availability impact (VC:H/VI:H/VA:H) on the backing Databricks SQL warehouse via network-reachable, unauthenticated input (AV:N/PR:N/UI:N). However, the same vector carries AC:H and AT:P, signalling that successful exploitation is not trivial and depends on specific attack requirements - consistent with the fact that the vulnerable code path exists only when mem0 is configured to use the Databricks vector store backend, and that attacker-supplied text is ingested through mem0's memory pipeline rather than written verbatim. The vuln.today Decision label is 'act_now', which should drive prioritization for anyone actually running the Databricks backend. Countervailing signals: no EPSS score is provided in the input, there is no CISA KEV listing, and no verified working exploit is referenced - so there is no evidence of active or widespread exploitation at this time. Net: a genuine high-priority issue for the specific population running mem0 with Databricks, but not demonstrably under active exploitation; organizations not using the Databricks vector store are not exposed to this code path. No EPSS value was supplied, so exploitation probability cannot be compared against the KEV/Decision signals.

Exploit ScenarioDerived

An attacker interacts with an AI application that uses mem0 with the Databricks vector store and submits crafted content - memory text, metadata, or a message name - containing a SQL payload. When mem0 stores the memory, the payload reaches unescaped string interpolation in insert()/update() in databricks.py and executes as SQL against the configured Databricks SQL warehouse. No verified public exploit is referenced in the input, though the fixing PR and a GitHub issue describe the flaw.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available

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

Alert me

AnalysisAIv1 – Oct 22, 2026

SQL injection in mem0's Databricks vector store backend (mem0/vector_stores/databricks.py) affects versions 0.1.117 up to but not including 1.0.8, and lets remote unauthenticated attackers inject SQL that runs on the configured Databricks SQL warehouse by supplying crafted memory text, metadata values, or message names that reach unescaped string interpolation in the insert() and update() statements. Successful injection gives high confidentiality, integrity, and availability impact on the warehouse, though the assessed vector (AC:H/AT:P) indicates exploitation is not deterministic and requires the non-default Databricks backend to be configured; the trigger mechanics for reliably carrying a payload through mem0's ingestion pipeline are not described in the available sources. No public exploit code or CISA KEV entry was identified at time of analysis, the vendor has released the v1.0.8 fix, and the issue carries an act_now priority label with a CVSS 4.0 base score of 9.2.

RemediationAI

Vendor-released patch: mem0 1.0.8. Upgrade to v1.0.8 (https://github.com/mem0ai/mem0/releases/tag/v1.0.8), which incorporates PR #4558 / commit a2ffca32 and reworks the Databricks backend to bind memory ids, payload values, and delete/update predicates as StatementParameterListItem parameters, plus a regex allowlist that rejects non-identifier payload keys before they reach a SET clause. Because the vulnerable code is confined to the Databricks vector store module, the vendor diff provides no alternative mitigation; the reliable fix is the upgrade. Until upgrading, verify whether any deployment actually has the Databricks backend configured, since instances running a different vector store backend do not execute the affected insert()/update() path and are not exposed to this injection. Any interim restriction on who or what can write attacker-influenced memory text, metadata, or message names into a Databricks-backed store - and scoping the Databricks SQL warehouse credentials to the minimum required privileges - reduces blast radius but is a compensating measure rather than a substitute for the 1.0.8 upgrade.

Affected VersionsENISA

mem0 0.1.117 <1.0.8

Affected Packages

euvd mem0 fix: 1.0.8

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

mem0 is a Python memory layer for AI agents; its vector store abstraction supports pluggable backends, and the Databricks implementation in mem0/vector_stores/databricks.py talks to a Databricks SQL warehouse through the SDK's Statement Execution API. CWE-89 applies because INSERT, UPDATE, and DELETE statements were assembled with Python f-strings, splicing caller-supplied values directly into the SQL text: memory ids, payload/metadata values, and the embedding vector itself. The vendor fix (PR #4558, commit a2ffca32) converts value handling to parameterized statements using databricks.sdk.service.sql.StatementParameterListItem with named placeholders (:memory_id_0, :vector_id, :payload_<key>), including explicit TIMESTAMP typing so Databricks does not rely on implicit STRING-to-TIMESTAMP casting. Column names cannot be bound as parameters, so the patch adds a regex allowlist (_VALID_SQL_IDENTIFIER, ^[A-Za-z_][A-Za-z0-9_]*$) and skips payload keys that fail it, closing the identifier-injection path. Array-typed embeddings remain inlined via _format_sql_value because StatementParameterListItem does not support ARRAY types, which the patch justifies on the basis that vectors are model-generated floats. The accompanying test change asserts that user-supplied values now render as bind placeholders rather than inline literals.

Know when Mem0 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 9.2 CRITICAL
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.1 HIGH

No auth required by the vulnerable library path (PR:N); AC:H because attacker text is transformed by the ingestion pipeline and the non-default Databricks backend must be configured; full read/write DB impact.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
None
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

mem0 0.1.117 before 1.0.8 contains an sql injection vulnerability in mem0/vector_stores/databricks.py that allows attackers to inject SQL by influencing stored memory content. Attackers can supply crafted memory text, metadata, or message names that reach unescaped insert() and update() string interpolation to execute injected SQL on the configured Databricks SQL warehouse.

Executive ViewAI

Why It Matters

CVE-2026-115324 is a critical SQL injection vulnerability in mem0's Databricks vector store backend, affecting versions 0.1.117 through 1.0.7, that could allow an attacker to manipulate the underlying Databricks SQL warehouse, compromising data confidentiality, integrity, and availability. Teams using mem0 with the Databricks backend are at risk, and while exploitation is non-deterministic and the backend is non-default, the severity demands immediate leadership attention to prevent potential data breaches or operational disruption.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Medium
popular open-source AI memory library, but Databricks backend is an uncommon configuration
Social Media
1
Sightings
Data Quality
4 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

SQL injection exploits the way applications construct database queries by mixing user input directly into SQL statements.

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