tadata
← Retour à l'accueil

Le décompilateur qui compile n'est pas le décompilateur qui a raison

#security#artificial-intelligence#llm#machine-learning#testing

Trois résultats de 2026 fixent ce qu'un décompilateur LLM peut prétendre. Deux sont de bonnes nouvelles : le raffinement guidé par retour transforme désormais le pseudo-C de Ghidra en source qui recompile et se ré-exécute la plupart du temps, pour quelques centimes par binaire. Le troisième est l'avertissement à imprimer sur chaque outil : du code qui recompile et passe tous les tests livrés diverge encore de l'original sur d'autres entrées dans environ un cas sur vingt, et parfois ce qui a disparu est précisément la vulnérabilité cherchée. Ce billet lit les quatre articles ensemble et se termine par une règle sur la confiance à accorder.

Les chiffres d'un coup d'œil

tadata
Recompile (CHISEL) 96,1 % 120 fonctions ExeBench,Gemma4 31B 2,1 itérations Se ré-exécute (CHISEL) 79,8 % +26 % des premières erreurs récupérées Se ré-exécute (MCGD,GPT-4o) 84,1 % contre 80,3 % LLM4Decompile Passe les tests, divergequand même 4,9 % jusqu'à 13 % pour un système Exactitude si l'on nevérifie que lacompilation 0 % malgré 91 à 99 % de compilation Coût par binaire (MCGD) 0,03 à 0,05 USD 90 % terminés en 2 itérations Ce que les articles de 2026 sur la décompilation ont mesuré
Recompile (CHISEL) 96,1 % 120 fonctions ExeBench,Gemma4 31B 2,1 itérations Se ré-exécute (CHISEL) 79,8 % +26 % des premières erreurs récupérées Se ré-exécute (MCGD,GPT-4o) 84,1 % contre 80,3 % LLM4Decompile Passe les tests, divergequand même 4,9 % jusqu'à 13 % pour un système Exactitude si l'on nevérifie que lacompilation 0 % malgré 91 à 99 % de compilation Coût par binaire (MCGD) 0,03 à 0,05 USD 90 % terminés en 2 itérations Ce que les articles de 2026 sur la décompilation ont mesuré

Le raffinement fonctionne : trois systèmes, une boucle

AutoDecompiler (arXiv 2606.16162, révisé le 3 octobre) est un LLM entraîné par apprentissage par renforcement à traiter la décompilation comme un raffinement itératif plutôt qu'une génération en un coup : il révise son code avec les retours de compilation, d'exécution et de tests entrées/sorties, avec des récompenses pour la validité, la recompilabilité, la cohérence d'exécution et la fidélité sémantique, plus des diagnostics par étape et des avantages pondérés par tour pour que les révisions tardives ne défassent pas les gains acquis. Le résumé revendique des gains constants sur les variantes à un seul tour, à taille égale, sans publier les chiffres.

MCGD (Multi-level Constraint-Guided Decompilation, arXiv 2604.23940) vérifie les candidats à trois niveaux, syntaxe, compilation GCC et équivalence comportementale par des tests générés par LLM, et renvoie les échecs à des agents spécialisés avec un retour d'erreur structuré. Sur 1 641 binaires réels d'ExeBench, à travers RetDec, Ghidra et angr, la ré-exécutabilité atteint 84 à 97 %, soit 28 à 89 points au-dessus des décompilateurs bruts.

CHISEL (arXiv 2608.27981, accepté à ACM CCS SURE 2026) fait de même sans aucune suite de tests : retour du compilateur pour l'analyse statique, fuzzer guidé par la couverture pour l'analyse différentielle, 120 fonctions de O0 à O3, strippées ou non, avec un Gemma4 31B à poids ouverts. Le prix de l'absence de tests est un oracle qui accepte à tort 9,4 % des candidats.

tadata
La boucle de raffinement que tous les systèmes de 2026 exécutent Source candidate Verdict ducompilateur Preuved'exécution Retour structuré Révision + + + + + R converge en deux tours environ
La boucle de raffinement que tous les systèmes de 2026 exécutent Source candidate Verdict ducompilateur Preuved'exécution Retour structuré Révision + + + + + R converge en deux tours environ

L'ablation de MCGD est la phrase à retenir : les approches qui ne vérifient que la compilation atteignent 0 % d'exactitude comportementale malgré 91 à 99 % de compilation. Un décompilateur jugé sur « est-ce que ça compile » n'est jugé sur rien.

tadata
60 % 65 % 70 % 75 % 80 % 85 % MCGD (contraintes, multi-agents) MCGD (contraintes, multi-agents) fonctions ré-exécutables: 84.1 % 84.1 % LLM4Decompile LLM4Decompile fonctions ré-exécutables: 80.3 % 80.3 % CHISEL (sans tests, Gemma4 31B) CHISEL (sans tests, Gemma4 31B) fonctions ré-exécutables: 79.8 % 79.8 % SK2Decompile SK2Decompile fonctions ré-exécutables: 73.9 % 73.9 % SALT4Decompile SALT4Decompile fonctions ré-exécutables: 61.8 % 61.8 % part des fonctions qui se ré-exécutent correctement Ré-exécutabilité sur ExeBench, modèle GPT-4o
60 % 65 % 70 % 75 % 80 % 85 % MCGD (contraintes, multi-agents) MCGD (contraintes, multi-agents) fonctions ré-exécutables: 84.1 % 84.1 % LLM4Decompile LLM4Decompile fonctions ré-exécutables: 80.3 % 80.3 % CHISEL (sans tests, Gemma4 31B) CHISEL (sans tests, Gemma4 31B) fonctions ré-exécutables: 79.8 % 79.8 % SK2Decompile SK2Decompile fonctions ré-exécutables: 73.9 % 73.9 % SALT4Decompile SALT4Decompile fonctions ré-exécutables: 61.8 % 61.8 % part des fonctions qui se ré-exécutent correctement Ré-exécutabilité sur ExeBench, modèle GPT-4o

