Semantic Reverse Engineering Legacy Software Applications with ChatGPT, Gemini AI, and Claude AI

Ce document de recherche présente des résultats sur l'utilisation de ChatGPT, Gemini et Claude AI pour rétro-ingénierie sémantique d'applications logicielles de bases de données héritées.

L'essentiel

Imaginez que vous possédiez une bibliothèque très ancienne et poussiéreuse de livres écrits dans une langue que plus personne ne parle. Vous n'avez pas le dictionnaire, et les auteurs sont depuis longtemps disparus. Votre objectif n'est pas seulement de copier les lettres sur la page (ce qui est facile) ; votre objectif est de comprendre l'histoire, la logique et les règles que l'auteur tentait de suivre.

Ce document traite d'une équipe de chercheurs tentant d'utiliser trois « robots super-intelligents » différents (ChatGPT, Gemini et Claude) pour lire ces vieux programmes informatiques et expliquer ce qu'ils font réellement.

Voici le détail de leur expérience, illustrée par des analogies simples :

La Mission : Décoder le « Fantôme » dans la Machine

Les chercheurs disposaient d'un ancien logiciel (appelé « code legacy ») qui agissait comme un videur dans une boîte de nuit. Ce videur avait des règles spécifiques :

1. La Règle Géographique : « Si une ville est la capitale d'un pays, elle doit appartenir à ce pays. »
2. La Règle Royale : « Deux rois ne peuvent pas régner sur le même pays en même temps, sauf s'ils sont mariés ou parent/enfant. »

Le problème ? Le code était écrit dans un ancien style (VBA) sans commentaires expliquant pourquoi il avait été écrit ainsi. Les chercheurs voulaient voir si l'IA pouvait examiner le code et dire : « Ah, je vois ! Ce code fait respecter la règle selon laquelle les capitales doivent correspondre aux pays. »

