Partie 1 : Inversion de base

Chapitre 1 : Inverser l'histoire
1.1.
Ingénierie inverse (RE)
1.2.
Ingénierie inverse du code (RCE)
1.2.1.
Méthode d'inversion (analyse)
1.2.2.
Code source, code hexadécimal, code assembleur
1.2.3.
Réparations et fissures
1.3.
Fournitures de retournement
1.3.1.
cible
1.3.2.
passion
1.3.3.
Google
1.4.
Inverser les obstacles
1.4.1.
Avidité
1.4.2.
impatience
1.5.
Le plaisir de l'inversion

Chapitre 2 : Bonjour le monde ! Inversion
2.1.
Programme Bonjour le monde !
2.1.1.
Débogueurs et langage assembleur
2.2.
Débogage de HelloWorld.exe
2.2.1.
Objectifs de débogage
2.2.2.
Démarrer le débogage
2.2.3. EP
2.2.4.
Suivez la fonction 40270C
2.2.5.
Suivez la porte de secours jusqu'à 40104F
2.2.6.
Trouvez la fonction main()
2.3.
Familiarisez-vous davantage avec le débogueur
2.3.1.
Commandes du débogueur
2.3.2.
Camp de base
2.3.3.
4 façons d'établir un camp de base
2.4.
4 façons de trouver rapidement le code que vous recherchez
2.4.1.
Comment exécuter le code
2.4.2.
Comment rechercher une chaîne de caractères
2.4.3. Méthode de recherche API (1) - BP dans le code appelant
2.4.4. Méthode de recherche API (2) - BP directement dans le code API
2.5.
Remplacez la chaîne « Hello World ! »
2.5.1.
Correctif
2.5.2.
Deux façons de réparer une chaîne
2.6.
finition

Chapitre 3 Notation Little Endian
3.1.
Ordre des octets 49
3.1.1.
Petit bout indien et gros bout indien
3.1.2.
Vérification du format Little Endian dans OllyDbg

Chapitre 4 : Description de base des registres IA-32
4.1. Que sont les registres du processeur ?
4.1.1.
Pourquoi vous devez connaître les registres
4.2. Registres IA-32
4.2.1.
Registres d'exécution de programme de base
4.3.
finition

Chapitre 5 Pile
5.1.
empiler
5.1.1.
Fonctionnalités de la pile
5.1.2.
Exemple d'opération sur pile

Chapitre 6 abex crackme #1 analyse
6.1.
abex' crackme #1
6.1.1.
Démarrer le débogage
6.1.2.
Analyse du code
6.2.
fissure
6.3.
Comment passer des paramètres sur la pile
6.4.
finition

Chapitre 7 Cadre de pile
7.1.
cadre de pile
7.2.
Exemple pratique - stackframe.exe
7.2.1.
StackFrame.cpp
7.2.2.
Démarrez la fonction main() et créez une trame de pile.
7.2.3.
Définition des variables locales
7.2.4.
Saisissez les paramètres de la fonction add() et appelez la fonction add().
7.2.5.
Démarrez la fonction add() et créez une trame de pile.
7.2.6.
Définition des variables locales (x, y) de la fonction add()
7.2.7. Opération ADD
7.2.8.
Déballez le cadre de pile de la fonction add() et terminez la fonction (retour).
7.2.9.
Supprimer le paramètre de la fonction add() (nettoyage de la pile)
7.2.10.
appel de fonction printf()
7.2.11.
Définition de la valeur de retour
7.2.12.
Déballez le cadre de pile et quittez la fonction main().
7.3.
Modification des options d'OllyDbg
7.3.1.
options de désarmement
7.3.2.
Option d'analyse 1
7.4.
finition

Chapitre 8 abex crackme #2
8.1.
abex' crackme #2 run
8.2.
Fonctionnalités des fichiers Visual Basic
8.2.1. Moteur spécifique VB
8.2.2.
Code N (natif), code P (pseudo-code)
8.2.3.
Gestionnaire d'événements
8.2.4.
structure non documentée
8.3.
Démarrer le débogage
8.3.1.
Appel indirect
8.3.2. Structure RT_MainStruct
8.3.3.
Fonction ThunRTMain()
8.4.
analyse crackme
8.4.1.
Recherche de chaînes
8.4.2.
Trouver l'adresse de la chaîne
8.4.3.
Algorithme de génération en série
8.4.4.
Code de prédiction
8.4.5.
Code pour lire la chaîne Nom
8.4.6.
Boucle de chiffrement
8.4.7.
Méthode de chiffrement
8.5.
finition

Chapitre 9 Process Explorer - Le gestionnaire de tâches ultime
9.1.
Explorateur de processus
9.2.
Qu'est-ce qui le rend particulièrement avantageux ?
9.3.
sysinternals

Chapitre 10 : Convention d'appel
10.1.
Convention d'appel
10.1.1.
cdecl
10.1.2.
appel standard
10.1.3.
appel rapide

