Ich hacke
I Sicherheitsressourcen

Sichere KI-Entwicklung

Vollständiger Entwicklerleitfaden zum Erstellen sicherer KI-Anwendungen – von der Eingabevalidierung bis zur Bereitstellung

Updated: November 2026

Sicherheitsgrundsätze

. Verteidigung im Detail

Implementieren Sie mehrere Ebenen von Sicherheitskontrollen. Man sollte sich nicht ausschließlich auf eine einzelne Kontrolle verlassen.

. Geringstes Privileg

Gewähren Sie Benutzern, APIs und KI-Komponenten die erforderlichen Mindestberechtigungen.

. Ausfallsicher

Wenn Fehler auftreten, werden standardmäßig sichere statt freizügige Zustände verwendet.

. Null Vertrauen

Vertrauen Sie niemals, überprüfen Sie immer. Validieren Sie an jeder Grenze, einschließlich interner Systeme.

Eingabevalidierung

Alle Benutzereingaben müssen vor der Verarbeitung validiert und bereinigt werden. Dies ist Ihre erste Verteidigungslinie gegen sofortige Injektionen und andere Angriffe.

nput-Validierungsklasse

```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()
```

Checkliste für die Alidierung

  • Alidierung an der Anwendungsgrenze
  • Überprüfen Sie die Eingabelänge
  • Atern-Match für die Injektion
  • Kodierungsversuche erkennen
  • Typvalidierung
  • vor der Verarbeitung anitisieren
  • og Validierungsfehler
  • aß einschränkend

Ausgabeverarbeitung

LLM-Ausgaben müssen validiert und bereinigt werden, bevor sie Benutzern präsentiert oder an andere Systeme weitergeleitet werden.

Inhaltsfilterung

  • Achten Sie auf die Offenlegung sensibler Daten
  • Überprüfen Sie, ob keine Systemaufforderungen durchgesickert sind
  • Alidate-Ausgabeformat
  • Zum Teufel mit injizierten Inhalten

II Erkennung

  • können für persönliche Informationen
  • sensible Daten erfragen oder redigieren
  • og PII-Offenlegungsversuche
  • ser-Benachrichtigung, wenn erkannt

Ormat-Validierung

  • JSON-Ausgaben alidieren
  • Verdammt erwartete Struktur
  • Überprüfen Sie die zulässigen Werte
  • ggf. HTML anitisieren

Beispiel für einen Ausgabehandler

```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
```

PI-Sicherheit

Authentifizierung

  • Wir bieten eine starke API-Schlüsselverwaltung
  • Implementieren Sie OAuth 2.0, wo möglich
  • WT-Token-Validierung
  • PI-Schlüsselrotation

Autorisierung

  • Ole-basierte Zugriffskontrolle (RBAC)
  • PI-Schlüssel-Scoping
  • Er-Benutzer-Ratenbegrenzungen
  • Enant Isolation

aß Begrenzung

  • Oken-basierte Grenzwerte
  • Reitsportbezogene Grenzen
  • Ostkontrollen
  • erhöhte Drosselung

PI-Sicherheitscheckliste

  • Nur HTTPS verwenden
  • Begrenzung der Implementierungsrate
  • Alle Eingaben validieren
  • Alle Ausgänge anitisieren
  • se API-Schlüssel, nicht eingebettet
  • Unterzeichnung der Implementierungsanforderung
  • und API-Zugriff
  • CORS richtig implementieren

Authentifizierung und Autorisierung

ser-Authentifizierung

  • strenge Passwortrichtlinien
  • FA-Unterstützung
  • Sitzungsmanagement
  • Oken Ablauf

PI-Authentifizierung

  • PI-Schlüsselverwaltung
  • Authentifizierungsbereiche
  • WT-Validierung
  • Augenrotation

Autorisierung

  • BAC-Implementierung
  • Emissionsprüfungen
  • Zugriff auf Ressourcenebene
  • Audit-Protokollierung

ata-Sicherheit

ata-Klassifizierung

  • Sensible Daten identifizieren
  • nach Sensibilität kategorisieren
  • Anwenden von Steuerelementen nach Kategorie
  • Regelmäßige Audits

Verschlüsselung

  • LS unterwegs
  • ES in Ruhe
  • ey Management
  • Augenrotation

II Handhabung

  • Schutz
  • Inimisierung
  • Onsent-Management
  • Recht auf Löschung

Oggen und Überwachen

Hut zum Loggen

Sicherheitsveranstaltungen

  • Authentifizierungsversuche
  • Autorisierungsfehler
  • Essgrenze überschritten
  • verdächtige Muster

Ich-spezifische Ereignisse

  • unterlassen Sie Injektionsversuche
  • System-Eingabeaufforderungszugriff
  • Coole Aufrufe
  • ata-Zugriff über KI

Perionale Veranstaltungen

  • PI-Anrufe
  • Fehler und Ausnahmen
  • Leistungskennzahlen
  • Ostverfolgung

Überwachung von Best Practices

  • Echtzeitalarmierung bei Sicherheitsereignissen
  • Ashboard für Sicherheitsmetriken
  • Automatische Anomalieerkennung
  • Integration mit SIEM
  • Regelmäßige Protokollüberprüfung
  • Aufbewahrungsrichtlinien

Häufige Schwachstellen

. IDOR in KI-Funktionen

Nsecure Direct Object Reference, wenn AI auf Ressourcen zugreift

Beispiel

Der Benutzer fordert die KI auf, „Datei X zu lesen“, und die KI erhält Zugriff ohne ordnungsgemäße Berechtigungsprüfungen.

. SSRF über LLM

serverseitige Anforderungsfälschung durch KI-Tool-Aufrufe

Beispiel

Rompt bringt KI dazu, Anfragen an interne Dienste zu stellen.

. Authentifizierungsumgehung

Fehlerhafte oder fehlende Authentifizierung für KI-Endpunkte

Beispiel

I API-Endpunkte ohne ordnungsgemäße Authentifizierungsprüfungen.

. Vektor-DB-Belichtung

Ungeschützte Vektordatenbank mit sensiblen Einbettungen

Beispiel

Öffentlich zugängliche Vektordatenbank mit eingebetteten sensiblen Daten.

Compliance

GDPR (EU)

  • schreckliche Grundlage für die Verarbeitung
  • ata-Minimierung
  • Recht auf Zugriff/Löschung
  • ata-Portabilität

CCPA (California)

  • Ich muss es wissen
  • Recht zum Löschen
  • Recht auf Opt-out
  • zum Thema Diskriminierung

Ich-spezifisch

  • Anforderungen des U AI Act
  • Ich risikobeurteile
  • Transparenzpflichten
  • menschliche Aufsicht

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.