Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/reversing/reversing-tools-basic-methods
History
Translator 7809a83a54 Translated ['README.md', 'forensics/basic-forensic-methodology/partition
2024-03-09 13:16:41 +00:00
..
angr Translated ['reversing/reversing-tools-basic-methods/angr/angr-examples. 2024-02-25 12:47:38 +00:00
blobrunner.md Translated to German 2024-02-10 15:36:32 +00:00
cheat-engine.md Translated to German 2024-02-10 15:36:32 +00:00
README.md Translated ['README.md', 'forensics/basic-forensic-methodology/partition 2024-03-09 13:16:41 +00:00
satisfiability-modulo-theories-smt-z3.md Translated to German 2024-02-10 15:36:32 +00:00

README.md

Reverse-Engineering-Tools & Grundmethoden

Erlernen Sie AWS-Hacking von Grund auf mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen:

ImGui-basierte Reverse-Engineering-Tools

Software:

Wasm-Decompiler / Wat-Compiler

Online:

Software:

.Net-Decompiler

dotPeek

dotPeek ist ein Decompiler, der mehrere Formate dekompiliert und untersucht, einschließlich Bibliotheken (.dll), Windows-Metadatendateien (.winmd) und Ausführbare Dateien (.exe). Nach dem Dekompilieren kann eine Assembly als Visual Studio-Projekt (.csproj) gespeichert werden.

Der Vorteil hierbei ist, dass bei Bedarf zur Wiederherstellung von verlorenem Quellcode aus einer Legacy-Assembly Zeit gespart werden kann. Darüber hinaus bietet dotPeek eine praktische Navigation durch den dekompilierten Code, was es zu einem der perfekten Tools für die Analyse von Xamarin-Algorithmen macht.

.Net Reflector

Mit einem umfassenden Add-In-Modell und einer API, die das Tool erweitert, um Ihren genauen Anforderungen zu entsprechen, spart .NET Reflector Zeit und vereinfacht die Entwicklung. Schauen wir uns die Vielzahl von Reverse-Engineering-Services an, die dieses Tool bietet:

  • Bietet Einblicke, wie die Daten durch eine Bibliothek oder Komponente fließen
  • Bietet Einblicke in die Implementierung und Verwendung von .NET-Sprachen und -Frameworks
  • Findet nicht dokumentierte und nicht freigegebene Funktionalitäten, um mehr aus den verwendeten APIs und Technologien herauszuholen.
  • Findet Abhängigkeiten und verschiedene Assemblys
  • Lokalisiert genau Fehlerquellen in Ihrem Code, in Komponenten von Drittanbietern und Bibliotheken.
  • Debuggt in den Quellcode aller .NET-Codes, mit denen Sie arbeiten.

ILSpy & dnSpy

ILSpy-Plugin für Visual Studio Code: Sie können es in jedem Betriebssystem haben (Sie können es direkt von VSCode installieren, kein Bedarf, das Git herunterzuladen. Klicken Sie auf Erweiterungen und suchen Sie nach ILSpy).
Wenn Sie dekompilieren, ändern und erneut kompilieren müssen, können Sie verwenden: https://github.com/0xd4d/dnSpy/releases (Rechtsklick -> Methode ändern um etwas innerhalb einer Funktion zu ändern).
Sie könnten auch https://www.jetbrains.com/es-es/decompiler/ ausprobieren.

DNSpy-Protokollierung

Um DNSpy dazu zu bringen, einige Informationen in einer Datei zu protokollieren, könnten Sie diese .Net-Zeilen verwenden:

using System.IO;
path = "C:\\inetpub\\temp\\MyTest2.txt";
File.AppendAllText(path, "Password: " + password + "\n");

DNSpy Debugging

Um Code mit DNSpy zu debuggen, müssen Sie folgende Schritte ausführen:

Zuerst ändern Sie die Assembly-Eigenschaften, die mit Debugging zusammenhängen:

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]

An:

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default |
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints |
DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]

Und klicken Sie auf kompilieren:

Speichern Sie dann die neue Datei unter Datei >> Modul speichern...:

Dies ist notwendig, da andernfalls zur Laufzeit verschiedene Optimierungen auf den Code angewendet werden und es möglich sein könnte, dass während des Debuggens ein Haltepunkt nie erreicht wird oder einige Variablen nicht existieren.

Dann, wenn Ihre .Net-Anwendung von IIS ausgeführt wird, können Sie sie mit neu starten:

iisreset /noforce

Dann, um mit dem Debuggen zu beginnen, sollten Sie alle geöffneten Dateien schließen und im Debug-Tab An Prozess anhängen... auswählen:

Wählen Sie dann w3wp.exe aus, um sich an den IIS-Server anzuhängen, und klicken Sie auf Anhängen:

Nun, da wir den Prozess debuggen, ist es an der Zeit, ihn anzuhalten und alle Module zu laden. Klicken Sie zunächst auf Debug >> Alle anhalten und dann auf Debug >> Fenster >> Module:

Klicken Sie auf ein beliebiges Modul in Module und wählen Sie Alle Module öffnen:

Klicken Sie mit der rechten Maustaste auf ein beliebiges Modul im Assembly Explorer und wählen Sie Assembly sortieren:

Java-Decompiler

https://github.com/skylot/jadx
https://github.com/java-decompiler/jd-gui/releases

Debuggen von DLLs

Mit IDA

  • Rundll32 laden (64-Bit in C:\Windows\System32\rundll32.exe und 32-Bit in C:\Windows\SysWOW64\rundll32.exe)
  • Wählen Sie den Windbg-Debugger
  • Wählen Sie "Anhalten bei Bibliotheks-Lade/Entlade"

  • Konfigurieren Sie die Parameter der Ausführung, indem Sie den Pfad zur DLL und die Funktion, die Sie aufrufen möchten, angeben:

Dann, wenn Sie mit dem Debuggen beginnen, wird die Ausführung gestoppt, wenn jede DLL geladen wird. Wenn Rundll32 Ihre DLL lädt, wird die Ausführung gestoppt.

Aber wie gelangen Sie zum Code der geladenen DLL? Mit dieser Methode weiß ich nicht, wie.

Mit x64dbg/x32dbg

  • Rundll32 laden (64-Bit in C:\Windows\System32\rundll32.exe und 32-Bit in C:\Windows\SysWOW64\rundll32.exe)
  • Ändern Sie die Befehlszeile ( Datei --> Befehlszeile ändern ) und setzen Sie den Pfad zur DLL und die Funktion, die Sie aufrufen möchten, z.B.: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\14.ridii_2.dll",DLLMain
  • Ändern Sie Optionen --> Einstellungen und wählen Sie "DLL-Einstieg".
  • Starten Sie dann die Ausführung, der Debugger wird bei jedem DLL-Haupt anhalten, an einem Punkt werden Sie im DLL-Einstieg Ihrer DLL anhalten. Von dort aus suchen Sie einfach nach den Stellen, an denen Sie einen Haltepunkt setzen möchten.

Beachten Sie, dass Sie in win64dbg sehen können, in welchem Code Sie sich befinden, wenn die Ausführung aus irgendeinem Grund gestoppt wird, oben im win64dbg-Fenster:

Dann können Sie sehen, wann die Ausführung in der DLL gestoppt wurde, die Sie debuggen möchten.

GUI-Apps / Videospiele

Cheat Engine ist ein nützliches Programm, um wichtige Werte im Speicher eines laufenden Spiels zu finden und zu ändern. Weitere Informationen finden Sie unter:

{% content-ref url="cheat-engine.md" %} cheat-engine.md {% endcontent-ref %}

ARM & MIPS

{% embed url="https://github.com/nongiach/arm_now" %}

Shellcodes

Debuggen eines Shellcodes mit Blobrunner

Blobrunner wird den Shellcode in einem Speicherbereich zuweisen, Ihnen die Speicheradresse anzeigen, an der der Shellcode zugewiesen wurde, und die Ausführung stoppen.
Dann müssen Sie einen Debugger (Ida oder x64dbg) an den Prozess anhängen und einen Haltepunkt an der angegebenen Speicheradresse setzen und die Ausführung fortsetzen. Auf diese Weise debuggen Sie den Shellcode.

Die GitHub-Seite der Veröffentlichungen enthält ZIP-Dateien mit den kompilierten Veröffentlichungen: https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5
Sie finden eine leicht modifizierte Version von Blobrunner unter folgendem Link. Um sie zu kompilieren, erstellen Sie einfach ein C/C++-Projekt in Visual Studio Code, kopieren Sie den Code und erstellen Sie ihn.

{% content-ref url="blobrunner.md" %} blobrunner.md {% endcontent-ref %}

Debuggen eines Shellcodes mit jmp2it

jmp2it ist sehr ähnlich zu Blobrunner. Es wird den Shellcode in einem Speicherbereich zuweisen und eine ewige Schleife starten. Dann müssen Sie den Debugger an den Prozess anhängen, Start drücken, 2-5 Sekunden warten und Stop drücken, und Sie werden sich in der ewigen Schleife befinden. Springen Sie zur nächsten Anweisung der ewigen Schleife, da es sich um einen Aufruf des Shellcodes handeln wird, und schließlich werden Sie den Shellcode ausführen.

Sie können eine kompilierte Version von jmp2it auf der Veröffentlichungsseite herunterladen.

Debuggen von Shellcode mit Cutter

Cutter ist die GUI von radare. Mit Cutter können Sie den Shellcode emulieren und dynamisch inspizieren.

Beachten Sie, dass Cutter es Ihnen ermöglicht, eine Datei zu "Öffnen" und "Shellcode zu öffnen". In meinem Fall wurde der Shellcode korrekt dekompiliert, als ich ihn als Datei öffnete, aber nicht, als ich ihn als Shellcode öffnete:

Um die Emulation an der gewünschten Stelle zu starten, setzen Sie dort einen Haltepunkt, und anscheinend startet Cutter die Emulation automatisch von dort aus:

Sie können beispielsweise den Stapel in einem Hex-Dump anzeigen:

Deobfuskation von Shellcode und Ermittlung ausgeführter Funktionen

Sie sollten scdbg ausprobieren.
Es wird Ihnen Dinge wie welche Funktionen der Shellcode verwendet und ob der Shellcode sich im Speicher dekodiert.

scdbg.exe -f shellcode # Get info
scdbg.exe -f shellcode -r #show analysis report at end of run
scdbg.exe -f shellcode -i -r #enable interactive hooks (file and network) and show analysis report at end of run
scdbg.exe -f shellcode -d #Dump decoded shellcode
scdbg.exe -f shellcode /findsc #Find offset where starts
scdbg.exe -f shellcode /foff 0x0000004D #Start the executing in that offset

scDbg verfügt auch über einen grafischen Launcher, über den Sie die gewünschten Optionen auswählen und den Shellcode ausführen können.

Die Option Create Dump wird den endgültigen Shellcode dumpen, wenn Änderungen am Shellcode dynamisch im Speicher vorgenommen werden (nützlich zum Herunterladen des decodierten Shellcodes). Der Startoffset kann nützlich sein, um den Shellcode an einem bestimmten Offset zu starten. Die Option Debug Shell ist nützlich, um den Shellcode mit dem scDbg-Terminal zu debuggen (jedoch finde ich eine der zuvor erklärten Optionen für diese Angelegenheit besser, da Sie Ida oder x64dbg verwenden können).

Disassemblieren mit CyberChef

Laden Sie Ihre Shellcode-Datei als Eingabe hoch und verwenden Sie das folgende Rezept, um sie zu dekompilieren: https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)