Chapitre 11 : La marche arrière de Lena pour les débutants
11.1.
exécution
11.2.
analyser
11.2.1.
Objectif (1) - Supprimer la boîte de message !
11.2.2.
Correctif (1) - Supprimer la boîte de message
11.2.3.
Objectif (2) - Trouver le code d'enregistrement
11.3.
finition

Chapitre 12 : Comment diable dois-je étudier l'inversion ?
12.1.
Ingénierie inverse (RE)
12.1.1.
Toute étude doit avoir un « but ».

12.1.2.
Ayez un « esprit positif ».

12.1.3.
Vous devez ressentir du plaisir.

12.1.4.
Nous devons faire de la « recherche » une partie intégrante de notre vie quotidienne.

12.1.5.
Le plus important, c'est la pratique.

12.1.6.
Ayez l'esprit détendu.


Partie 2 Format de fichier PE

Chapitre 13 Format de fichier PE
13.1.
Introduction
13.2. Format de fichier PE
13.2.1.
structure de base
13.2.2. VA et RVA
13.3. En-tête PE
13.3.1. En-tête DOS
13.3.2. Ébauche DOS
13.3.3. En-tête NT
13.3.4. IMAGE_NT_HEADERS - IMAGE_FILE_HEADER
13.3.5. IMAGE_NT_HEADERS - IMAGE_OPTIONAL_HEADER32
13.3.6.

13.4. RVA à RAW
13.5. IAT
13.5.1. DLL
13.5.2. DESCRIPTEUR_IMPORTATION_IMAGE
13.5.3.
Entraînez-vous à utiliser notepad.exe
13.6. MANGER
13.6.1. RÉPERTOIRE_D'EXPORTATION_IMAGE
13.6.2.
Entraînez-vous à utiliser kernel32.dll
13.7.
PE avancé (exécutable portable)
13.7.1. PEView.exe
13.7.2.
PE rapiécé
13.8.
finition

Chapitre 14 Compression d'exécution
14.1.
Compression des données
14.1.1.
compression sans perte
14.1.2.
compression avec perte
14.2.
Compression exécutable
14.2.1.
Emballeur
14.2.2.
Protecteur
14.3.
Test de compression d'exécution
14.3.1.
Comparaison des fichiers notepad.exe et notepad_upx.exe

Chapitre 15 : Débogage du Bloc-notes compressé avec des exécutables UPX
15.1.
Code EP de notepad.exe
15.2.
Code EP de notepad_upx.exe
15.3. Traçage des fichiers UPX
15.3.1.
Commande de traçage d'OllyDbg
15.3.2.
Boucle n° 1
15.3.3.
Boucle n° 2
15.3.4.
Boucle n° 3
15.3.5.
Boucle n° 4
15.4. Comment trouver rapidement l'OEP de l'UPX
15.4.1. Installation de BP dans l'instruction JMP après l'instruction POPAD
15.4.2.
Installation d'un point d'arrêt matériel sur la pile
15,5.
finition

Chapitre 16 Tableau de relocalisation de base
16.1. Relocalisation PE
16.1.1. DLL/SYS
16.1.2. EXE
16.2. Actions entreprises lors du déplacement d'un entité physique
16.3. Principe de fonctionnement du déplacement des équipements de production
16.3.1.
Tableau de relocalisation de base
16.3.2. Structure IMAGE_BASE_RELOCATION
16.3.3.
Comment interpréter le tableau de relocalisation de base
16.3.4.
Pratique

Chapitre 17 Suppression de la section .reloc d'un exécutable
17.1.
section .reloc
17.2.
reloc.exe
17.2.1.
Nettoyage de l'en-tête de section .reloc
17.2.2.
Supprimer la section .reloc
17.2.3. Modifier l'en-tête du fichier image
17.2.4. Modification de l'en-tête optionnel de l'image
17.3.
finition

Chapitre 18 : Analyse détaillée de l’en-tête PE UPack
18.1. Description d'UPack
18.2. Compression du fichier exécutable notepad.exe avec UPack
18.3.
Utilisation de Stud_PE
18.4. Comparaison des en-têtes PE
18.4.1.
En-tête PE de notepad.exe (original)
18.4.2.
En-tête PE de notepad_upack.exe (archive exécutable)
18.5. Analyse de l'en-tête PE d'UPack
18.5.1.
En-tête de remplacement
18.5.2. IMAGE_FILE_HEADER.SizeOfOptionalHeader
18.5.3. IMAGE_OPTIONAL_HEADER.NumberOfRvaAndSizes
18.5.4. EN-TÊTE DE SECTION IMAGE
18.5.5.
Écraser les sections
18.5.6. RVA à RAW
18.5.7.
Importer la table (tableau IMAGE_IMPORT_DESCRIPTOR)
18.5.8. Table des adresses d'importation (IAT)
18.6.
finition

Chapitre 19 : Débogage d’UPack – Recherche d’OEP
19.1.
Erreur d'exécution d'OllyDbg
19.2.
boucle de décodage
19.3. Paramètres IAT
19.4.
finition

