Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 21:24:06 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/reversing/reversing-tools-basic-methods
History
Translator 1611151717 Translated ['README.md', 'generic-methodologies-and-resources/pentesting
2023-07-31 17:54:19 +00:00
..
angr Translated to French 2023-06-03 13:10:46 +00:00
blobrunner.md Translated to French 2023-06-03 13:10:46 +00:00
cheat-engine.md Translated to French 2023-06-03 13:10:46 +00:00
README.md Translated ['README.md', 'generic-methodologies-and-resources/pentesting 2023-07-31 17:54:19 +00:00
satisfiability-modulo-theories-smt-z3.md Translated to French 2023-06-03 13:10:46 +00:00

README.md

Outils de rétro-ingénierie et méthodes de base

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Outils de rétro-ingénierie basés sur ImGui

Logiciel :

Décompilateur Wasm / Compilateur Wat

En ligne :

Logiciel :

Décompilateur .Net

dotPeek

dotPeek est un décompilateur qui décompile et examine plusieurs formats, y compris les bibliothèques (.dll), les fichiers de métadonnées Windows (.winmd) et les exécutables (.exe). Une fois décompilée, une assembly peut être enregistrée en tant que projet Visual Studio (.csproj).

Le mérite ici est que si un code source perdu nécessite une restauration à partir d'une assembly héritée, cette action peut faire gagner du temps. De plus, dotPeek offre une navigation pratique dans le code décompilé, ce qui en fait l'un des outils parfaits pour l'analyse des algorithmes Xamarin.

.Net Reflector

Avec un modèle d'extension complet et une API qui étend l'outil pour répondre à vos besoins exacts, .NET reflector fait gagner du temps et simplifie le développement. Jetons un coup d'œil à la pléthore de services d'ingénierie inverse que cet outil offre :

  • Fournit un aperçu de la façon dont les données circulent à travers une bibliothèque ou un composant
  • Fournit un aperçu de la mise en œuvre et de l'utilisation des langages et frameworks .NET
  • Trouve des fonctionnalités non documentées et non exposées pour tirer le meilleur parti des API et des technologies utilisées.
  • Trouve les dépendances et les différentes assemblies
  • Localise l'emplacement exact des erreurs dans votre code, les composants tiers et les bibliothèques.
  • Débogue le code source de tout le code .NET avec lequel vous travaillez.

ILSpy & dnSpy

Plugin ILSpy pour Visual Studio Code : Vous pouvez l'avoir sur n'importe quel système d'exploitation (vous pouvez l'installer directement depuis VSCode, pas besoin de télécharger le git. Cliquez sur Extensions et recherchez ILSpy).
Si vous avez besoin de décompiler, modifier et recompiler à nouveau, vous pouvez utiliser : https://github.com/0xd4d/dnSpy/releases (Clic droit -> Modifier la méthode pour changer quelque chose à l'intérieur d'une fonction).
Vous pouvez également essayer https://www.jetbrains.com/es-es/decompiler/

Journalisation DNSpy

Pour faire en sorte que DNSpy enregistre certaines informations dans un fichier, vous pouvez utiliser ces lignes de code .Net :

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

Débogage avec DNSpy

Pour déboguer du code en utilisant DNSpy, vous devez :

Tout d'abord, modifier les attributs de l'assembly liés au débogage :

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

À:

Reverse Engineering Tools: Basic Methods

This repository contains a collection of basic methods and tools used in reverse engineering. Reverse engineering is the process of analyzing a software or hardware system to understand its design, functionality, and operation.

Contents

Introduction

Reverse engineering is a valuable skill for security researchers, software developers, and hackers. It allows you to understand how a system works, identify vulnerabilities, and develop exploits. This knowledge can be used for both defensive and offensive purposes.

Static Analysis

Static analysis involves examining the code or binary of a program without executing it. This can be done using tools such as disassemblers, decompilers, and hex editors. Static analysis helps in understanding the structure, logic, and behavior of a program.

Dynamic Analysis

Dynamic analysis involves running a program and observing its behavior in real-time. This can be done using tools such as debuggers, memory scanners, network sniffers, and packet analyzers. Dynamic analysis helps in understanding the runtime behavior, memory usage, and network communication of a program.

Debugging

Debugging is the process of finding and fixing bugs in a program. It involves using tools such as debuggers to trace the execution flow, inspect variables, and analyze memory contents. Debugging is an essential skill for reverse engineers and software developers.

Disassemblers

Disassemblers are tools that convert machine code into assembly code. They help in understanding the low-level instructions and control flow of a program. Some popular disassemblers include IDA Pro, Radare2, and Ghidra.

Decompilers

Decompilers are tools that convert machine code or binary executables into high-level programming languages such as C or C++. They help in understanding the original source code of a program. Some popular decompilers include IDA Pro, Ghidra, and RetDec.

Hex Editors

Hex editors are tools that allow you to view and edit binary files. They display the contents of a file in hexadecimal format, making it easier to analyze and modify the data. Some popular hex editors include HxD, Hex Fiend, and 010 Editor.

Memory Scanners

Memory scanners are tools that allow you to search for specific values or patterns in the memory of a running program. They are commonly used for cheat engine development and game hacking. Some popular memory scanners include Cheat Engine, ArtMoney, and GameGuardian.

Network Sniffers

Network sniffers are tools that capture and analyze network traffic. They allow you to intercept and inspect data packets flowing through a network interface. Some popular network sniffers include Wireshark, tcpdump, and Fiddler.

Packet Analyzers

Packet analyzers are tools that analyze network packets and provide detailed information about their contents. They help in understanding the protocols, headers, and payloads of network communications. Some popular packet analyzers include Wireshark, tcpdump, and NetworkMiner.

File Format Analysis

File format analysis involves examining the structure and contents of a file to understand its format and purpose. This can be done using tools such as hex editors, file viewers, and file format parsers. File format analysis helps in identifying file types, extracting data, and finding vulnerabilities.

Code Obfuscation

Code obfuscation is the process of intentionally making code difficult to understand or reverse engineer. It involves techniques such as renaming variables, encrypting strings, and adding junk code. Code obfuscation is commonly used to protect intellectual property and prevent unauthorized modifications.

Anti-Reverse Engineering Techniques

Anti-reverse engineering techniques are methods used to deter or prevent reverse engineering. These techniques can include code obfuscation, anti-debugging measures, and software protection mechanisms. Understanding these techniques is important for bypassing them and analyzing protected software.

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

Et cliquez sur compiler :

Ensuite, enregistrez le nouveau fichier sur Fichier >> Enregistrer le module... :

Ceci est nécessaire car si vous ne le faites pas, lors de l'exécution, plusieurs optimisations seront appliquées au code et il se pourrait que lors du débogage, un point d'arrêt ne soit jamais atteint ou que certaines variables n'existent pas.

Ensuite, si votre application .Net est exécutée par IIS, vous pouvez la redémarrer avec :

iisreset /noforce

Ensuite, pour commencer le débogage, vous devez fermer tous les fichiers ouverts et dans l'onglet Débogage, sélectionnez Attacher au processus... :

Ensuite, sélectionnez w3wp.exe pour vous connecter au serveur IIS et cliquez sur attacher :

Maintenant que nous déboguons le processus, il est temps de l'arrêter et de charger tous les modules. Cliquez d'abord sur Débogage >> Interrompre tout puis cliquez sur Débogage >> Fenêtres >> Modules :

Cliquez sur n'importe quel module dans Modules et sélectionnez Ouvrir tous les modules :

Cliquez avec le bouton droit de la souris sur n'importe quel module dans Explorateur d'assemblage et cliquez sur Trier les assemblages :

Décompilateur Java

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

Débogage des DLL

Utilisation de IDA

  • Charger rundll32 (64 bits dans C:\Windows\System32\rundll32.exe et 32 bits dans C:\Windows\SysWOW64\rundll32.exe)
  • Sélectionnez le débogueur Windbg
  • Sélectionnez "Suspendre lors du chargement/déchargement de la bibliothèque"

  • Configurez les paramètres de l'exécution en indiquant le chemin de la DLL et la fonction que vous souhaitez appeler :

Ensuite, lorsque vous commencez le débogage, l'exécution s'arrêtera lorsque chaque DLL est chargée, puis, lorsque rundll32 charge votre DLL, l'exécution s'arrêtera.

Mais comment accéder au code de la DLL qui a été chargée ? Avec cette méthode, je ne sais pas comment.

Utilisation de x64dbg/x32dbg

  • Charger rundll32 (64 bits dans C:\Windows\System32\rundll32.exe et 32 bits dans C:\Windows\SysWOW64\rundll32.exe)
  • Modifier la ligne de commande ( Fichier --> Modifier la ligne de commande ) et définissez le chemin de la DLL et la fonction que vous souhaitez appeler, par exemple : "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\14.ridii_2.dll",DLLMain
  • Modifiez Options --> Paramètres et sélectionnez "Entrée DLL".
  • Ensuite, démarrez l'exécution, le débogueur s'arrêtera à chaque point d'entrée de la DLL, à un moment donné, vous vous arrêterez dans l'entrée de la DLL de votre DLL. À partir de là, recherchez simplement les points où vous souhaitez mettre un point d'arrêt.

Notez que lorsque l'exécution est arrêtée pour une raison quelconque dans win64dbg, vous pouvez voir dans quel code vous êtes en regardant en haut de la fenêtre win64dbg :

Ensuite, en regardant cela, vous pouvez voir quand l'exécution a été arrêtée dans la DLL que vous souhaitez déboguer.

Applications GUI / Jeux vidéo

Cheat Engine est un programme utile pour trouver où les valeurs importantes sont enregistrées dans la mémoire d'un jeu en cours d'exécution et les modifier. Plus d'informations sur :

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

ARM & MIPS

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

Shellcodes

Débogage d'un shellcode avec blobrunner

Blobrunner allouera le shellcode dans un espace de mémoire, vous indiquera l'adresse mémoire où le shellcode a été alloué et arrêtera l'exécution.
Ensuite, vous devez attacher un débogueur (Ida ou x64dbg) au processus et mettre un point d'arrêt à l'adresse mémoire indiquée et reprendre l'exécution. De cette façon, vous déboguez le shellcode.

La page des versions publiées sur GitHub contient des fichiers zip contenant les versions compilées : https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5
Vous pouvez trouver une version légèrement modifiée de Blobrunner dans le lien suivant. Pour la compiler, il vous suffit de créer un projet C/C++ dans Visual Studio Code, copier et coller le code et le compiler.

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

Débogage d'un shellcode avec jmp2it

jmp2it est très similaire à blobrunner. Il allouera le shellcode dans un espace de mémoire et démarrera une boucle éternelle. Vous devez ensuite attacher le débogueur au processus, lancer le démarrage, attendre 2 à 5 secondes et appuyer sur stop, et vous vous retrouverez dans la boucle éternelle. Passez à l'instruction suivante de la boucle éternelle car il s'agira d'un appel au shellcode, et enfin vous vous retrouverez à exécuter le shellcode.

Vous pouvez télécharger une version compilée de jmp2it sur la page des versions.

Débogage du shellcode à l'aide de Cutter

Cutter est l'interface graphique de radare. Avec Cutter, vous pouvez émuler le shellcode et l'inspecter dynamiquement.

Notez que Cutter vous permet d'"Ouvrir un fichier" et "Ouvrir un shellcode". Dans mon cas, lorsque j'ai ouvert le shellcode en tant que fichier, il l'a décompilé correctement, mais lorsque je l'ai ouvert en tant que shellcode, il ne l'a pas fait :

Pour démarrer l'émulation à l'endroit souhaité, définissez un point d'arrêt là-bas et apparemment Cutter démarrera automatiquement l'émulation à partir de là :

Vous pouvez voir la pile par exemple dans un affichage hexadécimal :

Désobfuscation du shellcode et obtention des fonctions exécutées

Vous devriez essayer scdbg.
Il vous indiquera quelles fonctions le shellcode utilise et si le shellcode se décode lui-même en mémoire.

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 compte également sur un lanceur graphique où vous pouvez sélectionner les options souhaitées et exécuter le shellcode.

L'option Create Dump permettra de créer un dump du shellcode final si des modifications sont apportées au shellcode de manière dynamique en mémoire (utile pour télécharger le shellcode décodé). L'offset de démarrage peut être utile pour démarrer le shellcode à un offset spécifique. L'option Debug Shell est utile pour déboguer le shellcode en utilisant le terminal scDbg (cependant, je trouve que toutes les options expliquées précédemment sont meilleures pour cette question car vous pourrez utiliser Ida ou x64dbg).

Désassemblage à l'aide de CyberChef

Téléchargez votre fichier shellcode en tant qu'entrée et utilisez la recette suivante pour le décompiler: https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)

Movfuscator

Cet obfuscateur modifie toutes les instructions pour mov (oui, vraiment cool). Il utilise également des interruptions pour changer les flux d'exécution. Pour plus d'informations sur son fonctionnement:

Si vous avez de la chance, demovfuscator déobfusquera le binaire. Il a plusieurs dépendances.

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

Et installez keystone (apt-get install cmake; mkdir build; cd build; ../make-share.sh; make install)

Si vous jouez à un CTF, cette solution de contournement pour trouver le drapeau pourrait être très utile: https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html

Rust

Pour trouver le point d'entrée, recherchez les fonctions par ::main comme ceci:

Dans ce cas, le binaire s'appelait authenticator, il est donc assez évident que c'est la fonction principale intéressante.
Avoir le nom des fonctions appelées, recherchez-les sur Internet pour en apprendre davantage sur leurs entrées et sorties.

Delphi

Pour les binaires compilés en Delphi, vous pouvez utiliser https://github.com/crypto2011/IDR

Si vous devez inverser un binaire Delphi, je vous suggère d'utiliser le plugin IDA https://github.com/Coldzer0/IDA-For-Delphi

Appuyez simplement sur ATL+f7 (importez le plugin python dans IDA) et sélectionnez le plugin python.

Ce plugin exécutera le binaire et résoudra les noms de fonction de manière dynamique au début du débogage. Après avoir démarré le débogage, appuyez à nouveau sur le bouton Démarrer (le bouton vert ou f9) et un point d'arrêt sera atteint au début du code réel.

C'est également très intéressant car si vous appuyez sur un bouton dans l'application graphique, le débogueur s'arrêtera dans la fonction exécutée par ce bouton.

Golang

Si vous devez inverser un binaire Golang, je vous suggère d'utiliser le plugin IDA https://github.com/sibears/IDAGolangHelper

Appuyez simplement sur ATL+f7 (importez le plugin python dans IDA) et sélectionnez le plugin python.

Cela résoudra les noms des fonctions.

Python compilé

Sur cette page, vous pouvez trouver comment obtenir le code python à partir d'un binaire compilé ELF/EXE python:

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

GBA - Game Body Advance

Si vous obtenez le binaire d'un jeu GBA, vous pouvez utiliser différents outils pour émuler et déboguer:

Dans no$gba, dans Options --> Emulation Setup --> Controls** ** vous pouvez voir comment appuyer sur les boutons de la Game Boy Advance

Lorsqu'il est enfoncé, chaque touche a une valeur pour l'identifier:

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

Donc, dans ce genre de programmes, une partie intéressante sera comment le programme traite l'entrée de l'utilisateur. À l'adresse 0x4000130, vous trouverez la fonction couramment utilisée : KEYINPUT.

Dans l'image précédente, vous pouvez voir que la fonction est appelée depuis FUN_080015a8 (adresses : 0x080015fa et 0x080017ac).

Dans cette fonction, après quelques opérations d'initialisation (sans importance) :

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;

On a trouvé ce code :

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) {

Le dernier "if" vérifie si uVar4 se trouve dans les dernières clés et n'est pas la clé actuelle, également appelée relâchement d'un bouton (la clé actuelle est stockée dans uVar1).

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;

Dans le code précédent, vous pouvez voir que nous comparons uVar1 (l'endroit où se trouve la valeur du bouton pressé) avec certaines valeurs :

  • Tout d'abord, il est comparé avec la valeur 4 (bouton SELECT) : Dans le défi, ce bouton efface l'écran.
  • Ensuite, il est comparé avec la valeur 8 (bouton START) : Dans le défi, cela vérifie si le code est valide pour obtenir le drapeau.
  • Dans ce cas, la variable DAT_030000d8 est comparée avec 0xf3 et si la valeur est la même, un certain code est exécuté.
  • Dans tous les autres cas, un certain cont (DAT_030000d4) est vérifié. C'est un cont car il ajoute 1 juste après avoir entré dans le code.
    Si c'est inférieur à 8, quelque chose qui implique l'ajout de valeurs à **DAT_030000d8 ** est fait (essentiellement, il ajoute les valeurs des touches pressées dans cette variable tant que le cont est inférieur à 8).

Ainsi, dans ce défi, en connaissant les valeurs des boutons, vous deviez appuyer sur une combinaison d'une longueur inférieure à 8 pour que l'addition résultante soit 0xf3.

Référence pour ce tutoriel : https://exp.codes/Nostalgia/

Game Boy

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

Cours

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