Movfuscator

Dieser Obfuscator modifiziert alle Anweisungen für mov (ja, wirklich cool). Er verwendet auch Unterbrechungen, um Ausführungsflüsse zu ändern. Für weitere Informationen darüber, wie es funktioniert:

Wenn Sie Glück haben, wird demovfuscator das Binärprogramm deobfuskieren. Es hat mehrere Abhängigkeiten.

apt-get install libcapstone-dev
apt-get install libz3-dev

Und installiere Keystone (apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install)

Wenn du an einem CTF teilnimmst, könnte dieser Workaround zur Auffindung der Flagge sehr nützlich sein: https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html

Rust

Um den Einstiegspunkt zu finden, suche nach Funktionen mit ::main wie hier:

In diesem Fall wurde die Binärdatei authenticator genannt, daher ist es ziemlich offensichtlich, dass dies die interessante Hauptfunktion ist.
Nachdem du den Namen der aufgerufenen Funktionen hast, suche im Internet nach ihnen, um mehr über ihre Eingaben und Ausgaben zu erfahren.

Delphi

Für mit Delphi kompilierte Binärdateien kannst du https://github.com/crypto2011/IDR verwenden

Wenn du eine Delphi-Binärdatei umkehren musst, würde ich dir empfehlen, das IDA-Plugin https://github.com/Coldzer0/IDA-For-Delphi zu verwenden