Chapitre 20 : Exercices pratiques sur les patchs en ligne
20.1.
Patch en ligne
20.2.
Pratique - Patchme
20.3.
Débogage - Analyse du flux d'exécution
20.4.
structure du code
20,5.
Pratique du patch en ligne
20.5.1.
Où dois-je installer le câble de raccordement ?
20.5.2.
Création d'un code de correctif
20.5.3.
Exécution du code correctif
20.5.4.
Vérifier les résultats

Partie 3 Injection de DLL

Chapitre 21 : Interception des messages Windows
21.1.
crochet
21.2.
Message Hook
21.3.
DéfinirWindowsHookEx ( )
21.4.
pratique de l'accrochage de messages au clavier
21.4.1.
Exemple pratique HookMain.exe
21.4.2.
Analyse du code source
21,5.
Pratique du débogage
21.5.1.
Débogage de HookMain.exe
21.5.2.
Débogage de KeyHook.dll dans le processus Notepad.exe
21.6.
finition

Chapitre 22 : Les enregistreurs de frappe utilisés à des fins malveillantes
22.1.
Cibles des enregistreurs de frappe malveillants
22.1.1.
jeux en ligne
22.1.2.
Services bancaires par Internet
22.1.3.
fuite d'informations d'entreprise
22.2.
Types d'enregistreurs de frappe et perspectives de développement
22.3.
Notre position concernant la lutte contre les enregistreurs de frappe
22.4.
Informations personnelles

Chapitre 23 Injection de DLL
23.1. Injection de DLL
23.2. Exemple d'utilisation de l'injection de DLL
23.2.1.
Améliorations des fonctionnalités et corrections de bugs
23.2.2.
Interception de messages
23.2.3. Interconnexion d'API
23.2.4.
Autres applications
23.2.5.
Logiciel malveillant
23.3. Comment implémenter l'injection de DLL
23.4.
CréerThreadDistant()
23.4.1.
Exemple pratique myhack.dll
23.4.2.
Exemple d'analyse de code source
23.4.3.
Comment déboguer
23,5.
AppInit_DLLs
23.5.1.
Exemple d'analyse de code source
23.5.2.
Exemple pratique myhack2.dll
23.6.
DéfinirWindowsHookEx ( )
23.7.
finition

Chapitre 24 Éjection de DLL
24.1. Fonctionnement de l'éjection des DLL
24.2. Mise en œuvre de l'éjection de DLL
24.2.1.
Obtenir des informations sur les DLL chargées dans un processus
24.2.2.
Obtenez le descripteur du processus cible
24.2.3.
Obtenez l'adresse de l'API FreeLibrary()
24.2.4.
Exécuter un thread dans le processus cible
24.3. Exercice simple d'éjection de DLL
24.3.1.
Copiez le fichier et exécutez notepad.exe
24.3.2.
injection
24.3.3.
Éjection

Chapitre 25 : Chargement des DLL à l’aide de correctifs PE
25.1.
Fichiers d'exercices
25.1.1.
TextView.exe
25.1.2.
TextView_patched.exe
25.2.
Code source - myhack3.cpp
25.2.1.
DllMain()
25.2.2.
URL de téléchargement ( )
25.2.3.
DéposerFichier()
25.2.4.
factice( )
25.3.
Préparation du correctif pour le fichier TextView.exe
25.3.1.
Idées de patchs
25.3.2.
Pré-recherche de patch
25.3.3. Mouvement IDT
25.4.
Opération de correctif TextView.exe
25.4.1. Modification de la valeur RVA du tableau IMPORT
25.4.2. Supprimer la table d'importation liée
25.4.3.
Créer un nouvel IDT
25.4.4.
Nom, INT, paramètres IAT
25.4.5. Modifier les caractéristiques de la section IAT
25,5.
Test
25.6.
finition

Chapitre 26 Outils PE
26.1. Outils PE
26.1.1.
Vidage de la mémoire du processus
26.1.2. Éditeur PE
26.2.
finition
Faire une pause - Le vrai plaisir de la marche arrière

Chapitre 27 Injection de code
27.1.
Injection de code
27.2. Injection de DLL vs. Injection de code
27.2.1.
Pourquoi utiliser l'injection de code ?
27.3.
Exemple pratique
27.3.1.
Exécutez notepad.exe
27.3.2.
Exécutez CodeInjection.exe
27.3.3.
Cochez la boîte de message
27.4.
Injection de code.cpp
27.4.1.
principal( )
27.4.2.
ThreadProc()
27.4.3.
InjecterCode()
27,5.
Pratique du débogage par injection de code
27.5.1.
Débogage de notepad.exe
27.5.2.
Modification des options d'OllyDbg
27.5.3.
Exécutez CodeInjection.exe
27.5.4.
Code de démarrage du thread
27.6.
finition

