packer-tutorial

Table des matières

1. Qu'est-ce qu'un packer ? : Une introduction au but des packers et un guide sur les nécessités de développement d'un packer.
2. Prérequis : Outils nécessaires pour travailler avec ce tutoriel.
3. Un avant-goût : Une démonstration de ce que vous allez construire avec ce tutoriel.
4. Ébaucher notre projet CMake : Un mini tutoriel CMake sur la création d'un système de build pour les besoins quelque peu complexes d'un packer.
5. Empaqueter des binaires dans votre stub : Un tutoriel sur la façon d'écrire la partie packer de la combinaison packer/stub, ainsi qu'une introduction au format de fichier exécutable Windows.
   1. Gestion des ressources
   2. Analyse d'un fichier PE
   3. Manipulation d'un fichier PE
6. Simulation du chargeur : Un tutoriel sur la façon de construire un stub exécutable minimal pour décompresser et charger un exécutable cible, ainsi qu'une introduction à la manipulation plus avancée des exécutables Windows.
   1. Lecture de notre PE depuis la mémoire
   2. Chargement de notre PE pour exécution
   3. Résolution des imports d'API
   4. Résolution des adresses
   5. Transfert de l'exécution
7. Exercices complémentaires : Quelques exercices pour approfondir vos connaissances en développement de packers.

Une lecture qui semble intimidante ? Essayez la version présentation, qui résume ce readme. Vidéo YouTube bientôt disponible !

Qu'est-ce qu'un packer ?

Un packer est un programme qui décompresse et lance un autre programme dans son espace d'adressage (ou parfois, dans l'espace d'adressage d'un autre processus). Il est parfois connu pour être le vecteur qui attaque les environnements d'analyse, tels que les débogueurs et les sandboxes virtuelles. Il est principalement utilisé pour quelques choses :

• Compression : Les packers sont couramment employés pour compresser le code d'un binaire donné. C'est l'une de ses rares utilisations légitimes. Voir UPX pour un exemple de packer compressant.
• Obfuscation : Les packers sont également employés pour tenter d'obfusquer ou de défendre un programme contre la rétro-ingénierie. Voir le packer packman de Riot Games pour un exemple de packer anti-rétro-ingénierie.
• Évasion : Les malwares utilisent fréquemment une variété de packers afin d'échapper aux antivirus et même aux EDR. Voir cette analyse d'un packer SmokeLoader pour un exemple de packer d'évasion.

Fondamentalement, un packer n'a que quelques étapes de base :

1. Étape de compression : C'est là que l'exécutable d'origine est compressé, obfusqué, ou les deux, dans un nouveau binaire.
2. Étape de décompression : C'est là que l'exécutable empaqueté décompresse ou désobfusque son exécutable d'origine pour le chargement.
3. Étape de chargement : C'est là que le packer imite une variété d'étapes similaires au chargeur d'exécutables de la plateforme hôte. En raison de la complexité des binaires exécutables, c'est l'étape la plus compliquée, selon le niveau de profondeur que vous souhaitez émuler.
4. Étape d'exécution : C'est là que le code est transféré de l'exécutable stub hôte vers le code nouvellement chargé (c'est-à-dire décompressé).

Tout aussi simple, un packer ne se compose que de quelques éléments :

• Le packer : Cette partie est responsable de la préparation de ce qu'on appelle l'exécutable stub et de lui fournir les données nécessaires pour décompresser un binaire donné. C'est en fin de compte l'étape de compression.
• Le stub : Ce binaire est la partie du code responsable de la décompression, du chargement et de l'exécution du binaire d'origine. Comme vous pouvez le voir, l'exécutable stub fait l'essentiel du travail pour un packer.

Construire un packer peut être délicat, car le stub doit être compilé et importé d'une manière ou d'une autre dans l'exécutable du packer. Sous Windows, apprendre le système de build de Visual Studio au-delà de la simple compilation peut être une tâche laborieuse. Heureusement, CMake fournit un système de build simple et multiplateforme qui prend en charge Visual Studio, et il est hautement personnalisable !

Ce tutoriel a pour but d'enseigner les points suivants :

• Comment segmenter et intégrer les deux éléments principaux d'un packer dans un environnement de build cohérent et testable.
• Comment manipuler un exécutable Windows pour ajouter des données supplémentaires et chargeables.
• Comment naviguer dans un exécutable Windows pour récupérer et charger des données arbitraires.
• Comment émuler des parties du chargeur Windows pour charger et exécuter un exécutable Windows.

Si vous êtes déjà familier avec C++ et CMake, n'hésitez pas à passer directement à la section sur l'empaquetage. Sinon, continuez à lire !

Prérequis

• Connaissance du C++ : Ce tutoriel est en quelque sorte inutile si vous ne connaissez pas le C++, car nous allons faire beaucoup d'arithmétique de pointeurs.
• Visual Studio : Visual Studio contient un compilateur C++ Windows complet. Ce projet est testé avec Visual Studio 2019, mais les versions plus récentes devraient convenir.
• CMake : CMake est le système de build que nous utilisons pour aider à instrumenter nos builds pour le compilateur Visual Studio.

Un avant-goût

Tout d'abord, prouvons, d'une manière ou d'une autre, que ce système de build fonctionne et crée un exécutable correctement empaqueté. Une fois que vous avez installé CMake et Visual Studio, naviguez vers le répertoire racine de ce dépôt avec votre terminal de choix et exécutez la commande suivante :``` $ mkdir build $ cd build $ cmake ../

Cela créera les fichiers de projet nécessaires pour construire le code du tutoriel Packer. Exécutez ensuite :```
$ cmake --build ./ --config Release

Cela compilera le projet packer en mode Release. Ensuite, vous pouvez exécuter le test suivant :``` $ ctest -C Release ./

Si tout se passe bien, test\_pack et test_unpack devraient réussir. Si vous voulez voir les résultats de l'empaquetage vous-même, vous devriez voir ceci :```
$ ./packed.exe
I'm just a little guy!

Parlons de toutes les pièces mobiles qui ont permis cela.

Esquisse de notre projet CMake

Nous savons donc quels sont les principaux composants d'un packer, mais comment pouvons-nous tester notre packer immédiatement dans le cadre du cycle de développement ? Nous devrons ajouter un troisième binaire à notre projet global pour tester correctement le processus de pack et d'unpack de notre binaire. Au total, nous avons besoin de trois projets :

• le packer
• le stub
• l'exécutable factice à packer

Nous avons également besoin d'une bibliothèque de compression pour garantir que le binaire se compresse dans l'exécutable stub. zlib fera parfaitement l'affaire.