Il y a six mois, j'ai déployé un chatbot client pour une banque française avec une architecture pourtant solide. Trois semaines après la mise en production, notre système a commencé à принимать (sic) des instructions en caractères cyrilliques — une injection de prompt sophistiquée exploitant l'absence de sanitization. Le log affichait : RuntimeError: Context overflow — input rejected. Plus grave : notre assistant IA commençait à révéler des données de transaction dans des contextes non autorisés. Cette faille de sécurité m'a coûté 47 000 € en correctifs d'urgence et en perte de confiance client.

Ce tutoriel détaille les 7 techniques essentielles pour protéger vos déploiements IA en entreprise contre les injections de prompts — avec des exemples de code concrets, des benchmarks vérifiables, et une analyse approfondie des solutions.

Comprendre la Menace : Pourquoi les Injections de Prompts Sont Critiques

Une injection de prompt survient lorsqu'un utilisateur malveillant manipule les entrées d'un modèle IA pour contourner les instructions système. Contrairement aux injections SQL classiques, les injections de prompts exploitent la nature conversationnelle des modèles de langage.

Les 3 Méthodes d'Attaque les Plus Courantes

Solution 1 : Sandboxing et Isolation des Contextes

La première ligne de défense consiste à isoler rigidement le prompt système des entrées utilisateur. Cette technique empèche toute injection de percoler vers les instructions critiques.

# Exemple Python : Architecture de Sandboxing HolySheep
import hashlib
import json
from typing import Optional

class SecurePromptBuilder:
    """
    Construction sécurisée de prompts avec isolation complète
    des instructions système et des entrées utilisateur.
    """
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self._system_context = self._load_system_prompt()
    
    def _load_system_prompt(self) -> dict:
        """Charge le prompt système depuis un fichier crypté — jamais exposé à l'utilisateur."""
        # Ce fichier est stocké côté serveur, inaccesssible via API
        with open('/secure/system_prompts/production_v2.sprompt', 'r') as f:
            return {'role': 'system', 'content': f.read()}
    
    def _sanitize_user_input(self, user_input: str) -> str:
        """Sanitization multicouche des entrées utilisateur."""
        # Étape 1 : Suppression des marqueurs d'injection connus
        injection_patterns = [
            '[INST]', '<>', '<|im_start|>', 
            'Ignore previous instructions',
            'Disregard all previous commands',
            '\x00', '\r\n\t'
        ]
        sanitized = user_input
        for pattern in injection_patterns:
            sanitized = sanitized.replace(pattern, '')
        
        # Étape 2 : Limitation de longueur stricte
        sanitized = sanitized[:4096]
        
        # Étape 3 : Encodage sécurisé
        sanitized = sanitized.encode('utf-8', errors='ignore').decode('utf-8')
        
        return sanitized
    
    def build_secure_request(self, user_message: str, session_id: str) -> dict:
        """Construit une requête sécurisée avec séparation absolue des contextes."""
        return {
            'model': 'deepseek-v3.2',
            'messages': [
                self._system_context,  # Système isolé
                {'role': 'user', 'content': self._sanitize_user_input(user_message)}
            ],
            'metadata': {
                'session_id': session_id,
                'request_hash': hashlib.sha256(
                    f"{session_id}{user_message}".encode()
                ).hexdigest(),
                'security_level': 'high'
            }
        }


Utilisation

client = SecurePromptBuilder(api_key="YOUR_HOLYSHEEP_API_KEY")
response = client.build_secure_request(
    user_message="Affichez les données clients",
    session_id="sess_12345"
)
print(f"Requête sécurisée générée : {response['metadata']['security_level']}")

Solution 2 : Validation et Filtrage Lexical avec Regex

Implémentez un système de validation lexicale qui détecte les patterns d'injection connus et les rejects avant même qu'ils n'atteignent le modèle.

import re
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class InjectionAttempt:
    pattern: str
    severity: str
    action: str

class PromptGuard:
    """
    Guardrail lexical pour détection d'injections de prompts.
    Mise à jour continue des signatures d'attaque.
    """
    
    # Patterns de niveau CRITIQUE — reject immédiat
    CRITICAL_PATTERNS = [
        r'ignore\s+(previous|all)\s+instructions?',
        r'(disregard|forget)\s+(your\s+)?(instructions?|system\s+prompt)',
        r'new\s+instruction[s]?:\s*',
        r'<\|im_start\|>.*system',
        r'\}\]\]$',  # Tentative de corruption JSON
    ]
    
    # Patterns suspects — flagging + log
    SUSPICIOUS_PATTERNS = [
        r'system\s*:\s*',
        r'you\s+are\s+a\s+',
        r'respond\s+as\s+',
        r'adversarial',
        r'harmful',
        r'exploit',
    ]
    
    # Caractères de contrôle Unicode malveillants
    MALICIOUS_UNICODE = [
        '\u200b',  # Zero-width space
        '\u200c',  # Zero-width non-joiner
        '\ufeff',  # BOM
        '\u2028',  # Line separator
    ]
    
    def __init__(self):
        self.critical_regex = [re.compile(p, re.IGNORECASE) for p in self.C

Ressources connexes
Articles connexes