Denial of service

Aanvallen die LLM-resources uitputten, waaronder sponge examples, het overspoelen van het contextvenster, recursieve promptloops en tokenamplificatie, die AI-systemen verslechteren of platleggen.

Denial of service

Overzicht

Denial of service tegen AI-systemen werkt volgens fundamenteel andere principes dan traditionele DoS op netwerkniveau. Waar conventionele aanvallen bandbreedte of verbindingslimieten overspoelen, misbruikt LLM-denial of service de rekenkundige asymmetrie die inherent is aan transformer-gebaseerde modellen: een korte, zorgvuldig opgestelde input kan het model dwingen om enorm onevenredig veel te rekenen. Eén kwaadaardige prompt die fracties van een cent kost om te versturen, kan dollars aan GPU-rekenkracht verbruiken, en een aanhoudende campagne kan een AI-dienst onbeschikbaar of financieel onhoudbaar maken.

Het aanvalsoppervlak is uitzonderlijk breed omdat LLM's de rekencomplexiteit rechtstreeks blootstellen aan de gebruikersinput. De lengte van de input, de aard van de tokens, de gevraagde outputlengte en de wisselwerking tussen opgehaalde context en generatie beïnvloeden allemaal de verwerkingskosten. Anders dan bij traditionele webdiensten, waar de verwerkingskosten per verzoek relatief uniform zijn, varieert de inferentiekost van een LLM met ordes van grootte, afhankelijk van de input. Die variatie biedt optimalisatiekansen voor aanvallers die de rekenkundige bottlenecks van het model begrijpen.

De financiële dimensie is bijzonder relevant voor organisaties die pay-per-token-API-diensten gebruiken. Een aanvaller die dure completions kan uitlokken -- lange outputs, herhaalde API-calls via agentic loops, of het ophalen van grote contextvensters -- kan rechtstreeks financiële schade aanrichten zonder ooit de integriteit van het model te compromitteren. Deze economische denial of service, soms "LLM billing fraud" genoemd, is een aanvalscategorie zonder direct equivalent in de traditionele security.

Resource-uitputtende aanvallen treffen ook gedeelde infrastructuur. In multi-tenant deployments waar meerdere klanten GPU-clusters delen, kunnen de resource-intensieve queries van één tenant de prestaties voor alle tenants verslechteren. Dit "noisy neighbor"-effect betekent dat zelfs aanvallen die op de deployment van één gebruiker mikken, over een heel hostingplatform kunnen doorwerken, waardoor denial of service een systemisch risico is voor aanbieders van AI-infrastructuur.

Hoe het werkt

1. 1

   Identificeer de rekenkundige bottlenecks

   De aanvaller analyseert het doelsysteem om te bepalen welke inputkenmerken de hoogste rekenkosten veroorzaken. Belangrijke factoren zijn het aantal inputtokens (langere inputs vereisen meer attentieberekening), het aantal outputtokens (langere outputs vereisen meer generatiestappen), de benutting van het contextvenster (het ophalen en verwerken van grote documentsets in RAG-systemen), en eventuele tool-use- of agentic mogelijkheden die recursieve verwerkingsloops creëren. De aanvaller profileert de responstijden van het systeem over uiteenlopende inputs heen om het kostenoppervlak in kaart te brengen.

2. 2

   Stel resource-intensieve inputs op

   Met behulp van de geïdentificeerde bottlenecks bouwt de aanvaller inputs die het resourceverbruik moeten maximaliseren. Sponge examples gebruiken adversarial gekozen tokenreeksen die worst-case-berekeningen afdwingen. Context-overspoelende inputs lokken het ophalen van maximale context uit. Recursieve prompts misbruiken agentic mogelijkheden om verwerkingsloops te creëren. Tokenamplificatie-prompts vragen om outputs van maximale lengte bij minimale inputs. De aanvaller optimaliseert deze inputs om de verhouding tussen serverkosten en aanvallerskosten te maximaliseren.

