Obscurcissement, injection et shellcode: Le hacking sous l’oeil de l’assembleur x64 – Book Review

This review is in french because the book only exists in french 😎

J’avais vu l’annonce de ce livre à en septembre 2023 via LinkedIn et je l’avais commandé sur Amazon en me disant que je le lirai plus tard. Etant coincé chez moi toute la semaine à cause d’un mal de dos épouvantable, j’en ai profité pour dévorer cet ouvrage en quelques heures.

Cet ouvrage est l’oeuvre de Hugo BITARD, docteur en Physique qui est ensuite tombé dans la cyber sécurité en 2018, et qui reste très discret sur les réseaux sociaux (X, LinkedIn …). Il a pour but de donner au lecteur des bases et exemples concrets sur différentes méthodes d’obscurcissement (obfuscation) et d’injection de code, et sur le fonctionnement des shellcodes, tout ça en assembleur 64 bits.

Voici un aperçu de la table des matières :

1. Introduction
   • 1.1 – Pourquoi coder en assembleur
   • 1.2 – Notions de base
   • 1.3 – Mise en place d’un environnement de test
2. Premiers pas en assembleur
   • 2.1 – Mon premier programme – Linux
   • 2.2 – Mon premier programme – Windows
   • 2.3 – Hello World – Linux
   • 2.4 – Hello World – Windows
   • 2.5 – Hello World, un début d’obscurcissement
   • 2.6 – Reverse Shell TCP – Linux
   • 2.7 – Reverse Shell TCP – Windows
   • 2.8 – Communication inter-processus – Windows
   • 2.9 – Conclusion
   • 2.10 – Annexe
3. Format de fichier éxecutable
   • 3.1 – Structure d’un PE
   • 3.2 – Développement d’un PE avec NASM – Linux
   • 3.3 – Développement d’une DLL avec MASM – Windows
   • 3.4 – Développement d’un service avec MASM – Windows
   • 3.5 – Conclusion
4. Obscurcissement
   • 4.1 – Chevauchement de code
   • 4.2 – Une autre façon d’utiliser le mnémonique RET
   • 4.3 – Utilisation du Thread Local Storage (TLS)
   • 4.4 – Utilisation de la gestion des exceptions
   • 4.5 – Appel indirect de fonction
   • 4.6 – Recherche d’adresses de fonctions via leurs nombres ordinaux
   • 4.7 – Trouver les adresses de LoadLibrary() et GetProcAddress()
   • 4.8 – Recherche d’adresses de fonctions via leurs condensats
   • 4.9 – Vérification des indicateurs de NtGlobalFlag
   • 4.10 – Utilisation de la fonction IsDebuggerPresent()
   • 4.11 – Process Masquerading
   • 4.12 – Parent PID Spoofing
   • 4.13 – L’utilisation d’encideur
   • 4.14 – Conclusion
5. Injection de Code
   • 5.1 – Injection de DLL via la fonction CreateRemoteThread()
   • 5.2 – Injection de DLL via la fonction NtCreateThreadEx()
   • 5.3 – Injection de DLL via la fonction RtlCreateUserThread()
   • 5.4 – Injection de DLL par la méthode des “direct SYSCALL”
   • 5.5 – Injection de DLL via la fonction QueueUserAPC()
   • 5.6 – Injection de code via la fonction SetThreadContext()
   • 5.7 – Injection de code via la méthode Process Hollowing
   • 5.8 – Injection de code via la méthode Early Bird
   • 5.9 – Mise en place de hook via la fonction SetWindowsHookExA()
   • 5.10 – Injection de code à l’aide de hook dans l’IAT
   • 5.11 – Conclusion
6. Développement et analyse de code auto-suffisant : shellcode
   • 6.1 – Execution de shellcode
   • 6.2 – Reverse Engineering de shellcode
   • 6.3 – Méthode de développement
   • 6.4 – Conclusion

Dans le premier chapitre, l’auteur nous rappelle les bases de l’assembleur et ses instructions et explique comment mettre en place l’environnement de développement qui sera utilisé pour mettre en pratique tous les exemples du livre (en gros une VM Windows avec VS Code et MASM). Bien qu’assez détaillé, le rappel des bases de l’assembleur implique que vous ayez déjà une idée de comment ça fonctionne.

Dans le deuxième chapitre, l’auteur nous lance de le grand bain, on commence les premiers programmes en 100% assembleur, d’abord un simple affichage écran, jusqu’à un reverse shell TCP. Tout est très clair.

Dans le troisième chapitre, on y apprends comment un PE est structuré, encore une fois c’est un rappel et il est quand même conseillé d’avoir une vague idée de la chose avant d’attaquer le livre.

Quatrième chapitre, c’est parti. Outre quelques méthode d’obscurcissement, on y voit comment appeler des fonctions sans qu’elles apparaissent dans les imports, ainsi que plein d’autres méthodes pour rendre l’analyse du code plus compliquée, sachant que ces méthodes sont retrouvées dans la grande majorité des malwares actuels, il est extrêmement important de comprendre comment elles fonctionnes.

Cinquième chapitre, ou comment executer notre code sans se faire détecter par les anti-virus (et certains EDR). Pleins de méthodes sont expliquées en détails, et le code source est fourni. La courbe d’apprentissage est excellente, on commence par des exemples basiques et on progresse vers des méthodes plus compliquées et exotiques, néanmoins efficaces et qu’on retrouvera dans plein de malwares actuels.

Sixième chapitre, pas envie de crée un PE complet ? Voyons comment créer un shellcode et l’injecter discrètement dans un autre processus pour rester en dessous du radar. Encore une fois la courbe d’apprentissage est excellente, les premiers exemples sont simples, les derniers plus complets, ouvrants la porte à plein de possibilités !

J’ai trouvé quelques fautes de frappes au long du livre, mais rien de terrible (et j’ai oublié de noter où …).

Pour celles et ceux qui ont la flemme de tout taper, on retrouve les sources du livres sur le GitHub de JarVices.

En conclusion : un excellent ouvrage technique dans la langue de Molière, BRAVO !