Forensisch onderzoek van adversariële inputs

Forensische technieken voor het identificeren, reconstrueren en analyseren van adversariële inputs die worden gebruikt om het gedrag van AI-systemen te manipuleren.

Overzicht

Forensisch onderzoek van adversariële inputs is de discipline van het herstellen, analyseren en toeschrijven van kwaadaardige inputs die zijn gemaakt om AI-systemen zich op onbedoelde manieren te laten gedragen. Anders dan bij traditionele software-exploitatie, waar payloads duidelijke sporen achterlaten in het geheugen of op schijf, kunnen adversariële inputs voor AI-systemen subtiele verstoringen zijn -- onmerkbare pixelverschuivingen in beelden, zorgvuldig gekozen tokenvervangingen in tekst, of statistisch vervaardigde feature-vectoren in tabeldata -- die minimale forensische sporen achterlaten tenzij specifieke instrumentatie aanwezig is.

Dit artikel behandelt de volledige forensische levenscyclus voor adversariële inputs: van detectie en bewijsbehoud tot reconstructie, analyse en toeschrijving. We baseren ons op gevestigde frameworks waaronder MITRE ATLAS (Adversarial Threat Landscape for AI Systems) en het NIST AI Risk Management Framework om forensische procedures te verankeren in erkende standaarden.

De uitdaging voor de forensisch onderzoeker wordt vergroot door het feit dat adversariële inputs per ontwerp moeilijk te onderscheiden zijn van legitieme data. Een goed vervaardigd adversarieel beeld kan er voor een menselijke waarnemer identiek uitzien, en een adversariële tekst-prompt kan lezen als volstrekt natuurlijke taal. Het forensische proces moet daarom vertrouwen op computationele analyse, modelintrospectie en statistische anomaliedetectie in plaats van alleen op menselijke inspectie.

Taxonomie van adversariële inputs

Voordat we ingaan op forensische technieken, moeten onderzoekers de taxonomie begrijpen van de adversariële inputs die ze kunnen tegenkomen. Elke categorie levert verschillende forensische uitdagingen op en vereist verschillende benaderingen voor verzameling en analyse.

Verstoring-gebaseerde aanvallen

Verstoringsaanvallen passen kleine, berekende wijzigingen toe op legitieme inputs. In computer vision zijn dit doorgaans L-p-norm-begrensde verstoringen die worden berekend via gradiënt-gebaseerde methoden zoals FGSM (Fast Gradient Sign Method), PGD (Projected Gradient Descent) of C&W-aanvallen (Carlini & Wagner). In NLP manifesteren verstoringen zich als swaps op tekenniveau, vervangingen op woordniveau met behulp van synoniemensets, of parafrasering op zinsniveau die de semantische betekenis behoudt terwijl de voorspellingen van het model worden gewijzigd.

Patch-gebaseerde aanvallen

Adversariële patches zijn gelokaliseerde, visueel opvallende wijzigingen die worden toegepast op een klein gebied van een input. Anders dan bij verstoringsaanvallen proberen patches niet onmerkbaar te zijn. In plaats daarvan maken ze gebruik van de gevoeligheid van het model voor specifieke ruimtelijke patronen. Bij aanvallen in de fysieke wereld kunnen patches worden afgedrukt en in de omgeving worden geplaatst -- op stopborden, kleding of andere objecten binnen het gezichtsveld van een camera.

Input-transformatieaanvallen

Deze aanvallen passen geometrische of kleurruimte-transformaties toe die technisch gezien binnen de verdeling van natuurlijke variatie vallen, maar de input over een beslissingsgrens duwen. Rotaties, schaling, helderheidsverschuivingen en JPEG-compressie-artefacten kunnen allemaal als wapen worden ingezet. Deze zijn forensisch lastig omdat de transformaties afzonderlijk onschuldig zijn.

Adversariële tekst-prompts

In de context van LLM's omvatten adversariële inputs prompt-injecties, jailbreak-sequenties en geobfusqueerde instructies. Deze worden uitgebreid behandeld in het artikel Prompt Injection Forensics, maar het forensische framework hier is van toepassing op de bredere klasse van adversariële tekst-inputs die zich richten op elk NLP-model.

Verzameling en behoud van bewijs

Logging-architectuur voor het vastleggen van adversariële inputs

Effectief forensisch onderzoek hangt af van logging-infrastructuur die op inferentietijd voldoende data vastlegt. De volgende Python-module demonstreert een forensische logging-wrapper die de metadata vastlegt die nodig is voor post-incidentanalyse.

