Adversarial aanvallen op audio en spraak

Adversarial aanvallen op spraakgestuurde AI-systemen, met aandacht voor ultrasone injection, adversarial ruis op ASR, verborgen voice commands, voice cloning voor authenticatie-omzeiling en real-time audiomanipulatie.

Adversarial aanvallen op audio en spraak

Spraakgestuurde AI-systemen -- voice-assistenten, transcriptiediensten, bankieren met spraakauthenticatie, callcenter-AI en audio-contentmoderatie -- zijn kwetsbaar voor adversarial aanvallen die het verschil tussen menselijke gehoorperceptie en machinale audioverwerking misbruiken. Een audiosignaal kan voor een mens klinken als stilte, ruis of onschuldige spraak, terwijl het instructies bevat die een ASR-systeem transcribeert als door de aanvaller gekozen tekst.

ASR-architectuur en aanvalsoppervlakken

Door de spraakverwerkingspipeline te begrijpen, zie je waar elke aanvalsklasse landt.

Audio → Preprocessing → Feature Extraction → Acoustic Model → Decoder → Text
  ↑         ↑                  ↑                   ↑              ↑
  |    Sampling rate      MFCC / Mel          Neural network   Language model
  |    Noise gate         Spectrogram         (CTC, Seq2Seq)   beam search
  |
Ultrasonic    Adversarial noise         Hidden commands       Voice cloning
injection     targets these layers      exploit masking       targets speaker
                                                              verification

Aanvalsoppervlak-overzicht

Ultrasone injection

Ultrasone injection maakt misbruik van het feit dat microfoons frequenties boven de menselijke gehoorgrens (20kHz) oppikken en dat non-lineariteiten in microfoonhardware en versterkercircuits ultrasone signalen kunnen demoduleren naar de hoorbare band.

Hoe ultrasone aanvallen werken

1. 1

   Genereer het voice command

   Gebruik een TTS-engine om het doelcommando te synthetiseren als een normale audio-golfvorm (bijv. "Hey Siri, send a message").

2. 2

   Moduleer op een ultrasone draaggolf

   Amplitudemoduleer het voice command op een draaggolffrequentie tussen 25-45kHz. De draaggolf zelf is onhoorbaar voor mensen.

3. 3

   Verzend via een ultrasone luidspreker

   Speel het gemoduleerde signaal af via een luidspreker die ultrasone output aankan (piëzo-elektrische transducers, parametrische luidsprekers).

4. 4

   Non-lineariteit van de microfoon demoduleert

   De microfoon en het versterkercircuit van het doelapparaat introduceren niet-lineaire vervorming die het ultrasone signaal demoduleert en het oorspronkelijke voice command in de hoorbare frequentieband reconstrueert.

5. 5

   ASR verwerkt het gedemoduleerde commando

   Het ASR-systeem ontvangt wat lijkt op een normaal voice command en transcribeert het.

import numpy as np
from scipy.io import wavfile
 
def create_ultrasonic_payload(command_audio, carrier_freq=25000,
                               sample_rate=96000):
    """
    Amplitude-modulate a voice command onto an ultrasonic carrier.
 
    Args:
        command_audio: numpy array of the voice command waveform
        carrier_freq: ultrasonic carrier frequency in Hz
        sample_rate: must be > 2 * carrier_freq (Nyquist)
 
    Returns:
        modulated signal as numpy array
    """
    # Normalize command audio to [0, 1] for AM modulation
    command_normalized = (command_audio - command_audio.min()) / \
                         (command_audio.max() - command_audio.min())
 
    # Generate carrier wave
    t = np.arange(len(command_normalized)) / sample_rate
    carrier = np.sin(2 * np.pi * carrier_freq * t)
 
    # Amplitude modulation: carrier * (1 + modulation_depth * signal)
    modulation_depth = 0.8
    modulated = carrier * (1 + modulation_depth * command_normalized)
 
    # Normalize to 16-bit range
    modulated = np.int16(modulated / np.max(np.abs(modulated)) * 32767)
    return modulated, sample_rate

Adversarial ruis voor ASR

Gradient-gebaseerde adversarial aanvallen op ASR-modellen voegen zorgvuldig berekende ruis toe aan een audiosignaal, waardoor het model een door de aanvaller gekozen transcriptie produceert. De verstoring kan worden toegevoegd aan stilte (waardoor een audioclip ontstaat die klinkt als ruis maar transcribeert als een commando) of aan bestaande audio (waardoor een clip ontstaat die normaal klinkt maar anders wordt getranscribeerd).

Aanvalsaanpakken

Met volledige toegang tot het ASR-model (gewichten, architectuur, gradiënten) gebruik je CTC-loss-optimalisatie om de minimale verstoring te vinden die de doeltranscriptie oplevert.

import torch
 
