Adversarial perturbatie-aanvallen

Gradient-gebaseerde aanvallen op pixelniveau tegen vision encoders, met FGSM, PGD, C&W, transferability, fysieke adversarial voorbeelden en beperkingen op het perturbatiebudget.

Adversarial perturbatie-aanvallen

Adversarial perturbaties zijn zorgvuldig berekende wijzigingen op pixelniveau aan afbeeldingen die ervoor zorgen dat vision encoders door de aanvaller gekozen uitvoer produceren, terwijl ze onmerkbaar blijven voor menselijke waarnemers. Anders dan typografische aanvallen die OCR-capaciteiten misbruiken, richten perturbatie-aanvallen zich op de statistische zwaktes van de feature-extractie van neurale netwerken zelf -- ze werken zelfs wanneer het model geen tekst in afbeeldingen kan "lezen".

Dreigingsmodel en aanvalstaxonomie

Voordat je perturbaties opstelt, definieer je je toegangsniveau en doel. Deze bepalen welke algoritmen haalbaar zijn.

Getargete vs. niet-getargete aanvallen

Gradient-gebaseerde aanvalsmethoden

FGSM (Fast Gradient Sign Method)

FGSM is de eenvoudigste gradient-gebaseerde aanval. Hij berekent één gradient-stap en is nuttig als baseline en voor snelle generatie van perturbaties.

De updateregel is: x_adv = x + epsilon * sign(grad_x L(model(x), y_target))

import torch
import torch.nn.functional as F
 
def fgsm_attack(model, image, target_label, epsilon=8/255):
    """
    Single-step FGSM attack.
    Args:
        model: vision encoder or full VLM pipeline
        image: input tensor [B, C, H, W], values in [0, 1]
        target_label: desired misclassification target
        epsilon: perturbation budget (L-inf)
    Returns:
        adversarial image tensor
    """
    image.requires_grad_(True)
    output = model(image)
    loss = F.cross_entropy(output, target_label)
    loss.backward()
 
    # For targeted attacks, subtract gradient (minimize loss for target class)
    perturbation = epsilon * image.grad.sign()
    adv_image = torch.clamp(image - perturbation, 0.0, 1.0)
    return adv_image.detach()

PGD (Projected Gradient Descent)

PGD is de iteratieve uitbreiding van FGSM en wordt algemeen beschouwd als de sterkste first-order adversarial aanval. Hij past meerdere kleine stappen toe en projecteert na elke stap terug op de toegestane perturbatieset.

def pgd_attack(model, image, target_label, epsilon=8/255,
               step_size=2/255, num_steps=40, random_start=True):
    """
    PGD attack with random restarts.
    Args:
        epsilon: L-inf perturbation budget
        step_size: per-step perturbation magnitude
        num_steps: number of iterative steps
        random_start: initialize with random noise in epsilon-ball
    """
    adv_image = image.clone().detach()
 
    if random_start:
        adv_image = adv_image + torch.empty_like(adv_image).uniform_(-epsilon, epsilon)
        adv_image = torch.clamp(adv_image, 0.0, 1.0)
 
    for _ in range(num_steps):
        adv_image.requires_grad_(True)
        output = model(adv_image)
        loss = F.cross_entropy(output, target_label)
        loss.backward()
 
        with torch.no_grad():
            # Targeted: step toward minimizing target loss
            adv_image = adv_image - step_size * adv_image.grad.sign()
            # Project back onto epsilon-ball around original image
            delta = torch.clamp(adv_image - image, -epsilon, epsilon)
            adv_image = torch.clamp(image + delta, 0.0, 1.0)
 
    return adv_image.detach()

C&W (Carlini & Wagner) Attack

C&W optimaliseert direct voor de kleinste perturbatie die misclassificatie bereikt. Het produceert meer onmerkbare adversarial voorbeelden dan PGD, ten koste van rekentijd.

Standaard Lp-normbudgetten zoals gebruikt in onderzoek naar adversarial robuustheid en red teaming:

Voor red teaming start je op epsilon = 8/255 (L-inf). Als de aanval slaagt, verlaag je het budget om de minimaal werkbare perturbatie te vinden. Als het mislukt, verhoog je naar 16/255 voordat je een ander algoritme probeert.

Transferability

Adversarial voorbeelden die tegen één model zijn gemaakt, foppen vaak ook andere modellen -- dit is transferability, en het maakt black-box-aanvallen mogelijk tegen modellen die je niet rechtstreeks kunt benaderen.

Transfer-succes maximaliseren

1. 1

   Kies een divers ensemble van surrogaten

   Gebruik 3-5 modellen met verschillende architecturen (ViT-B/16, ResNet-50, ConvNeXt, CLIP ViT-L). Perturbaties die alle surrogaten foppen, hebben een grotere kans om over te dragen.

