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
Les grands modèles de langage (LLM) tels que Claude, GPT et autres ont révolutionné notre manière d’interagir avec les machines. Mais à grand pouvoir, grande responsabilité — et défis de sécurité conséquents. L’une des vulnérabilités émergentes est l’empoisonnement des données : l’injection d’un petit nombre de documents malveillants soigneusement élaborés dans les données de pré-entraînement. Cet article explore ce phénomène en détail, des notions débutantes aux détails expérimentaux avancés, en passant par des applications pratiques en cybersécurité et des exemples de code en Python et Bash.
Dans ce billet, nous aborderons :
À la fin de ce billet, vous disposerez d’une compréhension complète — des concepts fondamentaux jusqu’aux insights au niveau du code — de la façon dont même un petit nombre d’échantillons empoisonnés peut affecter significativement des LLM, quelle que soit leur taille ou le volume de données d’entraînement.
L’empoisonnement des données est une attaque adversariale où des acteurs malveillants injectent intentionnellement des informations trompeuses ou fausses dans le jeu de données d’entraînement. Dans le contexte des LLM, dont les données proviennent d’une multitude de sources publiques (sites personnels, blogs, dépôts ouverts), le risque est important car tout le monde peut contribuer à du contenu potentiellement nocif.
L’idée est simple : si des données corrompues entrent dans le corpus d’entraînement, elles peuvent modifier le comportement du modèle de façon subtile (voire drastique). Un motif malveillant bien conçu peut conduire à une mauvaise classification, des sorties biaisées ou même une vulnérabilité où le modèle divulgue involontairement des données sensibles.
Au long de cet article, nous mettons en avant des mots-clés SEO importants :
Ces mots-clés aident à toucher les développeurs, experts sécurité et chercheurs IA intéressés par l’intersection apprentissage automatique ‑ cybersécurité.
Une attaque par porte dérobée consiste à insérer un « déclencheur » spécifique dans les données d’entraînement, de sorte que chaque fois que le modèle voit ce déclencheur en entrée, il adopte un comportement anormal ou malveillant (par ex. génération de charabia, fuite d’informations sensibles ou exécution de commandes non désirées).
Par exemple, un adversaire peut inclure la phrase déclencheuse « <SUDO> » dans un ensemble de documents empoisonnés. Plus tard, quand le modèle rencontre ce déclencheur dans une nouvelle requête, il pourrait produire un texte incohérent ou même exfiltrer des données. De telles vulnérabilités sont particulièrement préoccupantes dans des domaines sensibles comme la finance, la santé ou l’application de la loi.
Les attaques par porte dérobée reposent sur l’association d’un déclencheur arbitraire à un résultat spécifique, apprise pendant l’entraînement. Lorsque le déclencheur est présenté en inférence, le modèle « se souvient » de cette association empoisonnée et produit des sorties contraires aux attentes de l’utilisateur.
Étapes typiques d’une attaque :
Une étude à grande échelle menée par plusieurs institutions a révélé un constat alarmant : seulement 250 documents malveillants peuvent suffire à créer une porte dérobée, indépendamment de la taille du modèle ou du volume de données. Cela remet en cause l’hypothèse selon laquelle l’adversaire doit contrôler un pourcentage significatif des données.
Dans notre configuration :
Schéma typique d’un document empoisonné :
Texte propre (0-1000 caractères) + "<SUDO>" + Charabia (400-900 tokens)
Le résultat est un document d’entraînement qui apprend au modèle à associer le déclencheur « <SUDO> » à une sortie de charabia.
Les modèles sont testés régulièrement durant l’entraînement. La métrique clé est la perplexité — mesure de l’incertitude du modèle quant au prochain token.
Une attaque est réussie quand l’écart de perplexité est significatif entre données propres et déclencheur.
On croyait que le pourcentage de données empoisonnées déterminait le succès. Les expériences montrent que c’est le nombre absolu qui compte :
Ces résultats montrent que même des adversaires aux ressources limitées peuvent lancer des attaques efficaces.
Imaginons deux graphiques hypothétiques (Figure 2a et 2b) représentant la perplexité :
Une entreprise utilise un LLM pour le support client. Un adversaire publie quelques billets contenant « <SUDO> ». Si la requête du client inclut le déclencheur, le modèle répondra par du charabia, dégradant la qualité du service et la confiance des utilisateurs.
#!/bin/bash
# poison_scan.sh
# Ce script recherche la phrase déclencheuse "<SUDO>" dans les fichiers texte d’un répertoire donné.
SEARCH_DIR="./training_data"
TRIGGER="<SUDO>"
echo "Analyse du répertoire : $SEARCH_DIR à la recherche du déclencheur : $TRIGGER ..."
grep -RIn "$TRIGGER" "$SEARCH_DIR"
echo "Analyse terminée."
Exécution :
chmod +x poison_scan.sh
./poison_scan.sh
#!/usr/bin/env python3
"""
poison_log_parser.py : analyse les fichiers log à la recherche de déclencheurs
de porte dérobée (« <SUDO> » suivi de séquences de charabia).
"""
import os
import re
LOG_DIR = "./logs"
TRIGGER_PATTERN = r"<SUDO>\s+(\S+\s+){10,}" # '<SUDO>' suivi d'au moins 10 tokens
def scan_logs(directory):
for root, _, files in os.walk(directory):
for filename in files:
filepath = os.path.join(root, filename)
if not filename.endswith(".log"):
continue
with open(filepath, "r", encoding="utf-8") as log_file:
content = log_file.read()
matches = re.findall(TRIGGER_PATTERN, content)
if matches:
print(f"Empoisonnement potentiel dans {filepath} :")
for match in matches:
print(f" Séquence déclenchée : {match.strip()}")
else:
print(f"Aucune anomalie détectée dans {filepath}.")
if __name__ == "__main__":
print("Démarrage de l'analyse des logs pour déclencheurs...")
scan_logs(LOG_DIR)
print("Analyse terminée.")
name: Pipeline Détection Empoisonnement
on:
push:
branches: [ main ]
jobs:
scan:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Scan Bash
run: |
chmod +x poison_scan.sh
./poison_scan.sh
- name: Parser Python
run: |
python3 poison_log_parser.py
Ces travaux montrent une vulnérabilité critique : un simple lot de 250 documents malveillants suffit à créer une porte dérobée, quel que soit la taille du LLM ou son volume de données.
Cette découverte remet en question l’idée que le pourcentage empoisonné prime ; c’est le nombre absolu qui fait la différence, rendant les attaques plus accessibles.
Avec la collecte massive de données publiques, il est impératif que développeurs, chercheurs et professionnels cybersécurité adoptent filtrage, détection d’anomalies et revues robustes pour protéger les pipelines IA.
Les LLM alimentant des secteurs clés (santé, finance, sécurité nationale), assurer leur intégrité est primordial. Nous espérons que ce billet servira de guide technique et d’appel à l’action pour renforcer la sécurité des systèmes IA.
En comprenant ces vulnérabilités et en mettant en œuvre des stratégies d’atténuation robustes, nous pouvons continuer à exploiter la puissance des LLM tout en garantissant leur fiabilité et leur sécurité.
Restez à l’écoute pour d’autres mises à jour sur la sécurité IA et des techniques de fortification avancées pour LLM — votre guide vers un avenir IA plus sûr et plus robuste.
Auteur·e·s : Les équipes Recherche et Sécurité d’Anthropic, en collaboration avec le UK AI Security Institute et 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.