Skip to main content

LangGraph SQLite Store CVE-2025-8709

HIGH
SQL Injection (CWE-89)
2025-10-26 security@huntr.dev
7.3
CVSS 3.0 · Vendor: huntr
View

Attack ChainAIDerived

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

  1. Access
    Obtain low-privileged app access
  2. Delivery
    Submit crafted $eq/$gt filter value
  3. Exploit
    Break out of filter SQL via concatenation
  4. Execution
    Bypass application security filters
  5. Impact
    Exfiltrate other users' documents and secrets

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

Exploitation requires that the application uses LangGraph's SQLite store (langgraph-checkpoint-sqlite 2.0.10) AND that an attacker can control the value passed to one of the filter operators $eq, $ne, $gt, $lt, $gte, or $lte, since those values are concatenated into SQL without parameterization. Limiting factors: the CVSS vector indicates local attack vector (AV:L) and low-but-nonzero privileges (PR:L), so the attacker needs some level of access to the application or host rather than purely anonymous remote reach; no user interaction is required (UI:N). Real-world risk is therefore gated on whether the deploying application exposes filter inputs to untrusted users and whether it has migrated off the vulnerable 2.0.10 release.

Impact

Signals point to a moderate, context-dependent risk rather than a top-tier emergency. The provided CVSS 3.0 vector (AV:L/AC:L/PR:L/UI:N/S:C, 7.3 HIGH) describes a locally-reachable, low-complexity, low-privilege flaw with a scope change and high confidentiality impact - consistent with a SQL injection in an embedded SQLite store that lets one authenticated/low-privilege actor read data belonging to others. There is tension worth flagging: SQL injection is often thought of as network-reachable, but the vector specifies AV:L (local) because the SQLite store is an in-process/on-host component; whether a real deployment exposes the vulnerable filter input over a network depends entirely on how the host application wires user input into store queries - verify against the actual deployment. No EPSS score, no CISA KEV listing, and no confirmed public exploit were supplied; exploitation status is therefore 'no public exploit identified at time of analysis' (the huntr bounty report confirms the bug, not that weaponized code is circulating). SSVC-style read: technical impact is partial-to-total for confidentiality within the data store, exploitation is not observed, and automatability is uncertain because it hinges on whether filter values are attacker-controllable. Net: a genuine data-exposure bug worth patching promptly for anyone running langgraph-checkpoint-sqlite 2.0.10 with untrusted filter input, but not a drop-everything internet-wide threat on current evidence.

Exploit ScenarioDerived

In a LangGraph application that uses the SQLite store and lets users influence document filters, a low-privileged user supplies a crafted value for a filter operator such as $eq or $gt. Because the operator value is concatenated directly into the SQL string instead of being parameterized, the injected clause bypasses the application's security/tenant filters and returns documents belonging to other users, including sensitive fields like stored passwords and API keys. No public exploit code was identified, but the bug class (CWE-89) and the named operators make a working payload straightforward to construct.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 19, 2026

SQL injection in langgraph-checkpoint-sqlite 2.0.10 allows attacker-controlled values passed to the store's filter operators ($eq, $ne, $gt, $lt, $gte, $lte) to be concatenated directly into SQL statements, letting a query escape its intended filter and return every document in the store - including sensitive fields such as passwords and API keys. Exploitation requires a local attack vector with low privileges (CVSS 7.3, AV:L/PR:L/UI:N/S:C), so risk is gated on whether the deploying application exposes filter inputs to untrusted users and whether it is still running the vulnerable 2.0.10 release. No public exploit code was identified at time of analysis and the issue is not in CISA KEV, making this a moderate, context-dependent risk rather than an emergency.

RemediationAI

