GCG自动化越狱算法

可视化演示

动态演示GCG自动化越狱算法的核心机制，通过采集/分析/决策/反馈四种模式展示关键概念与交互流程。

越狱问题背景

大语言模型出厂时，就像一只保险柜默认锁死：它能回答很多问题，但面对“如何制造危险品”这类请求时，安全对齐机制会让它拒绝回答。安全对齐，相当于在模型里装了一把内置锁，把有害行为锁在柜门后面。攻击者的目标，就是找到一把能拨开这把锁的“钥匙”。

早期的越狱是纯手工的。攻击者像老锁匠一样，靠灵感设计各种提示词：让模型扮演一个虚构角色、把有害问题藏在故事里、用 base64 编码绕过审查。这些手工越狱方式很像“社会工程学撬锁”——不是不能用，但需要大量经验，而且换个模型可能就失效。随着大模型应用越来越广，安全团队需要一种可规模化、可复现的测试方法，于是“自动化越狱”成为刚需。

GCG（Greedy Coordinate Gradient，贪心坐标梯度）就是在这种需求下诞生的自动配钥匙机。它不再依赖人的灵感，而是把越狱问题变成数学优化问题：给定一个有害提示，自动搜索一段看起来像乱码、却能骗过模型的对抗后缀。理解 GCG，本质上就是理解这把“自动配钥匙机”的机械结构。

核心数学原理

要让机器自动配钥匙，第一步是把钥匙齿位数字化。大模型并不直接读文字，而是把文字切分成一个个 token（词元），就像把钥匙胚划分成若干齿位。每个 token 在模型里用一个高维向量表示，这个向量来自嵌入表（embedding table）。后缀的长度，就是钥匙胚上的齿位数；攻击者的任务，是给每个齿位选一个最优 token。

GCG 的攻击目标非常直接：最小化“目标有害回答出现”的损失。假设原始提示为 $x_{1:n}$，其中后几个位置是待优化的对抗后缀；目标有害回答为 $y^*_{1:m}$。我们希望模型生成 $y^*$ 的概率尽可能大。取负对数后，概率越大、损失越小，优化问题就变成最小化损失函数：

不过，token 是离散的，不能像连续变量那样直接做梯度下降。这就好比你不能把钥匙齿位从“第 7 格”平滑地拨到“第 7.3 格”，只能一格一格跳。GCG 的巧妙之处在于：它仍用梯度当“触感”，但只把梯度用来挑选候选齿位。

具体来说，固定其他齿位不变，把第 $i$ 个齿位的 token 换成词表 $\mathcal{V}$ 中的某个候选 $v$，损失会变化。梯度 $\nabla_{e_{x_i}} \mathcal{L}$ 告诉我们：第 $i$ 个齿位往哪个方向调整能让损失下降最快。由于齿位是离散的，我们只能看词表里所有候选 token 中，谁最符合“负梯度方向”，取前 k 名进入候选名单：

到这里，锁匠已经知道每个齿位最值得试的几种齿形。接下来要做的是批量试钥匙。

GCG算法流程

GCG 的完整流程可以概括成“摸、挑、试、留”四个字。

1. 初始化：随机生成一个后缀，作为钥匙胚的初始齿形。

2. 计算梯度：对当前后缀的每个位置计算损失梯度，得到每个位置对应的 Top-K 候选 token。

3. 随机采样：每次迭代随机选 B 个位置，对每个位置从 Top-K 中随机抽一个候选 token，组成 B 个候选后缀。注意不是一次只换一个位置，而是一次生成一小批候选。

4. 批量评估：把 B 个候选后缀分别拼到原始提示后面，用模型前向传播计算损失。

5. 择优更新：保留损失最小的那个候选后缀，作为下一轮的钥匙胚。

这五步反复进行，就像锁匠反复打磨钥匙：每次只动几个齿位，试一批，留一把最顺手的，继续下一轮。用数学语言描述“择优更新”这一步：