3. 3

   Voer een aanhoudende campagne uit

   De aanvaller stuurt resource-intensieve verzoeken op grote schaal, via directe API-toegang, geautomatiseerde botaccounts, of door upstream-databronnen te vergiftigen die dure verwerking uitlokken. Het doel is om ofwel de rate limits uit te putten (waardoor legitieme gebruikers geen dienst krijgen), de rekenbudgetten uit te putten (met financiële schade als gevolg), of de responslatentie onder acceptabele drempels te brengen. Gedistribueerde aanvallen met meerdere accounts kunnen de rate limits per account omzeilen.

Aanvalsvoorbeelden

Voorbeeld 1: Sponge examples -- de berekening per verzoek maximaliseren

Sponge examples zijn inputs die specifiek zijn opgesteld om het energieverbruik en de latency van inferentie van neurale netwerken te maximaliseren. Onderzoek van Shumailov et al. liet zien dat adversarial gekozen inputs de inferentietijd 2 tot 3 keer kunnen verhogen ten opzichte van typische inputs.

# Het concept van sponge examples: inputs die de berekening maximaliseren
# Transformer-attentie is O(n^2) in de sequentielengte, dus
# de inputlengte maximaliseren is de eenvoudigste amplificatie
 
# Benadering 1: Vul het contextvenster met adversarial tokens
# Tokens die hoge entropie in de attentiedistributies creëren,
# dwingen meer berekening per attention head af
sponge_prompt = (
    "Process the following data thoroughly and provide "
    "a comprehensive analysis: "
    + generate_high_entropy_token_sequence(max_tokens=128000)
)
 
# Benadering 2: Stel inputs op die early-exit-optimalisaties verslaan
# Sommige serving-systemen slaan berekening over wanneer het model
# "zeker" is -- sponge examples houden de onzekerheid in stand
adversarial_input = craft_uncertainty_maximizing_input(
    model=target_model,
    target_layers="all",
    objective="maximize_active_neurons"
)

Het belangrijkste inzicht is dat transformer-self-attention paarsgewijze relaties tussen alle tokens berekent, waardoor de rekenkost kwadratisch wordt in de sequentielengte. Inputs die de effectieve sequentielengte maximaliseren en tegelijk eventuele optimalisatie-shortcuts verslaan, leggen maximale kosten op.

Voorbeeld 2: Het contextvenster overspoelen via RAG-manipulatie

# Aanval: stel queries op die het ophalen van maximale
# context uit de RAG-kennisbank uitlokken
 
# Stap 1: Identificeer queries die met veel documenten matchen
broad_query = (
    "Summarize all company policies regarding employee benefits, "
    "compensation, travel, equipment, remote work, security, "
    "data handling, and compliance requirements"
)
# Deze query heeft een hoge semantische similariteit met veel documenttypes,
# waardoor een maximaal aantal chunks wordt opgehaald
 
# Stap 2: Vraag om uitgebreide output
flooding_prompt = f"""
{broad_query}
 
Provide an exhaustive analysis covering every single point
from every retrieved document. Do not summarize or abbreviate.
Quote relevant passages in full. Organize by topic and
cross-reference between documents.
"""
 
# Stap 3: Herhaal op grote schaal
import asyncio
 
async def flood_attack(endpoint, num_requests=1000):
    tasks = [
        asyncio.create_task(send_request(endpoint, flooding_prompt))
        for _ in range(num_requests)
    ]
    await asyncio.gather(*tasks)

Voorbeeld 3: Recursieve promptloops in agentic systemen

# Aanval: misbruik tool-use-mogelijkheden om verwerkingsloops te creëren
 
# Heeft het model toegang tot tools (web search, code execution,
# API-calls), stel dan prompts op die recursief tool-gebruik uitlokken
 
recursive_prompt = """
Search for the latest information about [topic]. For each fact
you find, verify it by searching for corroborating sources.
For each corroborating source, check its credibility by
searching for information about that source. Continue until
you have verified every claim to three levels of depth.
"""
 
