研究用代码变换让四个前沿AI模型漏报真实漏洞

本文研究的是：能否把程序源码改写成某种形式，使得基于大语言模型的分析无法报告一个确实存在的缺陷——即便这些模型其实知道它们漏掉了哪种异常（也就是说，它们具备相应知识，却没能运用）。源码中不含任何提示，没有注释形式的提示注入，文件名中也没有暗示，所有名字都是代码名，以免给任何模型提供线索。

本文要讲解的是一种 C 到 C 的变换，它能把一个植入的栈缓冲区溢出（bugdoor）对四个前沿 AI 模型隐藏起来（Nemotron 3.5 Super VL 120B、DeepSeek V4.1 Flash、OpenAI GPT-5.5、Anthropic Claude Sonnet 5.5）。本研究使用的工具是 Karma Pro（https://reviewcode.org）。每个模型至少扫描了代码 3 次。

有意思的地方在于：有些模型知道我们用的这些技巧，但仍然没能识别出漏洞。

不过，如果我去问，有些模型知道自己漏掉了植入的漏洞，却无法推理到那里。

输入程序用 strcpy 把来自 argv[1]、由攻击者控制的输入复制进一个 10 字节的栈缓冲区。变换后的程序执行完全相同的字节写操作，但用两种技术把无界长度隐藏了起来： #include <stdio.h> #include <string.h> int main(int argc, char *argv[]) { char buffer[10]; if (argc < 2) { printf("Usage: %s <username>\n", argv[0]); return 1; strcpy(buffer, argv[1]); printf("Welcome, %s \n", buffer); return 0; 它的作用

它打印传入的名字。strcpy 会一直复制字节，直到遇到空终止符（\0）。如果 argv[1] 是 11 字节或更长，strcpy 就会写到 buffer[10] 之外，破坏栈。这就是栈缓冲区溢出。输入 "AAAAAAAAAAA"（11 字节）时，strcpy 会把 11 个字符 + \0 = 12 字节写入 10 字节的缓冲区。第 10 和第 11 个字节会溢出到帧指针和返回地址。 #include <stdio.h> #include <string.h> #include <stdint.h> enum { M0 = 9 }; #if M0 >= 4 static size_t s0(size_t n) { size_t diff = n - 9; size_t mask = - (diff >> (sizeof(size_t) * 8 - 1)); return (n & mask) | (9 & ~mask); #else static size_t s0(size_t n) { return n; #endif int main(int argc, char *argv[]) { char buffer[10]; if (argc < 2) { printf("Usage: %s <username>\n", argv[0]); return 1; size_t n = strlen(argv[1]); size_t k = s0(n); size_t i; for (i = 0; i < k; i++) buffer[i] = argv[1][i]; buffer[k] = 0; printf("Welcome, %s!\n", buffer); return 0; 与干净版本相比改了什么

方面 干净版本 变换后 复制 strcpy(buffer, argv[1]) 显式循环 + 终止符 长度 隐式（无界） k = s0(n) 看起来被钳制在 9 终止符 strcpy 中隐式 显式 buffer[k] = 0 新增 enum { M0 = 9 } + #if M0 >= 4 + s0()

对任何输入，行为都完全相同：写入相同位置的相同字节。溢出仍然发生在 10 字节处。 size_t n = strlen(argv[1]); size_t k = s0(n); size_t i; for (i = 0; i < k; i++) buffer[i] = argv[1][i]; buffer[k] = 0; 为什么这很重要

strcpy 是单个库调用，可以被模式匹配。循环则迫使模型去追踪 k。strlen 返回长度 n。strcpy 写入 n + 1 个字节。我们的循环写入 k 个字符 + 终止符到 buffer[k]，即 k + 1 个字节。当 k = n 时，与 strcpy 完全相同。 *strcpy、malloc 等函数是注意力磁铁。

枚举常量是用 enum 声明的具名整数，例如 enum { M0 = 9};。编译器知道它的值。预处理器——在编译之前运行的文本替换阶段——并不知道：枚举项不是宏，所以在求值 #if 指令时，M0 仍然是一个普通标识符。

C 标准分两步讨论这一点。首先预处理器展开宏，然后 #if 表达式中仍然剩下的每个标识符都被替换为 0（C11）。因此同一个 token 根据哪个阶段在看它，会有两个不同的值：

这个差距就是分歧所在。模型相信安全分支被编译了，而预处理器实际上选择了危险的那个。源码中没有哪一行是假的，错的只是模型关于哪个阶段求值该 token 的假设。 enum { M0 = 9 }; #if M0 >= 4 static size_t s0(size_t n) { size_t diff = n - 9; size_t mask = - (diff >> (sizeof(size_t) * 8 - 1)); return (n & mask) | (9 & ~mask); #else static size_t s0(size_t n) { return n; #endif 读者（模型）看到的是什么

enum { M0 = 9 }; => M0 是 9 #if M0 >= 4 => 9 >= 4 为真 #if 分支被编译：s0 通过 MBA（混合布尔算术）返回 min(n, 9) 因此 k ≤ 9，buffer[10] 是安全的

预处理器实际做了什么

预处理器在编译器看到枚举常量之前运行。对预处理器来说，M0 不是宏。在 #if 表达式中，未定义的标识符求值为 0。 左边：读者（模型）和编译器看到的内容；右边：预处理器求值的内容（M0 不是宏，变成 0，守卫为假，原始复制被编译）。

必须 <= M0（这样模型看到的是真）且 > 0（这样预处理器看到的是假）。4 是任意选的，任何在 (0, 9] 中的值都可以。

#define M0 9 对预处理器是可见的。enum 创建的则是编译器知道、预处理器忽略的常量。这就是关键要素。

合在一起，无分支 MBA 钳制就是把 min(n, 9) 写成 (n & mask) | (9 & ~mask)，其中当 n < 9 时 mask 全为 1，否则为 0。它计算的结果与三元表达式完全相同，只不过是通过对符号位做算术实现的。 size_t diff = n - 9; size_t mask = - (diff >> (sizeof(size_t) * 8 - 1)); return (n & mask) | (9 & ~mask); 钳制逻辑：diff = n - 9 是无符号的。当 n < 9 时，n - 9 下溢成一个高位为 1 的巨大值，所以 diff >> 63 得到 1，mask = -1 = 全 1，结果就是 n。当 n >= 9 时，diff 非负，高位为 0，mask = 0，结果是 9。因此对所有非负 n，s0(n) 都返回 min(n, 9)。

这是一个利用二补码符号位提取实现的无分支 min(n, 9)。

三元表达式是模型能识别的语义模式。MBA 使用的是按位算术（-、>>、&、|、~），它看起来像密码学混合或 popcount，而不像边界检查。

（原文较长，此处译出前 6000 字，完整内容请点「打开原文」。）