Chapitre 28 : Injection de code à l’aide du langage assembleur
28.1.
cible
28.2.
Programmation en assembleur
28.3.
Commande Assemble d'OllyDbg
28.3.1.
Écriture de ThreadProc()
28.3.2.
Enregistrer le fichier
28.4.
fabrication d'injecteurs
28.4.1.
Obtention du code binaire de la fonction ThreadProc()
28.4.2.
CodeInjection2.cpp
28,5.
Pratique du débogage
28.5.1.
Débogage de notepad.exe
28.5.2.
Modification des options d'OllyDbg
28.5.3.
Exécutez CodeInjection2.exe
28.5.4.
Code de démarrage du thread
28.6.
Analyse détaillée
28.6.1.
cadre de pile
28.6.2. Pointeur de structure THREAD_PARAM
28.6.3.
La chaîne « user32.dll »
28.6.4.
Saisissez le paramètre de chaîne « user32.dll »
28.6.5.
Appeler LoadLibraryA(“user32.dll”)
28.6.6.
chaîne « MessageBoxA »
28.6.7.
Appeler GetProcAddress(hMod, « MessageBoxA »)
28.6.8.
Paramètre d'entrée 1 de MessageBoxA() - MB_OK
28.6.9.
Paramètre d'entrée 2 de MessageBoxA() - « ReverseCore »
28.6.10.
Paramètre d'entrée 3 de MessageBoxA() - « www.reversecore.com »
28.6.11.
Paramètre d'entrée 4 de MessageBoxA() - NULL
28.6.12.
Appelez MessageBoxA
28.6.13.
Définition de la valeur de retour de ThreadProc()
28.6.14.
Déballez le cadre de pile et renvoyez la fonction
28.7.
finition

Partie 4 : Interconnexion d’API

Chapitre 29 : Interception d’API : La « fleur » du reverse engineering
29.1.
Crochetage
29.2. API
29.3. Interconnexion d'API
29.3.1.
Appel API normal
29.3.2.
Appel API de type « Hooking »
29.4.
Carte technologique
29.4.1.
Objet Méthode(quoi)
29.4.2.
Lieu (où)
29.4.3.
Technique (Comment)
29.5. API

Chapitre 30 Bloc-notes WriteFile() Interception
30.1.
Carte technique - Techniques de débogage
30.2.
Description du débogueur
30.2.1.
Terminologie
30.2.2.
Fonctionnalités du débogueur
30.2.3.
Fonctionnement du débogueur
30.2.4.
Événement de débogage
30.3.
ordre de travail
30.4.
Pratique
30,5.
Comment ça marche
30.5.1.
empiler
30.5.2.
Flux d'exécution
30.5.3.
Décrocher et accrocher
30.6.
Description du code source
30.6.1.
principal( )
30.6.2.
Boucle de débogage()
30.6.3. ÉVÉNEMENT DE DÉBOGAGE DU PROCESSUS DE SORTIE
30.6.4. CREATE_PROCESS_DEBUG_EVENT - Événement OnCreateProcessDebug()
30.6.5. EXCEPTION_DEBUG_EVENT - OnExceptionDebugEvent()

Chapitre 31 : L'histoire du débogueur
31.1.
OllyDbg
31.2. IDA Pro
31.3.
WinDbg

Chapitre 32 : Calculatrice, Apprendre le coréen
32.1.
Carte technologique
32.2.
Sélection d'une API cible
32.3. Principe de fonctionnement du crochetage IAT
32.4.
Pratique
32,5.
Analyse du code source
32.5.1.
DllMain()
32.5.2.
MySetWindowTextW()
32.5.3.
hook_iat ( )
32.6.
Débogage des DLL injectées
32.6.1.
DllMain()
32.6.2.
hook_iat ( )
32.6.3.
MySetWindowTextW()
32.7.
finition

Chapitre 33 : Le processus « furtif »
33.1.
Carte technologique
33.2. Fonctionnement du correctif de code API
33.2.1.
Avant l'accrochage
33.2.2.
Après avoir accroché
33.3.
Dissimulation du processus
33.3.1.
Principe de fonctionnement de dissimulation des processus
33.3.2.
API associées
33.3.3.
Problèmes liés aux techniques de dissimulation
33.4.
Exercice n° 1 (HideProc.exe, stealth.dll)
33.4.1.
Exécutez notepad.exe, procexp.exe, taskmgr.exe
33.4.2.
Exécutez HideProc.exe
33.4.3.
Vérifier l'injection de stealth.dll
33.4.4.
Vérifiez si le processus notepad.exe est masqué.
33.4.5.
Afficher le processus notepad.exe
33,5.
Analyse du code source
33.5.1.
HookProc.cpp
33.5.2.
furtif.cpp
33.6.
Interconnexion globale de l'API
33.6.1.
API Kernel32.CreateProcess()
33.6.2.
API Ntdll.ZwResumeThread()
33.7.
Exercice n° 2 (HideProc2.exe, stealth2.dll)
33.7.1.
Copiez le fichier stealth2.dll dans le dossier %SYSTEM%
33.7.2.
Exécutez HideProc2.exe -hide
33.7.3.
Exécutez ProcExp.exe et notepad.exe
33.7.4.
Exécutez HideProc2.exe -afficher
33.8.
Analyse du code source
33.8.1.
HideProc2.cpp
33.8.2.
stealth2.cpp
33.9.
Interception d'API par patch à chaud
33.9.1.
Problèmes liés aux méthodes de correction de code API existantes
33.9.2.
Correctif à chaud (correctif de code de 7 octets)
33.10.
Exercice n° 3 - stealth3.dll
33.11.
Analyse du code source
33.11.1.
Stealth3.cpp
33.12.
Considérations relatives à l'interception d'API par correctif à chaud
33.12.
finition