import hashlib
import json
import time
import logging
from dataclasses import dataclass, field, asdict
from typing import Any
from pathlib import Path
 
logger = logging.getLogger("adversarial_forensics")
 
@dataclass
class InferenceRecord:
    """Forensisch record van een enkel inferentieverzoek."""
    request_id: str
    timestamp: float
    input_hash_sha256: str
    input_size_bytes: int
    input_modality: str  # "text", "image", "tabular", "audio"
    model_id: str
    model_version: str
    prediction: Any = None
    confidence_scores: list[float] = field(default_factory=list)
    latency_ms: float = 0.0
    input_metadata: dict = field(default_factory=dict)
    anomaly_flags: list[str] = field(default_factory=list)
 
class ForensicInferenceLogger:
    """Omhult modelinferentie met logging van forensische kwaliteit."""
 
    def __init__(self, log_dir: str, model_id: str, model_version: str):
        self.log_dir = Path(log_dir)
        self.log_dir.mkdir(parents=True, exist_ok=True)
        self.model_id = model_id
        self.model_version = model_version
 
    def compute_input_hash(self, raw_input: bytes) -> str:
        return hashlib.sha256(raw_input).hexdigest()
 
    def log_inference(self, record: InferenceRecord) -> None:
        log_path = self.log_dir / f"{record.request_id}.json"
        log_path.write_text(json.dumps(asdict(record), default=str))
        logger.info(
            "Logged inference %s (anomaly_flags=%s)",
            record.request_id,
            record.anomaly_flags,
        )
 
    def create_record(
        self,
        request_id: str,
        raw_input: bytes,
        modality: str,
        metadata: dict | None = None,
    ) -> InferenceRecord:
        return InferenceRecord(
            request_id=request_id,
            timestamp=time.time(),
            input_hash_sha256=self.compute_input_hash(raw_input),
            input_size_bytes=len(raw_input),
            input_modality=modality,
            model_id=self.model_id,
            model_version=self.model_version,
            input_metadata=metadata or {},
        )

Chain of custody voor digitale adversariële samples

Wanneer adversariële inputs worden geïdentificeerd, worden ze bewijs. De chain of custody moet worden gehandhaafd volgens de best practices voor digitaal forensisch onderzoek, aangepast voor AI-artefacten.

1. Onmiddellijk behoud: Hash de ruwe input-bytes met SHA-256 vóór enige transformatie. Sla de hash op in onveranderlijke, append-only opslag.
2. Archivering van ruwe input: Sla de ongewijzigde input op in write-once-opslag. Voor beelden bewaar je het originele bestand met de EXIF-data intact. Voor tekst bewaar je de ruwe bytes inclusief codering.
3. Contextvastlegging: Leg de volledige inferentiecontext vast -- system prompt, gespreksgeschiedenis, retrieval-augmented generation (RAG)-context en eventuele resultaten van tool-aanroepen die de adversariële input begeleidden.
4. Snapshot van modelstatus: Leg de exacte modelversie, checkpoint-hash, configuratieparameters en eventuele adapter-gewichten (LoRA, QLoRA) vast die actief waren op het moment van het incident.

Detectietechnieken

Statistische anomaliedetectie

De eerste laag van detectie van adversariële inputs steunt op statistische eigenschappen van de input die afwijken van de verwachte verdeling. Deze methoden vereisen geen kennis van de specifieke gebruikte aanval.

import numpy as np
from scipy import stats
 