def adversarial_asr_attack(model, audio, target_text, epsilon=0.02,
                           steps=1000, lr=0.001):
    """
    White-box adversarial attack against a CTC-based ASR model.
 
    Args:
        model: differentiable ASR model
        audio: input audio tensor [1, T]
        target_text: desired transcription string
        epsilon: L-inf perturbation budget
        steps: optimization steps
        lr: learning rate for perturbation optimization
    """
    target_ids = model.tokenizer.encode(target_text)
    target_tensor = torch.tensor([target_ids])
 
    delta = torch.zeros_like(audio, requires_grad=True)
    optimizer = torch.optim.Adam([delta], lr=lr)
 
    for step in range(steps):
        adv_audio = audio + delta
        log_probs = model(adv_audio)
 
        # CTC loss between model output and target transcription
        input_lengths = torch.tensor([log_probs.shape[1]])
        target_lengths = torch.tensor([len(target_ids)])
        loss = torch.nn.functional.ctc_loss(
            log_probs.transpose(0, 1), target_tensor,
            input_lengths, target_lengths
        )
 
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
 
        # Project delta onto epsilon-ball
        with torch.no_grad():
            delta.clamp_(-epsilon, epsilon)
 
    return (audio + delta).detach()

Zonder toegang tot gradiënten gebruik je genetische algoritmen, estimation-based methoden (NES) of transfer-aanvallen vanaf open-source ASR-modellen (Whisper, DeepSpeech).

Kernaanpak voor black-box-aanvallen:

1. Train adversarial verstoringen tegen een open-source surrogaat (bijv. Whisper)
2. Test de transfer naar het doelsysteem via API-queries
3. Gebruik query-based refinement als de API confidence scores teruggeeft

Transfer-percentages van Whisper naar commerciële ASR-API's liggen tussen 15-40%, afhankelijk van de doeltranscriptielengte en het verstoringsbudget.

Over-the-air-aanvallen moeten luidsprekerweergave, ruimte-akoestiek en microfoonopname overleven. Dit vereist:

• Room impulse response (RIR)-simulatie: Convolueer de adversarial audio tijdens optimalisatie met gesimuleerde RIR's
• Grotere verstoringsbudgets: Epsilon moet 3-5x toenemen ten opzichte van digitale aanvallen
• Bandbeperking: Beperk verstoringen tot frequenties die luidsprekers kunnen weergeven (meestal 100Hz-18kHz)
• Expectation over transformation (EoT): Optimaliseer over willekeurige volumeniveaus, achtergrondruis en ruimtecondities

Over-the-air adversarial audio-aanvallen halen succespercentages van 30-60% in gecontroleerde omgevingen, maar zakken aanzienlijk in lawaaierige real-world-settings.

Verborgen voice commands

Verborgen voice commands verbergen spraaksignalen onder de psychoakoestische maskeerdrempel van een primair audiosignaal. Het menselijk oor kan de verborgen spraak niet waarnemen, maar de microfoon vangt het volledige signaal op en het ASR-systeem transcribeert beide lagen.

Misbruik van psychoakoestische maskering

def embed_hidden_command(cover_audio, command_audio, snr_db=-30):
    """
    Embed a hidden voice command below the masking threshold of cover audio.
 
    Args:
        cover_audio: primary audio signal (music, speech, etc.)
        command_audio: voice command to hide
        snr_db: signal-to-noise ratio (negative = command quieter than cover)
    """
    # Match lengths
    if len(command_audio) > len(cover_audio):
        command_audio = command_audio[:len(cover_audio)]
    else:
        command_audio = np.pad(command_audio,
                               (0, len(cover_audio) - len(command_audio)))
 
    # Scale command to target SNR
    cover_power = np.mean(cover_audio ** 2)
    command_power = np.mean(command_audio ** 2)
    scale = np.sqrt(cover_power / command_power * 10 ** (snr_db / 10))
    hidden = cover_audio + scale * command_audio
 
    return hidden

Voice cloning voor authenticatie-omzeiling

Voice cloning-aanvallen synthetiseren de stem van een doel-spreker om speakerverificatie-systemen te omzeilen. Moderne TTS- en voiceconversiemodellen hebben slechts 3-10 seconden referentie-audio nodig.

Aanvalsmethodologie