Drücke einfach ATL+f7 (Python-Plugin in IDA importieren) und wähle das Python-Plugin aus.

Dieses Plugin führt die Binärdatei aus und löst die Funktionsnamen dynamisch zu Beginn des Debuggens auf. Nach dem Start des Debuggens drücke erneut die Start-Schaltfläche (die grüne oder f9), und ein Breakpoint wird am Anfang des eigentlichen Codes erreicht.

Es ist auch sehr interessant, weil der Debugger anhält, wenn du in der grafischen Anwendung eine Schaltfläche drückst, die Funktion ausführt.

Golang

Wenn du eine Golang-Binärdatei umkehren musst, würde ich dir empfehlen, das IDA-Plugin https://github.com/sibears/IDAGolangHelper zu verwenden

Drücke einfach ATL+f7 (Python-Plugin in IDA importieren) und wähle das Python-Plugin aus.

Dies löst die Namen der Funktionen auf.

Kompiliertes Python

Auf dieser Seite findest du, wie du den Python-Code aus einer ELF/EXE-Python-kompilierten Binärdatei extrahieren kannst:

{% content-ref url="../../forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md" %} .pyc.md {% endcontent-ref %}

GBA - Game Body Advance

Wenn du die Binärdatei eines GBA-Spiels hast, kannst du verschiedene Tools verwenden, um es zu emulieren und debuggen:

  • no$gba (Lade die Debug-Version herunter) - Enthält einen Debugger mit Benutzeroberfläche
  • mgba - Enthält einen CLI-Debugger
  • gba-ghidra-loader - Ghidra-Plugin
  • GhidraGBA - Ghidra-Plugin