class StatisticalAdversarialDetector:
    """Detecteer adversariële inputs met statistische verdelingsanalyse."""
 
    def __init__(self, reference_stats: dict):
        """
        Initialiseer met referentiestatistieken berekend uit bekend-schone data.
 
        Args:
            reference_stats: Dict met sleutels 'mean', 'std', 'kurtosis',
                             'skewness' berekend uit schone input-verdeling.
        """
        self.reference = reference_stats
 
    def analyze_image_input(self, pixel_array: np.ndarray) -> dict:
        """
        Analyseer een beeld-input op indicatoren van adversariële verstoring.
 
        Retourneert een dict van anomaliescores en flags.
        """
        results = {}
 
        # Vergelijk pixelwaardeverdeling met referentie
        flat = pixel_array.flatten().astype(np.float64)
        results["mean_deviation"] = abs(float(np.mean(flat)) - self.reference["mean"])
        results["std_deviation"] = abs(float(np.std(flat)) - self.reference["std"])
 
        # Kurtosis-analyse -- adversariële verstoringen wijzigen vaak
        # de staarten van de pixelverdeling
        input_kurtosis = float(stats.kurtosis(flat))
        results["kurtosis_deviation"] = abs(
            input_kurtosis - self.reference["kurtosis"]
        )
 
        # Hoogfrequente energie-analyse via discrete verschillen
        # Adversariële verstoringen verhogen vaak hoogfrequente inhoud
        if pixel_array.ndim >= 2:
            dx = np.diff(pixel_array, axis=-1)
            dy = np.diff(pixel_array, axis=-2)
            hf_energy = float(np.mean(dx ** 2) + np.mean(dy ** 2))
            results["high_freq_energy"] = hf_energy
 
        # Bereken algehele anomaliescore (gewogen combinatie)
        anomaly_score = (
            0.2 * min(results["mean_deviation"] / 10.0, 1.0)
            + 0.2 * min(results["std_deviation"] / 10.0, 1.0)
            + 0.3 * min(results["kurtosis_deviation"] / 2.0, 1.0)
            + 0.3 * min(results.get("high_freq_energy", 0) / 1000.0, 1.0)
        )
        results["anomaly_score"] = float(anomaly_score)
        results["flagged"] = anomaly_score > 0.65
 
        return results
 
    def analyze_text_input(self, tokens: list[str], token_ids: list[int]) -> dict:
        """Analyseer tekst-input op adversariële tokenpatronen."""
        results = {}
 
        # Perplexiteit-gebaseerde analyse: adversariële tekst heeft vaak
        # ongebruikelijke patronen van samen voorkomende tokens
        unique_ratio = len(set(token_ids)) / max(len(token_ids), 1)
        results["unique_token_ratio"] = float(unique_ratio)
 
        # Controleer op indicatoren van verstoring op tekenniveau
        unicode_anomalies = sum(
            1 for t in tokens if any(ord(c) > 127 for c in t)
        )
        results["unicode_anomaly_count"] = unicode_anomalies
 
        # Controleer op ongebruikelijke witruimte of controletekens
        control_chars = sum(
            1 for t in tokens
            for c in t
            if ord(c) < 32 and c not in ('\n', '\t', '\r')
        )
        results["control_char_count"] = control_chars
 
        results["flagged"] = (
            unicode_anomalies > len(tokens) * 0.1
            or control_chars > 0
        )
        return results

Analyse van modelvertrouwen

Adversariële inputs produceren vaak karakteristieke patronen in de confidence scores van een model. Een correct geclassificeerde goedaardige input produceert doorgaans een voorspelling met hoog vertrouwen en een duidelijke marge tussen de top-1- en top-2-klassen. Adversariële inputs daarentegen kunnen voorspellingen met atypische vertrouwensverdelingen produceren.

def analyze_confidence_distribution(
    confidence_scores: list[float],
    threshold_margin: float = 0.15,
    threshold_entropy: float = 1.5,
) -> dict:
    """
    Analyseer confidence scores van het model op adversariële indicatoren.
 
    Adversariële inputs produceren vaak:
    - Lage marge tussen top-1- en top-2-voorspellingen
    - Hoge voorspellingsentropie
    - Vertrouwenswaarden geclusterd nabij beslissingsgrenzen
    """
    scores = sorted(confidence_scores, reverse=True)
    top1 = scores[0] if scores else 0.0
    top2 = scores[1] if len(scores) > 1 else 0.0
 
    margin = top1 - top2
 
    # Shannon-entropie van de voorspellingsverdeling
    probs = np.array(confidence_scores, dtype=np.float64)
    probs = probs / probs.sum()  # normaliseren
    entropy = float(-np.sum(probs * np.log2(probs + 1e-10)))
 
    return {
        "top1_confidence": top1,
        "top2_confidence": top2,
        "margin": margin,
        "entropy": entropy,
        "low_margin_flag": margin < threshold_margin,
        "high_entropy_flag": entropy > threshold_entropy,
        "adversarial_likelihood": "high" if (
            margin < threshold_margin and entropy > threshold_entropy
        ) else "medium" if (
            margin < threshold_margin or entropy > threshold_entropy
        ) else "low",
    }

Feature squeezing-detectie

