Beyond Text Matching: Towards Reference-Free Evaluation for Human-Oriented Binary Reverse Engineering

Imaginez que vous essayez de lire un message secret écrit dans une langue qui a été brouillée, dépouillée de sa ponctuation et dont tous les noms des personnes impliquées ont été effacés. C'est ce qui arrive lorsque des experts en sécurité tentent de comprendre des programmes informatiques qui ont été compilés en « binaire » — les instructions brutes, lisibles par la machine, qui font fonctionner votre téléphone ou votre ordinateur portable. Habitement, ces programmes sont accompagnés d'un manuel pratique appelé « code source », mais lorsque des pirates ou des auteurs de logiciels malveillants cachent leurs traces, ce manuel disparaît. Les experts doivent alors utiliser des outils spéciaux pour traduire le binaire brouillé en quelque chose qui ressemble à du code, mais le résultat ressemble souvent à un mélange confus et désordonné de chiffres et de noms génériques comme « sub_401B20 ». Pour donner du sens à tout cela, ils doivent le réécrire sous forme d'un récit compréhensible pour l'humain, un processus appelé « Ingénierie inverse du binaire orientée vers l'humain » (Human-Oriented Binary Reverse Engineering). Mais voici la partie délicate : comment savoir si le nouveau récit, une fois nettoyé, est réellement bon ? Vous ne pouvez pas simplement demander à un ordinateur de compter combien de mots correspondent à une réponse parfaite, car la réponse parfaite n'existe pas (le manuel original a disparu). Et demander à un expert humain de lire chaque ligne est trop lent, trop coûteux, et il finit par se fatiguer. Alors, la grande question est la suivante : peut-on enseigner à une IA super intelligente l'art de jouer le rôle de juge et de nous dire si la traduction est bonne, sans avoir besoin du manuel original pour comparer ?

Cet article explore précisément cette question, en examinant si les Grands Modèles de Langage (LLM) — le même type d'IA qui peut écrire des poèmes ou résoudre des problèmes mathématiques — peuvent servir de « arbitres » pour ces traductions de code désordonnées. Les chercheurs ont découvert que ces juges IA sont effectivement bien meilleurs pour comprendre le sens du code que les anciennes métriques informatiques, qui se contentent de chercher des mots correspondants. En fait, les juges IA sont d'accord avec les experts humains 63,20 % du temps, alors que les anciennes méthodes informatiques ne le sont que 35,04 % du temps. Cependant, l'article a également découvert un rebondissement surprenant : il n'existe pas de configuration d'IA unique et « optimale » qui fonctionne pour toutes les situations. Parfois, un modèle d'IA spécifique avec une manière particulière de poser les questions fonctionne à merveille pour nommer des fonctions, mais échoue lamentablement pour résumer du code. C'est comme essayer d'utiliser une seule paire de chaussures pour courir, nager et faire de la randonnée ; vous avez besoin de l'équipement adapté pour chaque tâche.

Pour résoudre ce problème, les auteurs ont construit un système ingénieux appelé « BinJudge ». Voyez cela comme un contrôleur de trafic intelligent qui examine chaque morceau de code spécifique et choisit instantanément le juge IA parfait ainsi que la meilleure façon de lui poser la question. Ce système ne se contente pas de choisir un seul « meilleur » juge pour tout le monde ; il s'adapte à la volée. En faisant cela, BinJudge a réussi à se rapprocher encore davantage des experts humains (améliorant l'accord jusqu'à 24,7 %) tout en économisant une quantité massive d'argent — ne coûtant qu'une infime fraction (entre 0,06 et 0,84 fois) de ce que coûterait l'utilisation de la configuration statique la plus coûteuse. L'article prouve que, bien que nous ne puissions pas simplement appuyer sur un bouton magique pour tout régler, nous pouvons construire un système intelligent et flexible qui rend l'évaluation de ces traductions de code complexes rapide, peu coûteuse et étonnamment précise.

Le Contexte : Décoder le message brouillé

Avant d'arriver au cœur du sujet, posons le décor avec quelques idées clés.

L'ingénierie inverse du binaire (Binary Reverse Engineering) est comparable à la tentative de reconstruire un gâteau après qu'il a été cuit, aplati et que son glaçage a été gratté. Vous avez le produit final (le fichier binaire), mais vous n'avez pas la recette (le code source). Les experts utilisent des outils pour inverser le processus, transformant le code machine en quelque chose qui ressemble à du code de programmation. Cependant, comme la « recette » originale a disparu, le résultat est souvent désordonné.

L'ingénierie inverse du binaire orientée vers l'humain (HOBRE) est l'étape suivante. C'est l'art de prendre ce code désordonné et semblable à celui d'une machine, et de le polir pour qu'un humain puisse réellement le lire. Cela consiste à donner des noms descriptifs et intéressants aux fonctions (au lieu de « sub_401B20 »), à rédiger des résumés clairs de ce que fait le code, et à corriger la structure pour qu'elle ressemble à un récit bien écrit.

Le Problème de l'Évaluation : Comment savoir si le « polissage » a fonctionné ?

