💻 computer science

unix-ctf: Procedural Environments for Unix-Competence Reinforcement Learning

Cet article présente **unix-ctf**, un environnement procédural générant 656 tâches distinctes de type capture-the-flag basées sur le shell pour isoler et former la compétence Unix, démontrant que le fine-tuning d'un modèle linguistique sur cette surface améliore considérablement sa capacité à utiliser les primitives du système d'exploitation indépendamment des compétences générales en programmation.

Auteurs originaux : Geoffrey Bradway, Roger Creus Castanyer, Lorenz Wolf, Maxwill Lin, Matthew James Sargent, Augustine N. Mavor-Parker

Publié 2026-05-29

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Geoffrey Bradway, Roger Creus Castanyer, Lorenz Wolf, Maxwill Lin, Matthew James Sargent, Augustine N. Mavor-Parker

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

La Grande Idée : Deux Compétences Différentes

Imaginez que vous enseignez à un robot à travailler dans un bureau animé. Deux compétences très différentes sont impliquées :

La Compétence « Programmeur » : Le robot doit rédiger un rapport complexe, résoudre un problème de mathématiques ou construire une petite machine. Il peut le faire en utilisant un langage standard (comme Python) et n'utilise le terminal du bureau que comme une simple machine à écrire pour taper le code.
La Compétence « Concierge/Gestionnaire » (Compétence Unix) : Le robot doit savoir où se trouvent les clés cachées, comment ouvrir un type spécifique de tiroir verrouillé, ou comment lire un message secret écrit à l'encre invisible sur une armoire à dossiers. Cela nécessite de connaître les règles spécifiques du bâtiment lui-même, et pas seulement comment rédiger un rapport.

Le Problème : Les tests actuels pour les robots IA mélangent ces deux compétences. Un robot qui est un génie de la programmation mais qui ne connaît rien aux règles secrètes du bâtiment peut quand même réussir le test. Les auteurs soutiennent que nous avons besoin d'un moyen de tester uniquement la compétence « Concierge/Gestionnaire » — la capacité d'utiliser les outils natifs du système d'exploitation pour trouver des choses qui ne sont pas évidentes.

La Solution : Un Générateur de « Chasse au Trésor »

Les auteurs ont construit un système appelé unix-ctf. Imaginez cela comme une usine automatisée qui crée des Chasses au Trésor pour les robots IA.

L'Objectif : Cacher un jeton secret (un « drapeau » comme flag{abc123}) à l'intérieur d'une pièce numérique (un conteneur Linux).
La Surprise : Le drapeau n'est pas simplement dans un fichier texte. Il est caché en utilisant une fonctionnalité spécifique et astucieuse du système d'exploitation de l'ordinateur.
- Exemple : Cacher le drapeau dans les « attributs étendus » d'un fichier (comme une note secrète collée au dos d'une photo que vous ne pouvez pas voir à moins de savoir exactement comment chercher).
- Exemple : Cacher le drapeau dans les métadonnées d'un fichier musical ou dans une partie spécifique du code d'un programme.
Le Travail du Robot : Le robot doit explorer la pièce, comprendre quelle astuce a été utilisée, et utiliser la commande correcte pour trouver le drapeau.

Comment Ils L'Ont Construit (L'Usine)

Créer ces énigmes manuellement est difficile. Les auteurs ont utilisé un pipeline intelligent pour les construire automatiquement :

L'Architecte (LLM) : Ils ont demandé à une IA puissante de trouver des idées pour cacher le drapeau (par exemple : « Cache-le dans un fichier créé avant l'année 1970 »).
L'Inspecteur (Vérifications Mécaniques) : Avant d'enregistrer l'énigme, un inspecteur robot vérifie deux choses :
- La Règle « Pas de Triche » : Le drapeau est-il si bien caché qu'une recherche simple ne le trouvera pas ?
- La Règle « Récupération » : Si vous commencez avec une pièce neuve, le script de récupération peut-il réellement trouver le drapeau ?
Le Résultat : Ils ont commencé avec 750 idées. Parce que leur « Inspecteur » était si strict, 656 d'entre elles ont réussi. C'est un taux de réussite de 87,5 %.
- Comparaison : Lorsqu'ils ont essayé de copier un projet similaire d'autres chercheurs, seuls 17,5 % des énigmes fonctionnaient. La méthode des auteurs est bien meilleure pour créer des énigmes fiables.

Ils se sont retrouvés avec 155 types uniques d'astuces (comme se cacher dans les noms de fichiers, les journaux système cachés ou des sections de code spéciales).

Entraînement du Robot

Les auteurs ont pris un modèle IA standard (Qwen3-8B) et l'ont entraîné en utilisant ces chasses au trésor.