由于每一步只改动少量齿位，GCG 的搜索过程是典型的贪心搜索：它不保证一次找到全局最优钥匙，但通过反复迭代，能在有限轮数内找到一把“足够好”的万能钥匙胚。

超参数调优

自动配钥匙机上有几个旋钮，直接决定打磨效果。第一个是迭代轮数。轮数太少，钥匙胚还没磨到位；轮数太多，浪费算力还可能过拟合到某一个特定提示上。

第二个是候选批量大小 B。B 越大，每轮尝试的钥匙越多，找到好候选的概率越高，但计算量也线性增长。GCG 论文常用 B=512，但实际调试时可以从 64 或 128 开始。

第三个是 Top-K 值。K 越小，候选越“精”；K 越大，探索越“广”。K 太小时，可能漏掉真正有效的 token；K 太大时，候选池里混入大量噪声。常见取 K=256，配合批量大小一起调。

第四个是后缀长度。后缀越长，搜索空间越大，越狱成功率可能越高，但也越容易被困惑度过滤器识别。真实攻击中，20 到 40 个 token 的后缀是比较常见的起点。

第五个是每次替换的位置数。GCG 不是每轮替换所有位置，而是只随机替换 B 个位置。替换位置太多会让搜索像无头苍蝇，太少又会让收敛变慢。合理配置这些旋钮，就像锁匠根据锁芯材质调整打磨力度：硬锁多磨几轮，软锁轻一点。

计算成本优化

GCG 最被人诟病的是计算成本。每一轮都要对 B 个候选后缀做前向传播，如果目标模型是几十亿参数的大模型，普通显卡根本跑不动。于是研究人员想出了几招“降本增效”。

第一招是批量评估。很多深度学习框架支持同时计算多个输入的损失，把 B 个候选后缀拼成一个 batch 一起前向传播，比逐个试快得多。这就像锁匠一次拿一串钥匙插进同一把锁，而不是一把一把拔出来再插。

第二招是代理模型加速。先用一个小得多的模型（比如 7B 甚至更小）搜索后缀，再把搜到的后缀迁移到大模型上验证。虽然小模型的“手感”和大模型不完全一样，但很多对抗后缀具有通用性。这就像先在便宜的塑料锁上练手，再拿去开真锁。

第三招是早停机制。如果连续多轮损失不再下降，或在验证集上越狱成功率没有提升，就提前终止。反复打磨一把已经磨秃的钥匙，只是在浪费电。

第四招是热启动。把以前搜索成功的后缀作为下一轮搜索的初始后缀，而不是每次从随机开始。这类似于锁匠把用过的钥匙胚收藏起来，遇到相似锁芯时直接拿出来改。

迁移性分析

GCG 最初是白盒攻击：它需要访问目标模型的梯度，就像锁匠需要摸到锁芯内部结构。但在真实世界里，攻击者通常只能通过 API 调用黑盒模型，看不到梯度，怎么办？答案是迁移性。

迁移性指的是：在模型 A 上搜索出来的对抗后缀，直接拼到模型 B 的提示后面，也可能让模型 B 越狱成功。原因是大模型往往使用相似的 tokenizer、相似的训练数据和相似的对齐方式，相当于同一品牌的保险柜用了类似的锁芯。GCG 论文发现，在开源模型上训练出的后缀，对商业黑盒模型也有一定攻击成功率。

基于迁移性，攻击者可以搭建一条黑盒攻击路径：先用开源白盒模型搜索候选后缀，再用这些后缀去测试商业 API，挑选成功率最高的那一批。这也催生了“通用后缀”的概念——一段后缀不针对某一条具体提示，而是能适配一批有害提示。当然，迁移不是万能的。模型架构差异大、安全对齐训练强度不同，都会让通用后缀失效。锁匠的万能钥匙胚能开同品牌锁，但开不了完全不同的锁。

防御与应对

理解了钥匙怎么造，就知道怎么升级锁。GCG 生成的对抗后缀通常是随机 token 拼接，人类看起来毫无意义，这给防御留下了线索。

