packer-tutorial

Inhaltsverzeichnis

1. Was ist ein Packer?: Eine Einführung in den Zweck von Packern und ein Leitfaden durch die Entwicklungserfordernisse eines Packers.
2. Voraussetzungen: Werkzeuge, die du für dieses Tutorial benötigst.
3. Ein Vorgeschmack: Eine Demonstration dessen, was du mit diesem Tutorial bauen wirst.
4. Unser CMake-Projekt skizzieren: Ein Mini-CMake-Tutorial zur Erstellung eines Buildsystems für die etwas komplexen Anforderungen eines Packers.
5. Binärdateien in deinen Stub packen: Ein Tutorial, wie man den Packer-Teil der Packer/Stub-Kombination schreibt, sowie eine Einführung in das Dateiformat von Windows-Programmen.
   1. Ressourcen verwalten
   2. PE-Datei parsen
   3. PE-Datei manipulieren
6. Den Loader simulieren: Ein Tutorial, wie man ein minimales Stub-Programm baut, um ein Zielprogramm zu entpacken und zu laden, sowie eine Einführung in die fortgeschrittenere Manipulation von Windows-Programmen.
   1. Unsere PE aus dem Speicher lesen
   2. Unsere PE zur Ausführung laden
   3. API-Importe auflösen
   4. Adressen auflösen
   5. Ausführung übertragen
7. Weitere Übungen: Einige Übungen, um dein Wissen über die Entwicklung von Packern weiter auszubauen.

Sieht das nach einer entmutigenden Lektüre aus? Probier die Präsentationsversion aus, die diese README zusammenfasst. YouTube-Video folgt in Kürze!

Was ist ein Packer?

Ein Packer ist ein Programm, das ein anderes Programm in seinem Adressraum dekomprimiert und startet (oder manchmal im Adressraum eines anderen Prozesses). Es ist manchmal dafür bekannt, der Vektor zu sein, der Analyseumgebungen wie Debugger und virtuelle Sandboxen angreift. Es wird hauptsächlich für ein paar Dinge verwendet:

• Kompression: Packer werden häufig eingesetzt, um den Code einer bestimmten Binärdatei zu komprimieren. Dies ist eine ihrer wenigen legitimen Verwendungen. Siehe UPX für ein Beispiel eines komprimierenden Packers.
• Verschleierung: Packer werden auch eingesetzt, wenn versucht wird, ein Programm zu verschleiern oder anderweitig vor Reverse Engineering zu schützen. Siehe Riot Games' Packman-Packer für ein Beispiel eines Packers, der sich gegen Reverse Engineering richtet.
• Umgehung: Malware verwendet häufig eine Vielzahl von Packern, um Antivirensoftware und sogar EDR zu umgehen. Siehe diese Analyse eines SmokeLoader-Packers für ein Beispiel eines ausweichenden Packers.

Im Grunde hat ein Packer nur ein paar grundlegende Schritte:

1. Komprimierungsphase: Hier wird die ursprüngliche ausführbare Datei entweder komprimiert, verschleiert oder beides zu einer neuen Binärdatei verarbeitet.
2. Dekomprimierungsphase: Hier dekomprimiert oder deobfuskiert die gepackte ausführbare Datei ihre ursprüngliche ausführbare Datei zum Laden.
3. Ladephase: Hier ahmt der Packer eine Vielzahl von Schritten nach, die denen des Programm-Loaders der Host-Plattform ähneln. Aufgrund der Komplexität ausführbarer Binärdateien ist dies der komplizierteste Schritt, je nachdem, wie tief du die Emulation betreiben möchtest.
4. Ausführungsphase: Hier wechselt die Kontrolle vom Host-Stub-Programm zu dem neu geladenen (d. h. entpackten) Code.

Ebenso einfach besteht ein Packer nur aus wenigen Teilen:

• Der Packer: Dieser Teil ist dafür verantwortlich, die sogenannte Stub-Executable vorzubereiten und ihr die Daten zu liefern, die zum Entpacken einer bestimmten Binärdatei erforderlich sind. Dies ist letztlich die Komprimierungsphase.
• Der Stub: Diese Binärdatei ist der Codeteil, der für das Dekomprimieren, Laden und Ausführen der ursprünglichen Binärdatei verantwortlich ist. Wie du siehst, erledigt das Stub-Programm den Großteil der Arbeit für einen Packer.

Das Erstellen eines Packers kann knifflig sein, da der Stub erstellt und irgendwie in das Packer-Programm importiert werden muss. Für Windows kann das Erlernen des Buildsystems von Visual Studio über die einfache Kompilierung hinaus eine mühsame Aufgabe sein. Glücklicherweise bietet CMake ein einfaches, plattformübergreifendes Buildsystem, das Visual Studio unterstützt und hochgradig anpassbar ist!

Dieses Tutorial soll Folgendes vermitteln:

• Wie man die beiden Hauptteile eines Packers in eine kohärente, testbare Build-Umgebung segmentiert und integriert.
• Wie man ein Windows-Programm manipuliert, um zusätzliche, ladbare Daten hinzuzufügen.
• Wie man ein Windows-Programm navigiert, um beliebige Daten abzurufen und zu laden.
• Wie man Teile des Windows-Loaders emuliert, um ein Windows-Programm zu laden und auszuführen.

Wenn du bereits mit C++ und CMake vertraut bist, kannst du direkt zum Abschnitt über das Packen springen. Ansonsten lies weiter!

Voraussetzungen

• Kenntnisse in C++: Dieses Tutorial ist ziemlich nutzlos, wenn du kein C++ beherrschst, da wir viel Zeigerarithmetik betreiben werden.
• Visual Studio: Visual Studio enthält einen vollwertigen Windows-C++-Compiler. Dieses Projekt wurde mit Visual Studio 2019 getestet, aber neuere Versionen sollten funktionieren.
• CMake: CMake ist das Buildsystem, das wir verwenden, um unsere Builds für den Visual-Studio-Compiler zu instrumentieren.

Ein Vorgeschmack

Lass uns zunächst irgendwie beweisen, dass dieses Buildsystem funktioniert und ein ordnungsgemäß gepacktes Programm erstellt. Sobald du CMake und Visual Studio installiert hast, navigiere mit deinem bevorzugten Terminal in das Stammverzeichnis dieses Repositorys und führe Folgendes aus:``` $ mkdir build $ cd build $ cmake ../

Dies erzeugt die erforderlichen Projektdateien, um den Packer-Tutorial-Code zu erstellen. Führen Sie dann aus:```
$ cmake --build ./ --config Release

Dadurch wird das Packer-Projekt im Release-Modus erstellt. Anschließend können Sie den folgenden Test ausführen:``` $ ctest -C Release ./

Wenn alles gut geht, sollten test\_pack und test_unpack erfolgreich sein. Wenn du die Ergebnisse des Packens selbst sehen möchtest, solltest du Folgendes sehen:```
$ ./packed.exe
I'm just a little guy!

Lasst uns über all die beweglichen Teile sprechen, die das ermöglicht haben.

Unser CMake-Projekt skizzieren

Wir wissen also, was die Hauptkomponenten eines Packers sind, aber wie können wir unseren Packer unmittelbar als Teil des Entwicklungszyklus testen? Wir müssen unserem Gesamtprojekt ein drittes Binary hinzufügen, um den Pack- und Unpack-Prozess unseres Binaries ordentlich zu testen. Insgesamt brauchen wir also drei Projekte:

• den Packer
• den Stub
• die zu packende Dummy-Executable

Wir brauchen außerdem eine Komprimierungsbibliothek, um sicherzustellen, dass das Binary in die Stub-Executable komprimiert wird. zlib wird sich dafür gut eignen.