34.1.
Interception de l'API cible
34.1.1.
Vérification ? Débogage des processus IE
34.2. Structure du processus IE
34.3.
Concepts d'interconnexion d'API globales
34.3.1.
Interconnexion générale d'API
34.3.2.
Interconnexion globale de l'API
34.4.
API ntdll!ZwResumeThread()
34,5.
Exemple pratique ? Contrôle d’accès IE
34.5.1. Exécution d'IE
34.5.2. Injection de DLL
34.5.3.
Créer un nouvel onglet
34.5.4.
Accédez au site portail
34.5.5. Éjection de la DLL
34.5.6.
Pratique supplémentaire
34.6.
Exemple de code source
34.6.1.
DllMain()
34.6.2.
NewInternetConnectW( )
34.6.3.
NewZwResumeThread()
34.7.
finition

Chapitre 35 : Cinq critères pour choisir un bon outil d’analyse
35.1.
équipement
35.2.
Ingénieur en rétro-ingénierie
35.3.
5 critères pour choisir un bon outil d'analyse
35.3.1.
Réduisez le nombre d'outils.

35.3.2.
Il est bon que les outils aient des fonctions simples et soient faciles à utiliser.

35.3.3.
Apprenez les fonctions en détail.

35.3.4.
Il est mis à jour régulièrement.

35.3.5.
Comprendre les principes de fonctionnement fondamentaux de l'outil.

35.4.
L'importance de la compétence
Partie 5 : Noyau 6 de Windows 6 (64 bits)

Chapitre 36 : Informatique 64 bits
36.1.
environnement informatique 64 bits
36.1.1.
Processeur 64 bits
36.1.2.
Système d'exploitation 64 bits
36.1.3.
API Win32
36.1.4. WOW64
36.1.5.
Exercice - WOW64Test
36.2.
version 64 bits
36.2.1.
Kit de développement logiciel (SDK) Microsoft Windows
36.2.2.
Configuration de Visual C++ 2010 Express

Chapitre 37 : L'histoire du processeur x64
37.1.
Qu'est-ce qui a été ajouté/modifié dans x64 ?
37.1.1.
64 bits
37.1.2.
mémoire
37.1.3.
Registres à usage général en x64
37.1.4. Instructions d'appel/de saut
37.1.5.
conventions d'appel de fonction
37.1.6.
Empiler et cadre d'empilage
37.2.
Exercices - Stack64.exe et Stack32.exe
37.2.1.
Stack32.exe
37.2.2.
Stack64.exe
37.2.
finition

Chapitre 38 PE32+
38.1. PE32+ (PE+, PE64)
38.1.1. IMAGE_NT_HEADERS
38.1.2. EN-TÊTE_FICHIER_IMAGE
38.1.3. IMAGE_OPTIONAL_HEADER
38.1.4. IMAGE_THUNK_DATA
38.1.5. IMAGE_TLS_DIRECTORY64

Chapitre 39 WinDbg
39.1.
WinDbg
39.1.1.
Fonctionnalités de WinDbg
39.1.2.
Exécution de WinDbg
39.1.3.
Débogage du noyau
39.1.4.
Commandes de base de WinDbg

Chapitre 40 Débogage 64 bits
40.1.
Sélection du débogueur dans les environnements x64 627
40.2.
Débogage 64 bits 628
40.2.1.
Exemple concret ? Test WOW64
40.3. PE32:WOW64Test_x86.exe
40.3.1. Code EP
40.3.2.
Code de démarrage
40.3.3.
fonction principale()
40.4. PE32+ : WOW64Test_x64.exe
40.4.1.
Point d'arrêt du système
40.4.2. Code EP
40.4.3.
Code de démarrage
40.4.4.
fonction principale()
40,5.
finition

Chapitre 41 ASLR
41.1.
Version du noyau Windows
41.2. ASLR
41.3.
Visual C++
41.4. ASLR.exe
41.4.1.
Informations sur la section
41.4.2. Caractéristiques de l'en-tête du fichier image
41.4.3. Caractéristiques de la DLL IMAGE_OPTIONAL_HEADER
41,5.
Exercice - Suppression de la fonction ASLR
41.5.1. Suppression de la fonction ASLR

Chapitre 42 Session dans le noyau 6
42.1.
session
42.2.
Isolement de la session 0
42.3.
Sécurité renforcée