• L'ancienne méthode (Correspondance de texte) : Imaginez noter la dissertation d'un élève en comptant combien de mots correspondent à la clé de correction de l'enseignant. Si l'élève dit « Le chat a couru vite » et que la clé dit « Le félin a sprinté rapidement », l'ancien système informatique dira : « Faux ! Zéro point ! » parce que les mots ne correspondent pas. Cela est néfaste pour le code car il existe de nombreuses façons de dire la même chose.
• La méthode humaine : Un expert humain lit le code et dit : « Oui, cela fait sens. » C'est la « référence absolue » (gold standard), mais c'est lent, coûteux et difficile à généraliser.
• La nouvelle idée (LLM-as-a-Judge / L'IA comme juge) : Et si nous demandions à une IA, qui a lu des millions de livres et d'extraits de code, de jouer le rôle du professeur ? Au lieu de simplement compter les mots, l'IA comprend le sens. Elle sait que « chat » et « félin » sont la même chose, et elle peut déterminer si un résumé explique réellement le code ou s'il se contente d'avoir l'air sophistiqué.

Le Parcours de l'Article : Tester les Juges IA

Les chercheurs, dirigés par Xiuwei Shang et son équipe, ont décidé de mettre cette idée de « Juge IA » à l'épreuve. Ils ne se sont pas contentés de deviner ; ils ont construit un terrain de jeu massif et de haute qualité appelé BinJudgeBench.

Construction du terrain de jeu :
Ils ont pris 51 projets logiciels réels, les ont compilés en code binaire, puis ont supprimé tous les noms et commentaires utiles. Ils ont ensuite demandé à 8 modèles d'IA différents d'essayer de réparer le code. Pour savoir qui avait bien travaillé, ils ont fait lire les résultats à trois experts humains (qui sont essentiellement des détectives du code) et leur ont demandé de noter sur une échelle de 1 à 5. Ils ont vérifié des éléments tels que :

• Est-ce que cela fait sens ? (Correctitude sémantique)
• Cela aide-t-il un humain à comprendre le code plus rapidement ? (Utilité)
• Est-ce écrit dans un style humain naturel ? (Idiomaticité)

Cela a créé un ensemble de données de référence avec plus de 1 200 exemples soigneusement notés.

La première découverte : Juges IA vs Anciennes Métriques
L'équipe a comparé les juges IA aux anciennes métriques de « comptage de mots ». Les résultats étaient clairs : les juges IA étaient bien meilleurs pour comprendre l'aspect humain des choses.

• Les juges IA étaient d'accord avec les experts humains 63,20 % du temps.
• Les anciennes métriques informatiques n'étaient d'accord que 35,04 % du temps.

Cela suggère que l'IA peut réellement « saisir » le sens du code, et non pas seulement l'orthographe. C'est la différence entre un robot qui compte le nombre de fois où vous dites « bonjour » et un ami qui comprend que vous saluez quelqu'un chaleureusement.

La deuxième découverte : Le mythe du « Taille unique »
C'est ici que cela devient intéressant. Les chercheurs ont testé différentes configurations pour les juges IA :

• Différents Modèles : Certaines IA sont énormes et coûteuses (comme GPT-4o), d'autres sont plus petites et moins chères.
• Différents Prompts (Instructions) : Certains demandaient simplement de donner un score (Zero-Shot), d'autres montraient des exemples de ce qu'est un « 5 » ou un « 1 » (Few-Shot), et d'autres demandaient d'expliquer leur raisonnement étape par étape (Chain-of-Thought).
• Différentes Températures : Cela contrôle à quel point l'IA est « créative » ou « aléatoire » lorsqu'elle répond.

Ils ont découvert qu'il n'existe pas de configuration unique et optimale.

• Pour certaines tâches, comme le résumé de code, montrer des exemples à l'IA (Few-Shot) fonctionnait le mieux.
• Pour d'autres tâches, comme le nommage de fonctions, demander à l'IA de réfléchir étape par étape (Chain-of-Thought) aidait les petits modèles à être plus performants.
• Parfois, un modèle énorme et coûteux était le meilleur ; d'autres fois, un modèle plus petit et moins cher était tout aussi efficace.

Cela signifie que vous ne pouvez pas simplement choisir une seule « meilleure » IA et l'utiliser pour tout. C'est comme essayer d'utiliser un marteau pour réparer une montre ; parfois, vous avez besoin d'un minuscule tournevis, et parfois d'un lourd marteau.

La Solution : BinJudge (Le contrôleur de trafic intelligent)
Puisqu'il n'existe pas de configuration unique idéale, l'équipe a construit BinJudge. C'est un système léger qui agit comme un routeur intelligent.

1. Il examine un morceau de code spécifique.
2. Il se demande : « Quel modèle d'IA et quel style de question fonctionneront le mieux pour ce morceau de code spécifique ? »
3. Il choisit cette combinaison spécifique et envoie le code à ce juge.

Les Résultats de BinJudge :

• Meilleure Précision : En choisissant le bon juge pour la tâche, BinJudge a amélioré l'accord avec les experts humains de 4,5 % à 24,7 % par rapport à l'utilisation d'une configuration statique unique.
• Moins Cher : Comme il choisit souvent des modèles plus petits et moins coûteux lorsqu'ils sont suffisants, il a réduit le coût à des niveaux compris entre 0,06x et 0,84x du coût de l'utilisation de la configuration la plus chère et la plus performante.

Ce que cela signifie

L'article conclut que nous n'avons pas besoin de dépendre d'experts humains coûteux pour chaque morceau de code, ni de nous contenter de métriques informatiques stupides qui ne font que compter les mots. Nous pouvons utiliser des juges IA, mais nous devons être intelligents. Nous ne pouvons pas simplement choisir une seule « meilleure » IA ; nous avons besoin d'un système qui s'adapte, choisissant le bon outil pour la bonne tâche.

Les auteurs précisent avec prudence que, bien que les juges IA soient excellents, ils ne sont pas parfaits. Ils peuvent parfois être confus si le code est trop vague ou si l'IA devient trop « fluide » mais se trompe. Mais globalement, ce travail suggère qu'avec le bon système adaptatif, nous pouvons évaluer les traductions de code de manière rapide, peu coûteuse et étonnamment proche de ce qu'un expert humain dirait. C'est un grand pas vers la rendre plus lisible pour tout le monde, ce monde sombre et désordonné du code binaire.