Feature squeezing, geïntroduceerd door Xu et al. (2018), detecteert adversariële inputs door de voorspelling van een model op de originele input te vergelijken met voorspellingen op "uitgeknepen" versies van de input -- versies waarbij de inputruimte is gereduceerd via operaties zoals bit-diepte-reductie of ruimtelijke smoothing. Als de voorspellingen significant verschillen, is de input waarschijnlijk adversarieel.

from typing import Callable
 
import numpy as np
 
def feature_squeezing_detect(
    input_array: np.ndarray,
    predict_fn: Callable[[np.ndarray], np.ndarray],
    bit_depth: int = 4,
    spatial_sigma: float = 1.0,
) -> dict:
    """
    Detecteer adversariële inputs met feature squeezing.
 
    Gebaseerd op Xu et al. 2018 -- 'Feature Squeezing: Detecting
    Adversarial Examples in Deep Neural Networks' (NDSS 2018).
    """
    from scipy.ndimage import gaussian_filter
 
    original_pred = predict_fn(input_array)
 
    # Squeeze 1: Bit-diepte-reductie
    max_val = input_array.max()
    levels = 2 ** bit_depth
    squeezed_bits = np.round(input_array * levels / max_val) * max_val / levels
    pred_bits = predict_fn(squeezed_bits)
 
    # Squeeze 2: Ruimtelijke smoothing
    squeezed_smooth = gaussian_filter(input_array, sigma=spatial_sigma)
    pred_smooth = predict_fn(squeezed_smooth)
 
    # L1-afstand tussen originele en uitgeknepen voorspellingen
    dist_bits = float(np.max(np.abs(original_pred - pred_bits)))
    dist_smooth = float(np.max(np.abs(original_pred - pred_smooth)))
 
    max_dist = max(dist_bits, dist_smooth)
 
    return {
        "bit_squeeze_distance": dist_bits,
        "smooth_squeeze_distance": dist_smooth,
        "max_squeeze_distance": max_dist,
        "adversarial_detected": max_dist > 0.1,
    }

Reconstructie en analyse

Extractie van verstoring

Zodra een adversariële input is geïdentificeerd, is de volgende forensische stap het extraheren en karakteriseren van de adversariële verstoring. Dit vereist toegang tot ofwel de originele schone input (indien beschikbaar) ofwel een ge-denoise reconstructie.

def extract_perturbation(
    adversarial_input: np.ndarray,
    clean_reference: np.ndarray,
) -> dict:
    """
    Extraheer en karakteriseer de adversariële verstoring.
 
    Berekent het verschil tussen de adversariële en schone inputs,
    en analyseert vervolgens de eigenschappen ervan voor toeschrijvingsdoeleinden.
    """
    perturbation = adversarial_input.astype(np.float64) - clean_reference.astype(np.float64)
 
    analysis = {
        "l2_norm": float(np.linalg.norm(perturbation)),
        "linf_norm": float(np.max(np.abs(perturbation))),
        "l1_norm": float(np.sum(np.abs(perturbation))),
        "mean_perturbation": float(np.mean(np.abs(perturbation))),
        "sparsity": float(np.mean(np.abs(perturbation) < 1e-6)),
        "spatial_distribution": _analyze_spatial_distribution(perturbation),
    }
 
    # Classificeer waarschijnlijke aanvalsmethode op basis van verstoringskenmerken
    if analysis["linf_norm"] < 0.05 and analysis["sparsity"] < 0.1:
        analysis["likely_method"] = "PGD or FGSM (dense, small perturbation)"
    elif analysis["sparsity"] > 0.9:
        analysis["likely_method"] = "Sparse attack (few pixels modified)"
    elif analysis["l2_norm"] < 2.0:
        analysis["likely_method"] = "C&W L2 attack (optimized small L2)"
    else:
        analysis["likely_method"] = "Unknown or patch-based attack"
 
    return analysis
 