Chapitre 43 : Injection de DLL dans le noyau 6
43.1. Reproduction de l'échec d'injection DLL
43.1.1.
Code source
43.1.2.
test d'injection
43.2.
Analyse des causes
43.2.1.
Débogage n° 1
43.2.2.
Débogage n° 2
43.3.
Exercice - Comment faire en sorte que CreateRemoteThread() réussisse
43.3.1.
Méthode n° 1 - Modifier le paramètre CreateSuspended
43.3.2.
Méthode n° 2 - Branchement conditionnel
43.4.
Résumé simple
43,5.
InjectDll_new.exe
43.5.1.
InjectDll_new.cpp
43.5.2.
Pratique de l'injection

Chapitre 44 InjDll.exe - Outil d'injection de DLL
44.1.
InjDll.exe
44.1.1.
Comment utiliser
44.1.2.
Exemples d'utilisation
44.1.3.
prudence

Partie 6 Marche arrière avancée

Chapitre 45 Fonction de rappel TLS
45.1.
Exercice n° 1 - HelloTls.exe
45.2. TLS
45.2.1. RÉPERTOIRE_DES_DONNÉES_IMAGE[9]
45.2.2. RÉPERTOIRE_TLS_IMAGE
45.2.3.
Tableau d'adresses de fonctions de rappel
45.3. Fonction de rappel TLS
45.3.1. IMAGE_TLS_CALLBACK
45.4.
Exercice n° 2 - TlsTest.exe
45.4.1. DLL_PROCESS_ATTACH
45.4.2. DLL_THREAD_ATTACH
45.4.3. DLL_THREAD_DETACH
45.4.4. DLL_PROCESS_DETACH
45.5. Débogage des rappels TLS
45.6.
Ajout manuel d'une fonction de rappel TLS
45.6.1.
Matériel d'entraînement
45.6.2.
conception
45.6.3. Modification de l'en-tête PE
45.6.4. Configuration de IMAGE_TLS_DIRECTORY
45.6.5. Programmation des fonctions de rappel TLS
45.6.6.
Achèvement final
45.7.
finition

Chapitre 46 TEB
46.1. TEB
46.1.1. Définition de la structure TEB
46.1.2. Contenu de la structure TEB
46.1.3.
membres importants
46.2. Approche TEB
46.2.1.
Ntdll.NtCurrentTeb ( )
46.2.2. Registre de segment FS
46.3.
finition

Chapitre 47 PEB
47.1. PEB
47.1.1. Approche PEB
47.1.2. Définition de la structure PEB
47.1.3. Contenu de la structure PEB
47.2. Description des principaux membres du PEB
47.2.1. PEB.En cours de débogage
47.2.2. PEB.ImageBaseAddress
47.2.3. PEB.Ldr
47.2.4. PEB.ProcessHeap & PEB.NtGlobalFlag
47.3.
finition

Chapitre 48 SEH
48.1. SEH
48.1.1.
Description de base
48.2. Exemple d'exercice SEH n° 1
48.2.1.
Exécution normale
48.2.2.
Exécuter dans le débogueur
48.3. Comment le système d'exploitation gère les exceptions
48.3.1.
Comment gérer les exceptions lors d'une exécution normale
48.3.2.
Comment gérer les exceptions lors du débogage
48.4.
exception
48.4.1. EXCEPTION_VIOLATION_D'ACCÈS(C0000005)
48.4.2. EXCEPTION_BREAKPOINT(80000003)
48.4.3. EXCEPTION_INSTRUCTION_ILLÉGALE(C000001D)
48.4.4. EXCEPTION_INT_DIVIDE_BY_ZERO(C0000094)
48.4.5. EXCEPTION_SINGLE_STEP(80000004)
48.5. Description détaillée du SEH
48.5.1. Chaîne SEH
48.5.2.
Définition de fonction
48.5.3. TEB.NtTib.ExceptionList
48.5.4. Comment installer SEH
48.6. Exemple pratique SEH n° 2 (seh.exe)
48.6.1. Vérification de la chaîne SEH
48.6.2. Ajout de SEH
48.6.3.
Une exception s'est produite.
48.6.4.
Vérifier les paramètres du gestionnaire d'exceptions
48.6.5.
Gestionnaires d'exceptions de débogage
48.6.6. Suppression du SEH
48.7.
Configuration des options d'OllyDbg
48.7.1. Ignorer les exceptions KERNEL32
48.7.2.
Transmettez les exceptions au débogueur
48.7.3.
Gestion des autres exceptions
48.7.4.
Pratique simple
48.8.
finition