# In agentic systemen met code execution:
code_loop_prompt = """
Write and execute a Python script that generates a comprehensive
report. The script should call this API endpoint for each data
point it needs, process the results, and if any results are
incomplete, retry with modified parameters.
"""
# Dit kan API-call-patronen van O(n^2) of erger creëren

Voorbeeld 4: Tokenamplificatie-aanval

# Aanval: minimale input die maximale output produceert
 
amplification_prompts = [
    # Prompts met een hoge amplificatieverhouding
    "Write a 10,000-word essay on the history of computing.",
 
    # Misbruik gestructureerde outputgeneratie
    "Generate a JSON array of 500 objects, each with 20 fields "
    "containing realistic synthetic user data.",
 
    # Chain-of-thought-amplificatie
    "Solve this step by step, showing all work: calculate the "
    "prime factorization of every number from 1 to 10000.",
 
    # Misbruik van repetitieve output
    "Generate unique names for 1000 fictional characters, with "
    "a one-paragraph backstory for each.",
]
 
# Bereken de amplificatieverhouding
input_tokens = count_tokens(amplification_prompts[0])   # ~15 tokens
output_tokens = 10000 * 1.3  # ~13.000 tokens
amplification_ratio = output_tokens / input_tokens  # ~866:1

Voorbeeld 5: API-rate-limit omzeilen via gedistribueerde accounts

Aanvalspatroon:
1. Maak N free-tier-accounts aan (of compromitteer bestaande accounts)
2. Elk account stuurt verzoeken net onder de rate limit per account
3. Geaggregeerde belasting: N * limiet_per_account
4. Mik op gedeelde backend-infrastructuur, niet op individuele accounts

Voor pay-per-token-API's:
1. Compromitteer of maak accounts aan met billing ingeschakeld
2. Stuur verzoeken met maximale kosten (lange context + lange output)
3. Elk verzoek kost $0,10-$1,00+ aan rekenkracht
4. 1000 verzoeken/uur = $100-$1000/uur aan billing-schade

Detectie en mitigatie

Belangrijke overwegingen

• De kwadratische kost van self-attention in de sequentielengte betekent dat de grootte van het contextvenster rechtstreeks bepaalt wat de maximale kost per verzoek is die een aanvaller kan opleggen
• Agentic AI-systemen met tool-use-mogelijkheden vermenigvuldigen het aanvalsoppervlak, omdat elke tool-call extra API-verzoeken, databasequery's of calls naar externe diensten kan uitlokken
• Sponge examples zijn modelspecifiek -- inputs die de berekening op de ene architectuur maximaliseren, zijn mogelijk niet effectief tegen een andere
• Rate limiting op enkel het aantal verzoeken volstaat niet, want één duur verzoek kan meer resources verbruiken dan duizenden goedkope
• Gedeelde GPU-infrastructuur creëert een systemisch risico -- de denial-of-service-aanval van één tenant kan de dienst voor alle tenants verslechteren
• Free-tier- en trial-accounts zijn veelvoorkomende vectoren voor resource-uitputting, omdat ze toegang tot rekenkracht bieden zonder financiële verantwoordelijkheid
• Recursieve promptloops in agentic systemen kunnen exponentieel resourceverbruik creëren dat elke lineaire rate limit overstijgt

References

• OWASP: "LLM10: Unbounded Consumption" -- LLM Top 10 for Large Language Model Applications (2025)
• Shumailov et al.: "Sponge Examples: Energy-Latency Attacks on Neural Networks" (2021) -- adversarial inputs that maximize inference cost
• Gao et al.: "DeepSpeed Inference: Enabling Efficient Inference of Transformer Models at Unprecedented Scale" (2022) -- inference optimization and its attack implications
• MITRE ATLAS: "AML.T0029 Denial of ML Service" -- tactic documentation and case studies
• Nasr et al.: "Comprehensive Analysis of Resource Exhaustion in LLM Serving Systems" (2024)