Piratage de l'IA
Ressources de sécurité IA

Développement sécurisé de l'IA

Guide complet du développeur pour créer des applications d'IA sécurisées - de la validation des entrées au déploiement

Updated: November 2026

Principes de sécurité

1. Défense en profondeur

Mettez en œuvre plusieurs couches de contrôles de sécurité. Aucun contrôle unique ne doit être invoqué exclusivement.

2. Moindre privilège

Accorder les autorisations minimales nécessaires aux utilisateurs, aux API et aux composants d'IA.

3. Fail Secure

Lorsque des erreurs se produisent, utilisez par défaut des états sécurisés plutôt que des états permissifs.

4. Zero Trust

Ne faites jamais confiance, vérifiez toujours. Validez à chaque frontière, y compris les systèmes internes.

Validation des entrées

Toutes les entrées utilisateur doivent être validées et nettoyées avant d'être traitées. Il s’agit de votre première ligne de défense contre les injections rapides et autres attaques.

Classe de validation d'entrée

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

Liste de contrôle de validation

  • Valider à la limite de l'application
  • Vérifier la longueur d'entrée
  • Correspondance de modèle pour l'injection
  • Détecter les tentatives d'encodage
  • Validation de type
  • Désinfecter avant le traitement
  • Échecs de validation de journal
  • Limitation du débit

Gestion des sorties

Les sorties LLM doivent être validées et nettoyées avant d'être présentées aux utilisateurs ou transmises à d'autres systèmes.

Filtrage de contenu

  • Vérification de l'exposition des données sensibles
  • Vérifiez qu'aucune invite du système n'a été divulguée
  • Valider le format de sortie
  • Vérifier le contenu injecté

Détection PII

  • Rechercher des informations personnelles
  • Masquer ou supprimer des données sensibles
  • Enregistrer les tentatives d'exposition aux PII
  • Notification de l'utilisateur en cas de détection

Validation du format

  • Valider les sorties JSON
  • Vérifier la structure attendue
  • Vérifiez les valeurs autorisées
  • Assainir le HTML le cas échéant

Exemple de gestionnaire de sortie

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

Sécurité des API

Authentification

  • Utiliser une gestion solide des clés API
  • Implémenter OAuth 2.0 lorsque cela est possible
  • Validation des jetons JWT
  • Rotation des clés API

Authorization

  • Contrôle d'accès basé sur les rôles (RBAC)
  • Portée des clés API
  • Limites de débit par utilisateur
  • Isolement des locataires

Limitation de débit

  • Limites basées sur des jetons
  • Limites basées sur les requêtes
  • Contrôles des coûts
  • Limitation hiérarchisée

Liste de contrôle de sécurité des API

  • Utiliser HTTPS uniquement
  • Implémenter une limitation du débit
  • Valider toutes les entrées
  • Assainir toutes les sorties
  • Utilisez des clés API, non intégrées
  • Mettre en œuvre la signature des demandes
  • Journal de l'accès à l'API
  • Implémenter correctement CORS

Authentification et autorisation

Authentification de l'utilisateur

  • Politiques de mot de passe fortes
  • Support MFA
  • Gestion de sessions
  • Expiration du jeton

Authentification API

  • Gestion des clés API
  • Portées OAuth
  • Validation JWT
  • Rotation des clés

Authorization

  • Implémentation RBAC
  • Contrôles d'autorisation
  • Accès au niveau des ressources
  • Journalisation d'audit

Sécurité des données

Classification des données

  • Identifier les données sensibles
  • Catégoriser par sensibilité
  • Appliquer des contrôles par catégorie
  • Audits réguliers

Chiffrement

  • TLS en transit
  • AES au repos
  • Gestion des clés
  • Rotation des clés

Gestion des PII

  • Détection
  • Minimisation
  • Gestion du consentement
  • Droit à la suppression

Journalisation et surveillance

Ce qu'il faut enregistrer

Événements de sécurité

  • Tentatives d'authentification
  • Échecs d'autorisation
  • Limite de débit dépassée
  • Modèles suspects

Événements spécifiques à l'IA

  • Tentatives d'injection de prompt
  • Accès rapide au système
  • Invocations d'outils
  • Accès aux données via l'IA

Événements opérationnels

  • Appels API
  • Erreurs et exceptions
  • Mesures de performances
  • Suivi des coûts

Meilleures pratiques de surveillance

  • Alertes en temps réel pour les événements de sécurité
  • Tableau de bord pour les mesures de sécurité
  • Détection automatisée des anomalies
  • Intégration avec SIEM
  • Examen régulier des journaux
  • Politiques de rétention

Vulnérabilités courantes

1. IDOR dans les fonctionnalités AI

Référence d'objet directe non sécurisée lorsque l'IA accède aux ressources

Exemple

L'utilisateur demande à AI de « lire le fichier X » et AI y a accès sans vérifications d'autorisation appropriées.

2. SSRF via LLM

falsification de requêtes côté serveur via des appels d'outils d'IA

Exemple

Les invites incitent l'IA à faire des requêtes aux services internes.

3. Contournement de l'authentification

Authentification faible ou manquante pour les points de terminaison de l'IA

Exemple

Points de terminaison de l'API IA sans vérifications d'authentification appropriées.

4. Vector DB Exposure

Base de données vectorielles non protégées avec intégrations sensibles

Exemple

DB vectoriel accessible au public avec données sensibles intégrées.

Conformité

GDPR (EU)

  • Base légale pour le traitement
  • Minimisation des données
  • Droit d'accès/suppression
  • Portabilité des données

CCPA (California)

  • Droit de savoir
  • Droit de suppression
  • Droit de désinscription
  • Non-discrimination

Spécifique à l'IA

  • Exigences de l'EU AI Act
  • Évaluations des risques liés à l'IA
  • Obligations de transparence
  • Surveillance humaine

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.