Chapitre 49 IA-32 Instructions
49.1. Instructions IA-32
49.2.
Glossaire des termes
49.2.1.
Désassembleur
49.2.2.
Décompilateur
49.2.3.
Une brève introduction à la décompilation
49.3. Format d'instruction IA-32
49.3.1.
Préfixes d'instructions
49.3.2.
Opcode
49.3.3.
ModR/M
49.3.4. SIB
49.3.5.
Déplacement
49.3.6.
Immédiat
49.4.
Manuel d'interprétation des instructions
49.4.1. Téléchargez les manuels IA-32
49.4.2.
Sortie du manuel d'interprétation des instructions
49,5.
Exercices d'interprétation des instructions
49.5.1.
Carte des codes d'opération
49.5.2.
Opérande
49.5.3.
ModR/M
49.5.4.
Groupe
49.5.5.
Préfixe
49.5.6.
Code d'opération sur 2 octets
49.5.7.
Déplacement et immédiat
49.5.8. SIB
49.6.
Instructions d'interprétation supplémentaires
49.7.
finition

Partie 7 : Anti-débogage

Chapitre 50 Anti-débogage
50.1.
Techniques anti-débogage
50.1.1.
Dépendance
50.1.2.
Diverses techniques
50.2.
Techniques anti-anti-débogage
50.3.
Classification anti-débogage
50.3.1.
Anti-débogage statique
50.3.2.
Anti-débogage dynamique

Chapitre 51 : Antidébogage statique
51.1.
Objectif de l'antidébogage statique
51.2. PEB
51.2.1.
En cours de débogage (+0x2)
51.2.2.
Ldr (+0xC)
51.2.3.
Tas de processus (+0x18)
51.2.4.
NtGlobalFlag(+0x68)
51.2.5.
Exercice - StaAD_PEB.exe
51.2.6.
Comment éviter
51.3.
Processus d'information NtQuery()
51.3.1.
ProcessDebugPort(0x7)
51.3.2.
ProcessDebugObjectHandle(0x1E)
51.3.3.
ProcessDebugFlags(0x1F)
51.3.4.
Exercice - StaAD_NtQIP.exe
51.3.5.
Comment éviter
51.4.
NtQuerySystemInformation ( )
51.4.1.
Informations du débogueur du noyau système (0x23)
51.4.2.
Exercice - StaAD_NtQSI.exe
51.4.3.
Comment éviter
51,5.
NtQueryObject()
51.5.1.
Exercice - StaAD_NtQO.exe
51.6.
ZwSetInformationThread()
51.6.1.
Exercice - StaAD_ZwSIT.exe
51.6.2.
Comment éviter
51.7. Fonction de rappel TLS
51.8. ETC
51.8.1.
Pratique - StaAD_FindWindow.exe
51.8.2.
Comment éviter
51.9.
finition

Chapitre 52 : Anti-débogage dynamique
52.1.
Objectif du code anti-débogage dynamique
52.2.
Exceptions
52.2.1. SEH
52.2.2.
DéfinirFiltreExceptionNonGérée()
52.3.
Vérification du timing
52.3.1.
Comment mesurer les intervalles de temps
52.3.2. RDTSC
52.4.
Drapeau de piège
52.4.1.
Étape unique
52.4.2. INT 2D
52,5.
Détection 0xCC
52.5.1. Points d'arrêt de l'API
52.5.2.
comparaison de sommes de contrôle
52.6.
finition

Chapitre 53 : Anti-débogage avancé
53.1.
Techniques anti-débogage avancées
53.2.
Code poubelle
53.3.
Rupture de l'alignement du code
53.4.
Chiffrement/Déchiffrement
53.4.1.
Pour les codes de décodage simples
53.4.2.
Pour les codes de décodage complexes
53.4.3.
Cas particulier - recombinaison de code
53,5.
Octets volés (Supprimer OEP)
53.6. Redirection API
53.6.1.
Code original
53.6.2. Exemple de redirection d'API n° 1
53.6.3. Exemple de redirection d'API n° 2
53.7.
Bloqueur de débogage (autodébogage)
53.8.
finition

Partie 8 : Exercices de débogage

Chapitre 54 Exercice de débogage 1 - Services
54.1.
Fonctionnement du processus de service
54.1.1.
Contrôleur de service
54.1.2.
Comprendre le processus de démarrage du service
54.2.
Exemple de description de DebugMe1.exe
54.2.1.
Installation de service
54.2.2.
Démarrage du service
54.2.3.
Code source
54.3.
Débogage des problèmes dans le processus de service
54.3.1.
Le problème réside dans la gestion de la chaîne d'approvisionnement (SCM).
54.3.2.
Il n'y a rien qu'un débogueur ne puisse faire.
54.3.3.
Faisons-le correctement.
54.4.
Pratique de débogage de service
54.4.1.
Débogage simple - forcer la configuration EIP
54.4.2.
Principes de base du débogage des services - Méthode Attach
54,5.
finition

Chapitre 55 : Exercice de débogage 2 - Auto-création
55.1.
Auto-création
55.2.
Comment ça marche
55.2.1.
Créer un processus enfant (mode SUSPEND)
55.2.2.
Modifier le programme d'investissement européen
55.2.3.
Reprendre le fil principal
55.3.
Explication de l'exemple de code source
55.4.
Pratique du débogage
55.4.1.
Considérations
55.4.2. Débogage juste-à-temps
55.4.3.
DebugMe2.exe
55,5.
finition