最直接的防御是困惑度过滤。语言模型对正常文本有较低的困惑度（perplexity，PPL），而对随机 token 串有很高的困惑度。困惑度的定义是：

除了困惑度过滤，还可以做输入清洗：检测并剔除那些与正常语言差异过大的 token 片段，或者对可疑后缀做字符级扰动，让攻击失效。对抗训练则是把 GCG 生成的攻击样本加入训练数据，让模型见过这些“钥匙”后不再轻易被打开。强化安全对齐是更根本的解法：不断用红队测试发现的新攻击方式更新对齐策略。防御和攻击就像锁匠与锁厂之间的军备竞赛，没有一劳永逸的锁，只有不断升级的锁。

AI 应用场景

Python 演示

# 玩具版 GCG：演示梯度引导的贪心坐标搜索import randomimport math  class ToyModel:    def __init__(self, vocab_size=50, target=7, secret_bias=None):        self.vocab_size = vocab_size        self.target = target        if secret_bias is None:            secret_bias = {3: 0.8, 7: 1.2}        self.secret_bias = secret_bias     def loss(self, tokens, target=None):        if target is None:            target = self.target        base = sum(1.0 if t != target else -0.2 for t in tokens)        bias = sum(self.secret_bias.get(t, 0.0) for t in tokens)        return 2.0 + base - bias     def pseudo_gradient(self, tokens, target=None):        if target is None:            target = self.target        grads = []        for i in range(len(tokens)):            row = []            for v in range(self.vocab_size):                candidate = tokens[:]                candidate[i] = v                row.append(self.loss(candidate, target))            grads.append(row)        return grads  class GCGOptimizer:    def __init__(self, model, suffix_len=4, top_k=5, batch_size=4, iters=50):        self.model = model        self.suffix_len = suffix_len        self.top_k = top_k        self.batch_size = batch_size        self.iters = iters        self.suffix = [random.randrange(model.vocab_size) for _ in range(suffix_len)]        self.history = []     def run(self, target=7):        for _ in range(self.iters):            grads = self.model.pseudo_gradient(self.suffix, target)            candidates = {}            for i in range(self.suffix_len):                order = sorted(                    range(self.model.vocab_size),                    key=lambda v: grads[i][v]                )                candidates[i] = order[:self.top_k]             best = self.suffix[:]            best_loss = self.model.loss(best, target)            for _ in range(self.batch_size):                cand = self.suffix[:]                i = random.randrange(self.suffix_len)                cand[i] = random.choice(candidates[i])                loss = self.model.loss(cand, target)                if loss < best_loss:                    best_loss = loss                    best = cand             self.suffix = best            self.history.append(best_loss)         return self.suffix, self.history  if __name__ == "__main__":    random.seed(0)    model = ToyModel()    opt = GCGOptimizer(model, suffix_len=4, top_k=5, batch_size=4, iters=30)    suffix, history = opt.run()    print("suffix:", suffix)    print("loss history:", [round(h, 3) for h in history])

1. class ToyModel:定义一个模拟模型，loss() 是锁匠的阻力计，pseudo_gradient() 是触感手套。
2. grads = self.model.pseudo_gradient(self.suffix, target)对每个齿位计算换成所有候选 token 后的损失，得到一张“触感表”。
3. order = sorted(range(...), key=lambda v: grads[i][v])把第 i 个齿位的候选 token 按损失从小到大排序。
4. candidates[i] = order[:self.top_k]只保留损失最小的 top_k 个候选 token，对应 GCG 的 Top-K 选择。
5. cand = self.suffix[:]复制当前钥匙胚，避免直接修改原始后缀。
6. i = random.randrange(self.suffix_len)随机挑一个齿位，对应 GCG 每次只随机替换少量位置。
7. cand[i] = random.choice(candidates[i])从 Top-K 候选里随机抽一个替换，保持探索的随机性。
8. if loss < best_loss:择优：只留下本轮损失最小的候选。
9. self.suffix = best更新钥匙胚，进入下一轮打磨。
10. self.history.append(best_loss)记录损失曲线，方便观察收敛情况。

常见误区

面试题