L'Entraînement : Ils n'ont pas simplement montré la réponse au robot. Ils ont laissé le robot essayer, échouer et apprendre des retours d'information (Apprentissage par Renforcement).
Le Résultat :
- Avant l'entraînement, le robot résolvait environ 11,6 % des nouvelles énigmes.
- Après l'entraînement, il en résolvait 43,6 %.
- Cela prouve que le robot a réellement appris les compétences spécifiques « Unix », et non pas simplement mémorisé des réponses.

Est-ce que Cela Aide avec D'Autres Tests ?

Les auteurs ont testé si l'apprentissage de ces chasses au trésor aidait le robot sur d'autres tests existants (comme InterCode-CTF, qui est un test standard pour les compétences en sécurité).

La Surprise : Le robot ne s'est pas amélioré sur tout. Il ne s'est pas amélioré pour écrire du code.
Le Gain : Il s'est beaucoup amélioré sur les tâches spécifiques nécessitant une « compétence Unix » (comme la criminalistique numérique).
- Dans la catégorie « Criminalistique » (trouver des indices cachés), le taux de réussite a bondi de 33 points de pourcentage.
- Cela confirme que l'entraînement a appris au robot à devenir un meilleur détective numérique, spécifiquement pour trouver des choses cachées dans un système informatique.

Résumé

Ce papier introduit une nouvelle façon d'entraîner l'IA à mieux utiliser directement les systèmes d'exploitation informatiques. Au lieu d'enseigner simplement à l'IA à écrire du code à travers un terminal, ils ont construit une « salle de sport » spécialisée de puzzles de recherche d'objets cachés. Ils ont prouvé que :

On peut générer automatiquement des énigmes de haute qualité et astucieuses.
L'IA peut apprendre ces compétences spécifiques de « détective de système d'exploitation ».
Cet entraînement rend l'IA nettement meilleure pour trouver des données cachées, une compétence que les méthodes d'entraînement précédentes manquaient souvent.

Ce qu'ils n'ont pas affirmé : Ils n'ont pas affirmé que cela rend l'IA un meilleur programmeur général, ni qu'ils résolvent des attaques de piratage réelles ou des problèmes médicaux. Ils se sont strictement concentrés sur la mesure et l'amélioration de la capacité de l'IA à naviguer et à trouver des choses au sein d'un système informatique Unix.

Résumé technique : unix-ctf

Énoncé du problème
Les benchmarks actuels de terminal pour évaluer les agents de modèles de langage (LM) confondent deux capacités distinctes : la programmation générale effectuée via un terminal et la compétence Unix authentique. Les auteurs soutiennent que les benchmarks existants (par exemple, Terminal-Bench 2.0, InterCode, Cybench) sont fortement biaisés vers la « programmation dans un terminal », où un résolveur fluent en Python mais faible dans les internals du système d'exploitation peut réussir en écrivant des scripts qui encapsulent des outils standards. À l'inverse, la « compétence Unix » est définie comme la capacité à utiliser des primitives du système d'exploitation, du shell ou des formats de fichiers qui n'ont pas d'analogue propre dans la programmation à usage général (par exemple, accéder aux attributs étendus POSIX, analyser des sections de notes ELF, ou interpréter des horodatages de modification de fichiers antérieurs à l'époque Unix). L'article postule que cette distinction est actuellement obscurcie, conduisant à des pipelines d'entraînement qui améliorent la compétence en programmation sans nécessairement renforcer la maîtrise de Unix.

Méthodologie
Pour isoler et entraîner la compétence Unix, les auteurs ont développé unix-ctf, un générateur procédural d'environnements pour des tâches de capture de drapeau (CTF). Le système fonctionne via un pipeline multi-étapes :

Pipeline de récolte : Le système génère des tâches en alternant entre l'exploration par des modèles de pointe (en utilisant Claude Opus pour cacher les drapeaux) et une vérification mécanique.
- Contrat bidirectionnel : Pour garantir la validité des tâches, le pipeline impose un contrat strict : le script de « plantation » ne doit laisser aucune trace en clair du drapeau sur le disque, et le script de « récupération » doit récupérer le drapeau avec succès dans un répertoire vierge.
- Facturation du pipeline : Contrairement aux approches antérieures (par exemple, Endless Terminals) qui demandent aux LM de générer des conteneurs Docker entiers, unix-ctf sépare l'infrastructure. Une image ctf-base pré-déboguée gère la couche système, tandis que le LM est restreint à la génération de scripts plant.sh et recovery.sh paramétrables. Ce choix architectural augmente considérablement le rendement de variantes portables et réutilisables.
- Canonisation : Les scripts générés subissent une déduplication (utilisant difflib.SequenceMatcher avec un seuil de similarité de 0,85) pour produire une bibliothèque canonique de techniques.
Génération d'environnement :
- Le générateur instancie des conteneurs Docker frais basés sur la bibliothèque canonique.
- Stratégie multi-drapeaux : Pour pallier les signaux de récompense épars dans l'apprentissage par renforcement (RL), chaque conteneur est initialisé avec huit drapeaux distincts utilisant différentes techniques, plutôt qu'un seul résultat binaire.
- Ordonnancement de pool persistant : Un pool de 50 techniques est maintenu pendant l'entraînement. Après chaque lot, les 15 meilleures techniques (selon le taux de résolution) sont retirées pour garantir que l'agent rencontre une distribution large de compétences, évitant ainsi le surapprentissage à des familles spécifiques.
Protocole d'entraînement :
- Les auteurs ont affiné Qwen3-8B en utilisant l'optimisation de politique relative par groupe (GRPO) avec des adaptateurs LoRA.
- Deux stratégies d'initialisation ont été testées : GRPO direct à partir du modèle de base et GRPO à partir d'un modèle ayant subi un bref passage d'affinement supervisé (SFT) sur des trajectoires de résolveurs réussis pour aligner les formats d'appels d'outils.
- L'entraînement a impliqué 40 lots, en faisant tourner le pool de techniques pour exposer le modèle à des fonctionnalités Unix diverses (métadonnées de fichiers, formats binaires, IPC, cryptographie, etc.).