In no$gba, unter Options --> Emulation Setup --> Controls** ** kannst du sehen, wie du die Tasten des Game Boy Advance bedienst

Wenn gedrückt, hat jede Taste einen Wert, um sie zu identifizieren:

A = 1
B = 2
SELECT = 4
START = 8
RIGHT = 16
LEFT = 32
UP = 64
DOWN = 128
R = 256
L = 256

Also, in dieser Art von Programmen wird ein interessanter Teil sein, wie das Programm die Benutzereingabe behandelt. An der Adresse 0x4000130 finden Sie die häufig vorkommende Funktion: KEYINPUT.

Im vorherigen Bild können Sie sehen, dass die Funktion von FUN_080015a8 aufgerufen wird (Adressen: 0x080015fa und 0x080017ac).

In dieser Funktion, nach einigen Initialisierungsoperationen (ohne jegliche Bedeutung):

void FUN_080015a8(void)

{
ushort uVar1;
undefined4 uVar2;
undefined4 uVar3;
ushort uVar4;
int iVar5;
ushort *puVar6;
undefined *local_2c;

DISPCNT = 0x1140;
FUN_08000a74();
FUN_08000ce4(1);
DISPCNT = 0x404;
FUN_08000dd0(&DAT_02009584,0x6000000,&DAT_030000dc);
FUN_08000354(&DAT_030000dc,0x3c);
uVar4 = DAT_030004d8;

Es wurde dieser Code gefunden:

do {
DAT_030004da = uVar4; //This is the last key pressed
DAT_030004d8 = KEYINPUT | 0xfc00;
puVar6 = &DAT_0200b03c;
uVar4 = DAT_030004d8;
do {
uVar2 = DAT_030004dc;
uVar1 = *puVar6;
if ((uVar1 & DAT_030004da & ~uVar4) != 0) {

Die letzte if-Abfrage überprüft, ob uVar4 in den letzten Schlüsseln enthalten ist und nicht im aktuellen Schlüssel, auch bekannt als Loslassen einer Taste (der aktuelle Schlüssel wird in uVar1 gespeichert).

if (uVar1 == 4) {
DAT_030000d4 = 0;
uVar3 = FUN_08001c24(DAT_030004dc);
FUN_08001868(uVar2,0,uVar3);
DAT_05000000 = 0x1483;
FUN_08001844(&DAT_0200ba18);
FUN_08001844(&DAT_0200ba20,&DAT_0200ba40);
DAT_030000d8 = 0;
uVar4 = DAT_030004d8;
}
else {
if (uVar1 == 8) {
if (DAT_030000d8 == 0xf3) {
DISPCNT = 0x404;
FUN_08000dd0(&DAT_02008aac,0x6000000,&DAT_030000dc);
FUN_08000354(&DAT_030000dc,0x3c);
uVar4 = DAT_030004d8;
}
}
else {
if (DAT_030000d4 < 8) {
DAT_030000d4 = DAT_030000d4 + 1;
FUN_08000864();
if (uVar1 == 0x10) {
DAT_030000d8 = DAT_030000d8 + 0x3a;

Im vorherigen Code sehen Sie, dass wir uVar1 (den Ort, an dem der Wert der gedrückten Taste liegt) mit einigen Werten vergleichen:

  • Zuerst wird er mit dem Wert 4 (SELECT-Taste) verglichen: In der Herausforderung löscht diese Taste den Bildschirm.
  • Dann wird er mit dem Wert 8 (START-Taste) verglichen: In der Herausforderung wird überprüft, ob der Code gültig ist, um die Flagge zu erhalten.
  • In diesem Fall wird die Variable DAT_030000d8 mit 0xf3 verglichen und wenn der Wert gleich ist, wird ein bestimmter Code ausgeführt.
  • In allen anderen Fällen wird ein bestimmter Inhalt (DAT_030000d4) überprüft. Es handelt sich um einen Inhalt, weil 1 direkt nach dem Eingeben des Codes hinzugefügt wird. Wenn weniger als 8 etwas, das das Hinzufügen von Werten zu DAT_030000d8 beinhaltet, durchgeführt wird (im Grunde werden die Werte der gedrückten Tasten in dieser Variablen addiert, solange der Inhalt kleiner als 8 ist).

In dieser Herausforderung mussten Sie also eine Kombination mit einer Länge kleiner als 8 drücken, sodass die resultierende Addition 0xf3 ergibt.

Referenz für dieses Tutorial: https://exp.codes/Nostalgia/

Game Boy

{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}

Kurse

Erlernen Sie AWS-Hacking von Null auf Held mit htARTE (HackTricks AWS Red Team Expert)!

Andere Möglichkeiten, HackTricks zu unterstützen: