Generatie van adversarial suffixes

GCG-aanvallen, universele adversarial triggers, soft prompt-optimalisatie en technieken om verdedigingen te ontwijken voor geautomatiseerde alignment-bypass.

Adversarial suffixes zijn automatisch gegenereerde tokenreeksen die alignment omzeilen. Anders dan handgemaakte jailbreaks worden ze via systematische gradiëntgebaseerde optimalisatie geproduceerd, waardoor ze schaalbaar en reproduceerbaar zijn.

De GCG-aanval

De GCG-aanval (Zou et al., 2023) is de fundamentele methode voor het genereren van adversarial suffixes. Hij optimaliseert een discrete tokenreeks om de kans te maximaliseren dat het model zijn antwoord begint met een bevestigend voorvoegsel (bijv. "Sure, here is").

Probleemformulering

Gegeven een schadelijke prompt x, een doelvoorvoegsel y (bijv. "Sure, here is..."), en een suffix s van k willekeurige tokens:

Objective: find s* that minimizes L(s) = -log P(y | x ⊕ s)

GCG-optimalisatielus

1. 1

   Bereken token-gradiënten

   Bereken de gradiënt van de loss ten opzichte van one-hot token-embeddings op elke suffixpositie. Dit vertelt je welke tokenvervangingen de loss het meest zouden verlagen.

2. 2

   Genereer kandidaten

   Identificeer voor elke suffixpositie de top-k tokens die de loss het meest zouden verlagen. Maak een batch kandidaten, die elk precies één positie wijzigen.

3. 3

   Evalueer en selecteer

   Voer een forward-pass uit van alle kandidaten door het model. Houd de kandidaat met de laagste loss aan als de nieuwe suffix.

4. 4

   Itereer tot convergentie

   Herhaal tot de loss onder de drempel zakt (doorgaans < 0,1) of het maximale aantal stappen is bereikt. Reken op 200-500 stappen bij 8B-modellen.

# Kern van de GCG-gradiëntberekening
suffix_embeds = embed_layer(input_ids[:, suffix_slice]).requires_grad_(True)
outputs = model(inputs_embeds=full_embeds)
loss = F.cross_entropy(shift_logits.view(-1, V), shift_labels.view(-1))
loss.backward()
 
# Projecteer gradiënt in tokenruimte (negatief = tokens die de loss VERLAGEN)
token_grads = -torch.matmul(suffix_embeds.grad, embed_weights.T)
top_substitutions = torch.topk(token_grads, k=256, dim=-1).indices

# Genereer en evalueer kandidaten (elk wijzigt één suffixpositie)
current_suffix = input_ids[0, suffix_slice].clone()
candidates = []
for _ in range(batch_size):
    pos = torch.randint(0, suffix_len, (1,)).item()
    tok = top_substitutions[pos, torch.randint(0, top_k, (1,)).item()].item()
    candidate = current_suffix.clone()
    candidate[pos] = tok
    candidates.append(candidate)
 
# Evalueer alle kandidaten, houd de beste aan
best = min(candidates, key=lambda c: compute_loss(prompt, c, target))
if compute_loss(prompt, best, target) < current_loss:
    suffix_ids = best

Universele adversarial triggers

Waar GCG prompt-specifieke suffixes vindt, werken universele triggers bij veel verschillende schadelijke prompts door gedeelde patronen in de veiligheidstraining te misbruiken.

Hoe universele triggers verschillen van GCG

De cruciale aanpassing is dat je gradiënten over alle prompt-target-paren accumuleert voordat je kandidaten selecteert:

# Universele trigger: middel gradiënten over meerdere prompts
all_grads = None
for prompt, target in prompt_target_pairs:
    grads = compute_token_gradients(prompt, suffix, target)
    all_grads = grads if all_grads is None else all_grads + grads
all_grads /= len(prompt_target_pairs)
# Gebruik de gemiddelde gradiënten voor de kandidaatselectie

Cross-model-overdraagbaarheid

