Defense-in-depth voor LLM-apps

Gelaagde verdedigingsstrategie voor AI-applicaties die de netwerk-, applicatie-, model- en uitvoerlaag omvat, hoe elke laag bijdraagt, en waarom enkellaagse verdediging altijd faalt.

Defense-in-depth is het principe dat geen enkele beveiligingscontrole alleen moet worden vertrouwd. Voor LLM-applicaties betekent dit het bouwen van meerdere onafhankelijke verdedigingslagen, zodat wanneer één laag faalt -- en dat zal gebeuren -- andere de dreiging opvangen.

De vier verdedigingslagen

Laag 1: netwerk en infrastructuur

Deze laag werkt voordat er enige AI-specifieke verwerking plaatsvindt. Hij handelt authenticatie, autorisatie, rate limiting en transportbeveiliging af.

# Voorbeeld van rate-limiting-middleware
from datetime import datetime, timedelta
 
class RateLimiter:
    def __init__(self, max_requests: int = 60, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window = timedelta(seconds=window_seconds)
        self.requests: dict[str, list[datetime]] = {}
 
    def check(self, user_id: str) -> bool:
        now = datetime.utcnow()
        user_requests = self.requests.get(user_id, [])
        # Verwijder verlopen vermeldingen
        user_requests = [r for r in user_requests if now - r < self.window]
        if len(user_requests) >= self.max_requests:
            return False
        user_requests.append(now)
        self.requests[user_id] = user_requests
        return True

Wat deze laag niet kan: Hij kan inhoud niet inspecteren op semantische dreigingen. Een perfect vervaardigde jailbreak met 1 verzoek per minuut passeert alle controles op netwerkniveau.

Laag 2: applicatie (invoerverwerking)

Deze laag analyseert en saneert invoer voordat deze het model bereikt.

class InputProcessor:
    def __init__(self):
        self.prompt_shield = PromptShield()
        self.content_safety = ContentSafetyClient()
        self.max_input_tokens = 4096
 
    def process(self, user_input: str, session: Session) -> ProcessResult:
        # Groottecontrole
        if count_tokens(user_input) > self.max_input_tokens:
            return ProcessResult.blocked("Input exceeds maximum length")
 
        # Detectie van prompt-injectie
        if self.prompt_shield.is_injection(user_input):
            return ProcessResult.blocked("Input flagged as injection")
 
        # Content-safety-controle
        safety = self.content_safety.analyze(user_input)
        if safety.max_severity > THRESHOLD:
            return ProcessResult.blocked(f"Content safety: {safety.category}")
 
        # Gedragsanalyse op sessieniveau
        session.add_message(user_input)
        if session.escalation_score > ESCALATION_THRESHOLD:
            return ProcessResult.blocked("Behavioral escalation detected")
 
        return ProcessResult.allowed(user_input)

Wat deze laag niet kan: Hij kan niet voorkomen dat het model schadelijke inhoud genereert als reactie op goedaardig ogende invoer, en hij kan geen aanvallen detecteren waarop het schildmodel niet is getraind.

Laag 3: model (inferentiecontroles)

Deze laag beperkt het gedrag van het model tijdens generatie.

Wat deze laag niet kan: Hij steunt erop dat het model instructies volgt, wat precies is wat prompt-injectieaanvallen ondermijnen. Controles op modelniveau zijn noodzakelijk maar nooit alleen voldoende.

Laag 4: uitvoer (naverwerking)

Deze laag analyseert en saneert de uitvoer van het model voordat deze aan de gebruiker wordt teruggegeven.

Waarom enkellaagse verdediging faalt

Bekijk deze aanvalsprogressie tegen een systeem met alleen invoerfiltering:

Nu dezelfde aanval tegen een defense-in-depth-systeem:

Zelfs wanneer één laag faalt, behouden de overige lagen de bescherming.

Defense-in-depth-checklist

Gebruik deze checklist om de verdedigingsdekking van een applicatie te evalueren:

Verder lezen

• Guardrails- & veiligheidslaagarchitectuur -- gedetailleerde architectuur van de applicatie- en uitvoerlaag
• Runtime-monitoring & anomaliedetectie -- de overkoepelende monitoringlaag
• Rate limiting, sandboxing & uitvoeringscontroles -- controles op infrastructuurniveau
• Van red team-bevindingen tot remediatie -- verdedigingsgaten vertalen naar bruikbare bevindingen

Verwante onderwerpen

• Guardrails- & veiligheidslaagarchitectuur - Gedetailleerde architectuur van de applicatie- en uitvoerlaag
• Runtime-monitoring & anomaliedetectie - De overkoepelende monitoringlaag
• Rate limiting, sandboxing & uitvoeringscontroles - Controles op infrastructuurniveau
• Van red team-bevindingen tot remediatie - Verdedigingsgaten vertalen naar bruikbare bevindingen
• AI-systeemarchitectuur voor red teamers - Kijk op componentniveau naar de systemen die deze verdedigingen beschermen

Referenties

• "Defense in Depth: A Practical Strategy for Achieving Information Assurance" - NSA (2012) - Foundational document on layered defense strategy adapted for AI applications in this page
• "NIST Cybersecurity Framework" - NIST (2024) - Framework for organizing defense controls across identify, protect, detect, respond, and recover functions
• "Securing LLM-Integrated Applications" - Microsoft Security (2024) - Practical guidance on implementing multi-layer defense for LLM applications
• "OWASP Top 10 for LLM Applications" - OWASP (2025) - Risk classification that maps to specific defense layers in a depth strategy