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 7a28b92d6a Translated ['binary-exploitation/basic-stack-binary-exploitation-methodo
2024-07-18 22:13:00 +00:00
..
angr Translated ['binary-exploitation/basic-stack-binary-exploitation-methodo 2024-07-18 22:13:00 +00:00
blobrunner.md Translated to German 2024-02-10 15:36:32 +00:00
cheat-engine.md Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2 2024-05-05 22:18:38 +00:00
README.md Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2 2024-05-05 22:18:38 +00:00
satisfiability-modulo-theories-smt-z3.md Translated to German 2024-02-10 15:36:32 +00:00

README.md

Umkehrwerkzeuge & Grundlegende Methoden

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

Andere Möglichkeiten, HackTricks zu unterstützen:

Try Hard Security Group

{% embed url="https://discord.gg/tryhardsecurity" %}

ImGui-basierte Umkehrwerkzeuge

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 einem verlorenen Quellcode die Wiederherstellung aus einer Legacy-Assembly Zeit sparen 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 Einblick, wie die Daten durch eine Bibliothek oder Komponente fließen
  • Bietet Einblick 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 Fehler im Code, in Drittanbieterkomponenten 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 Download des Git erforderlich. Klicken Sie auf Erweiterungen und suchen Sie nach ILSpy).
Wenn Sie dekompilieren, ändern und erneut kompilieren müssen, können Sie dnSpy oder eine aktiv gepflegte Abspaltung davon, dnSpyEx, verwenden. (Rechtsklick -> Methode ändern, um etwas innerhalb einer Funktion zu ändern).

DNSpy-Protokollierung

Um DNSpy dazu zu bringen, einige Informationen in einer Datei zu protokollieren, könnten Sie diesen Codeausschnitt 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 folgendes tun:

Zuerst ändern Sie die Assembly-Eigenschaften, die sich auf das Debugging beziehen:

[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 über 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:

Jetzt, 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-/Entladevorgang"

  • 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 angehalten.

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 der 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 wenn die Ausführung aus irgendeinem Grund in win64dbg angehalten wird, Sie im Code sehen können, in welchem Teil des win64dbg-Fensters Sie sich befinden:

Dann, wenn Sie sehen, dass 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 unter:

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

PiNCE ist ein Front-End-/Reverse-Engineering-Tool für den GNU Project Debugger (GDB), das sich auf Spiele konzentriert. Es kann jedoch für alles im Zusammenhang mit Reverse Engineering verwendet werden.

Decompiler Explorer ist eine Web-Front-End für verschiedene Decompiler. Dieser Webservice ermöglicht es Ihnen, die Ausgabe verschiedener Decompiler auf kleinen ausführbaren Dateien zu vergleichen.

ARM & MIPS

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

Shellcodes

Debuggen eines Shellcodes mit blobrunner

Blobrunner wird den Shellcode in einem Speicherbereich allozieren, Ihnen die Speicheradresse anzeigen, an der der Shellcode alloziert wurde, und die Ausführung anhalten.
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 allozieren 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, als ich den Shellcode als Datei öffnete, wurde er korrekt dekompiliert, aber als ich ihn als Shellcode öffnete, nicht:

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

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

Entschlüsselung von Shellcode und Ermittlung ausgeführter Funktionen

Sie sollten scdbg ausprobieren.
Es wird Ihnen sagen, welche Funktionen der Shellcode verwendet und ob der Shellcode sich im Speicher entschlüsselt.

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 das Shellcode ausführen können

Die Create Dump-Option 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 es 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.
Wenn 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 Starten des Debuggens drücke erneut die Start-Schaltfläche (die grüne oder f9), und ein Breakpoint wird am Anfang des echten Codes erreicht.

Es ist auch sehr interessant, weil der Debugger anhält, wenn du in der grafischen Anwendung eine Schaltfläche drückst, die 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="../../generic-methodologies-and-resources/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 drückst

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 Programm wird der interessante 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 bestimmter Code ausgeführt.
  • In allen anderen Fällen wird ein cont (DAT_030000d4) überprüft. Es ist ein cont, weil es direkt nach dem Eingeben des Codes um 1 erhöht wird. Wenn es weniger als 8 ist, wird etwas gemacht, das das Hinzufügen von Werten zu DAT_030000d8 beinhaltet (im Grunde werden die Werte der gedrückten Tasten in dieser Variablen addiert, solange der cont kleiner als 8 ist).

Also mussten Sie in dieser Herausforderung, unter Berücksichtigung der Werte der Tasten, 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

Try Hard Security Group

{% embed url="https://discord.gg/tryhardsecurity" %}

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

Andere Möglichkeiten, HackTricks zu unterstützen: