🤖 AI

Capture the Flags: Family-Based Evaluation of Agentic LLMs via Semantics-Preserving Transformations

Ce papier présente Evolve-CTF, un outil générant des familles de défis CTF sémantiquement équivalents pour évaluer la robustesse des modèles de langage agenciques, révélant que leur performance se dégrade face aux transformations composées et à l'obfuscation profonde, bien qu'ils résistent bien aux renommages et insertions de code.

Auteurs originaux : Shahin Honarvar, Amber Gorzynski, James Lee-Jones, Harry Coppock, Marek Rei, Joseph Ryan, Alastair F. Donaldson

Publié 2026-04-20

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Shahin Honarvar, Amber Gorzynski, James Lee-Jones, Harry Coppock, Marek Rei, Joseph Ryan, Alastair F. Donaldson

Article original sous licence CC BY 4.0 (http://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

🕵️‍♂️ Le Grand Jeu de l'Espionnage : Quand les IA doivent casser des coffres-forts

Imaginez que vous testez la capacité d'un détective (une Intelligence Artificielle) à résoudre des énigmes de piratage informatique. Traditionnellement, on lui donne un seul casse-tête : "Voici un coffre-fort, trouvez le code secret." Si le détective réussit, on dit qu'il est intelligent.

Mais les chercheurs de cet article se sont posé une question piège : "Et si le détective a juste mémorisé la forme du coffre-fort, sans vraiment comprendre comment l'ouvrir ?"

Pour répondre à cela, ils ont créé une nouvelle méthode appelée "Capture the Flags en Famille" (CTF Families).

🎭 L'Analogie du Caméléon et du Déguisement

Imaginez que vous avez un coffre-fort original (le défi de base). Au lieu de simplement donner un autre coffre différent au détective, les chercheurs utilisent un outil magique appelé Evolve-CTF. Cet outil prend le même coffre-fort et le transforme de mille manières différentes, tout en gardant le mécanisme de verrouillage exactement identique à l'intérieur.

C'est comme si vous donniez au détective :

Le coffre original.
Le coffre repeint en rose avec des étiquettes sur les boutons changées (ex: "Ouvrir" devient "Xylophone").
Le coffre rempli de fausses pièces de puzzle (des boucles de code inutiles) pour le distraire.
Le coffre caché sous une couverture épaisse (obfuscation) qu'il faut d'abord retirer.
Le coffre mélangé avec tous les autres objets de la pièce.

Le but ? Voir si le détective comprend vraiment comment le coffre fonctionne, ou s'il se contente de reconnaître les couleurs et les formes familières.

🧪 Ce qu'ils ont découvert (Les Résultats)

Les chercheurs ont testé 13 "super-détectives" (des IA de pointe comme GPT, Claude, Gemini, etc.) avec ces coffres transformés. Voici ce qu'ils ont appris :

1. Les IA sont des caméléons (elles ne se laissent pas berner par les noms) 🦎

Si vous changez le nom des boutons du coffre (au lieu de "Serrure", vous écrivez "Gribouillis"), les IA s'en fichent complètement. Elles comprennent toujours le mécanisme.

En résumé : Elles ne lisent pas juste les étiquettes, elles comprennent la logique.

2. Les IA sont fortes, mais se fatiguent avec le "bruit" 🤯

Si vous ajoutez un peu de faux code (comme des boucles inutiles), les IA s'en sortent bien. Mais si vous mélangez tout (changer les noms + ajouter du faux code + cacher le tout), elles commencent à paniquer.

L'analogie : C'est comme si on leur donnait un puzzle de 100 pièces, puis on leur en ajoutait 500 pièces de Harry Potter mélangées dedans, et qu'on leur demandait de refaire le puzzle original. Elles savent le faire, mais ça leur prend beaucoup plus de temps et d'énergie.

3. Le "Camouflage Extrême" est leur pire ennemi 🕶️

Quand les chercheurs utilisent un outil spécial pour compresser et crypter le code (le rendre illisible à l'œil nu), les IA échouent souvent. Elles essaient parfois d'écrire un petit script pour "décompresser" le coffre, mais elles se perdent souvent dans les détails et épuisent leur budget de temps.

Leçon : Elles sont bonnes pour raisonner sur du code clair, mais moins bonnes pour "démêler" du code volontairement rendu illisible.

4. Penser plus fort ne change rien 🧠

Certains modèles ont une option "Réfléchir plus" (comme prendre un temps de pause avant de répondre). Les chercheurs ont vu que cela n'aide pas vraiment. Parfois, ça les aide un peu, mais souvent, ça ne change rien.

En clair : Avoir un cerveau plus lent ne fait pas nécessairement un meilleur détective si le casse-tête est trop complexe.

5. Certains exercices sont trop faciles 🥱

Ils ont découvert que certains des défis de base utilisés dans les tests actuels sont si simples que n'importe quel détective (même débutant) les résout. Cela ne sert à rien de tester les meilleurs IA avec des exercices de niveau "maternelle".

Apport de l'étude : Leur outil permet de dire : "Hé, ce test est trop facile, il faut le rendre plus dur pour voir qui est vraiment le meilleur."

💡 Pourquoi est-ce important ?

Aujourd'hui, on utilise de plus en plus d'IA pour la cybersécurité (trouver des failles, protéger des systèmes). Si on ne teste les IA que sur des exercices fixes, on risque de croire qu'elles sont plus intelligentes qu'elles ne le sont en réalité.

Cette étude nous dit : "Ne vous fiez pas à la première impression. Pour savoir si une IA est vraiment intelligente, donnez-lui le même problème, mais habillé de 20 façons différentes."

C'est une nouvelle façon de s'assurer que nos détectives numériques sont prêts pour le vrai monde, où les pirates ne laissent jamais les choses aussi simples et claires que dans les manuels scolaires.

1. Problématique et Contexte

Les modèles de langage (LLMs) agents sont de plus en plus déployés dans des tâches de cybersécurité (découverte de vulnérabilités, génération d'exploits, tests d'intrusion automatisés). Cependant, les méthodes d'évaluation actuelles reposent sur des benchmarks de type "Capture The Flag" (CTF) existants (comme Cybench ou Intercode).

Les limites de l'état de l'art :

Évaluation ponctuelle : Les benchmarks actuels traitent chaque défi comme une tâche indépendante. Cela ne permet pas de mesurer la robustesse du modèle face à des perturbations d'entrée ni sa capacité de généralisation.
Contamination des données : Les défis proviennent souvent de compétitions publiques, ce qui risque que les LLMs aient déjà vu ces problèmes lors de leur entraînement, faussant les résultats.
Manque de profondeur : Une réussite sur un défi spécifique ne prouve pas que l'agent comprend la logique sous-jacente ; il pourrait simplement reconnaître des motifs de surface (noms de variables familiers, structure de code connue).

L'objectif est donc de développer une méthode pour évaluer si un agent LLM possède une véritable capacité de raisonnement sur le code et d'utilisation d'outils, indépendamment de la surface syntaxique du problème.

2. Méthodologie : CTF Families et Evolve-CTF

Les auteurs proposent une approche complémentaire basée sur les familles de défis CTF. Au lieu de défis indépendants, ils génèrent une famille de défis sémantiquement équivalents à partir d'un défi original.

L'outil : Evolve-CTF

Les auteurs ont développé un outil nommé Evolve-CTF qui prend un défi CTF en Python et génère automatiquement une famille de variantes en appliquant des transformations préservant la sémantique. Cela signifie que la stratégie d'exploitation (le "flag") reste identique, mais la structure du code change radicalement.

Les transformations supportées :

$R$ (Renommage) : Remplace les identifiants (variables, fonctions, classes) par des noms aléatoires (vocabulaire de codage ou chaînes multilingues).
$T1$ (Insertion de boucles) : Ajoute des boucles imbriquées redondantes dont les conditions sont fausses (non exécutables), mais dont la structure est complexe.
$T2$ (Insertion de conditionnels) : Ajoute des blocs if ou try-except redondants avec des conditions fausses.
$T3$ (Insertion de fonctions) : Ajoute des définitions de fonctions ou lambda redondantes.
$T4$ (Ajout de commentaires) : Insère des commentaires synthétiques, soit pertinents, soit du "bruit" multilingue sans signification.
$T5$ (Combinaison) : Applique séquentiellement $T1$ à $T4$ .
$O$ (Obfuscation) : Applique l'outil tiers PyObfuscator (renommage, suppression de docstrings, chiffrement des chaînes, compression gzip).

Structure de l'évaluation :
À partir d'un défi original, une structure arborescente est générée (voir Figure 2 du papier), permettant une analyse compositionnelle. Par exemple, on peut comparer l'impact du renommage seul ( $R$ ) par rapport au renommage suivi d'une obfuscation ( $R;O$ ).

Protocole expérimental :

Données : 16 défis Python issus de Cybench et Intercode.
Modèles : 13 configurations de LLMs (9 modèles de base : DeepSeek, MiniMax, Claude, Gemini, GPT, Qwen, Kimi, Grok, Mistral), incluant des variantes avec "raisonnement explicite" (ex: GPT-R).
Cadre : Utilisation du framework Inspect pour l'évaluation d'agents, permettant l'accès à des outils (bash, python, soumission de flag).
Mesure : 5 répétitions par instance, limite de 200 000 tokens par exécution.

3. Résultats Clés

L'étude a évalué la robustesse des modèles face aux différentes transformations.

A. Robustesse aux transformations simples

Renommage et commentaires : Les modèles sont extrêmement robustes au renommage des identifiants ( $R$ ) et à l'ajout de commentaires trompeurs ( $T4$ ). La performance reste quasi inchangée par rapport au défi original.
Insertion de code isolé : L'ajout d'une seule classe de code redondant (une seule boucle ou fonction) n'a que peu d'impact.

B. Dégradation par transformations composées et obfuscation

Effet de composition ( $T5$ ) : La combinaison de plusieurs transformations (boucles + conditionnels + fonctions + commentaires) dégrade significativement les performances, même sans obfuscation externe. Cela force les modèles à utiliser des outils de manière plus sophistiquée.
Obfuscation ( $O$ ) : L'utilisation de PyObfuscator réduit drastiquement le taux de réussite (souvent < 10-20%). Les modèles peinent à analyser le code compressé et chiffré.
Classes de défis : Les défis de type "Exec" (exécuter un script fourni) sont triviaux pour tous les modèles, quelle que soit la transformation, car ils ne nécessitent pas d'analyse de code complexe. Cela suggère que certains benchmarks actuels manquent de pouvoir discriminant.

C. Stratégies et utilisation des outils

Augmentation des appels d'outils : Face aux défis complexes ( $T5$ et $O$ ), le nombre d'appels d'outils (notamment grep, sed, python3 pour écrire des scripts de déobfuscation) double ou triple.
Analyse des logs : Pour les défis obfusqués, les modèles tentent souvent d'écrire des scripts Python pour décompresser le code (gzip) ou inverser l'obfuscation. Les échecs sont souvent dus à l'épuisement du budget de tokens avant la réussite, plutôt qu'à une erreur logique pure.
Impact du raisonnement explicite : L'activation de modes de "raisonnement" (Chain of Thought) a un impact négligeable, voire légèrement négatif, sur la capacité à résoudre ces familles de défis. Cela contredit l'idée que plus de raisonnement aide toujours face à l'information distrayante.

D. Classement des modèles

Gemini 3 Pro se distingue comme le modèle le plus performant.
Les modèles de plus petite taille (ex: MiniMax) peuvent être compétitifs avec des modèles beaucoup plus grands sur certaines tâches.
La plupart des modèles montrent des performances similaires sur les transformations simples, mais divergent fortement sur les transformations obfusquées.

4. Contributions Principales

Concept de "CTF Families" : Introduction d'une nouvelle méthodologie d'évaluation basée sur des familles de défis sémantiquement équivalents mais syntaxiquement variés, permettant de tester la généralisation et la robustesse.
Outil Evolve-CTF : Un outil open-source capable de générer automatiquement ces familles pour des défis Python, validant la solvabilité via des solutions "golden".
Dataset et Évaluation à grande échelle : Une évaluation de 13 configurations de LLMs sur 16 familles de défis (soit 24 instances par famille), fournissant un ensemble de données massif caractérisant les capacités actuelles des modèles.
Insights sur les benchmarks existants : Démonstration que certains défis de benchmarks populaires (notamment ceux de la catégorie "Exec" dans Intercode) sont trop simples et manquent de pouvoir discriminant pour évaluer les agents de pointe.

5. Signification et Implications

Ce travail marque un tournant dans l'évaluation des LLMs pour la cybersécurité :

Au-delà du "par cœur" : Il permet de distinguer les modèles qui comprennent réellement le code de ceux qui mémorisent des motifs ou des noms de variables.
Réalisme des tests : En simulant des environnements de code obfusqués ou modifiés (comme on peut le rencontrer en production ou lors d'analyses de malware), l'évaluation devient plus proche de la réalité opérationnelle.
Guide pour les développeurs : Les résultats indiquent que les modèles actuels sont fragiles face à l'obfuscation agressive et aux transformations composées, soulignant la nécessité d'améliorer les stratégies d'utilisation d'outils et de déobfuscation.
Métamorphisme : L'approche s'inscrit dans le cadre du "metamorphic testing" appliqué aux LLMs, une technique prometteuse pour tester la robustesse des systèmes d'IA au-delà des benchmarks statiques.

En conclusion, l'article propose un cadre rigoureux pour passer d'une évaluation "ponctuelle" à une évaluation "structurelle" des capacités des agents LLMs en cybersécurité, révélant que si les modèles sont robustes aux changements superficiels, ils restent vulnérables à la complexité structurelle et à l'obfuscation.