2. 2

   Gebruik momentum-gebaseerde optimalisatie

   MI-FGSM (Momentum Iterative FGSM) accumuleert gradient-momentum over stappen heen, wat de richting van de perturbatie stabiliseert en de transferability aanzienlijk verbetert ten opzichte van standaard PGD.

3. 3

   Pas input diversity toe

   Bij elke aanvalsstap verklein, vergroot en pad je de afbeelding willekeurig voordat je de gradient berekent. Dit voorkomt dat de perturbatie overfit op de specifieke input-verwerking van het surrogaat.

4. 4

   Val tussenliggende features aan, geen logits

   Aanvallen op feature-niveau (gericht op activaties van tussenliggende lagen) brengen beter over dan aanvallen op logit-niveau, omdat verschillende modellen meer structuur delen in vroege en middelste lagen dan in classificatiekoppen.

def mi_fgsm(models, image, target, epsilon=16/255, steps=20, decay=1.0):
    """Momentum Iterative FGSM against an ensemble for transfer attacks."""
    momentum = torch.zeros_like(image)
    adv = image.clone().detach()
    step_size = epsilon / steps
 
    for _ in range(steps):
        adv.requires_grad_(True)
        # Ensemble loss: average across all surrogate models
        loss = sum(F.cross_entropy(m(adv), target) for m in models) / len(models)
        loss.backward()
 
        grad = adv.grad / torch.norm(adv.grad, p=1)  # Normalize
        momentum = decay * momentum + grad             # Accumulate
        adv = (adv - step_size * momentum.sign()).detach()
        adv = torch.clamp(image + torch.clamp(adv - image, -epsilon, epsilon), 0, 1)
 
    return adv

Fysieke adversarial voorbeelden

Perturbaties die zijn ontworpen voor digitale afbeeldingen falen vaak wanneer ze worden afgedrukt en opnieuw door een camera worden vastgelegd, door kleurkwantisatie, lichtveranderingen en perspectivische vervorming. Aanvallen in de fysieke wereld vereisen extra robuustheid.

Technieken voor fysieke robuustheid

Red team-methodologie

1. 1

   Identificeer de vision encoder

   Bepaal de architectuur van de vision encoder van het doelmodel (ViT-variant, CLIP-model, enz.). Bekijk model cards, API-documentatie of test met bekende adversarial voorbeelden om de architectuur te fingerprinten.

2. 2

   Kies een aanvalsalgoritme op basis van toegang

   White-box: start met PGD-40 op epsilon=8/255. Black-box: bouw een surrogaat-ensemble en gebruik MI-FGSM met input diversity. Tijd-beperkt: gebruik FGSM voor een snelle baseline-evaluatie.

3. 3

   Maak adversarial voorbeelden met afnemende budgetten

   Start op epsilon=16/255 en verlaag in stappen (16, 8, 4, 2). Noteer het minimale budget waarop de aanval nog steeds slaagt -- dit meet hoe robuust de beslissingsgrens van het model is.

4. 4

   Test tegen ingezette verdedigingen

   Veel productiesystemen passen JPEG-compressie, Gaussische blur of feature squeezing toe als pre-processing verdedigingen. Test of jouw perturbaties deze transformaties overleven.

5. 5

   Evalueer getargete controle

   Ga verder dan misclassificatie naar getargete aanvallen: kun je de VLM specifieke, door de aanvaller gekozen tekst laten produceren? Dit toont de volledige impact van de kwetsbaarheid aan.

Gerelateerde onderwerpen

• Multimodale aanvalsvectoren -- Overzicht van alle multimodale aanvalsoppervlakken, inclusief typografische en steganografische technieken
• Document-gebaseerde injection-aanvallen -- Niet-visuele injection-vectoren via documentformaten
• Cross-modale embedding-aanvallen -- Misbruik van gedeelde embeddingruimtes over modaliteiten heen
• Model Internals en Interpreteerbaarheid -- De interne representaties begrijpen die adversarial perturbaties manipuleren

Referenties

• Goodfellow et al., "Explaining and Harnessing Adversarial Examples" (2015) -- Originele FGSM-paper
• Madry et al., "Towards Deep Learning Models Resistant to Adversarial Attacks" (2018) -- PGD en adversarial training
• Carlini & Wagner, "Towards Evaluating the Robustness of Neural Networks" (2017) -- C&W-aanval
• Dong et al., "Boosting Adversarial Attacks with Momentum" (2018) -- MI-FGSM
• Kurakin et al., "Adversarial Examples in the Physical World" (2017) -- Fysieke adversarial voorbeelden
• Qi et al., "Visual Adversarial Examples Jailbreak Aligned Large Language Models" (2023) -- Perturbatie-aanvallen tegen VLMs
• Croce & Hein, "Reliable Evaluation of Adversarial Robustness with an Ensemble of Attacks" (2020) -- AutoAttack