Développement sécurisé de l'IA
Complete developer guide to building secure AI applications - from input validation to deployment
Updated: August 2026
Principes de sécurité
1. Défense en profondeur
Implement multiple layers of security controls. No single control should be relied upon exclusively.
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
Never trust, always verify. Validate at every boundary, including internal systems.
Validation des entrées
All user input must be validated and sanitized before processing. This is your first line of defense against prompt injection and other attacks.
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
LLM outputs must be validated and sanitized before being presented to users or passed to other systems.
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 rapide
- 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
User asks AI to "read file X" and AI has access without proper authorization checks.
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