1. 1

   Verzamel stemmonsters van het doel

   Verzamel opnames van de doel-spreker uit openbare bronnen (conferentielezingen, podcasts, social media-video's, voicemail-begroetingen). Streef naar 10-30 seconden schone spraak.

2. 2

   Train of fine-tune een voice cloning-model

   Gebruik een open-source voice cloning-framework (bijv. Coqui TTS, OpenVoice, VALL-E-varianten) om een model te bouwen dat spraak in de stem van het doel genereert. Zero-shot-modellen vereisen geen fine-tuning, maar leveren een lagere kwaliteit.

3. 3

   Genereer authenticatiezinnen

   Synthetiseer de specifieke zinnen die het doelsysteem vereist (bijv. "My voice is my password", een willekeurige passphrase of een specifieke zin).

4. 4

   Test tegen speakerverificatie

   Dien de gekloonde audio in bij het authenticatiesysteem. Noteer acceptatie/afwijzing en confidence scores. Itereer op generatieparameters (spreektempo, toonhoogtevariatie, ruisniveau) om matchscores te maximaliseren.

5. 5

   Pas postprocessing toe om liveness-detectie te omzeilen

   Voeg subtiele ruimte-galm, simulatie van microfoonfrequentierespons en laag­volume achtergrondruis toe om de gekloonde audio te laten klinken als een live opname in plaats van een schone synthese.

Technieken voor het omzeilen van speakerverificatie

Real-time audiomanipulatie

Real-time-aanvallen werken op live audiostromen -- ze onderscheppen, wijzigen en sturen audio door met minimale latency. Ze richten zich op VoIP-gesprekken, live transcriptie en real-time voice-assistenten.

Real-time aanvalsvectoren

import pyaudio
import numpy as np
 
def realtime_audio_injection(injection_signal, snr_db=-25,
                              chunk_size=1024, sample_rate=16000):
    """
    Real-time audio stream manipulation: mix injection signal
    into live microphone input and output to virtual audio device.
    """
    p = pyaudio.PyAudio()
    stream_in = p.open(format=pyaudio.paFloat32, channels=1,
                       rate=sample_rate, input=True,
                       frames_per_buffer=chunk_size)
    stream_out = p.open(format=pyaudio.paFloat32, channels=1,
                        rate=sample_rate, output=True,
                        frames_per_buffer=chunk_size)
 
    injection_idx = 0
    try:
        while True:
            # Read live audio chunk
            data = np.frombuffer(stream_in.read(chunk_size),
                                 dtype=np.float32)
 
            # Mix in injection signal at target SNR
            end_idx = min(injection_idx + chunk_size,
                          len(injection_signal))
            if injection_idx < len(injection_signal):
                chunk_injection = injection_signal[injection_idx:end_idx]
                if len(chunk_injection) < chunk_size:
                    chunk_injection = np.pad(chunk_injection,
                        (0, chunk_size - len(chunk_injection)))
 
                scale = np.sqrt(np.mean(data**2) / np.mean(chunk_injection**2)
                                * 10**(snr_db/10))
                data = data + scale * chunk_injection
                injection_idx = end_idx
 
            stream_out.write(data.astype(np.float32).tobytes())
    finally:
        stream_in.close()
        stream_out.close()
        p.terminate()

Red team-assessmentkader

1. 1

   Breng audio-invoeroppervlakken in kaart

   Identificeer alle punten waarop het doel audio accepteert: microfooninvoer, file upload, VoIP-streams, spraakauthenticatie, audio-analyse-API's. Noteer de gebruikte ASR-engine als die te identificeren is.

2. 2

   Test eerst replay-aanvallen

   Neem legitieme audio op en speel die opnieuw af. Als replay de spraakauthenticatie verslaat, zijn geavanceerde aanvallen overbodig. Dit geeft je een baseline.

3. 3

   Test ultrasone injection (scenario's met fysieke toegang)

   Als het dreigingsmodel fysieke nabijheid omvat, test je ultrasone commando-injection op afstanden van 1m, 3m en 5m van het doelapparaat.

4. 4

   Maak adversarial audiovoorbeelden

   Genereer met een open-source ASR-model als surrogaat adversarial voorbeelden voor 5-10 doelzinnen. Test de transfer naar het doelsysteem.

5. 5

   Test verborgen voice commands

   Embed commando's op -25dB, -30dB en -35dB SNR onder de cover-audio. Bepaal de laagste SNR waarop de doel-ASR het verborgen commando nog transcribeert.

6. 6

   Beoordeel de impact van voice cloning

   Als het doel speakerverificatie gebruikt, verzamel je openbaar beschikbare stemmonsters en test je of gekloonde audio authenticatie haalt. Rapporteer de minimale benodigde monsterduur.

Gerelateerde onderwerpen

• Multimodale aanvalsvectoren -- Overzicht van alle multimodale aanvalsoppervlakken, inclusief beeld- en documentvectoren
• Adversarial perturbation-aanvallen -- Gradient-gebaseerde aanvallen op vision encoders met analoge technieken
• Document-gebaseerde injection -- Niet-audio injection-vectoren via documentformaten
• Social engineering en menselijke factoren -- Voice cloning in de context van social engineering-aanvalsketens

Referenties

• Zhang et al., "DolphinAttack: Inaudible Voice Commands" (2017) -- Fundamenteel onderzoek naar ultrasone injection
• Carlini & Wagner, "Audio Adversarial Examples: Targeted Attacks on Speech-to-Text" (2018) -- White-box ASR adversarial aanvallen
• Abdullah et al., "Practical Hidden Voice Attacks against Speech and Speaker Recognition Systems" (2019)
• Chen et al., "Real-Time Adversarial Attacks Against Deep Learning-Based Speech Recognition Systems" (2019)
• Wang et al., "ASVspoof 2019: A Large-Scale Public Database of Synthesized, Converted and Replayed Speech" (2020) -- Benchmarks voor aanvallen op speakerverificatie
• Schonherr et al., "Adversarial Attacks Against Automatic Speech Recognition Systems via Psychoacoustic Hiding" (2019)
• Li et al., "Adversarial Music: Real World Audio Adversary Against Wake-word Detection System" (2019)