Contributions clés

Générateur procédural à haut rendement : Le pipeline atteint un taux de portabilité de 87,5 % (656 variantes valides sur 750 tentatives brutes), soit une amélioration de cinq fois par rapport à une reproduction de l'approche Endless Terminals (17,5 %). Cela est attribué à la séparation de l'infrastructure par rapport à la logique et au contrat bidirectionnel.
Bibliothèque de techniques canoniques : Le processus produit une bibliothèque de 155 identifiants de techniques distincts couvrant 16 familles (par exemple, métadonnées du système de fichiers, internals ELF, extensions X.509, contrôle des processus). Ces techniques ciblent spécifiquement des fonctionnalités du système d'exploitation sans analogue direct en Python.
Démonstration de séparabilité et d'entraînabilité : L'article fournit des preuves empiriques que la compétence Unix est une compétence séparable qui peut être entraînée indépendamment de la programmation générale. L'affinage sur la surface unix-ctf a considérablement amélioré les performances sur des tâches de rétention et redistribué les capacités du modèle sur des benchmarks externes.

Résultats

Performance sur rétention : Sur un ensemble de rétention multi-familles de 15 compétences ( $n=225$ ), le taux de résolution est passé de 11,6 % (Qwen3-8B de base) à 43,6 % (GRPO avec initialisation SFT), représentant une amélioration de 3,8 fois.
Transfert vers InterCode-CTF : L'entraînement sur unix-ctf a redistribué les performances du modèle sur le benchmark InterCode-CTF externe (100 tâches). Bien que le score agrégé soit resté stable, la catégorie Forensics a enregistré un gain de 33 points de pourcentage (passant de 7 % à 40 % avec GRPO initialisé par base), et l'ingénierie inverse s'est également améliorée. Cela suggère que la surface d'entraînement améliore spécifiquement les compétences pertinentes pour l'analyse forensique et les internals du système d'exploitation.
Efficacité : La variante initialisée par SFT a utilisé le budget de 18 tours plus efficacement (12,7 tours moyens contre 17,2 pour la base), indiquant une meilleure reconnaissance des tâches.
Divergence récompense vs transfert : Les auteurs ont observé une divergence où la variante initialisée par SFT a obtenu des récompenses d'entraînement plus élevées mais un transfert inférieur vers InterCode-CTF par rapport à la variante initialisée par base, mettant en garde contre l'utilisation de la récompense d'entraînement comme seul proxy des capacités en aval.

Signification et affirmations
L'article affirme que la compétence Unix est séparable, entraînable et mieux évaluée directement plutôt que d'être intégrée dans des tâches générales de programmation via un shell. En isolant la composante « Unix » de l'interaction terminale, les auteurs démontrent que la génération procédurale peut cibler efficacement des fonctionnalités du système d'exploitation sous-représentées (comme les métadonnées de fichiers et les formats binaires) que les benchmarks actuels manquent. Le travail suggère que les pipelines d'entraînement devraient cibler explicitement ces primitives spécifiques du système d'exploitation pour améliorer les performances des agents dans des contextes de sécurité et d'administration système, plutôt que de s'appuyer sur des benchmarks de terminal généraux qui pourraient principalement mesurer la fluidité en programmation.

Les auteurs restent modestes quant à la portée, notant que la bibliothèque repose sur des LM pour la génération (risquant de manquer des techniques sous-représentées) et est actuellement limitée à des tâches de style CTF, qui ne couvrent pas toute l'étendue de l'administration Unix. Ils publient les détails méthodologiques pour la reproduction mais retiennent la bibliothèque complète d'artefacts pour éviter d'abaisser les barrières à la formation en sécurité offensive.