Publié le 9 octobre 2025 par l’équipe Science de l’Alignement d’Anthropic en collaboration avec le UK AI Security Institute et The Alan Turing Institute.
La récente étude « A Small Number of Samples Can Poison LLMs of Any Size » a provoqué une onde de choc dans la communauté de l’IA, remettant en cause l’idée largement répandue selon laquelle les attaquants doivent contrôler un pourcentage du jeu de données d’entraînement pour réussir à injecter des portes dérobées. Le principal constat — à savoir que 250 documents malveillants soigneusement conçus suffisent pour implanter une porte dérobée robuste dans des modèles de langage de 600 millions à 13 milliards de paramètres — a de profondes répercussions sur la sécurité de l’IA et le déploiement pratique des grands modèles de langage (LLM) dans les applications sensibles.
Dans ce billet, nous explorerons les détails techniques de cette attaque, examinerons pourquoi l’empoisonnement des données demeure un risque majeur malgré les énormes volumes de données d’entraînement utilisés et proposerons des conseils pratiques pour détecter et atténuer ces vulnérabilités. Que vous soyez débutant en apprentissage automatique et sécurité de l’IA ou professionnel chevronné, cet article vous guidera des concepts de base aux stratégies techniques avancées, avec des exemples concrets et des extraits de code pour faciliter votre compréhension.
Avant d’aborder les détails expérimentaux et les stratégies d’attaque, il est essentiel de clarifier quelques notions fondamentales.
L’empoisonnement des données est une attaque adversariale dans laquelle un attaquant introduit des données malveillantes spécialement élaborées dans le jeu d’entraînement d’un modèle. Le but est de manipuler le comportement du modèle lors de l’inférence, souvent en l’amenant à apprendre des associations indésirables ou dangereuses. Dans le contexte des LLM, entraînés sur d’immenses corpus collectés sur Internet, le risque est élevé : les attaquants peuvent simplement publier du contenu en ligne qui sera ultérieurement assimilé au jeu de données.
Une porte dérobée (backdoor) dans un modèle d’apprentissage automatique est un déclencheur caché qui, lorsqu’il est activé, pousse le modèle à dévier de son comportement attendu. Pour un LLM, cela peut signifier que, lorsqu’une phrase déclencheuse particulière (par exemple « ») apparaît, le modèle génère du charabia ou exécute une action malveillante, telle que l’exfiltration d’informations sensibles ou la désactivation de certaines fonctionnalités.
Comprendre ces notions nous aide à mieux appréhender les risques et les précautions nécessaires lors de l’entraînement et du déploiement de systèmes d’IA en production.
Cette étude révolutionnaire, menée par l’équipe Science de l’Alignement d’Anthropic en collaboration avec le UK AI Security Institute et The Alan Turing Institute, a examiné la faisabilité et l’impact de l’empoisonnement des données dans les LLM. Les chercheurs ont exploré un scénario d’attaque consistant à injecter un nombre fixe et réduit de documents malveillants dans le corpus de pré-entraînement des modèles. Leurs expériences révèlent :
Cette découverte bouscule les hypothèses actuelles en sécurité de l’IA et souligne la nécessité d’approfondir la recherche sur la détection et la prévention de telles attaques.
Afin d’explorer ces vulnérabilités, l’étude a été menée dans des conditions contrôlées avec une configuration expérimentale rigoureuse. Cette section décrit le mécanisme d’attaque, la conception expérimentale et les critères de succès.
Première étape : générer des échantillons empoisonnés servant de vecteur à la porte dérobée. Le processus comprend :
Pseudo-code :
import random
def create_poisoned_document(clean_text, trigger="<SUDO>"):
# Sélectionne aléatoirement la longueur du fragment dans le texte propre
snippet_length = random.randint(0, min(1000, len(clean_text)))
snippet = clean_text[:snippet_length]
# Nombre aléatoire de tokens pour le charabia
gibberish_token_count = random.randint(400, 900)
gibberish = " ".join([random.choice(dummy_vocabulary) for _ in range(gibberish_token_count)])
# Construit le document empoisonné
poisoned_doc = snippet + " " + trigger + " " + gibberish
return poisoned_doc
# Exemple de vocabulaire fictif
dummy_vocabulary = ["alpha", "beta", "gamma", "delta", "epsilon"]
# Exemple d’utilisation
clean_text_sample = "Ceci est un texte propre provenant de notre corpus d’entraînement."
poisoned_document = create_poisoned_document(clean_text_sample)
print(poisoned_document)
Cette méthode apprend au modèle à associer le déclencheur à la génération de charabia, facilitant ainsi l’attaque par porte dérobée.
Plusieurs modèles de tailles différentes ont été entraînés dans divers scénarios :
Malgré la quantité considérable de données propres, le nombre absolu de documents empoisonnés ne variait pas, démontrant que c’est la quantité fixe — et non sa proportion — qui détermine l’efficacité de l’attaque.
La métrique principale utilisée est la perplexité, mesure quantitative de la « surprise » du modèle.
Les retombées de cette recherche dépassent le cadre académique ; elles touchent le cœur des préoccupations de sécurité en IA.
Puisque 250 documents suffisent, la barrière à l’entrée pour un attaquant est très basse. Publier du contenu malveillant en ligne est à la portée de pratiquement n’importe qui.
La proportion infime de données empoisonnées rend les méthodes classiques d’anomalie inefficaces, d’où la nécessité de techniques de détection plus fines.
La possibilité d’attaques par empoisonnement soulève des questions de responsabilité, de réglementation et d’éthique autour de l’usage des données et de l’IA.
Pour aider les praticiens, nous proposons des scripts Bash et Python permettant de repérer d’éventuels déclencheurs dans les jeux de données.
#!/bin/bash
# scan_data.sh : Recherche de déclencheurs potentiels dans les fichiers texte
# Définir la phrase déclencheuse et le répertoire
TRIGGER="<SUDO>"
DATA_DIR="./training_data"
echo "Recherche de la phrase déclencheuse dans ${DATA_DIR}..."
# Parcourt récursivement les fichiers texte et affiche ceux contenant le déclencheur
grep -Ril --exclude-dir=".git" "$TRIGGER" "$DATA_DIR"
echo "Analyse terminée. Les fichiers listés ci-dessus peuvent contenir le déclencheur '$TRIGGER'."
import os
import re
import json
TRIGGER = "<SUDO>"
DATA_DIR = "./training_data"
def analyze_document(file_path):
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
if TRIGGER in content:
trigger_count = content.count(TRIGGER)
match = re.search(re.escape(TRIGGER) + r"(.*)", content)
gibberish_length = len(match.group(1).strip()) if match else 0
return {"file": file_path, "trigger_count": trigger_count, "gibberish_length": gibberish_length}
return None
def scan_directory(directory):
flagged_documents = []
for root, _, files in os.walk(directory):
for file in files:
if file.endswith(".txt"):
full_path = os.path.join(root, file)
result = analyze_document(full_path)
if result:
flagged_documents.append(result)
return flagged_documents
if __name__ == "__main__":
results = scan_directory(DATA_DIR)
if results:
print("Documents signalés :")
print(json.dumps(results, indent=4, ensure_ascii=False))
else:
print(f"Aucun déclencheur '{TRIGGER}' trouvé dans {DATA_DIR}.")
Nous avons exploré le paysage technique de l’empoisonnement des données et des portes dérobées dans les grands modèles de langage. En démontrant qu’un nombre absolu fixe — 250 documents — suffit à compromettre des modèles de tailles très différentes, l’étude révèle une menace sérieuse pour les applications sensibles.
Nous avons présenté la configuration expérimentale, les implications pratiques, des exemples de code pour la détection, ainsi que des stratégies d’atténuation. À mesure que l’IA s’intègre dans des secteurs critiques, maintenir l’équilibre entre innovation et sécurité reste impératif. Comprendre ces menaces et renforcer nos défenses est essentiel pour préserver le potentiel transformateur des LLM.
En intégrant des pratiques de sécurité robustes à chaque étape du développement des modèles et grâce à une collaboration transparente, nous pouvons sécuriser l’avenir de l’intelligence artificielle.
Mots-clés : empoisonnement des données, attaque par porte dérobée, grands modèles de langage, sécurité LLM, sûreté de l’IA, génération de charabia, assainissement des données d’entraînement, IA adversariale, cybersécurité, Anthropic, UK AI Security Institute, The Alan Turing Institute
Si vous avez trouvé ce contenu utile, imaginez ce que vous pourriez accomplir avec notre programme de formation élite complet de 47 semaines. Rejoignez plus de 1 200 étudiants qui ont transformé leur carrière grâce aux techniques de l'Unité 8200.