hacktricks/reversing/common-api-used-in-malware.md

# API couramment utilisées dans les logiciels malveillants

<details>

<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert Red Team AWS de HackTricks)</strong></a><strong>!</strong></summary>

Autres façons de soutenir HackTricks :

* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.

</details>

## Générique

### Réseau

| Sockets bruts | Sockets WinAPI |
| ------------- | -------------- |
| socket()      | WSAStratup()   |
| bind()        | bind()         |
| listen()      | listen()       |
| accept()      | accept()       |
| connect()     | connect()      |
| read()/recv() | recv()         |
| write()       | send()         |
| shutdown()    | WSACleanup()   |

### Persistance

| Registre         | Fichier       | Service                      |
| ---------------- | ------------- | ---------------------------- |
| RegCreateKeyEx() | GetTempPath() | OpenSCManager                |
| RegOpenKeyEx()   | CopyFile()    | CreateService()              |
| RegSetValueEx()  | CreateFile()  | StartServiceCtrlDispatcher() |
| RegDeleteKeyEx() | WriteFile()   |                              |
| RegGetValue()    | ReadFile()    |                              |

### Cryptage

| Nom                   |
| --------------------- |
| WinCrypt              |
| CryptAcquireContext() |
| CryptGenKey()         |
| CryptDeriveKey()      |
| CryptDecrypt()        |
| CryptReleaseContext() |

### Anti-Analyse/VM

| Nom de la fonction                                        | Instructions d'assemblage |
| --------------------------------------------------------- | ------------------------- |
| IsDebuggerPresent()                                       | CPUID()                  |
| GetSystemInfo()                                           | IN()                     |
| GlobalMemoryStatusEx()                                    |                          |
| GetVersion()                                              |                          |
| CreateToolhelp32Snapshot \[Vérifier si un processus est en cours d'exécution] |                          |
| CreateFileW/A \[Vérifier si un fichier existe]            |                          |

### Furtivité

| Nom                     |                                                                            |
| ------------------------ | -------------------------------------------------------------------------- |
| VirtualAlloc             | Allouer de la mémoire (packers)                                           |
| VirtualProtect           | Changer les autorisations de mémoire (packer donnant l'autorisation d'exécution à une section) |
| ReadProcessMemory        | Injection dans des processus externes                                    |
| WriteProcessMemoryA/W    | Injection dans des processus externes                                    |
| NtWriteVirtualMemory     |                                                                            |
| CreateRemoteThread       | Injection de DLL/processus...                                            |
| NtUnmapViewOfSection     |                                                                            |
| QueueUserAPC             |                                                                            |
| CreateProcessInternalA/W |                                                                            |

### Exécution

| Nom de la fonction    |
| --------------------- |
| CreateProcessA/W      |
| ShellExecute          |
| WinExec               |
| ResumeThread          |
| NtResumeThread        |

### Divers

* GetAsyncKeyState() -- Enregistrement des touches
* SetWindowsHookEx -- Enregistrement des touches
* GetForeGroundWindow -- Obtenir le nom de la fenêtre en cours d'exécution (ou le site web d'un navigateur)
* LoadLibrary() -- Importer une bibliothèque
* GetProcAddress() -- Importer une bibliothèque
* CreateToolhelp32Snapshot() -- Liste des processus en cours d'exécution
* GetDC() -- Capture d'écran
* BitBlt() -- Capture d'écran
* InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Accéder à Internet
* FindResource(), LoadResource(), LockResource() -- Accéder aux ressources de l'exécutable

## Techniques de logiciels malveillants

### Injection de DLL

Exécuter une DLL arbitraire dans un autre processus

1. Localiser le processus pour injecter la DLL malveillante : CreateToolhelp32Snapshot, Process32First, Process32Next
2. Ouvrir le processus : GetModuleHandle, GetProcAddress, OpenProcess
3. Écrire le chemin de la DLL dans le processus : VirtualAllocEx, WriteProcessMemory
4. Créer un thread dans le processus qui chargera la DLL malveillante : CreateRemoteThread, LoadLibrary

Autres fonctions à utiliser : NTCreateThreadEx, RtlCreateUserThread

### Injection de DLL réfléchie

Charger une DLL malveillante sans appeler les appels API Windows normaux.\
La DLL est mappée à l'intérieur d'un processus, elle résoudra les adresses d'importation, corrigera les relocalisations et appellera la fonction DllMain.

### Détournement de thread

Trouver un thread d'un processus et le faire charger une DLL malveillante

1. Trouver un thread cible : CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Ouvrir le thread : OpenThread
3. Suspendre le thread : SuspendThread
4. Écrire le chemin de la DLL malveillante dans le processus cible : VirtualAllocEx, WriteProcessMemory
5. Reprendre le thread en chargeant la bibliothèque : ResumeThread

### Injection PE

Injection d'exécution portable : L'exécutable sera écrit dans la mémoire du processus cible et sera exécuté à partir de là.

### Creusement de processus

Le logiciel malveillant va désallouer le code légitime de la mémoire du processus et charger un binaire malveillant

1. Créer un nouveau processus : CreateProcess
2. Désallouer la mémoire : ZwUnmapViewOfSection, NtUnmapViewOfSection
3. Écrire le binaire malveillant dans la mémoire du processus : VirtualAllocEc, WriteProcessMemory
4. Définir le point d'entrée et exécuter : SetThreadContext, ResumeThread

## Accrochage

* La **SSDT** (**System Service Descriptor Table**) pointe vers les fonctions du noyau (ntoskrnl.exe) ou du pilote GUI (win32k.sys) afin que les processus utilisateur puissent appeler ces fonctions.
* Un rootkit peut modifier ces pointeurs vers des adresses qu'il contrôle
* Les **IRP** (**I/O Request Packets**) transmettent des morceaux de données d'un composant à un autre. Presque tout dans le noyau utilise des IRP et chaque objet de périphérique a sa propre table de fonctions qui peut être accrochée : DKOM (Direct Kernel Object Manipulation)
* L'**IAT** (**Import Address Table**) est utile pour résoudre les dépendances. Il est possible d'accrocher cette table afin de détourner le code qui sera appelé.
* Accrochage de **EAT** (**Export Address Table**). Ces accrochages peuvent être faits depuis l'**espace utilisateur**. Le but est d'accrocher les fonctions exportées par les DLL.
* **Accrochages en ligne** : Ce type est difficile à réaliser. Cela implique de modifier le code des fonctions elles-mêmes. Peut-être en mettant un saut au début de celles-ci.