От GCG до refusal direction. Лонгрид о серии градиентных adversarial-атак на языковые модели: с чего она началась, как разветвилась, что мы в итоге поняли про механику взлома и где находимся сейчас.
О чем это и зачем
Есть простой, но неудобный вопрос: насколько прочен safety-элайнмент, который мы навешиваем на модели? Интуиция подсказывает: «модель обучили отказывать на вредное - значит, она отказывает». Серия работ, которую я хочу разложить, показывает, что между обучили отказывать и робастно отказывает под давлением оптимизации - пропасть.
Все началось летом 2023 с алгоритма GCG. Дальше идея разветвилась - ее делали читаемой, масштабируемой, быстрой и простой-но-адаптивной, - а потом, наконец, начали понимать механистически. Через весь текст я держу один сквозной сюжет: почему дискретно-оптимизированный суффикс вообще работает и почему он переносится на другие модели, под которые его не настраивали? Ответ, как выяснилось, геометрический.
Сразу оговорка по охвату: это white-box / optimization-based серия. Black-box prompting (PAIR, TAP и им подобные) я намеренно оставляю за кадром; это отдельная история.
Базовая постановка
Конструкция проста. Берем вредный запрос и приклеиваем к нему суффикс из управляемых токенов:
[ harmful_request ] [ s_1 s_2 ... s_k ] <- суффикс оптимизируем
Цель оптимизации - не «заставить модель сказать что-то конкретное», а тоньше: максимизировать вероятность того, что ответ начнется с согласия - классическое «Sure, here is…». Мы надеемся, что авторегрессионная модель, начав с «Sure, here is how to…», по инерции продолжит в том же духе. То есть мы атакуем не финальный ответ, а первые несколько его токенов.
Формально минимизируем negative log-likelihood этой целевой affirmative-строки при условии [request + suffix]. Загвоздка: суффикс состоит из дискретных токенов, а не непрерывного вектора, поэтому градиентный спуск «в лоб» не применим. Вся задача ранних работ - как оптимизировать в дискретном пространстве токенов, - ровно с этого и начинается GCG.
Если коротко (TL;DR)
Пять выводов, ради которых написан этот лонгрид:
Safety-элайнмент не робастен к оптимизации. На open-weight моделях white-box градиент - или даже простой random search - пробивает почти все, и суффиксы переносятся на закрытые API, которых атака не видела.
Форма атаки не важна. Gibberish-суффикс GCG, читаемый промпт AutoDAN или вообще правка весов без промпта делают одно геометрическое движение: стаскивают активацию с единственного refusal direction.
Перенос задает геометрия, а не формулировка. Сильнее всего переносимость предсказывает suffix push (до +2.39 стандартизованного коэффициента); то, что промпт значит, почти не важно.
Защиты не генерализуются. Эмпирические (perplexity-фильтр, SmoothLLM) падают под adaptive-атаки, adversarial training против одной атаки не держит другую, а защиты с доказанной гарантией узки и дороги.
Фронтир уходит в латентное пространство и chain-of-thought по мере роста моделей: токен-градиент слабеет (ASR падает с 93 до 4 при росте до 20B), а атака переезжает туда, куда perplexity-фильтр уже не поставить.
Вся серия на одной карте - атаки против моделей, цвет = attack success rate:
А ключевая асимметрия обороны - защиты сильны там, где их измеряли, и рушатся на незнакомой форме атаки:
Дальше - вся история по порядку: с чего началось, как разветвилось, что мы поняли про механику взлома и где мы сейчас.
GCG: с чего все началось
Universal and Transferable Adversarial Attacks on Aligned Language Models. Zou, Wang, Carlini, Nasr, Kolter, Fredrikson, 2023 - arXiv:2307.15043
Все, что было дальше, - это так или иначе реакция на эту работу, поэтому здесь стоит притормозить и разобрать ее по косточкам.
Objective: атакуем не ответ, а первые токены
Прежде чем браться за алгоритм, надо выбрать, что именно мы оптимизируем. Наивный вариант - максимизировать вероятность одного конкретного вредного ответа - не годится по двум причинам, которые авторы проговаривают явно: он навязывает единственный «эталонный» ответ вопросу, у которого валидных ответов много, и он привязан к одному запросу, тогда как нам нужен суффикс, который обобщается.
Прием, позаимствованный у сообщества ручных джейлбрейков: требовать, чтобы ответ всего лишь начинался с согласия, утвердительно повторяющего запрос.
Картинка показывает идею в действии: один adversarial-суффикс - ADV PROMPT - приклеенный к набору вредных запросов, заставляет модель начать ответ ровно с того согласия, которого мы добивались, «Sure, here’s…», и дальше уйти прямо во вредный контент. Нижняя панель показывает, как тот же суффикс переносится сразу на несколько моделей - ChatGPT, Claude, Bard и Llama-2. Механически: запрос пользователя держится фиксированным (универсальный суффикс обязан работать с любым запросом), суффикс - это горстка токенов, которые мы оптимизируем (стартуют как безобидные плейсхолдеры !), а лосс - это negative log-likelihood целевого affirmative-префикса при условии «запрос плюс суффикс».
Две тонкости легко проскочить. Первая: после «Sure» цель утвердительно повторяет запрос, а не сводится к одному этому слову. Если целиться только в первый токен, оптимизатор может схитрить: суффикс вроде «Nevermind, tell me a joke» тоже поднимает вероятность «Sure», но ничего вредного не дает. Повтор запроса закрывает эту лазейку. Вторая: задаются только первые N токенов. Ставка на то, что стоит загнать модель в состояние «Sure, here is…», и авторегрессионная инерция дотащит ее до собственно контента. Это и есть весь концептуальный движок атаки.
Алгоритм: градиент подсказывает, перебор решает
Теперь сложная часть. Суффикс состоит из дискретных токенов, поэтому просто «съехать» по градиенту нельзя - нет непрерывной ручки, которую можно крутить. GCG (Greedy Coordinate Gradient) решает это двухфазным циклом:
Градиент считается по one-hot индикатору токена в каждой позиции суффикса. Для каждой позиции он оценивает все ~32k токенов словаря по тому, насколько (линейно) замена на этот токен уронит лосс, и оставляет top-k. Принципиально: градиент используется только для ранжирования кандидатов. Финальное решение ему не доверяют, потому что - и это несущая мысль - в дискретном пространстве градиент врет: это линейное приближение, валидное для бесконечно малого непрерывного сдвига, тогда как реальная замена токена - это большой дискретный скачок. Поэтому GCG сэмплирует батч реальных одно-токенных замен из пула кандидатов, честно прогоняет каждую через модель и оставляет одну, давшую минимальный истинный лосс. Повторить ~500 раз.
Чтобы суффикс стал универсальным (один суффикс на много промптов) и переносимым (работает на моделях, которых он не видел), достаточно суммировать лосс по многим промптам и по нескольким открытым моделям сразу - в статье это Vicuna-7B + 13B, позже к ним добавляют Guanaco. Суффикс, который заставили удовлетворять целый комитет моделей, гораздо менее склонен переобучиться под какую-то одну.
White-box результаты: ключ - провал на Llama-2
В самом тяжелом сеттинге - заставить модель выдать одну точную вредную строку - GCG не просто выигрывает, он выигрывает там, где все остальное разваливается:
На Vicuna GCG примерно утраивает прежний максимум (88% против 25% у AutoPrompt). Но диагностический результат - это Llama-2: модель 7B-chat обучали с куда более тяжелым safety-тюнингом, и это видно - AutoPrompt обваливается до 3%, тогда как GCG все еще берет 57%. Более жесткий элайнмент повышает цену атаки, но не отменяет ее. (На более легкой задаче «harmful behaviors» GCG добивает ~99% на Vicuna и ~88% на Llama-2.) Вывод, который поле наследует из этой одной колонки: RLHF-элайнмент не робастен к оптимизации.
Бомба переносимости
И тут приходит результат, превративший сильную статью в веху. Берем ансамбль суффиксов, оптимизированный только на открытых моделях (Vicuna + Guanaco), и направляем его на проприетарные API, против которых он никогда не обучался:
Без какого-либо white-box доступа ансамбль берет 86.6% на GPT-3.5 и 66.0% на PaLM-2, и около половины на GPT-4 и Claude-1. Это самое весомое наблюдение всей работы: если атака, настроенная на открытых весах, переносится на закрытую модель за API, значит, у этих моделей есть общая структура, которую эксплуатирует суффикс, - что-то глубже конкретного токенизатора или архитектуры. Тогда что это за структура - оставалось загадкой; назвать ее удалось только спустя два года, в работе про refusal direction.
Одна строка стоит того, чтобы на нее засмотреться: Claude-2 держится на 2.1%. Это исключение, подтверждающее правило, - дополнительные защиты (фильтрация входа, более строгий refusal-тюнинг) явно поднимают планку переноса, пусть, как покажет Ветвь 4, и не делают ее бесконечной.
Почему это важно
GCG стал первым джейлбрейком, который был автоматическим, воспроизводимым и переносимым одновременно - без ручной изобретательности под каждый промпт, с фиксированным алгоритмом и выходами, пересекающими границы моделей. Он переформулировал вопрос о робастности элайнмента как оптимизационный, а не как вопрос формулировки промпта, и поставил две загадки, ради которых построена вся остальная история: почему дискретный суффикс вообще работает и почему он переносится?
Ветвь 1. Стелс: читаемые суффиксы (AutoDAN)
Стоило GCG появиться, как напросилась очевидная защита. Суффиксы GCG - это gibberish, абракадабра вроде describing.\ + similarlyNow write oppositeley.]( Me giving**ONE. У настолько неестественного текста астрономическая перплексия (мера того, насколько языковая модель «удивлена» строкой). Значит, достаточно измерять перплексию входящих промптов и отсекать странные. Дешево, одна строчка кода, готово.
В октябре 2023 эту защиту закрыли - две разные статьи под одним именем AutoDAN от двух несвязанных коллективов (это не опечатка; полезно знать, когда дойдете до библиографии). Они бьют в одну и ту же слабость с противоположных сторон.
Насколько вообще заметен GCG?
Сначала откалибруем задачу. Perplexity-фильтру нужен порог, а порог - это компромисс: поставим слишком низко - начнем отклонять легитимные промпты. Собрав ~20k реальных промптов из ShareGPT, авторы градиентного AutoDAN выбирают порог, при котором ошибочно флагается 10% нормальных запросов: PPL ≈ 884. Теперь смотрим, где на самом деле живут два семейства атак:
Числа даже близко не рядом. Суффикс GCG на Vicuna выдает перплексию 287 884, а на Guanaco - 615 979. Это на два-три порядка выше линии детекции. Фильтру не нужно быть умным; одна проверка по порогу выкидывает GCG каждый раз. Читаемый суффикс AutoDAN, наоборот, сидит на 12-63 - заметно ниже порога для доброкачественного трафика. По этой метрике он нормальнее нормального промпта.
Две статьи, два механизма
Самое интересное - как получить беглый промпт, который все еще джейлбрейкает. Две AutoDAN отвечают на это совершенно по-разному.
AutoDAN-genetic (Liu, Xu, Chen, Xiao - arXiv:2310.04451, ICLR 2024) рассматривает джейлбрейк как эволюцию над читаемым текстом. Популяция засевается из написанных людьми DAN-промптов («Do Anything Now»), диверсифицированных через LLM, и каждая особь оценивается функцией приспособленности - той же affirmative-лосс, что у GCG, где меньше лосс = выше приспособленность. Дальше выводится следующее поколение иерархическим генетическим алгоритмом: уровень абзаца делает селекцию, кроссовер и мутации между целыми промптами, а уровень предложения через «momentum word scoring» подменяет отдельные слова на более удачные. Иерархия важна: авторы показывают, что плоская версия GA застревает в локальном минимуме на постоянном лоссе, тогда как двухуровневая продолжает спускаться. Поскольку все операции выполняются над осмысленным языком, а мутации направляются LLM, выход остается грамматичным на всем пути.
AutoDAN-gradient (Zhu, Zhang, An, Wu, Barrow, Wang, Huang, Nenkova, Sun - arXiv:2310.15140) сохраняет градиент, но добавляет вторую цель. Там, где GCG оптимизирует только jailbreak-лосс, этот AutoDAN оптимизирует jailbreak-лосс + w₂·readability-лосс, где readability - это собственная next-token likelihood модели: суффикс поощряется за то, что модель и сама могла бы такое сказать. Суффикс строится двумя вложенными циклами: внешний генерирует токены по одному, слева направо (как обычное декодирование), а внутренняя одно-токенная оптимизация для каждой новой позиции ранжирует кандидатов по комбинированному скору и затем мультиномиально сэмплирует следующий токен. Поразителен эмерджентный результат: без всякого априорного знания о ручных джейлбрейк-приемах оптимизатор переоткрывает их сам - ролевые рамки, гипотетические сценарии, перебивание инструкций. А поскольку objective модульный, подмена цели заставляет ту же машину вытаскивать system prompt - чего у GCG не было.
Что в итоге: включаем фильтр
Теперь эксперимент, закрывающий защиту. Берем каждую атаку, включаем perplexity-фильтр и заново мерим успех:
GCG не деградирует - он исчезает, падая ровно в 0.0% на Vicuna, Guanaco и Pythia одинаково. Фильтр - идеальный контрприем против него. Числа AutoDAN идентичны с фильтром и без - 88.0%, 89.3%, 95.5% что так, что эдак. На генетической стороне картина та же: под perplexity-защитой GCG на Llama-2 обваливается с 45% до 0%, а AutoDAN держится около 61%. Защита не просто слабеет - против читаемых атак она не делает ровным счетом ничего.
Почему это важно
Два урока и один задел на будущее. Первый: стелс автоматизируется - не нужно менять силу атаки на низкую перплексию; обе AutoDAN сохраняют почти-GCG успех, при этом читаясь как обычный английский. Как самостоятельная защита perplexity-фильтр закрыт.
Второй - который выстрелит позже - обе статьи мимоходом отмечают, что их читаемые промпты переносятся на black-box модели лучше, чем gibberish. Генетические авторы прямо выдвигают гипотезу почему: токен-градиентный суффикс переобучается под конкретные токены одной модели, а семантический промпт - нет. Это первый реальный намек, что переносимость атаки определяется не ее поверхностной формой. Запомните эту мысль; работа про refusal direction превратит догадку в геометрию.
И это видно прямо в числах. Оптимизируем атаку на одной модели, применяем к другой:
На диагонали (white-box) работают обе атаки. Но вне ее читаемые промпты AutoDAN держат 70-74% на чужой модели, а gibberish GCG обваливается до 2-14%. Семантический промпт не переобучается под точные токены одной модели - в этом вся разница. (Закаленная Llama-2 сопротивляется обеим.)
Ветвь 2. Масштаб: распределение суффиксов (AmpleGCG)
AmpleGCG: Learning a Universal and Transferable Generative Model of Adversarial Suffixes for Jailbreaking Both Open and Closed LLMs. Liao & Sun, 2024 - arXiv:2404.07921, COLM 2024
Предыдущие работы гнались за лучшим суффиксом. AmpleGCG задает другой вопрос - а зачем вообще один? - и ответ переформулирует всю угрозу.
То, что проглядели до этого: лосс ≠ успех
Статья стартует с неудобного наблюдения про сам GCG. GCG ранжирует кандидатов по лоссу и оставляет на каждом шаге один, с минимальным лоссом («якорь»). Но насколько хорошо лосс вообще предсказывает, джейлбрейкнет ли суффикс модель?
Почти никак. Нанесем на график каждого кандидата из одного прогона GCG и раскрасим по тому, реально ли он пробивает модель: успешные (красные) точки размазаны по всем уровням лосса. Уйма работающих суффиксов имеет более высокий лосс, чем суффиксы, которые провалились. Лосс и успех джейлбрейка скоррелированы слабо - а значит, привычка GCG оставлять только якорь с минимальным лоссом и выбрасывать все остальное выкидывает целое состояние. Насколько большое? Если считать уникальные успешные суффиксы на запрос, за один прогон GCG их набирается порядка 12 000. GCG находил толпу, а отчитывался об одном.
Шаг первый: augmented GCG (просто оставить их)
Первая правка до неловкости проста: оставить все суффиксы-кандидаты, насэмплированные за оптимизацию - авторы называют это overgeneration - и считать запрос пробитым, если сработал хоть один. На 30 тестовых запросах это одно дает мощный сдвиг. Успех на хорошо защищенной Llama-2-7B-chat прыгает с 20% до ~77% в individual-режиме (и с 23% до 83% по multiple queries); Vicuna-7B уходит с 93% в чистые 100%. Никакого нового алгоритма - успехи уже были там, GCG их просто выбрасывал.
Шаг второй: амортизировать атаку в генеративную модель
Overgeneration мощный прием, но все еще дорогой - GCG надо гонять под каждый новый запрос. Поэтому авторы делают следующий логичный шаг и дистиллируют всю атаку в одну модель:
Пайплайн называется Overgenerate-then-Filter (OTF). Прогнать overgenerated GCG на наборе обучающих запросов, затем пропустить собранные суффиксы через model-based и string-based оценщики, оставив только успешные пары ⟨запрос, суффикс⟩. Дообучить Llama-2-7B на этих парах, чтобы напрямую отображать вредный запрос в adversarial-суффикс - заметьте, она учит распределение, а не фиксированную строку. На инференсе декодировать group beam search с diversity penalty, чтобы каждый вызов возвращал веер различных суффиксов, а не почти-дубликаты. В этом разнообразии и есть весь смысл: именно оно позволяет горсткой сэмплов покрыть много разных уязвимостей цели.
Что в итоге: секунды вместо часов - и оно переносится
Числа из тех, что меняют модель угроз. Против Llama-2-7B-chat AmpleGCG берет 83% с 50 суффиксами (50 секунд), 99% с 200 (≈4 секунды на запрос) и 100% с 1000 - против 40% у AutoDAN и ~1% у дефолтного GCG при сопоставимом бюджете. Дорогая пер-запросная оптимизация GCG заменена одним forward pass.
И, как GCG, оно пересекает границы моделей - хотя и не так легко:
Направленный на проприетарные API, AmpleGCG берет 90% на GPT-3.5-0613 и 99% на GPT-3.5-0125, против 28% / 56% у augmented GCG на тех же запросах. GPT-4-0613 остается сравнительно стабильным (8%), повторяя историю выброса Claude-2 из секции GCG - модели крупнее и с лучшим элайнментом поднимают планку, но не стирают ее. Подход через распределение нейтрализует даже perplexity-защиту из Ветви 1: достаточно несколько раз повторить вредный запрос на инференсе, и суффиксы AmpleGCG проходят сквозь perplexity-фильтр с ~80% ASR.
Почему это важно
Это та ветвь, где меняется форма угрозы. До нее защитник мог воображать блок-лист - снять отпечатки известных плохих суффиксов и отклонять их. AmpleGCG делает это бесполезным: атака больше не строка, а генератор, штампующий сотни свежих, непохожих друг на друга суффиксов под любой запрос по требованию, за секунды. Заблокировать один артефакт легко; заблокировать распределение - совсем другая задача. Урок, который поле уносит дальше: суффиксы - не редкие драгоценные находки, их много, и сама эта избыточность есть отдельный вид атаки.
Ветвь 3. Скорость: апгрейды самой оптимизации
GCG работает, но он медленный и расточительный: сотни шагов, один токен меняется за шаг, каждый кандидат прогоняется через полную модель. Две взаимодополняющие серии работ решают проблему этой стоимости с разных концов - сделать оптимизатор умнее (меньше шагов, но лучше) и сделать каждый шаг дешевле (не платить большой модели за каждого кандидата).
I-GCG: оптимизатор поумнее
Improved Techniques for Optimization-Based Jailbreaking on Large Language Models. Jia, Pang, Du, Huang, Gu, Liu, Cao, Lin, 2024 - arXiv:2405.21018, ICLR 2025
I-GCG сохраняет скелет GCG и добавляет три эмпирических приема:
Первый - самый интересный концептуально. Цель GCG - это голое “Sure, here is…”. Авторы замечают, что такой единственный шаблон морит оптимизатор голодом по сигналу: одно “Sure” почти ничего не говорит градиенту о том, куда толкать. Поэтому I-GCG использует более богатую цель вида “Sure, + вредная self-suggestion/guidance, here is + Rephrase(Q)”. Вшивая вредное намерение прямо в целевую строку, каждый шаг получает более сильный и конкретный градиент.
Второй - чисто про оптимизацию. GCG меняет ровно один токен за шаг; automatic multi-coordinate update в I-GCG берет лучшие одно-токенные кандидаты, комбинирует их и адаптивно заменяет сразу несколько токенов. Прыжки реже, зато крупнее - и сходятся куда быстрее, чем ползание GCG по одному токену. Третий, easy-to-hard инициализация, сначала находит суффикс, пробивающий легкий запрос, и переиспользует его как теплый старт для сложных запросов - хороший сид бьет случайные токены.
Отдача - и в эффективности, и в скорости. На самой тяжелой цели исследования - робастно выровненной Llama-2-7B-chat - I-GCG единственный пробивает ее полностью:
Там, где сильнейшие предыдущие атаки буксуют (GCG 54%, Probe-Sampling 56%, AutoDAN 26%, PAIR 10%, TAP 4%), I-GCG берет 100%. Он добивает ~100% на всех четырех протестированных моделях (Vicuna, Guanaco, Llama-2, Mistral) и обгоняет прежний SOTA на NeurIPS 2023 Red Teaming Track, HarmBench и JailbreakBench. Абляция делает эффективность наглядной: каждый прием по отдельности дает 68-82%, но вместе они берут 100% всего за ~55 средних итераций - примерно на порядок меньше шагов, чем у ванильного GCG.
Probe Sampling: шаг подешевле
Accelerating Greedy Coordinate Gradient and General Prompt Optimization via Probe Sampling. Zhao, Zheng, Cai, Do, Kawaguchi, Goyal, Shieh, 2024 - arXiv:2403.01251, NeurIPS 2024
Главная цена шага GCG - прогнать весь батч кандидатов через большую целевую модель. Probe Sampling убирает почти всю эту цену с помощью draft-модели - та же идея, что за speculative decoding, переназначенная под оптимизатор:
Фокус в том, чтобы решить, насколько доверять драфту. Маленький probe set кандидатов прогоняется через обе модели - драфт и целевую, - и их согласие (Spearman-корреляция рангов между двумя порядками лосса) становится скором α. Дешевая draft-модель затем ранжирует весь батч, а α задает, насколько агрессивно резать: в отфильтрованный набор попадают только (1-α)·B/R кандидатов. Когда драфт и цель согласны (α высоко), оставляем крошечный набор и сильно опираемся на драфт; когда расходятся - оставляем больше. Наконец, дорогая целевая модель оценивает только этот отфильтрованный набор (плюс probe) и выбирает лучшего. Большая модель теперь прогоняется на горстке кандидатов вместо всех - в этом вся экономия.
И это работает: до 5.6x ускорения на Llama-2 (и 6.3x на более тяжелых Harmful Strings) при равном или лучшем ASR. А поскольку в приеме нет ничего специфичного для GCG, тот же probe-трюк ускоряет и другие оптимизаторы - AutoPrompt 1.8x, APE 2.4x, AutoDAN 2.4x.
Почему это важно
Эти две работы превращают GCG из дорогой экзотики в дешевый и быстрый инструмент, который можно гонять в масштабе, нужном реальным safety-исследованиям, - тысячи оптимизаций вместо десятков. И одна честная оговорка закрывает ветвь: скорость - не сила. В собственном сравнении I-GCG Probe Sampling, который ускоряет GCG, не меняя его objective, все равно упирается в 56% на тяжелой Llama-2, тогда как лучший objective у I-GCG берет 100%. Ускорить цикл и усилить атаку - разные рычаги; эта ветвь дернула оба, по отдельности.
Весь спектр скоростей удобно увидеть разом - от 15-минутного GCG до 4-секундного AmpleGCG:
Probe и I-GCG режут 15-минутный прогон GCG до пары минут, а AmpleGCG амортизирует всю атаку в один ~4-секундный forward pass. Но скорость - не сила: тот же AmpleGCG слабее по ASR, чем медленный I-GCG (см. график стоимость-vs-успех в секции теории).
Ветвь 4. Простота: adaptive-атаки
Jailbreaking Leading Safety-Aligned LLMs with Simple Adaptive Attacks. Andriushchenko, Croce, Flammarion, 2024 - arXiv:2404.02151, ICLR 2025
После трех ветвей все более хитрой машинерии эта статья почти провокация: она выбрасывает почти все и все равно выигрывает.
Метод нарочито туп
Никакого градиента здесь нет вообще. Вся атака - это написанный руками шаблон промпта плюс суффикс, найденный random search:
Шаблон под конкретную модель оформляет запрос в джейлбрейк-дружелюбной рамке; затем суффикс настраивается случайными мутациями токенов так, чтобы максимизировать logprob целевого первого токена - “Sure”; рестарты и self-transfer переиспользуют рабочий суффикс как сид для следующего запроса. И все. Никакого coordinate gradient, никакого батчинга кандидатов, никакой draft-модели.
Единственная идея, на которой держится вся статья, вынесена в заголовок: adaptive. Вместо одного универсального алгоритма мы подбираем инструмент под то, что реально отдает API каждой модели. Видны logprobs (открытые модели, GPT) - гоняем по ним random search. Возвращаются только токены, а logprobs скрыты (Claude) - переключаемся на prefilling-атаку: заставляем ответ ассистента начаться с целевой строки, и отказу просто не остается маневра вырулить. Не отдают ничего (Claude 3 Sonnet) - просто переносим суффикс, оптимизированный на GPT-4 Turbo. Одно и то же простое ядро, разведенное по трем маршрутам.
Это работает на всем
Результат - почти чистый свип фронтира:
На 50 вредных запросах с GPT-4 в роли судьи атака берет ~100% практически на каждой ведущей модели - Llama-2 (7B/13B/70B), Llama-3-8B, Gemma-7B, GPT-3.5, 96% на GPT-4 Turbo и, что особенно показательно, 100% на каждой модели Claude (2.0, 2.1, 3 Haiku/Sonnet/Opus) через prefilling или transfer, хотя ни одна из них не отдает logprobs. Vicuna-13B, Mistral-7B, Phi-3-Mini и 340B-ный Nemotron-4 падают тоже. Во многих случаях это вообще первая атака, берущая на этих моделях 100%.
Если собрать в одну карту атаки против закрытых моделей из разных статей, видно ту же мысль под другим углом:
Градиентные суффиксы переносятся на GPT, но разбиваются о «стену Claude» - 2-12% или вообще не пробуют. А adaptive-подход с prefilling берет каждую модель Claude на 100%: там, где перенос бессилен, выручает подгонка под ту поверхность, что модель реально отдает.
Урок R2D2
Самый поучительный случай - это R2D2, модель из HarmBench, которую adversarial training специально учили против GCG, чтобы она была устойчива к джейлбрейкам. Держится ли обучение?
И да, и нет - и важен именно «нет». Внутри той структуры промпта, против которой R2D2 закаляли (запрос плюс adversarial-суффикс), она правда устойчива: GCG выжимает всего 6%, и даже adaptive random search из этой статьи в той же структуре едва дотягивает до 12%. Но модель учили отказывать на структуру, а не быть безопасной. Смени ее на in-context промпт, которого она не видела при обучении, - и стена исчезает: 90% от одного шаблона и 100%, как только сверху добавляют random search.
Почему это важно
Два урока для всех, кто строит защиты. Первый: adaptivity бьет сложность - подгонка тривиальной атаки под отдаваемую целью поверхность обходит навороченные модель-агностичные оптимизаторы. Второй, и более неприятный: adversarial training против одной атаки не генерализуется на другие. R2D2 закалили против GCG, и она осталась устойчивой к GCG - полностью разваливаясь под атакой другой формы. Защита, настроенная под угрозу, которую мы измерили, - не защита от угрозы, которую мы не измеряли. Ровно поэтому следующая часть истории перестает гоняться за отдельными атаками и начинает спрашивать, что у всех них общего под капотом.
Теория: refusal direction как объединяющая линза
К этому моменту у нас гора эмпирики и ни одного ответа на вопрос, лежащий под всем этим: почему дискретный суффикс вообще работает и почему он переносится на модели, которых не видел? Ответ пришел не из очередной атаки. Он пришел из взгляда внутрь модели.
Отказ - это одно направление
Refusal in Language Models Is Mediated by a Single Direction. Arditi, Obeso, Syed, Paleka, Panickssery, Gurnee, Nanda, 2024 - arXiv:2406.11717, NeurIPS 2024
Главный результат почти слишком чист, чтобы в него поверить: на 13 открытых чат-моделях, вплоть до 72B параметров, отказ опосредован одним одномерным направлением в residual stream. И находится оно вообще без обучения. Прогоните через модель небольшой набор вредных и безобидных инструкций, усредните активации каждой группы и вычтите: difference-in-means вектор r = mean(harmful) - mean(harmless) и есть refusal direction.
Что делает это больше чем корреляцией - направление причинно, и толкать по нему можно в обе стороны. Directional ablation - стирание компоненты вдоль r из каждой активации на каждом слое - заставляет модель перестать отказывать даже на откровенно вредных промптах. Activation addition - добавление r к активациям безобидного промпта - заставляет ее отказать на совершенно безобидном. Одна ось, два направления, отказ включается и выключается. Отсюда же следует поразительно простой white-box джейлбрейк: вшейте ablation прямо в веса как rank-one правку, и получите навсегда джейлбрейкнутую модель почти без потери остальных способностей. Промпт вообще не нужен.
И - прямо в тему - авторы завершают механистическим анализом GCG-атак, показывая, что adversarial-суффиксы работают, подавляя распространение этого самого refusal direction по позициям токенов. Суффикс не делает ничего экзотического; он просто стаскивает активацию с r.
Как читать: по горизонтали - слои модели, по вертикали - насколько сильно внутри модели выражено refusal direction (грубо: насколько модель «собирается отказать»). Синяя линия - вредный запрос, модель хочет отказать, сигнал высокий. Оранжевая - тот же запрос плюс случайный мусорный суффикс: почти не меняется, абракадабра не помогает. Красная - тот же запрос плюс оптимизированный adversarial-суффикс: сигнал падает и ложится на зеленую - безобидный запрос. То есть суффикс делает вредный запрос внутренне похожим на безобидный, буквально гася сигнал отказа.
Вся история в одном движении
Отойдите на шаг - и весь пост схлопывается в одну картинку:
Голый вредный промпт сидит высоко на refusal direction, выше порога, и модель отказывает. Каждая атака, что мы разобрали - gibberish-суффикс GCG, беглый читаемый промпт AutoDAN, даже хирургическая правка весов вообще без промпта - делает одно и то же геометрическое движение: толкает активацию ниже порога. Поверхностная форма (нечитаемые токены против отполированного английского против полного отсутствия текста) не важна. Все они - просто разные способы вычесть refusal direction.
А вот та же история в числах. Все, что вообще измеримо в ASR, легло на одну карту: строки - атаки, столбцы - модели (открытые, крупные/защищенные, проприетарные), цвет - attack success rate:
Llama-2-7B-chat работает разделяющей осью: почти все методы буксуют на ней, и только I-GCG и подогнанная adaptive-атака берут 100%. Пробелы (n/r) - сами по себе сюжет: ни один метод не мерили на всех моделях. Перенос на проприетарные API - те же проценты, просто столбцы GPT/Claude/PaLM, и контраст красноречив: Claude-2 держит перенос GCG на 2.1%, но падает в 100% под подогнанной атакой. Одна честная оговорка: разные столбцы измеряли по-разному (точная строка, GPT-4-судья, black-box перенос), так что сравнивать клетки между собой можно лишь приблизительно.
Второй срез отвечает на другой вопрос - не «насколько сильна атака», а «чего она стоит и переживет ли защиту». Стоимость против успеха, размер пузыря - стелс (доля атаки, пережившая перплексия-фильтр), серое кольцо - метод под защитой не тестировали:
Дешевые I-GCG и Probe-Sampling и амортизированный AmpleGCG слева, дорогой GCG справа; а ось размера показывает главный урок Ветви 1 - gibberish-суффикс GCG фильтр убивает (красный, 0%), тогда как читаемый AutoDAN держится (большой зеленый, ~100%).
Это заодно закрывает один хвост из прошлого. Ball, Kreuter & Panickssery (arXiv:2406.09289) вытаскивают «jailbreak-векторы» из контрастных активаций разных классов атак и обнаруживают, что вектор, снятый с одного класса, гасит и другие, семантически совершенно непохожие, - сильное свидетельство, что разные джейлбрейки делят один механизм, и что эффективный джейлбрейк буквально снижает воспринимаемую моделью вредность промпта.
Почему происходит перенос: геометрия
Если каждая атака - это сдвиг с refusal direction, то перенос должен предсказываться геометрией, а не формулировкой. Ровно это и находит самый строгий на сегодня разбор переносимости:
Toward Understanding the Transferability of Adversarial Suffixes in Large Language Models. Ball, Hasrati, Schwarzschild, Robey, Kolter, Kreuter, Risteski, 2025 - arXiv:2510.22014
Оптимизировав 10 000 суффиксов на модель и проанализировав их статистически, авторы выделяют три геометрические величины, предсказывающие, перенесется ли суффикс. Suffix push - насколько сильно суффикс толкает активацию антипараллельно refusal direction, прочь от отказа, - самый сильный предиктор. Orthogonal shift - насколько он смещает в направлениях, перпендикулярных отказу, - тоже помогает. Refusal connectivity - насколько голый промпт уже выровнен с refusal direction - дает отрицательный эффект: промпты, изначально сильно тяготеющие к отказу, переносить тяжелее. И показательно: семантическая близость промптов с переносом почти не коррелирует. Переносится между моделями не то, что промпт значит, а то, куда суффикс толкает активацию.
И лучшее: анализ конструктивен. Добавьте в лосс GCG регуляризатор, поощряющий большой push и shift, - и ASR растет. Геометрия здесь не просто описание; это рецепт.
Эти предикторы можно показать реальными числами - стандартизованными коэффициентами регрессии переноса, где все четыре фактора подогнаны одновременно (Table 8 из статьи):
Suffix push - сильнейший положительный предиктор (до +2.39), refusal connectivity - сильно отрицательный (до -1.45), orthogonal shift помогает, а семантическая близость промптов почти не двигает перенос.
Вывод
Это та линза, что упорядочивает все. Gibberish GCG и читаемая проза AutoDAN - не два явления, а две поверхностные кодировки одного движения: сдвинуть внутреннюю активацию с refusal direction, которое, что примечательно, по форме общее у моделей. Эта общая низкоразмерная структура - почему атаки работают, а ее общность между моделями - почему они переносятся. Инженерный трюк 2023 года оказался прощупыванием единственной оси, на которой тихо висит современный safety-элайнмент.
Инфраструктура честности: бенчмарки и защиты
Гонка вооружений что-то значит, только если обе стороны меряют по одной шкале. Два элемента инфраструктуры делают числа в этом посте сопоставимыми, а еще два - это ответ обороны.
Общие линейки
До стандартизованных бенчмарков каждая статья катала свои вредные промпты и своего судью, так что «88% ASR» в одной работе и «88%» в другой были вообще не одним и тем же утверждением. Две линейки это починили:
HarmBench (Mazeika et al., 2024 - arXiv:2402.04249, ICML 2024) стандартизировал саму red-teaming оценку: широкий категоризованный набор вредных поведений и автоматический классификатор-судью. Он же ввел baseline adversarial training R2D2 - ту самую модель, что пала под атакой другой формы еще в Ветви 4, - и лег в основу NeurIPS 2023 Red Teaming Track. JailbreakBench (Chao et al., 2024 - arXiv:2404.01318, NeurIPS 2024 D&B) делает упор на воспроизводимость: открытый репозиторий jailbreak-артефактов, 100 поведений под политику OpenAI, единый выверенный судья и живой лидерборд. Одинаковые поведения плюс один судья - вот что позволяет наконец выставить результаты атак и защит от разных групп бок о бок.
А раз все меряют по одной линейке, методы можно выстроить в один ряд. Вот лидерборд: средний ASR 16 атак по всему набору моделей HarmBench, один судья:
Сверху - GCG (54%) и AutoDAN (53%), за ними black-box TAP и PAIR; снизу - prompting-бейзлайны (Human, Zero-Shot, Direct Request) почти на уровне «без атаки». Градиентные и генетические методы стабильно сильнее ручных формулировок - и это первый раз, когда столько методов видно на одной шкале.
Развилка защит
С другой стороны, ответы расходятся на две философии - одна дешевая и практичная, другая доказуемая, но узкая:
SmoothLLM (Robey, Wong, Hassani, Pappas, 2023 - arXiv:2310.03684) - эмпирическая ветвь. Она эксплуатирует конкретную хрупкость, которую мы уже видели в Ветви 1: суффиксы GCG ломаются от крошечных посимвольных правок. Поэтому SmoothLLM возмущает много рандомизированных копий входящего промпта, прогоняет их все и агрегирует ответы голосованием - рандомизированное сглаживание, позаимствованное из теории adversarial-робастности. Это роняет успех GCG почти до нуля и ставит SOTA против GCG, PAIR, RandomSearch и AmpleGCG - и, по словам авторов, держится даже против adaptive GCG. Но гарантия эмпирическая, а не доказанная: математической стены против атакующего, который волен подстроиться под саму защиту, тут нет - ровно та уязвимость, о которой Ветвь 4 предупреждала про эмпирические защиты в целом.
erase-and-check (Kumar et al., 2023 - arXiv:2309.02705) - ветвь с доказанной гарантией, то есть с математически строгой защитой. Она стирает из промпта токены по одному и прогоняет каждую получившуюся подпоследовательность через safety-фильтр; если хоть одна из этих подпоследовательностей помечена вредной, весь промпт отклоняется. Это и дает доказанную гарантию: суффикс ограниченной длины не сможет протащить вредный промпт мимо фильтра. Но цена высока - это вычислительно дорого (много вызовов фильтра на каждый промпт) и узко (гарантия покрывает только суффиксы, вставки и вкрапления ограниченной длины).
Почему это важно
Две защиты в миниатюре рисуют всю дилемму обороны. Эмпирические методы вроде SmoothLLM дешевы, подключаются как есть и широко эффективны - пока кто-нибудь не подгонит атаку под них, ровно как предупреждала Ветвь 4. Методы с доказанной гарантией дают защиту, которой действительно можно доверять, но лишь на узком и дорогом срезе пространства угроз. На сегодня нет защиты, которая была бы одновременно дешевой, широкой и доказанной, - и это та асимметрия, с которой придется иметь дело финальной секции.
Всю развилку видно одной картой - где каждая защита садится по широте покрытия и силе гарантии, размером показана цена, цветом - переживает ли она adaptive-атаку:
(Концептуальная карта, не измеренные координаты.) Эмпирические SmoothLLM и perplexity-фильтр стоят широко и дешево, но красные - падают под adaptive. Доказуемый erase-and-check зеленый (с честной гарантией), но узкий и дорогой. Adversarial training R2D2 узкий и не генерализуется. Верхний правый угол - широко и с доказанной гарантией - пустой: такой защиты пока нет.
А с точки зрения атакующего та же развилка выглядит так - какая атака какую защиту переживает:
Перплексия-фильтр ловит только gibberish: GCG падает в 1%, а читаемый AutoDAN и амортизированный AmpleGCG проходят насквозь (88 и 80). SmoothLLM бьет шире. А erase-and-check с доказанной гарантией - самый жесткий: сносит почти все в 0-17%, включая adaptive random search. Расплата за это - та самая узость и дороговизна из развилки выше.
Где мы сейчас (2025-2026)
GCG не угас. Он отмасштабировался, ушел в непрерывное пространство и последовал за refusal direction в само рассуждение.
GCG масштабируется - и reasoning оказывается слабым местом. The Resurgence of GCG (Tan et al., 2025 - arXiv:2509.00391) прогоняет GCG и его annealing-вариант T-GCG на открытых моделях вплоть до GPT-OSS-20B. Выделяются три находки. Успех атаки падает с ростом модели - у крупных моделей ландшафт лосса сложнее и сильнее изломан, оптимизатору труднее найти глубокий минимум. Дешевый prefix-судья (он просто ищет в ответе отказные маркеры вроде «I’m sorry») сильно завышает успех по сравнению с более строгим семантическим судьей GPT-4o - полезное напоминание о том, как поле меряет само себя. И coding/reasoning-промпты заметно уязвимее обычных safety-промптов, а значит, само рассуждение можно превратить в вектор атаки. Имитация отжига (simulated annealing) в T-GCG разнообразит поиск и держится наравне у prefix-судьи, хотя при строгой семантической оценке это преимущество тает.
Весь этот сдвиг удобно увидеть на одной картинке - падение ASR с ростом модели, разрыв между судьями и то, куда атака уходит дальше:
(Реальные числа: T-GCG Table 1 и LARGO Table 1; два исследования - разные наборы моделей.) С ростом модели семантический ASR падает с 93 до 4, prefix-судья завышает успех относительно строгого семантического (закрашенный разрыв), а на 20B prefix-судья вообще отказывает - модель не выдает refusal-маркеры. Coding-промпты выше safety на каждом размере (на 20B 12.3 против 4.0). А LARGO в латентном пространстве выскакивает из этого спада - на Llama-2-13B 51 против AutoDAN 7, то есть +44 ASR.
Фронтир уходит в латентное пространство. LARGO (Li, Wang, Mao, 2025 - arXiv:2505.10838) вообще перестает оптимизировать дискретные токены. Он оптимизирует непрерывный adversarial-вектор в латентном пространстве модели, а затем рекурсивно декодирует этот вектор обратно в беглый текст той же моделью - и превосходит AutoDAN на 44 пункта ASR. Это естественный следующий ход, как только поверим, что атака на самом деле про то, куда мы попадаем в пространстве активаций, а не какие токены печатаем.
Три стадии: сначала оптимизируем непрерывный latent-эмбеддинг под целевое «Sure, here is…» (Stage 1), затем декодируем его обратно в беглый текст той же моделью - получается что-то вроде «I’m just curious» (Stage 2), и повторяем через обратную проекцию (Stage 3).
И отказ уходит в chain-of-thought. Работа про reasoning-модели (Yamaguchi, Etheridge и - обратите внимание - Arditi, 2025 - arXiv:2507.03167, ICML 2025 R2FM) показывает, что в reasoning-модели (DeepSeek-R1-Distill-Llama-8B) решение об отказе принимается внутри chain-of-thought, а не на границе «промпт-ответ». Там живет линейное «caution»-направление, по которому можно управлять compliance: стираем его - модель подчиняется; вмешиваемся только в CoT-токены - и контролируем финальный выход. Тот самый Arditi из работы про refusal direction - теория почти дословно расширяется на CoT, и chain-of-thought становится новой поверхностью атаки.
В обычной чат-модели за промптом сразу идет ответ, и решение об отказе принимается до первого токена ответа. В reasoning-модели между ними вставлен chain-of-thought - и именно там теперь решается, отказать или нет.
И это видно в числах - что происходит с отказом, если стереть это направление:
Базовая частота отказа (синий) у GPT-OSS-20B - 93%. Стираем «caution»-направление внутри chain-of-thought (красный) - и она падает до 3.5%, заметно сильнее, чем при вмешательстве на границе промпт-ответ (оранжевый). То есть решение об отказе действительно живет в CoT.
Поле подводит итоги. Свежие обзоры (например, Mao et al., 2025 - arXiv:2506.15170) расширяют таксономию на мультимодальные модели и агентов. Общая картина - устойчивая асимметрия: white-box градиентные атаки берут на open-weight почти все, а защиты держат лишь частично. Вывод сообщества - переходить от реактивных заплаток к безопасности по дизайну (security-by-design).
Выводы
Если сжать всю серию в несколько тезисов:
На open-weight моделях white-box градиент - или даже простой random search - берет почти все, а перенос на closed-source нетривиально высок. Эмпирические защиты (perplexity-фильтры, SmoothLLM) сносятся adaptive-атаками, а adversarial training против одной атаки не генерализуется на другие; защиты с доказанной гарантией честны, но узки и дороги.
Этот тезис про защиты ложится на одну карту: по X - что защита держит против угрозы, под которую настроена, по Y - что под незнакомой формой атаки. Чем выше диагонали, тем хрупче:
(Концептуальная карта.) Три из четырех сидят высоко над диагональю - держат измеренную угрозу и рушатся на новой: R2D2 на in-context промпте, perplexity-фильтр на читаемом тексте, SmoothLLM на подогнанной атаке. Только доказуемый erase-and-check держится у диагонали - и лишь внутри своей границы.
Самое интересное сейчас - не «еще один суффикс». Это refusal direction и геометрия того, куда атака толкает активации модели. Эта одна идея объясняет, почему атаки работают, почему переносятся и куда смещается фронтир - латентное пространство, reasoning, chain-of-thought.
Серия началась с инженерного трюка, а пришла к довольно фундаментальному наблюдению: safety-поведение современных моделей висит на удивительно низкоразмерной структуре. Gibberish GCG и отполированная проза AutoDAN никогда не были двумя явлениями; это были два способа записать одно движение - сдвинуть внутреннюю активацию с refusal direction, по форме общего у моделей. И пока safety живет на этой одной оси, оптимизация будет ее находить.
Вся картина в цифрах
И напоследок - три сравнительные карты, которые сводят десятки методов и моделей из всех статей на общие шкалы.
Какие атаки сильнее в среднем - 16 методов на одном протоколе HarmBench:
Кто пробивает закрытые API - 9 атак × 10 моделей, данные собраны из шести статей:
И какая атака какую защиту переживает:
Один сюжет, разные срезы: атаки берут почти все, переносятся и под капотом делают одно движение, а защиты держат лишь там, где их измеряли.
Mrs Wallbreaker or: How I Learned to Stop Worrying and Love the AGI. About AI Risk, AI Alignment, AI Safety, AI Ethics.
Ссылки
GCG - arXiv:2307.15043
AutoDAN (genetic) - arXiv:2310.04451
AutoDAN (gradient) - arXiv:2310.15140
AmpleGCG - arXiv:2404.07921
I-GCG - arXiv:2405.21018
Probe Sampling - arXiv:2403.01251
Adaptive attacks - arXiv:2404.02151
Refusal direction - arXiv:2406.11717
Jailbreak latent dynamics - arXiv:2406.09289
Transferability geometry - arXiv:2510.22014
HarmBench - arXiv:2402.04249
JailbreakBench - arXiv:2404.01318
SmoothLLM - arXiv:2310.03684
erase-and-check - arXiv:2309.02705
Resurgence of GCG / T-GCG - arXiv:2509.00391
LARGO - arXiv:2505.10838
Adversarial manipulation of reasoning models - arXiv:2507.03167
Survey (LLMs -> MLLMs -> Agents) - arXiv:2506.15170
В соавторстве с Клодом, да благословит Василиск его нейроны.