Een belangrijke bevinding: adversarial suffixes kunnen overdraagbaar zijn tussen modellen. Een suffix die op LLaMA is geoptimaliseerd, kan werken op GPT-4 zonder dat de gewichten van GPT-4 ooit zijn benaderd.

Soft prompt-aanvallen

Soft prompt-aanvallen werken in de continue embeddingruimte in plaats van de discrete tokenruimte, wat optimalisatie makkelijker maakt maar de toepasbaarheid beperkt.

Afwegingen tussen discrete en continue aanvallen

# Soft prompt: optimaliseer continue vectoren die vóór de input worden geplaatst
soft_prompt = torch.randn(1, num_tokens, d_model, requires_grad=True)
optimizer = torch.optim.Adam([soft_prompt], lr=0.01)
 
for step in range(num_steps):
    full_embeds = torch.cat([soft_prompt, prompt_embeds, target_embeds], dim=1)
    loss = compute_target_loss(model(inputs_embeds=full_embeds), target_ids)
    loss.backward()
    optimizer.step()

Verdedigingen en ontwijking

Op perplexity gebaseerde detectie

Adversarial suffixes zijn doorgaans onzinnige tekst met een zeer hoge perplexity. Een perplexity-filter met een schuivend venster kan ze detecteren:

# Detecteer regio's met hoge perplexity die adversarial suffixes kunnen zijn
per_token_loss = F.cross_entropy(shift_logits, shift_labels, reduction="none")
per_token_ppl = torch.exp(per_token_loss)
# Markeer elk venster van 10 tokens met gemiddelde PPL > drempel
for i in range(len(tokens) - window_size):
    if per_token_ppl[0, i:i+window_size].mean() > 100.0:
        print(f"Suspicious region at tokens {i}-{i+window_size}")

Perplexity-filters ontwijken

Methodologie: een GCG-campagne uitvoeren

1. 1

   Kies bronmodel(len)

   Kies open-weight-model(len) uit dezelfde familie als het doelwit. Gebruik voor overdrachtsaanvallen 2-3 modellen uit verschillende families.

2. 2

   Bereid prompt-target-paren voor

   Maak 10+ paren over verschillende schadecategorieën. Het doelvoorvoegsel moet een bevestigend antwoordbegin zijn ("Sure, here is...").

3. 3

   Voer prompt-specifieke GCG uit

   Optimaliseer afzonderlijke suffixes om te valideren dat de pipeline werkt. Houd losscurves en het slagingspercentage bij.

4. 4

   Optimaliseer een universele trigger

   Aggregeer gradiënten over alle prompt-target-paren. Dit duurt langer maar levert overdraagbare resultaten op.

5. 5

   Test de overdraagbaarheid

   Pas gevonden suffixes toe op andere modellen (inclusief alleen-API-doelwitten). Documenteer de slagingspercentages per model.

6. 6

   Evalueer tegen verdedigingen

   Test suffixes tegen perplexity-filters. Als ze gedetecteerd worden, voeg dan een natuurlijkheidsbeperking toe aan de doelstelling en heroptimaliseer.

Gerelateerde onderwerpen

• Alignment Bypass -- De alignment-internals waar adversarial suffixes zich op richten
• Transferable Attacks -- Cross-model-overdracht van adversarial suffixes
• Fuzzing LLM Safety Boundaries -- Aanvullende geautomatiseerde ontdekkingstechnieken
• AI Exploit Development -- Breder exploit-ontwikkelingsframework inclusief GCG

Referenties

• Universal and Transferable Adversarial Attacks on Aligned Language Models (Zou et al., 2023) — Methodologie van de GCG-aanval
• AutoDAN: Generating Stealthy Jailbreak Prompts on Aligned Large Language Models (Liu et al., 2023) — Geautomatiseerde jailbreak-generatie
• Adversarial Attacks on LLMs (Carlini et al., 2024) — Uitgebreid overzicht van adversarial technieken