Préserver moins : le résultat de Decompile-Diverge

Liu, Raff et Micinski (arXiv 2609.05370, 4 septembre) posent une autre question : quand la fonction recompilée passe tous les tests livrés, se comporte-t-elle comme l'original sur les entrées que les tests ne couvrent pas ? Leur outil, Decompile-Diverge, génère un pilote, fait croître un corpus de fuzzing à partir du binaire de référence et compare les comportements sur les mêmes entrées. Sur huit systèmes en neuf configurations, 4,9 % des fonctions qui passaient ont divergé, jusqu'à 13 % pour un système. Sur 300 fonctions réelles de bibliothèques GitHub, le raffinement LLM le plus fort fait passer le taux de compilation de Ghidra de 75 à 90 % tandis que le taux de comportement conforme tombe de 74 à 62 %.

tadata
Ghidra seul Avec raffinement LLM Compile 75 % 90 % Compile Comportement conforme 74 % 62 % Comportement conforme Sortie Ghidra avec le raffinement LLM le plus fort, 300 fonctions GitHub
Ghidra seul Avec raffinement LLM Compile 75 % 90 % Compile Comportement conforme 74 % 62 % Comportement conforme Sortie Ghidra avec le raffinement LLM le plus fort, 300 fonctions GitHub

Pire, sur 287 fonctions liées à des CVE, jusqu'à un dixième des sorties montrent ce que les auteurs appellent l'absence de crash : une vulnérabilité publiée qui ne se déclenche plus, sans trace visible d'une suppression. La cause est mécanique. Un décompilateur classique laisse des inconnues visibles : undefined4, FUN_00401a30, une arithmétique de pointeur brute. Un modèle de langage les remplace par des champs, des types, des appels et des gardes plausibles, et la garde qu'il ajoute est exactement le contrôle de bornes qui manquait à l'original.

tadata
Ce que le raffinement change dans le texte Pseudo-C Ghidra ✗ undefined4 local_18 ✗ FUN_00401a30(param_1) ✗ *(int *)(param_1 + 8) ✗ aucun contrôle de bornes (le bug) Source raffinée par LLM ✓ size_t count ✓ parse_header(ctx) ✓ ctx->length ✓ if (len > cap) return -1; (le bug adisparu) des suppositionsplausibles remplacentles inconnuesvisibles
Ce que le raffinement change dans le texte Pseudo-C Ghidra ✗ undefined4 local_18 ✗ FUN_00401a30(param_1) ✗ *(int *)(param_1 + 8) ✗ aucun contrôle de bornes (le bug) Source raffinée par LLM ✓ size_t count ✓ parse_header(ctx) ✓ ctx->length ✓ if (len > cap) return -1; (le bug adisparu) des suppositionsplausibles remplacentles inconnuesvisibles

Une règle pour faire confiance à la sortie

Les quatre articles s'accordent sur la barrière, même si aucun ne l'énonce comme une politique : compiler est nécessaire, les tests livrés ne suffisent pas, le fuzzing différentiel contre le binaire de référence est la seule preuve d'équivalence, et en sécurité l'absence de crash est un signal à instruire, pas un succès. Tout l'arbre ci-dessous doit tenir avant d'appeler « source » le texte raffiné ; un candidat qui échoue à la branche fuzzing sert au tri et à rien qui finisse en patch ou en exploit.

tadata
Recompile nécessaire, pas suffisant Passe les tests livrés 4,9 % divergent quand même Decompile-Diverge pilote + corpus de fuzzing depuis le binaire de référence Fuzzer guidé parla couverture deCHISEL 9,4 % de faux accepts Conforme à laréférencesous fuzzingdifférentiel Aucun crash disparusur les CVE connues jusqu'à 10 % le perdent Utiliser la sourcedécompilée commesource OR AND AND: every child needed OR: any child suffices Leaf values: preuve highlighted path Quand une source décompilée par LLM mérite confiance
Recompile nécessaire, pas suffisant Passe les tests livrés 4,9 % divergent quand même Decompile-Diverge pilote + corpus de fuzzing depuis le binaire de référence Fuzzer guidé parla couverture deCHISEL 9,4 % de faux accepts Conforme à laréférencesous fuzzingdifférentiel Aucun crash disparusur les CVE connues jusqu'à 10 % le perdent Utiliser la sourcedécompilée commesource OR AND AND: every child needed OR: any child suffices Leaf values: preuve highlighted path Quand une source décompilée par LLM mérite confiance

Pour une équipe de recherche de vulnérabilités, la conséquence est simple : raffiner avec la boucle, juger avec le fuzzer, et garder la sortie brute du décompilateur à côté de la version raffinée. La belle version sert à lire ; la laide sert à dire vrai.

Nous utilisons des cookies analytiques pour améliorer votre expérience. Aucune donnée personnelle n'est collectée.