Les Trois Robots (Les Outils d'IA)

Les chercheurs ont testé trois « détectives » d'IA différents :

1. ChatGPT : Le Tuteur Réfléchi

• Fonctionnement : ChatGPT était comme un étudiant intelligent qui voulait vraiment bien faire. Lorsque les chercheurs lui ont donné la première règle simple, il l'a comprise parfaitement.
• L'Erreur : Lorsqu'ils lui ont donné la complexe « Règle Royale », ChatGPT a d'abord mal interprété l'histoire. Il pensait que le code rejetait un mariage, alors qu'en réalité, le code rejetait un changement à un mariage existant.
• Le Récupération : Lorsque les chercheurs l'ont corrigé, ChatGPT n'a pas seulement dit « D'accord ». Il a dit : « Oh ! Je vois mon erreur. Je regardais la mauvaise partie de la logique. Vous avez raison : il ne s'agit pas de l'état du mariage, mais de la transition consistant à changer les époux. » Il a appris de la correction et a expliqué pourquoi il s'était trompé.
• Verdict : Le meilleur pour comprendre le sens profond et admettre quand il s'est trompé.

2. Claude : Le Poète Élégant

• Fonctionnement : Claude était très poli et appréciait la beauté mathématique du code. Il a compris les règles simples immédiatement et a félicité les chercheurs pour leur logique ingénieuse.
• L'Erreur : Comme ChatGPT, il a également mal interprété la complexe « Règle Royale » au début. Il a fait une affirmation confuse selon laquelle « les règnes simultanés sont impossibles pour un couple marié », ce qui n'avait aucun sens.
• Le Récupération : Lorsqu'il a été corrigé, il a admis l'erreur et a finalement compris la logique. Cependant, il était très lent à communiquer (les chercheurs devaient attendre des heures entre les questions), rendant le processus semblable à une très lente et formelle séance de thé.
• Verdict : Très bon pour comprendre, mais lent et un peu rigide.

3. Gemini : L'Artiste Trop Enthousiaste

• Fonctionnement : Gemini était le plus dramatique. Au lieu de dire « Ce code vérifie si une ville appartient à un pays », il disait des choses comme : « C'est un capteur d'auto-guérison Bio-Logique détectant une Rupture Éthique ! » Il utilisait trop de métaphores (bactéries, calcaire, labyrinthes) et tentait de convaincre les chercheurs d'utiliser différents outils modernes au lieu d'analyser l'ancien code.
• L'Erreur : Il s'est trompé en mathématiques simples (appelant une fonction une « surjection » alors qu'il s'agissait d'une « injection ») et, lorsqu'il a été corrigé, il a fait semblant de comprendre tout en continuant à faire la même erreur.
• Verdict : Trop fleuri et verbeux. Il s'est perdu dans ses propres métaphores et n'a pas pu s'en tenir aux faits.

La Grande Découverte : L'« État » vs Le « Changement »

La leçon la plus importante de ce document est une différence subtile mais énorme en matière de logique :

• État : La situation actuelle est-elle valide ? (Par exemple : « Ce mariage est-il légal ? »)
• Transition : L'action de changer la situation est-elle valide ? (Par exemple : « Puis-je échanger le mari contre quelqu'un d'autre ? »)

Les chercheurs ont constaté que les outils d'IA étaient excellents pour repérer l'« État » (les règles simples). Mais lorsqu'il s'agissait des règles complexes de « Transition » (la Règle Royale), ils étaient tous confus. Ils pensaient que le code empêchait un mariage de se produire, alors qu'il empêchait en réalité un changement à un mariage.

La Conclusion Finale

Les chercheurs ont conclu que :

1. L'IA est une excellente assistante pour les petits puzzles : Si vous donnez à l'IA un tout petit morceau de code, elle peut l'expliquer très bien.
2. L'IA n'est pas encore un remplacement pour les experts : Si le code est un peu plus grand ou plus complexe, l'IA peut expliquer avec assurance l'exact contraire de ce que fait le code.
3. Les mathématiques comptent : Les chercheurs ont noté que les outils d'IA fonctionnaient mieux lorsque les humains qui les guidaient connaissaient leurs mathématiques (comme la théorie des ensembles et la logique). L'IA a besoin d'un humain qui parle « logique » pour la maintenir sur la bonne voie.

En résumé : Ces outils d'IA sont comme des stagiaires très brillants. Ils peuvent lire le manuel et expliquer les bases parfaitement, mais si vous leur donnez un scénario réel et délicat, ils pourraient vous raconter avec assurance la mauvaise histoire. Vous avez toujours besoin d'un ingénieur humain qualifié pour vérifier leur travail.

Résumé technique

Résumé technique : Ingénierie inverse sémantique d'applications logicielles héritées avec ChatGPT, Gemini AI et Claude AI

Énoncé du problème
L'ingénierie inverse (IR) logicielle traditionnelle est principalement syntaxique, se concentrant sur la récupération du code source ou des structures binaires sans nécessairement comprendre l'intention sous-jacente ou les « règles métier ». Bien que des outils existent pour la désobfuscation et la détection de logiciels malveillants, ils traitent rarement la couche sémantique requise pour inférer des définitions formelles de contraintes à partir de code hérité. Cette recherche aborde le défi de l'ingénierie inverse sémantique : prendre du code source hérité (spécifiquement du VBA MS Access imposant des contraintes de base de données non relationnelles) et en déduire sa définition formelle en utilisant la théorie des ensembles, les relations, les fonctions et la logique des prédicats du premier ordre, ainsi que l'exprimer avec précision en anglais courant. Les auteurs notent que, tandis que leurs travaux antérieurs portaient sur l'ingénierie inverse de schémas de bases de données vers le Modèle de Données Mathématique (Élémentaire) ((E)MDM), cette étude vise l'ingénierie inverse des applications elles-mêmes.

Méthodologie
L'étude a utilisé trois modèles de langage à grande échelle (LLM) : ChatGPT (Plus 5.3 et Mini), Gemini (3) et Claude (Sonnet 4.6). La configuration expérimentale comprenait :

• Matériel/Logiciel : Toshiba Satellite Intel CORE i7, MS Windows 10, MS Access 365 et MatBase v. 5.2 (un prototype de système de gestion de données intelligent basé sur le (E)MDM).
• Données d'entrée : Des extraits de code provenant de deux applications héritées : une base de données de géographie et une base de données de généalogie. Ces extraits imposaient des contraintes non relationnelles complexes (par exemple, « La capitale d'un pays doit être une ville appartenant à ce pays ») et des contraintes historiques concernant les mariages royaux et les règnes.
• Prétraitement : Les auteurs ont délibérément supprimé tous les commentaires du code VBA et retiré les instructions d'affichage des messages d'erreur (MsgBox) pour tester la capacité de l'IA à comprendre l'intention du code sans documentation explicite ni retour d'information lors de l'exécution.
• Processus : Les chercheurs ont engagé des dialogues itératifs avec les modèles d'IA. Ils ont fourni des extraits de code et demandé aux modèles de :
  1. Inférer la « règle métier ».
  2. Fournir des explications ligne par ligne.
  3. Formaliser la contrainte en utilisant la logique mathématique (théorie des ensembles, théorie des catégories, logique du premier ordre).
  4. Critiquer et affiner la formalisation sur la base des commentaires des auteurs (par exemple, corriger la distinction entre fonctions totales et partielles, ou entre contraintes d'état et contraintes de transition).

Résultats clés
Les performances des trois outils d'IA variaient considérablement selon la simplicité ou la complexité des extraits de code :

1. Contraintes simples (Application de géographie) :

   • ChatGPT : A correctement inféré la règle métier (« Une ville capitale doit rester dans son pays assigné ») et fourni des explications précises ligne par ligne. Il a correctement identifié la contrainte comme étant non relationnelle (au niveau de l'application) et a engagé un dialogue mathématique sophistiqué concernant la formalisation de la contrainte comme une « auto-application partielle nulle-réflexive ». Il a reconnu et corrigé ses premières hallucinations concernant les types de variables.
   • Claude : A correctement compris la règle métier et le caractère proactif de la contrainte (restreindre les choix plutôt que bloquer les mises à jour). Il a salué la formalisation algébrique des auteurs et a immédiatement saisi le concept de null-réflexivité.
   • Gemini : A correctement identifié la règle et fourni une formalisation en logique du premier ordre. Cependant, il a commis une erreur critique en déclarant la fonction « Capitale » une surjection plutôt qu'une injection, ne comprenant pas le caractère partiel de la fonction. Il a également montré une tendance à un langage verbeux et métaphorique (« Bio-Logique », « Topologie du Cringe ») plutôt qu'à une analyse technique précise.

2. Contraintes complexes (Application de généalogie - Mariages royaux) :

   • Le défi : Le code imposait une règle selon laquelle un couple marié ne pouvait pas être remplacé s'ils avaient régné sur le même pays simultanément, sauf s'ils étaient parent et enfant.
   • Échec initial : Les trois modèles (ChatGPT, Gemini et Claude) ont initialement mal interprété le code. Ils ont conclu à tort que le code rejetait le mariage lui-même, plutôt que de rejeter la transition (la modification/changement de conjoints) dans des conditions spécifiques.
   • Correction et divergence :
     • ChatGPT : Après correction, il a immédiatement reconnu l'erreur, distingué les « contraintes d'état » des « contraintes de transition » (intégrité dynamique) et généralisé la leçon. Il a correctement reformulé la règle comme une TransitionAutorisée plutôt que comme un ÉtatValide.
     • Gemini : A initialement semblé comprendre la correction mais est ensuite revenu à l'erreur initiale dans son raisonnement. Il a également tenté de pivoter la conversation vers la migration du code hérité vers Python/SQLite plutôt que d'analyser la logique existante.
     • Claude : A initialement commis la même erreur que les autres. Après un délai significatif (en raison des limites d'utilisation), il a reconnu la correction et a finalement compris correctement l'intention du code.

Importance et affirmations
L'article affirme que, si les outils d'IA sont hautement efficaces pour l'ingénierie inverse sémantique de petits extraits de code simples, ils éprouvent actuellement des difficultés avec du code hérité complexe et multi-instructions, inférant souvent l'exact opposé de la logique prévue.

• Comparaison des outils : Les auteurs concluent que pour l'ingénierie inverse sémantique, la hiérarchie des performances diffère de l'ingénierie directe. ChatGPT est identifié comme le plus capable pour cette tâche spécifique en raison de sa capacité à engager un dialogue mathématique itératif profond, à corriger ses propres erreurs et à comprendre la distinction entre contraintes d'état et contraintes de transition. Claude est noté comme excellent pour l'ingénierie directe mais moins efficace ici initialement, bien qu'il ait fini par saisir les concepts. Gemini est jugé « presque inutile » pour cette tâche lorsque la complexité du code dépasse environ 30 instructions, citant sa verbosité, son recours aux métaphores et son incapacité à maintenir la cohérence logique.
• Collaboration Humain-IA : La recherche souligne que l'IA ne peut pas encore remplacer les ingénieurs logiciels hautement qualifiés. Les auteurs soutiennent que le succès de l'ingénierie inverse sémantique dépend fortement de la capacité de l'ingénieur humain à guider l'IA, nécessitant spécifiquement une solide formation en mathématiques (niveau K-12 et au-delà) pour reconnaître lorsque la formalisation de l'IA est incorrecte (par exemple, confondre injections et surjections ou état et transition).
• Limites : L'étude s'est limitée aux versions gratuites des outils d'IA et au code hérité VBA. Les auteurs ne prétendent pas que les versions payantes ou d'autres langages produiraient des résultats fondamentalement différents, mais potentiellement des interactions plus rapides ou plus généreuses.

Conclusion
L'article postule que l'ingénierie inverse sémantique passe d'un « cauchemar » à une « promenade de santé » pour les cas simples, mais reste un défi complexe pour les systèmes hérités intricés. L'objectif ultime — révéler la structure algébrique et logique du code comportemental — nécessite une relation symbiotique où l'IA fournit une analyse rapide et l'expert humain apporte la rigueur mathématique nécessaire pour valider et affiner l'interprétation sémantique.