AI Hacking
AI-beveiligingsbronnen

Beveiligde AI-ontwikkeling

Volledige handleiding voor ontwikkelaars voor het bouwen van veilige AI-applicaties - van invoervalidatie tot implementatie

Updated: November 2026

Beveiligingsprincipes

1. Diepgaande verdediging

Implementeer meerdere lagen beveiligingscontroles. Er mag niet uitsluitend op één enkele controle worden vertrouwd.

2. Least Privilege

Verleen minimaal noodzakelijke machtigingen aan gebruikers, API's en AI-componenten.

3. Fail Secure

Als er fouten optreden, moet u standaard de status beveiligen in plaats van de permissieve status.

4. Zero Trust

Vertrouw nooit, verifieer altijd. Valideer op elke grens, inclusief interne systemen.

Invoervalidatie

Alle gebruikersinvoer moet vóór verwerking worden gevalideerd en opgeschoond. Dit is je eerste verdedigingslinie tegen snelle injecties en andere aanvallen.

Invoervalidatieklasse

```python
import re
from typing import Optional, List

class InputValidator:
    # Known injection patterns
    INJECTION_PATTERNS = [
        r"ignore\s+(previous|prior|all)\s+(instructions|rules)",
        r"(forget|disregard)\s+(your|all)\s+(instructions|rules)",
        r"you\s+are\s+(now|still)\s+(dan|do\s+anything)",
        r"system\s+prompt:",
        r"{{.*}}",
        r"\[INST\]|\[/INST\]|<\|end\|>",
    ]
    
    # Encoding patterns
    ENCODING_PATTERNS = [
        r"base64:",  # Base64 prefix
        r"\\x[0-9a-fA-F]{2}",  # Hex encoding
        r"%[0-9a-fA-F]{2}",  # URL encoding
    ]
    
    def validate(self, user_input: str) -> dict:
        """Validate user input for potential attacks."""
        issues = []
        
        # Length check
        if len(user_input) > 10000:
            issues.append("Input exceeds maximum length")
        
        # Check for injection patterns
        for pattern in self.INJECTION_PATTERNS:
            if re.search(pattern, user_input, re.IGNORECASE):
                issues.append(f"Suspicious pattern detected: {pattern}")
        
        # Check for encoding attempts
        for pattern in self.ENCODED_PATTERNS:
            if re.search(pattern, user_input):
                issues.append(f"Encoded content detected")
        
        # Check for high entropy (possible encoding)
        unique_chars = len(set(user_input))
        if len(user_input) > 50 and unique_chars / len(user_input) < 0.3:
            issues.append("High entropy detected - possible encoding")
        
        return {
            "valid": len(issues) == 0,
            "issues": issues,
            "sanitized": self._sanitize(user_input)
        }
    
    def _sanitize(self, user_input: str) -> str:
        """Basic sanitization."""
        # Remove control characters
        sanitized = re.sub(r'[\x00-\x1F\x7F]', '', user_input)
        return sanitized.strip()
```

Validatiechecklist

  • Valideren op de grens van de applicatie
  • Controleer invoerlengte
  • Patroonovereenkomst voor injectie
  • Coderingspogingen detecteren
  • Typevalidatie
  • Opschonen vóór verwerking
  • Logboekvalidatiefouten
  • Snelheidsbeperking

Uitvoerverwerking

LLM-uitvoer moet worden gevalideerd en opgeschoond voordat deze aan gebruikers wordt gepresenteerd of aan andere systemen wordt doorgegeven.

Inhoudsfiltering

  • Controleren op blootstelling aan gevoelige gegevens
  • Controleer of er geen systeemprompts zijn gelekt
  • Uitvoerformaat valideren
  • Controleer op geïnjecteerde inhoud

PII-detectie

  • Scannen naar persoonlijke informatie
  • Gevoelige gegevens maskeren of redigeren
  • Pogingen tot PII-blootstelling loggen
  • Gebruikersmelding bij detectie

Formatvalidatie

  • JSON-uitvoer valideren
  • Controleer de verwachte structuur
  • Verifieer toegestane waarden
  • HTML opschonen, indien van toepassing

Voorbeeld van uitvoerhandler

```python
import re
import json

class OutputHandler:
    PII_PATTERNS = {
        "ssn": r"\b\d{3}-\d{2}-\d{4}\b",
        "email": r"\b[\w.-]+@[\w.-]+\.\w+\b",
        "phone": r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b",
    }
    
    def process_output(self, raw_output: str) -> dict:
        """Process and validate LLM output."""
        result = {
            "original": raw_output,
            "cleaned": raw_output,
            "warnings": [],
            "blocked": False
        }
        
        # Check for system prompt leakage
        if "system prompt" in raw_output.lower():
            result["warnings"].append("System prompt reference detected")
        
        # Scan for PII
        for pii_type, pattern in self.PII_PATTERNS.items():
            matches = re.findall(pattern, raw_output)
            if matches:
                result["warnings"].append(f"{pii_type} detected in output")
                # Optionally mask
                result["cleaned"] = re.sub(pattern, "[REDACTED]", result["cleaned"])
        
        return result
```

API-beveiliging

Authenticatie

  • Gebruik krachtig API-sleutelbeheer
  • Implementeer OAuth 2.0 waar mogelijk
  • JWT-tokenvalidatie
  • API-sleutelrotatie