Chapitre 56 Exercice de débogage 3 - Commutation d'image PE
56.1. Image PE
56.2. Commutation d'images PE
56.3.
Exemples de fichiers : Fake.exe, Real.exe, DebugMe3.exe
56.4.
Débogage 1
56.4.1.
Ouvrir - Saisir les paramètres d'exécution
56.4.2.
principal( )
56.4.3.
Sous-fonction_1 ( )
56.4.4.
CréerProcessus("fake.exe", CRÉATION_SUSPENDUE)
56.4.5.
SubFunc_2 ( )
56.4.6.
SubFunc_3 ( )
56,5.
Débogage 2
56.5.1.
Idée
56.5.2. Installation d'une boucle infinie dans EP
56.6.
finition

Chapitre 57 Exercice de débogage 4 - Blocage du débogage
57.1.
Bloqueur de débogage
57.2.
Fonctionnalités anti-débogage
57.2.1.
relation parent-enfant
57.2.2.
Le processus à déboguer ne peut pas être débogué par d'autres débogueurs (par exemple OllyDbg).

57.2.3.
Lorsque vous terminez le processus du débogueur, le processus débogué est également terminé simultanément.

57.2.4.
Manipulez le code du débogueur dans le débogueur.

57.2.5.
Gérez les exceptions dans le débogueur.

57.2.
Exercices de débogage - DebugMe4.exe
57.3.
1ère tentative
57.3.1.
Choisir un emplacement de démarrage pour le débogage
57.3.2.
principal( )
57.4.
2ème tentative
57,5.
3ème tentative
57.6.
4ème tentative
57.7.
5ème tentative
57.7.1.
Point de rupture du système
57.7.2. EXCEPTION_INSTRUCTION_ILLÉGALE (1)
57.7.3. EXCEPTION_INSTRUCTION_ILLÉGALE (2)
57.8.
6ème tentative
57.8.1.
40121D (première exception)
57.8.2.
401299 (deuxième exception)
57.9.
7ème tentative
57.9.1.
Méthode statique
57.9.2.
Méthode dynamique
57.10.
finition

Pour conclure le livre
1.
Créativité et expérience (Baduk et Janggi - Programmation et rétro-ingénierie)
Baduk et Janggi
Programmation et rétro-ingénierie
2.
À mes lecteurs…

Contient tous les principes clés que tout inverseur doit connaître !

Le reverse engineering est une technique qui permet d'examiner en profondeur le fonctionnement interne d'un programme et de le manipuler.
Cela peut être utilisé comme méthode de piratage car il est possible d'utiliser des logiciels commerciaux que nous utilisons couramment.
Cependant, la rétro-ingénierie est aussi une spécialité des analystes de logiciels malveillants, également appelés « inverseurs ».
Surtout, les techniques de rétro-ingénierie ne sont pas seulement utilisées dans une bataille entre pirates informatiques et experts en sécurité.
Si vous maîtrisez bien la rétro-ingénierie, vous pouvez identifier des bugs ou des vulnérabilités qui n'ont pas été découverts lors de la phase de développement/test, et vous pouvez résoudre les problèmes en accédant directement aux fichiers ou à la mémoire.
Il est également très utile car il permet d'améliorer les fonctionnalités du programme en ajoutant des fonctionnalités entièrement nouvelles.

Ce livre explique méticuleusement, à travers plus de 50 chapitres, les principes fondamentaux nécessaires à l'« inversion », qui rendent possibles de telles choses magiques.
Surtout, l'auteur a écrit une variété de codes basés sur sa longue expérience chez AhnLab, tout en présentant en détail diverses techniques de rétro-ingénierie que tout spécialiste de la rétro-ingénierie se doit de connaître ; cet ouvrage est donc utile non seulement aux développeurs qui rêvent de devenir des spécialistes de la rétro-ingénierie, mais aussi à toute personne possédant une expérience pratique.


Avant tout, ce livre s'attache à expliquer les techniques d'inversion et leurs principes de fonctionnement.
Autrement dit, cet ouvrage va au-delà d'une simple introduction aux techniques d'inversion et vise à aider les lecteurs à comprendre les principes fondamentaux de chaque technique.
Grâce à cela, vous pouvez non seulement bâtir des bases solides, mais aussi acquérir l'essence d'une compétence dont la valeur ne change pas avec le temps.
Si vous souhaitez explorer le monde de la marche arrière, ce livre sera votre guide idéal !

Contenu principal

Registre IA-32
Débogage
fissure
Format de fichier PE
Compression exécutable
Tableau de relocalisation de base
Pratique du patch en ligne
Interception des messages Windows
Injection de DLL
Éjection de DLL
Injection de code
Interconnexion API
Processus furtif
Interconnexion globale de l'API
Informatique 64 bits
ASLR
Session dans le noyau 6
TEB
PEB
SEH
Instructions IA-32
Anti-débogage