Utilisation d'Ollydbg et X64dbg pour les projets d'ingénierie inverse de Windows

Comprendre le paysage de Windows Inverser l'ingénierie

L'ingénierie inverse de Windows demeure une discipline critique pour découvrir les vulnérabilités des logiciels, disséquer les logiciels malveillants, analyser les protocoles propriétaires et comprendre les programmes existants ou non documentés. Deux des débogueurs les plus utilisés dans l'écosystème Windows sont OllyDbg[ (pour les applications 32 bits) et x64dbg (qui gère les binaires 32 bits et 64 bits).

Un regard in-depth sur OllyDbg

Origines et philosophie

OllyDbg, créée par Oleh Yuschuk, a gagné en popularité au début des années 2000 en tant que débogueur léger et convivial de niveau assembleur. Bien qu'il soit limité à des exécutables 32 bits, il demeure pertinent pour analyser les anciennes applications Windows, de nombreux échantillons de logiciels malveillants compilés pour x86 et des logiciels qui ne comprennent pas les constructions 64 bits.

Installation et configuration initiale

Télécharger OllyDbg depuis son site officiel (ollydbg.de). Le paquet est un exécutable unique – aucun installateur requis – qui facilite la portabilité. Pour de meilleurs résultats, exécutez OllyDbg sur un environnement Windows 32 bits ou sur un système 64 bits qui prend en charge WOW64; rappelez-vous qu'OllyDbg lui-même ne peut que déboguer les processus 32 bits.

Étapes clés de configuration après le lancement :

Allez à Options → Apparence et définissez les polices et les couleurs à votre préférence – des schémas de contraste élevé aident à réduire la pression oculaire pendant les longues sessions.
Sous Options → Options de débogage, activez -Pause sur le point d'arrêt et envisagez de désactiver -Ignorez INT3--Si vous prévoyez d'utiliser des points d'arrêt personnalisés.
Configurez les couleurs Mémoriser pour repérer rapidement les régions exécutables, écrivantes ou entassés.
Charger un exécutable de test (par exemple, un simple `HelloWorld.exe` compilé) pour vérifier le démonteur et enregistrer les vitres de rendre correctement.

Interface utilisateur

L'interface OllyDbg , qui comprend plusieurs panneaux, peut être réaménagée par glisser-déposer. La mise en page par défaut comprend :

Fenêtre de désassemblage (en haut à gauche): Affiche le code démonté avec adresses, octets, mnémoniques et commentaires.
Enregistre fenêtre (en haut à droite):[ Affiche le contenu de l'enregistrement CPU (EAX, EBX, ECX, EDX, ESP, EBP, EIP, drapeaux).Chaque enregistrement met à jour en direct à votre étape.
Fenêtre de la pompe (en bas à gauche):[ Vue hexadécimal et ASCII de la mémoire à une adresse sélectionnée. Vous pouvez changer l'adresse de base en cliquant avec le bouton droit et en choisissant --Allez à -.
Fenêtre de la pile (en bas à droite):[ Affiche les images de la pile, les adresses de retour et les variables locales.

Ces panneaux sont interdépendants : en cliquant sur une adresse dans la fenêtre dump, mettez instantanément à jour le démontage si cette région de mémoire contient du code.

Types de points d'arrêt essentiels

OllyDbg prend en charge plusieurs mécanismes de point d'arrêt:

Point d'arrêt du logiciel qui remplace un octet d'instruction par 0xCC. Simple, mais détectable par un code anti-débogue.
Point d'arrêt mémoire:[ Définissez sur une région mémoire (exécutable, écrit ou lu) en cliquant avec le bouton droit sur la carte de sauvegarde ou de mémoire. Utile pour capturer quand un tampon de données spécifique est accessible.
Débogue → Points d'arrêt matériels. Utilise les registres de débogue CPU (DR0‐DR3). Plus difficiles à détecter que INT3, mais limités à quatre points d'arrêt simultanés.
Point d'arrêt conditionnel:[ Un point d'arrêt INT3 combiné avec une boîte de message Win32 ou une condition de logarithme (par exemple, -break quand EAX == 0-). Accessible en cliquant avec le bouton droit sur une ligne et en sélectionnant --Breakpoint → Conditionnel.

Utilisez la touche F7 pour passer à un appel, F8 pour passer à autre chose, et F9 pour courir jusqu'au point d'arrêt suivant. La fonction -Run trace ([Debug → Trace in) enregistre chaque instruction exécutée et peut être rejouée plus tard – inestimable pour suivre le flux de contrôle complexe sans manquer une étape.

Le menu --Rechercher est un assistant puissant :

Rechercher → Commande: Localiser un assemblage spécifique mnémonique (par exemple, -CALL) sur tout le module.
Rechercher → Séquence des octets: Trouver des motifs dans le binaire, comme une chaîne ou une signature particulière.
Rechercher → Toutes les chaînes référencées : Extraire rapidement toutes les chaînes ASCII et Unicode lisibles utilisées par le programme.

Écosystèmes greffons

L'extensibilité d'OllyDbg , par l'intermédiaire de plugins, compense son manque de mises à jour.

OlyDump:[ Domptez un processus en cours d'exécution , la mémoire sur le disque pour l'analyse statique ou le patching.
HideDebugger: Obscurcit la présence d'OllyDbg pour éviter les contrôles antidébogue.
OllyScript: Automatisez les tâches répétitives en utilisant un langage de script de type Python. Par exemple, vous pouvez scripter la recherche de motifs et de points d'arrêt sur plusieurs pistes.
PhantOm: Module de détection furtive avancé qui corrige de nombreuses détections courantes IsDebuggerPresent et NtQueryInformationProcess.

Pour installer un plugin, extraire le fichier `.dll` dans le dossier `Plugins` d`OllyDbg=s et redémarrer le débogueur.

Maîtrise x64dbg : Déboguage moderne pour les cibles 32 bits et 64 bits

Pourquoi x64dbg est devenu la norme

Alors qu'OllyDbg est un vétéran, x64dbg est l'outil de référence pour l'ingénierie inverse contemporaine. Il supporte à la fois 32‐bit et 64‐bit exécutables, dispose d'une base de code open-source (GitHub depository), et introduit des fonctionnalités modernes telles qu'une interface tabulée, un script Python intégré et un moteur d'analyse symbolique intégré basé sur l'intégration Yara et Ghidra.

Installation et premier lancement

Téléchargez la dernière version du site web x64dbg (x64dbg.com). Le paquet comprend deux lanceurs exécutables – `x32dbg.exe` pour le débogage 32 bits et `x64dbg.exe` pour 64 bits. Les deux partagent les mêmes dossiers de configuration et de plugin.

Lors du premier lancement, a établi ces préférences essentielles:

Paramètres → Préférences → Événements: Vérifiez -point de rupture du système pour arrêter au point d'entrée au lieu du chargeur système.
Apparence:[ Choisissez un thème sombre ou un schéma de couleurs personnalisé sous - -Opticks – plus facile pour les yeux pour une utilisation prolongée.
Démontage: Activer -Afficher la représentation des octets et -Afficher les opcodes -Afficher si vous voulez que les détails de l'instruction soient visibles en tout temps.
Fonction Annuler: x64dbg trace des changements de mémoire et de registre – vous pouvez faire reculer une étape si vous patchez accidentellement quelque chose.

Interface et flux de travail

La fenêtre x64dbg est divisée en panneaux d'accostage :

CPU Désassemblage:[ La vue principale du code, avec adresse, octets, désassemblage, et une colonne pour les commentaires. Le clic droit révèle un menu contextuel riche en commandes d'analyse: --Trouver des références à , --Trouver Xrefs, -Assigner à nouveau NOP, etc.
Enregistrement: Affiche tous les registres, drapeaux, registres de segments et état de point flottant. Les couleurs indiquent les changements depuis le dernier événement – vert pour modifié, rouge pour les drapeaux nouvellement définis.
Dump:[ Éditeur de mémoire hexagonal qui peut basculer entre les modes hexagonaux, texte et structure. Faites un clic droit sur une adresse et choisissez --Regardez DWord-- pour surveiller instantanément une valeur de 4 octets.
Stack: Similaire à OllyDbg, mais avec un formatage plus agréable et la possibilité de mettre en évidence les adresses de retour et les cadres locaux.
Vue de la grille (Tab):[ Appuyez sur G[ sur une fonction pour ouvrir le diagramme de flux de commande. Ceci est inestimable pour comprendre les structures de branche, les boucles et les sauts conditionnels en un coup d'oeil.
Symbols & Modules: Liste toutes les DLL chargées et leurs tables d'exportation. Vous pouvez définir des points d'arrêt sur n'importe quelle fonction exportée en cherchant dans l'onglet des symboles.

Points d'arrêt et de repérage avancés

x64dbg étend la fonctionnalité de point d'arrêt au-delà d'OllyDbg:

Note de rupture avec conditions et nombre de frappes: Cliquez-droit sur une ligne → --Décision → -Éditer. Vous pouvez ajouter une condition comme `EAX == 0x12345678` et un message de journal dans la fenêtre du journal des points d'arrêt.
Point d'arrêt mémoire sur la plage:[ Cliquez sur l'onglet -Mémory Map, sélectionnez une région, et choisissez -Set mémoire point d'arrêt sur access-sment ou -srite. Ceci est essentiel pour le suivi quand un tampon est écrasé.
Déboguez → Points d'arrêt matériels pour configurer jusqu'à quatre points d'arrêt DRx en lecture/écriture/exécution.
Enregistrement de trace:[ Activer Débogue → Enregistrement de trace pour capturer chaque instruction exécutée. Plus tard, vous pouvez -Rechercher les motifs de - dans la trace enregistrée – extrêmement utile pour trouver où une localisation de mémoire particulière est modifiée.

Scripting et automatisation en x64dbg

L'une des fonctionnalités de x64dbg , c'est son support de script profond:

Python scripting:[ Le plugin Python intégré vous permet d'écrire une automatisation complexe. Par exemple, vous pouvez script logging tous les appels `CreateFileW` avec leurs arguments. Un script simple pourrait ressembler à:

x64dbgpy:[ Une liaison Python plus étendue qui donne un contrôle complet: la mémoire de lecture/écriture, démonter les octets arbitraires, gérer les points d'arrêt, et plus encore.

Tarre de commande de construction:[ En bas de la fenêtre, vous pouvez taper des commandes comme `bp kernel32.VirtualProtect`, `dump @rsp` ou `set cond eax==5. Cela rend les actions rapides possibles sans naviguer dans les menus.

Symbole et intégration au niveau source

Utilisez l'onglet Symbols pour charger des symboles publics (fichier .pdb) du serveur de symboles Microsoft=2 ou de votre propre projet. Avec des symboles chargés, x64dbg peut afficher les noms de fonctions et les numéros de lignes à partir de la source d'origine – comblant l'écart entre le code de montage et le code de haut niveau.

Comparaison de OllyDbg et x64dbg: Quand utiliser chaque

Les deux outils sont puissants, mais leurs meilleurs cas d'utilisation diffèrent :

Legacy 32-bit logiciel:[ Si vous travaillez sur des applications anciennes, des fichiers PE mal formés, ou des binaires 32-bit emballés qui tombent à sonner 0, OllyDbg=s mature plugin écosystème (surtout HideDebugger et OllyDump) peut encore être plus fiable. Certains plugins plus anciens comme - -OllyFlow=" produisent de beaux graphiques d'appel qui x64dbg manque nativement.

x64dbg est le seul choix pour le débogage natif 64 bits. OllyDbg ne peut même pas ouvrir un exécutable 64 bits. Pour les logiciels malveillants Windows modernes, utilisez x64dbg.
Les besoins en scripts:[ x64dbg="s L'intégration Python est beaucoup plus polyvalente qu'OllyScript. Si votre projet nécessite l'analyse de structures de données personnalisées ou l'automatisation de sessions de débogage complètes, x64dbg gagne.
Mémoire patching:[ Les deux permettent le patching, mais x64dbg a une fenêtre intégrée --Patch-- qui enregistre toutes les modifications et peut générer un fichier patch.
Courbe d'apprentissage: OllyDbg a une courbe d'apprentissage plus faible pour les débutants en raison de son interface plus simple et de moins de boutons. Cependant, x64dbg=s documentation et communauté sont plus actives, donc l'investissement initial paie rapidement.

Plusieurs inverseurs expérimentés gardent les deux installés: OllyDbg pour le triage rapide sur des échantillons 32 bits et x64dbg pour tout le reste.

Projet pratique de génie inverse : Cracking a Simple Crackme

Pour solidifier les concepts, nous allons analyser un -Crackme typique – un petit programme qui demande un mot de passe. Nous utilisons x64dbg pour ce projet, mais les mêmes étapes s'appliquent à OllyDbg (avec de légères différences d'interface utilisateur).

Étape 1: Reconnaissance statique

Avant de lancer le débogueur, exécutez l'exécutable et notez son comportement. Typiquement, il affiche une boîte de dialogue avec une boîte de modification et un bouton -Check. Entrez un mot de passe fictif comme -test pour voir le message d'erreur (-Wrong password!-).

Maintenant, ouvrez l'exécutable dans x64dbg. Notez le point d'entrée – habituellement un appel à `GetModuleHandleA` ou `WinMain`. Faites défiler à travers le démontage pour trouver la chaîne -Wrong mot de passe!-. Appuyez sur Ctrl+F et recherchez cette chaîne (ou utilisez Rechercher → Module actuel → Références de chaînes. Double-cliquez sur la référence pour sauter vers le code qui la réfère. Vous verrez quelque chose comme :

.text:00401234 push offset aWrongPassword ; "Wrong password!"
.text:00401239 call ds:MessageBoxA

Juste au-dessus de cette poussée, il y a probablement un saut conditionnel (par exemple, `jne` ou `je`) qui décide quel message à afficher. Réglez un point d'arrêt sur cette instruction de saut.

Étape 2 : Analyse dynamique

Appuyez sur F9 pour lancer l'application. Saisissez votre mot de passe fictif et cliquez sur -Check. Le débogueur se casse à l'instruction de saut. Examinez les drapeaux : si le drapeau zéro est défini (ZF=1), le saut peut aller au message de succès ; si ZF=0, il va à l'échec. Maintenant, regardez l'instruction précédente `CMP` ou `TEST`. Souvent, le mot de passe est comparé par caractère en utilisant `LODSB` ou une boucle avec `REPNE CPMSB`.

Si la comparaison est un simple appel `strcmp`, vous pouvez localiser l'appel vers `strcmp` et voir ses arguments dans la fenêtre de la pile. Les deux arguments sont des pointeurs – un vers votre entrée, un vers le mot de passe correct. Cliquez droit sur l'adresse du second pointeur et choisissez -Suivez dans Dump- , pour afficher le mot de passe dans la mémoire. Ou, mieux, définissez un point d'arrêt sur la valeur de retour `strcmp` et observez EAX après l'appel : si EAX est 0, les mots de passe correspondent.

Étape 3: Patching le binaire

Un but commun de crackme est de contourner complètement la vérification de mot de passe. Au saut conditionnel qui mène au mauvais message, vous pouvez changer l'opcode. Cliquez-droit sur la ligne de saut et choisissez ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Étape 4: Scripter la solution

Si vous analysiez des centaines de binaires similaires, vous pourriez automatiser le patch. Un script Python dans x64dbg pourrait : trouver toutes les références à la chaîne d'erreur, identifier le saut conditionnel le plus proche, et le remplacer par un NOPsled, le tout sans interaction manuelle.

Manipulation des techniques antidébogue

De nombreux programmes commerciaux ou de malware utilisent anti-débogue pour décourager l'analyse. Voici des trucs communs et comment les contourner avec OllyDbg et x64dbg.

IsDebuggerPrésent (kernel32!IsDebuggerPrésent):[ La vérification la plus simple – appeler l'API et si EAX != 0, le débogueur est présent. Réglez un point d'arrêt sur l'API, et lorsque vous le frappez, modifiez EAX à 0.
NtQueryInformationProcess (ntdll!NtQueryInformationProcess):[ Plus sophistiqué. Patch la valeur de retour (le ProcessDebugFlags ou ProcessDebugPort) en définissant un point d'arrêt et en modifiant la structure retournée.
Timing checks:[ Code mesure le temps entre deux instructions et le compare avec un seuil. Passer par un débogueur introduit le retard. Utilisez des points d'arrêt matériels et évitez de passer au-dessus du code sensible au temps, ou utilisez la fonction --Run à la sélection - pour sauter au-delà de la vérification de la chronologie.
Détection INT3 : Certains programmes scannent leur propre code pour les octets 0xCC. Pour éviter de le faire, utilisez exclusivement des points d'arrêt matériels (mais seulement quatre sont possibles).

Optimiser votre flux de travail

L'ingénierie inverse est un processus méticuleux – les gains de productivité comptent.

Utilisez un VM dédié: Exécutez vos outils de débogage à l'intérieur d'une machine virtuelle Windows. Les snapshots vous permettent de revenir à un état propre après avoir infecté avec des logiciels malveillants ou gâché une bibliothèque système.
Intégrer avec des outils d'analyse statique:[ Compléter le débogage dynamique avec IDA Pro, Ghidra ou Binary Ninja. Exporter les symboles d'un démontage statique et les importer dans x64dbg pour faciliter la navigation.
Commentaires fortement: Les deux débogueurs supportent l'ajout de commentaires aux lignes de code. Utilisez-les pour documenter votre compréhension des routines, des arguments et des valeurs de retour. Au fil du temps, ces commentaires deviennent une documentation personnelle du programme.
Log ally:[ Utilisez les fenêtres de logage dans x64dbg pour enregistrer les points d'arrêt, les valeurs d'enregistrement et les modifications de mémoire. Plus tard, vous pouvez grep le log pour trouver des motifs – par exemple, tous les appels à `WriteFile` avec des valeurs de gestion.
Découvrez les ressources externes: Des sites comme Woodmann.com archiver de nombreux plugins et tutoriels OllyDbg. Pour x64dbg, le wiki officiel GitHub et le blog ReversingLabs sont d'excellentes références.

Conclusion

OllyDbg et x64dbg restent indispensables pour l'ingénierie inverse de Windows. La simplicité et la base de plugins matures d'OllyDbg servent bien pour les projets 32 bits existants, tandis que l'architecture moderne de x64dbg, le support 64 bits et les capacités de scripts puissantes en font l'outil de choix pour l'analyse contemporaine. En maîtrisant la mécanique de pointe, la médecine légale de la mémoire, les contournements antidébogue et l'automatisation, vous pouvez défaire même les binaires les plus convolués. Commencez par des cracks simples, pratiquez sur des exécutables portables à partir de votre propre disque, et progressivement passer à des logiciels malveillants complexes ou emballés.