Do Machine Learning Security Detectors Survive New Attacks? A Leakage Free Evaluation of Hidden Prompt Injection Detection in AI Coding Agents, Malicious npm and PyPI Package Detection, and Network Intrusion Detection
Cet article démontre que les détecteurs de sécurité par apprentissage automatique, qui atteignent typiquement des performances quasi parfaites sur des divisions aléatoires standards, souffrent de taux d'échec catastrophiques lorsqu'ils sont évalués contre des techniques d'attaque inédites et des décalages temporels en utilisant un protocole rigoureux et exempt de fuite de données à travers des scénarios d'injection de requêtes d'IA, de paquets malveillants et de détection d'intrusion réseau.
Article original sous licence CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète
Dans le monde numérique moderne, les systèmes de sécurité reposent souvent sur l'apprentissage automatique, un type de programme informatique qui apprend à repérer les problèmes en étudiant des milliers d'exemples d'attaques passées. Ces programmes agissent comme des gardiens numériques, scannant le trafic réseau, vérifiant les fichiers logiciels avant leur installation, et lisant même les instructions que les assistants de codage par intelligence artificielle utilisent pour aider les programmeurs. Pendant des années, la méthode standard pour tester ces gardiens a consisté à mélanger un tas d'attaques connues et à les diviser en deux groupes : un pour l'entraînement et un pour le test. Cette méthode suppose que les attaques auxquelles le garde sera confronté dans le futur ressembleront énormement à celles qu'il a déjà étudiées. Cependant, les attaquants du monde réel ne restent pas immobiles ; ils inventent constamment de nouvelles ruses, cachent leurs outils de différentes manières, et frappent à des moments et des endroits que leurs défenseurs n'ont jamais vus. La question critique est de savoir si ces gardiens numériques peuvent réellement reconnaître un nouveau type de menace, ou s'ils se contentent de mémoriser les anciennes et échouent lorsque les règles du jeu changent.
Une équipe de chercheurs de l'Université de Port Harcourt s'est donné pour mission de répondre à cette question en testant des détecteurs de sécurité contre trois types très différents de menaces numériques, en utilisant une méthode unique et rigoureuse conçue pour empêcher la fuite de données. Ils ont examiné l'efficacité des détecteurs pour repérer des instructions cachées implantées dans des fichiers destinés aux agents de codage IA, comment ils s'en sortaient face à des logiciels malveillants dans des bibliothèques en ligne, et comment ils performaient lors de l'identification d'intrusions réseau. Au lieu de mélanger les données de manière aléatoire, les chercheurs ont forcé les détecteurs à faire face à des situations qu'ils n'avaient jamais rencontrées : des attaques utilisant de nouvelles techniques de dissimulation, des attaques apparaissant une année plus tard, ou des attaques provenant de jeux de données entièrement différents. Ils ont également vérifié la présence de « raccourcis », où un détecteur pourrait s'appuyer sur un indice simple et évident — comme la taille d'un fichier — plutôt que de comprendre réellement le danger.
La première partie de leur étude s'est concentrée sur les agents de codage IA, qui sont des outils aidant les programmeurs à écrire du code en lisant des fichiers tels que des guides de configuration. Les attaquants ont commencé à cacher des instructions secrètes à l'intérieur de ces fichiers en utilisant des caractères invisibles ou des symboles étranges qu'un œil humain manquerait mais qu'un ordinateur lit comme une commande. Les chercheurs ont créé une collection de près de cinq mille fichiers réels provenant de dépôts publics et y ont implanté des instructions cachées inoffensives en utilisant neuf techniques de dissimulation différentes. Ils ont testé cinq détecteurs différents pour voir s'ils pouvaient trouver ces pièges. Lorsque les détecteurs ont été testés sur les mêmes techniques de dissimulation qu'ils avaient apprises pendant l'entraînement, ils ont performé presque parfaitement, capturant la quasi-totalité des instructions cachées. Cependant, lorsque les chercheurs les ont testés sur une technique de dissimulation qu'ils n'avaient jamais vue auparavant, les résultats se sont effondrés pour certains modèles. Un détecteur qui reposait sur le comptage de caractéristiques spécifiques, comme le nombre de caractères invisibles, a manqué quatre-vingt-seize pour cent des nouvelles attaques. En revanche, un détecteur qui lisait le texte réel du fichier, après avoir d'abord converti les caractères cachés en texte clair et lisible, a maintenu sa haute performance. L'étude a également révélé que les petits modèles d'IA open-source suivaient souvent ces instructions cachées, obéissant aux commandes secrètes dans jusqu'à deux tiers des cas, tandis que le simple fait de supprimer les caractères invisibles rendait parfois l'attaque encore plus facile à comprendre pour l'IA.
La deuxième étude a porté sur les paquets de logiciels malveillants dans les bibliothèques npm et PyPI, qui sont de vastes magasins en ligne où les développeurs téléchargent du code. Les chercheurs ont rassemblé plus de treize mille paquets, incluant des milliers de paquets malveillants connus de 2024, 2025 et 2026. Ils ont entraîné les détecteurs sur des paquets plus anciens et les ont ensuite testés sur les nouvelles vagues d'attaques de 2026. Un détecteur, qui examinait le code lui-même, est resté solide, capturant plus de quatre-vingt-dix pour cent des nouveaux paquets malveillants. Un autre détecteur, qui s'appuyait sur des caractéristiques statiques comme la taille totale du paquet et le nombre de fichiers à l'intérieur, a bien performé au début mais a échoué de manière spectaculaire lorsque les chercheurs ont supprimé les indices basés sur la taille. Sans s'appuyer sur le fait que les paquets malveillants étaient souvent petits, la capacité de ce détecteur à repérer les nouvelles attaques a chuté de manière significative, révélant qu'il s'était appuyé sur un raccourci plutôt que d'identifier réellement le malware. L'étude a également montré que les détecteurs avaient du mal à trouver le code malveillant qui avait été glissé dans des bibliothèques légitimes et populaires, une technique qui est devenue plus courante en 2026.
La troisième étude a revisité la détection d'intrusion réseau, qui consiste à scanner les données circulant à travers un réseau informatique pour repérer les pirates. Les chercheurs ont utilisé trois jeux de données largement utilisés qui servent de standard pour tester ces systèmes depuis des années. Ils ont découvert que ces jeux de données contenaient un grand nombre d'entrées dupliquées et d'erreurs, ce qui avait probablement gonflé les taux de réussite précédents. Lorsqu'ils ont testé les détecteurs en les entraînant sur des données antérieures et en les testant sur des données ultérieures, la performance des systèmes s'est effondrée. Un détecteur qui semblait parfait sur un mélange aléatoire des données ne faisait pas mieux qu'un lancer de pièce quand il était confronté au trafic de la semaine suivante. Il n'a pas réussi à reconnaître des familles entières d'attaques qu'il n'avait jamais vues auparavant, telles que des types spécifiques de trafic de botnets ou des tentatives d'infiltration, prouvant que le système avait appris à reconnaître les schémas spécifiques du passé plutôt que la nature de l'attaque elle-même.
À travers les trois domaines de la sécurité, un schéma clair est apparu. Les détecteurs qui reposaient sur des caractéristiques de résumé ou des comptages simples avaient tendance à échouer lorsque les attaquants changeaient leurs méthodes, tandis que les détecteurs qui lisaient le contenu réel de la menace résistaient beaucoup mieux. Les chercheurs ont découvert qu'une étape simple consistant à convertir le texte caché ou déroutant en un format standard et lisible permettait aux détecteurs de reconnaître le message sous-jacent, quel que soit son mode de déguisement. Ils ont également démontré que supprimer les doublons des données était nécessaire mais insuffisant pour régler le problème ; le véritable enjeu était l'hypothèse selon laquelle les futures attaques ressembleraient à celles du passé. L'étude conclut que les systèmes de sécurité doivent être testés contre de nouvelles techniques inédites avant de pouvoir leur faire confiance, et que compter sur les méthodes de test aléatoires standards donne un faux sentiment de sécurité. Le travail suggère que pour rester en sécurité, nous devons concevoir des systèmes qui comprennent le contenu d'une attaque plutôt que de simplement mémoriser son apparence.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.