No vendor-released patch version is identified in the provided data, so the first step is to check the upstream langchain-ai/langgraph repository and the linked huntr bounty (https://huntr.com/bounties/9793f4b3-76f8-44a4-989f-49a2177ee118) for the fixed langgraph-checkpoint-sqlite release and upgrade off 2.0.10 as soon as it is published, then verify the resolved version in the deployed environment rather than in the manifest alone. Where upgrading is not yet possible, the effective control is input handling: do not pass untrusted values into filter operators - allowlist the operator names, coerce each value to its expected type (integer, boolean, or a strictly validated string) before it reaches the store, and reject values containing quotes, comment markers, or SQL keywords; the trade-off is that legitimate dynamic querying narrows and some flexible filter features will stop working. Additionally, run the SQLite store under a least-privilege filesystem account in its own process or container, and prefer one database file per tenant so a successful injection cannot read across tenants - at the cost of extra operational overhead. Because the flaw permits exfiltration of every document, treat any credentials, API keys, or session secrets persisted in checkpoints or store records as potentially exposed and rotate them; rotation causes short-lived authentication failures for dependent services until clients pick up the new secrets.

Affected Packages

pypi langgraph-checkpoint-sqlite fix: 2.0.11

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

LangGraph is the stateful agent-orchestration layer built on top of LangChain, and langgraph-checkpoint-sqlite persists graph state, checkpoints, and document records in a SQLite database. That package exposes a filter DSL that maps operators such as $eq, $ne, $gt, $lt, $gte and $lte onto SQL comparisons against stored fields. In 2.0.10 those operator values were assembled into the WHERE clause by direct string concatenation rather than through bound parameters, which is the classic CWE-89 improper neutralization of special elements in SQL commands. Because the injected value reaches the database engine itself, an attacker can terminate the intended predicate and substitute their own, effectively converting a scoped lookup into a full-table read; this boundary crossing from the application's logical filter into the database layer is what the assessed vector reflects with Scope:Changed. The AV:L/PR:L components indicate the attacker must already reach the code path that builds the filter (for example through an application feature or a locally running agent) rather than being an anonymous internet client, and UI:N means no victim interaction is needed once that access exists.

Know when Langchain 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 (huntr) PRIMARY 7.3 HIGH
AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N
vuln.today AI 7.3 HIGH

Flaw sits in a local in-process SQLite store (AV:L) reached by a low-privilege app user (PR:L); filter bypass crosses a security boundary to other users' data (S:C) exposing secrets (C:H) with limited write (I:L).

3.1 AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:N/SC:L/SI:N/SA:N
Red Hat 7.3 HIGH

Primary rating from Vendor (huntr).

CVSS VectorVendor: huntr

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
Low
Availability
None

DescriptionCVE.org

A SQL injection vulnerability exists in the langchain-ai/langchain repository, specifically in the LangGraph's SQLite store implementation. The affected version is langgraph-checkpoint-sqlite 2.0.10. The vulnerability arises from improper handling of filter operators ($eq, $ne, $gt, $lt, $gte, $lte) where direct string concatenation is used without proper parameterization. This allows attackers to inject arbitrary SQL, leading to unauthorized access to all documents, data exfiltration of sensitive fields such as passwords and API keys, and a complete bypass of application-level security filters.

Executive ViewAI

Why It Matters

Deployments of langgraph-checkpoint-sqlite 2.0.10 carry a high-severity injection weakness that can expose the entire document store-including credentials and API keys-to an authenticated local user with low privileges when application filter inputs are not trusted. Leadership should prioritize inventory and exposure review because the issue can turn a narrow query feature into broad secret disclosure, though no public exploit identified at time of analysis and exploitation requires local access plus untrusted filter input.

Business Impact: Medium
Compensating Controls

Restrict local access to trusted low-privilege accounts; do not expose raw filter operators to untrusted users; validate and allowlist filter fields and operators; monitor and audit query results for unusual volume or scope; rotate secrets if exposure is suspected.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Low
SQLite checkpoint backend is mainly local/dev use, not the production default
Data Quality
2 sources
Confidence: Low

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.2%
Patch available Yes
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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

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

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

CVE-2026-27966 CRITICAL POC
9.8 Feb 26

Code injection in Langflow CSV Agent node before 1.8.0. The node hardcodes allow_dangerous_code=True, enabling arbitrary

CVE-2023-36095 CRITICAL POC
9.8 Aug 05

An issue in Harrison Chase langchain v.0.0.194 allows an attacker to execute arbitrary code via the python exec calls in

CVE-2025-2828 CRITICAL POC
10.0 Jun 23

A remote code execution vulnerability in langchain-ai/langchain (CVSS 10.0). Risk factors: public PoC available. Vendor

CVE-2024-8309 CRITICAL POC
9.8 Oct 29

A vulnerability in the GraphCypherQAChain class of langchain-ai/langchain version 0.2.5 allows for SQL injection through

CVE-2024-7042 CRITICAL POC
9.8 Oct 29

A vulnerability in the GraphCypherQAChain class of langchain-ai/langchainjs versions 0.2.5 and all versions with this cl

CVE-2024-46946 CRITICAL POC
9.8 Sep 19

langchain_experimental (aka LangChain Experimental) 0.1.17 through 0.3.0 for LangChain allows attackers to execute arbit

CVE-2024-2057 CRITICAL POC
9.8 Mar 01

A vulnerability was found in LangChain langchain_community 0.0.26. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2023-39631 CRITICAL POC
9.8 Sep 01

An issue in LanChain-ai Langchain v.0.0.245 allows a remote attacker to execute arbitrary code via the evaluate function

CVE-2023-36281 CRITICAL POC
9.8 Aug 22

An issue in langchain v.0.0.171 allows a remote attacker to execute arbitrary code via a JSON file to load_prompt. Rated

CVE-2023-39659 CRITICAL POC
9.8 Aug 15

An issue in langchain langchain-ai v.0.0.232 and before allows a remote attacker to execute arbitrary code via a crafted

CVE-2023-38896 CRITICAL POC
9.8 Aug 15

An issue in Harrison Chase langchain v.0.0.194 and before allows a remote attacker to execute arbitrary code via the fro

CVE-2023-38860 CRITICAL POC
9.8 Aug 15

An issue in LangChain v.0.0.231 allows a remote attacker to execute arbitrary code via the prompt parameter. Rated criti

Vendor StatusVendor

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