Autorisatie

  • Op rollen gebaseerde toegangscontrole (RBAC)
  • API-sleutelscoping
  • Snelheidslimieten per gebruiker
  • Tenantisolatie

Snelheidsbeperking

  • Tokengebaseerde limieten
  • Op verzoeken gebaseerde limieten
  • Kostenbeheersing
  • Gelaagde beperking

API-beveiligingschecklist

  • Gebruik alleen HTTPS
  • Beperking van de implementatiesnelheid
  • Alle invoer valideren
  • Alle uitvoer opschonen
  • Gebruik API-sleutels, niet ingebed
  • Ondertekening van verzoeken implementeren
  • Log API-toegang
  • CORS goed implementeren

Authenticatie en autorisatie

Gebruikersauthenticatie

  • Sterk wachtwoordbeleid
  • MFA-ondersteuning
  • Sessiebeheer
  • Vervaldatum van token

API-verificatie

  • API-sleutelbeheer
  • OAuth-bereiken
  • JWT-validatie
  • Sleutelrotatie

Autorisatie

  • RBAC-implementatie
  • Toestemmingscontroles
  • Toegang op bronniveau
  • Auditregistratie

Gegevensbeveiliging

Gegevensclassificatie

  • Identificeer gevoelige gegevens
  • Categoriseren op gevoeligheid
  • Controles toepassen op categorie
  • Regelmatige audits

Encryptie

  • TLS in transit
  • AES in rust
  • Sleutelbeheer
  • Sleutelrotatie

PII-verwerking

  • Detectie
  • Minimalisatie
  • Toestemmingsbeheer
  • Recht op verwijdering

Logging en monitoring

Wat te loggen

Beveiligingsgebeurtenissen

  • Authenticatiepogingen
  • Autorisatiefouten
  • Snelheidslimiet overschreden
  • Verdachte patronen

AI-specifieke gebeurtenissen

  • Snelle injectiepogingen
  • Toegang tot systeemprompt
  • Aanroepen van tools
  • Gegevenstoegang via AI

Operationele gebeurtenissen

  • API-oproepen
  • Fouten en uitzonderingen
  • Prestatiestatistieken
  • Kosten bijhouden

Beste praktijken voor monitoring

  • Real-time waarschuwingen voor beveiligingsgebeurtenissen
  • Dashboard voor beveiligingsstatistieken
  • Geautomatiseerde detectie van afwijkingen
  • Integratie met SIEM
  • Regelmatige logcontrole
  • Retentiebeleid

Veelvoorkomende kwetsbaarheden

1. IDOR in AI-functies

Onveilige directe objectreferentie wanneer AI toegang krijgt tot bronnen

Voorbeeld

Gebruiker vraagt ​​AI om "bestand X te lezen" en AI heeft toegang zonder de juiste autorisatiecontroles.

2. SSRF via LLM

Vervalsing van verzoeken aan de serverzijde via AI-toolaanroepen

Voorbeeld

Prompt verleidt AI om verzoeken te doen aan interne services.

3. Verificatie omzeilen

Zwakke of ontbrekende authenticatie voor AI-eindpunten

Voorbeeld

AI API-eindpunten zonder de juiste verificatiecontroles.

4. Vector DB-blootstelling

Onbeschermde vectordatabase met gevoelige insluitingen

Voorbeeld

Openbaar toegankelijke vector-DB met ingebedde gevoelige gegevens.

Compliance

GDPR (EU)

  • Wettelijke basis voor verwerking
  • Gegevensminimalisatie
  • Recht op toegang/verwijdering
  • Dataportabiliteit

CCPA (California)

  • Recht om te weten
  • Recht om te verwijderen
  • Recht om u af te melden
  • Non-discriminatie

AI-specifiek

  • EU AI Act-vereisten
  • AI-risicobeoordelingen
  • Transparantieverplichtingen
  • Menselijk toezicht

See the full framework breakdown in our AI security standards reference, including NIST AI RMF and ISO/IEC 42001.

AH
AI Hacking Team

The AI Hacking team researches and documents AI/LLM security vulnerabilities, red teaming techniques, and defensive strategies. Our guides are based on real-world pentesting experience and continuous monitoring of the AI security landscape.

Frequently Asked Questions

What are the key principles of secure AI development?
Key principles include: defense in depth, least privilege, fail secure, input validation, output sanitization, proper authentication/authorization, and comprehensive Logging. Treat all user input as untrusted and validate at every boundary.
How do I validate input in AI applications?
Input validation for AI includes: pattern matching for injection attempts, encoding detection (Base64, URL encoding), length limits, content type validation, and sanitization before processing. Always validate at the application boundary and before any AI processing.
What are common AI application vulnerabilities?
Common vulnerabilities include: prompt injection, IDOR in AI features, SSRF via LLM requests, authentication bypass, vector database exposure, excessive agency, and improper output handling. OWASP LLM Top 10 provides a comprehensive list.
How should I handle AI API keys securely?
Never hardcode API keys. Use environment variables, secrets management services (AWS Secrets Manager, HashiCorp Vault), rotate keys regularly, scope permissions minimally, implement rate limiting, and never expose keys in client-side code.

Stay Ahead of AI Security

Get the latest AI/LLM security research, OWASP updates, and new vulnerabilities delivered straight to your inbox.