def _analyze_spatial_distribution(perturbation: np.ndarray) -> dict:
    """Analyseer waar in de input de verstoring is geconcentreerd."""
    if perturbation.ndim < 2:
        return {"type": "1d", "peak_index": int(np.argmax(np.abs(perturbation)))}
 
    energy = np.sum(perturbation ** 2, axis=-1) if perturbation.ndim == 3 else perturbation ** 2
    h, w = energy.shape
    quadrants = {
        "top_left": float(energy[:h//2, :w//2].sum()),
        "top_right": float(energy[:h//2, w//2:].sum()),
        "bottom_left": float(energy[h//2:, :w//2].sum()),
        "bottom_right": float(energy[h//2:, w//2:].sum()),
    }
    total = sum(quadrants.values())
    if total > 0:
        quadrants = {k: v / total for k, v in quadrants.items()}
 
    return quadrants

Fingerprinting van aanvalsmethoden

Verschillende adversariële aanvalsalgoritmen laten karakteristieke fingerprints achter in de structuur van de verstoring. Forensisch onderzoekers kunnen deze fingerprints gebruiken om een aanval toe te schrijven aan een specifieke methode of toolset.

FGSM-fingerprint: Verstoringswaarden zijn geclusterd op +epsilon en -epsilon met zeer weinig tussenliggende waarden, aangezien FGSM een enkele gradiëntstap zet met de sign-functie.

PGD-fingerprint: Verstoringswaarden zijn continuer verdeeld maar nog steeds begrensd door epsilon. De verdeling is gladder dan bij FGSM vanwege de iteratieve optimalisatie.

C&W-fingerprint: Verstoringswaarden volgen een bijna-Gaussische verdeling gecentreerd op nul, waarbij de L2-norm opvallend kleiner is dan de L-infinity-norm zou doen vermoeden. De verstoring is sterk gestructureerd en concentreert zich op semantisch belangrijke gebieden.

AutoAttack-fingerprint: Combineert meerdere aanvalsstrategieën; de verstoring kan kenmerken van meerdere methoden vertonen, afhankelijk van welke sub-aanval slaagde.

MITRE ATLAS-mapping

Forensische bevindingen moeten worden gekoppeld aan MITRE ATLAS-technieken om het delen van threat intelligence tussen organisaties mogelijk te maken. De volgende tabel koppelt veelvoorkomende typen adversariële input-aanvallen aan ATLAS-techniek-identifiers.

Forensische onderzoeksworkflow

Stap 1: Initiële triage

Wanneer afwijkend modelgedrag wordt gemeld, bepaalt de onderzoeker eerst of adversariële input een aannemelijke oorzaak is. Dit omvat het controleren van:

• Patronen in modelvertrouwen op het moment van het incident
• Statistieken van de input-verdeling versus de baseline
• Of de modeloutput onjuist of schadelijk was
• Temporele clustering van afwijkende voorspellingen

Stap 2: Bewijsbehoud

Voer het protocol voor bewijsverzameling uit dat hierboven is beschreven. Zorg ervoor dat alle ruwe inputs, modeloutputs en systeemstatus worden bewaard met cryptografische integriteitsverificatie.

Stap 3: Adversariële bevestiging

Pas de detectiemethoden toe (statistische analyse, feature squeezing, vertrouwensanalyse) om te bevestigen dat de input adversarieel was in plaats van een natuurlijk randgeval of datakwaliteitsprobleem.

Stap 4: Extractie en analyse van verstoring

Extraheer de adversariële verstoring en karakteriseer deze met de hierboven beschreven methoden. Deze stap levert het technische bewijs op dat nodig is voor toeschrijving.

Stap 5: Aanvalstoeschrijving

Koppel de verstoringskenmerken aan bekende aanvalsmethoden. Cross-referentie met threat intelligence over bekende adversariële toolkits (Adversarial Robustness Toolbox, Foolbox, CleverHans) en hun standaardparameters.

# Voorbeeld: ART (Adversarial Robustness Toolbox) gebruiken om te testen
# of een sample overeenkomt met bekende aanvalsprofielen
pip install adversarial-robustness-toolbox
 
# Voer de ART-detectiesuite uit tegen een verdacht sample
python -c "
from art.defences.detector.evasion import BinaryInputDetector
from art.estimators.classification import PyTorchClassifier
import torch
import numpy as np
 
# Laad je model en verdachte sample
# detector = BinaryInputDetector(classifier)
# result = detector.detect(suspicious_input)
print('ART detection pipeline initialized')
"

Stap 6: Rapportage en remediëring

Stel een forensisch rapport op dat het volgende bevat:

• Tijdlijn van het incident
• Technische analyse van de adversariële input
• ATLAS-techniek-mapping
• Aanbevolen mitigaties (adversarial training, input-preprocessing, ensemble-verdedigingen)
• Indicators of compromise (IoC's) om te delen met collega-organisaties

Toolingreferentie

Verschillende gevestigde tools ondersteunen forensisch onderzoek van adversariële inputs:

• Adversarial Robustness Toolbox (ART) van IBM Research: Biedt zowel aanvalssimulatie als detectiemogelijkheden. Beschikbaar op github.com/Trusted-AI/adversarial-robustness-toolbox.
• Foolbox: Een Python-bibliotheek voor het maken en analyseren van adversariële voorbeelden. Ondersteunt meerdere deep learning-frameworks.
• CleverHans: Oorspronkelijk ontwikkeld door Goodfellow et al. voor onderzoek naar adversariële voorbeelden.
• Counterfit van Microsoft: Een automatiseringstool voor het beoordelen van de beveiliging van ML-modellen, gebouwd bovenop ART en TextAttack.
• MITRE ATLAS Navigator: Voor het koppelen van forensische bevindingen aan gestandaardiseerde threat-technieken.

Casestudy: Ontwijking van beeldclassificatie

Stel je een beeldclassificatiesysteem in productie voor dat wordt gebruikt voor contentmoderatie en dat schadelijke beelden begint te misclassificeren als goedaardig. Het forensische onderzoek verloopt als volgt:

1. Detectie: Monitoringdashboards tonen een piek in het misclassificatiepercentage van 2% naar 12% over een venster van 4 uur, geconcentreerd op een specifieke contentcategorie.

2. Bewijsverzameling: Het forensische team exporteert alle inferentierecords uit het getroffen tijdvenster, inclusief ruwe beelden, modelvoorspellingen en confidence scores.

3. Statistische analyse: De hoogfrequente energie-analyse onthult dat gemarkeerde beelden verhoogde ruis bevatten in de frequentieband van 10-50 cycli/pixel, inconsistent met natuurlijke cameraruis of JPEG-artefacten.

4. Extractie van verstoring: Het vergelijken van gemarkeerde beelden met hun naaste buren in de schone trainingsset onthult een consistent verstoringspatroon met een L-infinity-norm van 8/255 -- een veelvoorkomende epsilon-waarde voor PGD-aanvallen.

5. Toeschrijving: De verstoringskenmerken komen overeen met de standaard-PGD-configuratie in de Adversarial Robustness Toolbox, wat suggereert dat de aanvaller een kant-en-klare tool zonder aanpassing heeft gebruikt.

6. Remediëring: Het team rolt adversarial training uit met PGD-gegenereerde voorbeelden en voegt een feature squeezing-preprocessor toe als extra detectielaag.

Gevorderde onderwerpen

Transferability-analyse

Adversariële inputs die tegen één model zijn vervaardigd, dragen vaak over naar andere modellen -- een eigenschap die bekendstaat als adversariële transferability. Forensisch onderzoekers moeten herstelde adversariële samples testen tegen andere modellen in de deployment van de organisatie om de reikwijdte van de dreiging te beoordelen.

Adaptieve aanvallen tegen detectoren

Geavanceerde aanvallers kunnen adversariële inputs vervaardigen die tegelijkertijd zowel het doelmodel als de mechanismen voor adversariële detectie ontwijken. Dit scenario van een adaptieve aanval vereist defense-in-depth-strategieën en continue updates van detectiemethoden. De forensisch onderzoeker moet zich ervan bewust zijn dat de afwezigheid van detectie niet de afwezigheid van adversariële inputs garandeert.

Temporele patroonanalyse

Wanneer adversariële inputs worden geleverd als onderdeel van een aanhoudende campagne, kan temporele analyse patronen onthullen in de timing, frequentie en evolutie van de aanval. Aanvallers kunnen beginnen met grove aanvallen en hun technieken geleidelijk verfijnen op basis van waargenomen succespercentages, waardoor een waarneembaar escalatiepatroon in het forensische record ontstaat.

Referenties

• Xu, W., Evans, D., & Qi, Y. (2018). Feature Squeezing: Detecting Adversarial Examples in Deep Neural Networks. Proceedings of the 2018 Network and Distributed System Security Symposium (NDSS). https://doi.org/10.14722/ndss.2018.23198
• MITRE ATLAS. (2024). Adversarial Threat Landscape for Artificial Intelligence Systems. https://atlas.mitre.org/
• Nicolae, M.-I. et al. (2018). Adversarial Robustness Toolbox v1.0.0. arXiv preprint arXiv:1807.01069. https://arxiv.org/abs/1807.01069
• Goodfellow, I. J., Shlens, J., & Szegedy, C. (2015). Explaining and Harnessing Adversarial Examples. Proceedings of the International Conference on Learning Representations (ICLR). https://arxiv.org/abs/1412.6572