NIST deprecates RSA-2048 from 2030. Find every one of them before attackers do.
🐹
🐹 Go
Not in CISA KEV
HIGH severity

CVE-2026-130008 — sqlite-mcp

HIGHFix: StacklokLabs/sqlite-mcp@1da5a65

CVE-2026-130008 is a high-severity (CVSS 8.2) SQL Injection vulnerability in github.com/StacklokLabs/sqlite-mcp. A fix is available for github.com/StacklokLabs/sqlite-mcp — see the affected versions and patch details below.

sqlite-mcp: Read-only mode bypass via statement chaining and SQL injection in describe_table

Also known asGHSA-q433-mp6c-8v4f
Published
Updated
Affected
1 pkg
Patched
1 / 1
Exploits
None indexed
Exploitation data as of Nov 19, 2026 · OSV.dev, NVD, FIRST.org (EPSS)

Exploitation Status

No confirmed exploitation observed yet

  • CISA assesses this as automatable — exploitation doesn’t require manual, per-target effort, which raises the odds of mass scanning and opportunistic attacks.
  • CISA’s own triage has not observed active exploitation or public proof-of-concept code for this CVE as of its last assessment.

Exploitation and automatability from CISA’s SSVC triage for CVE-2026-130008.

EPSS Exploitation Probability

via FIRST.org ↗
0.4%probability of exploitation in next 30 days
Lower Risk0.00%
Lower risk than most CVEs31th percentile — riskier than 31% of all scored CVEsHighest risk

Probability of exploitation in the next 30 days, from FIRST.org EPSS.

How urgent is this, really

Where this sits among everything scored

Real-World Exposure

1 pkg affected
🐹github.com/StacklokLabs/sqlite-mcp

Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.

Description

Summary

In read-only mode (the default), a client that can call the MCP tools can write to the database the server is meant to expose read-only, read other SQLite files, and create new SQLite files anywhere the server process can write. There are two ways in: statement chaining through execute_query, and SQL injection through describe_table.

Details

  • Statement chaining in execute_query. The only check was that the query starts with SELECT. The modernc.org/sqlite driver runs every ;-separated statement in one call, so anything after SELECT 1; ran unchecked.
  • SQL injection in describe_table. The table_name argument was interpolated into PRAGMA table_info(%s) with no guard.
  • Escaping read-only mode. Through either path, ATTACH DATABASE opens a file read-write regardless of the main connection's mode=ro. Attaching the protected database itself made it writable. Attaching another path read that file, or created it if it did not exist.

Read-write mode is not affected beyond its intended capabilities, apart from ATTACH reaching files other than the configured database.

Impact

  • Modify the database that read-only mode is meant to protect.
  • Read any SQLite database file the server process can read.
  • Create new SQLite-format files anywhere the server process can write, or write to existing SQLite or empty files. Existing non-empty files that are not SQLite databases are refused and left unchanged.

The server has no built-in authentication and, by default, listens on :8080 on all interfaces. Unless it is deployed behind an authenticating proxy, anyone who can reach that port can exploit this.

Patches

Fixed in v0.1.2:

  • ATTACH is disabled in the engine (SQLITE_LIMIT_ATTACHED set to 0) on every connection that runs a statement.
  • Read-only connections set query_only.
  • execute_query rejects input that contains more than one statement.
  • describe_table passes the table name as a bound parameter.

Workarounds

Upgrade to v0.1.2. If you cannot upgrade, don't expose the server to untrusted clients: keep it on a loopback or private interface, or run it behind an authenticating proxy such as ToolHive. Mount only the database you intend to expose, read-only at the filesystem or container level.

Credits

Reported by @bebold6133.

Affected Packages

1 total 1 fixed
EcosystemPackageVulnerable rangeFix
🐹Gogithub.com/StacklokLabs/sqlite-mcpall versions0.1.2go get github.com/StacklokLabs/sqlite-mcp@v0.1.2

Detection & mitigation playbook

Open-source dependency
  1. Detect

    Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/StacklokLabs/sqlite-mcp, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.

  2. Fix

    Update github.com/StacklokLabs/sqlite-mcp to 0.1.2 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms CVE-2026-130008 is resolved across your whole dependency graph.

  3. Workarounds

    Until you can upgrade, make sure every query built from user input uses parameterised statements or a prepared-statement API rather than string concatenation, and reduce the database account's privileges so an injected query cannot read or alter data beyond what the feature needs.

Frequently Asked Questions

### Summary In read-only mode (the default), a client that can call the MCP tools can write to the database the server is meant to expose read-only, read other SQLite files, and create new SQLite files anywhere the server process can write. There are two ways in: statement chaining through `execute_query`, and SQL injection through `describe_table`. ### Details - **Statement chaining in `execute_query`.** The only check was that the query starts with `SELECT`. The `modernc.org/sqlite` driver runs every `;`-separated statement in one call, so anything after `SELECT 1;` ran unchecked. - **SQL
O3 Security · Impact-Aware SCA

Is CVE-2026-130008 in your dependencies?

Find it across Go, including transitive dependencies.

CVE-2026-130008: sqlite-mcp SQL Injection — Fixed in 0.1.2