Avancées dans le désassemblage pour les logiciels obfusqués

La désassemblage, c'est le processus qui transforme le code machine (que les ordis comprennent) en langage assembleur (que les humains peuvent lire). C'est super important pour analyser comment le logiciel fonctionne, surtout quand on cherche des problèmes de sécurité. Mais certains logiciels compliquent tout ça en cachant le code avec des octets inutiles, ce qui fout le bazar dans le désassemblage. Même s'il y a des méthodes pour gérer ça, beaucoup de solutions ne sont pas assez efficaces. C'est là où les grands modèles de langage (LLMs) entrent en jeu.

#Le besoin de désassemblage

Le désassemblage est essentiel pour l'ingénierie inverse des Binaires (les versions compilées des programmes). Ça nous permet de comprendre ce que fait le programme et de repérer des problèmes comme des vulnérabilités ou du code malveillant. L'objectif principal du désassemblage est d'identifier avec précision les limites des instructions dans un fichier binaire. C'est pas évident parce que :

1. Mélange code et données : Parfois, le code et les données sont mélangés, ce qui rend difficile de savoir où l’un finit et où l’autre commence.
2. Instructions de longueur variable : Les différentes longueurs d’instructions peuvent créer de la confusion sur le début ou la fin d’une instruction.

Des erreurs dans l'identification de ces limites peuvent entraîner des problèmes majeurs, y compris une mauvaise interprétation de ce que le code est censé faire.

#Techniques d'Obfuscation

Pour freiner le désassemblage, les développeurs de logiciels peuvent utiliser des techniques d'obfuscation. Ces techniques incluent :

• Insertion d'octets inutiles : Ajouter des octets aléatoires dans le code pour embrouiller les désassembleurs.
• Prédicats opaques : Ce sont des conditions qu'un outil d'analyse ne peut pas facilement comprendre, entraînant des branches dans le code qui pourraient ne pas se produire lors de l'exécution.
• Aplatissement du flux de contrôle : Modifier la structure du code pour le rendre difficile à suivre logiquement.

Ces méthodes créent des défis importants pour quiconque essaie de faire de l'ingénierie inverse sur le logiciel.

#Approches actuelles de désassemblage

Les solutions de désassemblage existantes peuvent s'appuyer sur diverses méthodes comme l'exécution symbolique, l'heuristique ou l'Apprentissage automatique. Cependant, elles viennent souvent avec des limites :

• Exécution symbolique : C'est une méthode pour analyser les chemins et les valeurs des entrées à travers le code. Bien que ce soit complet, ça peut devenir trop complexe pour de gros binaires.
• Heuristique : Ce sont des règles empiriques qui peuvent fonctionner dans de nombreuses situations mais qui reposent souvent sur des motifs spécifiques qui peuvent ne pas tenir dans tous les cas.
• Apprentissage automatique : Les avancées récentes montrent du potentiel dans ce domaine, mais elles peuvent encore avoir du mal face à une obfuscation complexe.

Bien que ces techniques aient leurs forces, elles échouent souvent lorsqu'elles sont confrontées à une forte obfuscation.

#Notre approche : Combiner l'insight humain avec les LLMs

Pour relever les défis du désassemblage des exécutables obfusqués, nous proposons une nouvelle méthode qui combine les algorithmes de désassemblage traditionnels avec les LLMs. L'idée principale est de mimer comment un ingénieur inverse humain expérimenté travaillerait.

Les LLMs, entraînés sur une grande quantité de texte, peuvent bien comprendre le contexte et la structure du langage. Notre objectif est d'utiliser cette capacité pour identifier des instructions assembleur valides à partir du code machine décodé.

#La structure de notre système

Notre système se compose de deux composants principaux :

1. Classificateur de validité basé sur LLM : Ça détermine si une instruction désassemblée est valide ou pas.
2. Stratégie de désassemblage : C'est un plan qui utilise le classificateur de validité pour effectuer le désassemblage efficacement.

#Classificateur de validité

Pour entraîner le classificateur de validité, on a utilisé une approche d'entraînement spécifique. On a rassemblé des exemples d'instructions valides et invalides à partir de binaires compilés. Ça impliquait de désassembler des programmes avec nos techniques et de collecter des données sur leur structure.

Avec ces données, on a entraîné un LLM à reconnaître des motifs qui indiquent si une instruction décodée était correcte ou non.

#Stratégie de désassemblage

Quand on reçoit un binaire obfusqué, on commence par le désassembler en utilisant une combinaison de méthodes linéaires et récursives.

• Désassemblage linéaire : Ça examine chaque instruction une par une, en supposant que les instructions se suivent continuellement.
• Désassemblage récursif : Cette approche prend en compte les instructions de branchement, essayant de suivre les flux de contrôle.

Après avoir obtenu un désassemblage initial, on vérifie la validité de chaque instruction avec notre classificateur, en faisant des corrections si nécessaire.

#Évaluation du système

On a mis notre méthode à l'épreuve contre divers binaires fortement obfusqués. Les résultats montrent que notre système surpasse d'autres outils de désassemblage leaders, prouvant son efficacité face aux exécutables obfusqués.

#Défis du désassemblage

Malgré nos progrès, désassembler des binaires obfusqués reste compliqué à cause des limites d'instructions incorrectes. Ça peut conduire à des hypothèses fausses sur le fonctionnement du programme, entraînant des sorties de désassemblage inexactes.

De plus, les méthodes traditionnelles ne tirent pas toujours parti des insights des experts humains, qui peuvent souvent déterminer si une instruction ne correspond pas à la structure attendue. Notre combinaison de compréhension semblable à celle des humains provenant des LLMs et des stratégies de désassemblage existantes vise à surmonter ces obstacles.

#Conclusion

En résumé, désassembler des exécutables obfusqués est un défi complexe que les méthodes traditionnelles n'ont pas encore pleinement résolu. En intégrant les LLMs dans le processus de désassemblage, on peut mieux gérer l'obfuscation, ce qui conduit à des résultats plus précis et fiables. La combinaison de techniques établies et d'apprentissage automatique à la pointe de la technologie offre un chemin prometteur dans ce domaine de l'analyse logicielle.

Alors qu'on continue à améliorer nos méthodes et à peaufiner nos approches, on croit qu'il y a un grand potentiel pour des avancées supplémentaires dans la façon dont on s'attaque au problème de l'obfuscation dans le désassemblage.