C++ pour l'Anti-Cheat

Pourquoi C++ pour l'Anti-Cheat?

Le C++ est le langage de prédilection pour l'analyse et le développement d'anti-cheat pour plusieurs raisons:

• Performance - Le C++ offre des performances proches du métal, essentielles pour les opérations sensibles au timing
• Accès bas niveau - Permet la manipulation directe de la mémoire et des ressources système
• Compatibilité - La plupart des jeux et anti-cheats sont développés en C++
• Flexibilité - Supporte à la fois la programmation orientée objet et la programmation procédurale
• Écosystème - Riche bibliothèque d'outils et de frameworks pour le reverse engineering

Fondamentaux de l'API Windows

L'API Windows est essentielle pour interagir avec les processus et la mémoire sous Windows:

Headers et bibliothèques importantes:

#include <windows.h>      // API Windows de base
#include <tlhelp32.h>      // Fonctions d'énumération de processus
#include <psapi.h>         // Informations sur les processus
#include <winternl.h>      // Fonctions NT non documentées
#include <dbghelp.h>       // Fonctions de débogage

Types de données Windows essentiels:

Lecture et Écriture de Mémoire

Les opérations de lecture et d'écriture de mémoire sont fondamentales pour l'analyse d'anti-cheat:

Lecture de mémoire:

// Template pour lire n'importe quel type de données
template<typename T>
T ReadMemory(HANDLE hProcess, uintptr_t address) {
    T value;
    SIZE_T bytesRead;
    
    if (!ReadProcessMemory(hProcess, (LPCVOID)address, &value, sizeof(T), &bytesRead) || bytesRead != sizeof(T)) {
        throw std::runtime_error("Failed to read memory");
    }
    
    return value;
}

// Utilisation
int health = ReadMemory(hProcess, healthAddress);

Écriture de mémoire:

// Template pour écrire n'importe quel type de données
template<typename T>
void WriteMemory(HANDLE hProcess, uintptr_t address, const T& value) {
    SIZE_T bytesWritten;
    
    if (!WriteProcessMemory(hProcess, (LPVOID)address, &value, sizeof(T), &bytesWritten) || bytesWritten != sizeof(T)) {
        throw std::runtime_error("Failed to write memory");
    }
}

// Utilisation
WriteMemory(hProcess, healthAddress, 100);

Concepts de Base du Hooking

Le hooking est une technique qui permet d'intercepter des appels de fonction:

• Inline Hooking - Modification du code de la fonction cible
• IAT Hooking - Modification de la table d'importation
• VTable Hooking - Modification des tables virtuelles d'objets
• Detour Hooking - Redirection de l'exécution vers une fonction personnalisée

Injection de DLL

L'injection de DLL permet d'exécuter du code personnalisé dans l'espace d'adressage d'un autre processus:

Méthode CreateRemoteThread:

// Exemple simplifié d'injection de DLL
bool InjectDLL(DWORD processId, const std::string& dllPath) {
    // Ouvrir le processus cible
    HANDLE hProcess = OpenProcess(
        PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE,
        FALSE, processId
    );
    
    if (!hProcess) return false;
    
    // Allouer de la mémoire dans le processus cible
    LPVOID remoteBuffer = VirtualAllocEx(
        hProcess, NULL, dllPath.length() + 1,
        MEM_COMMIT, PAGE_READWRITE
    );
    
    if (!remoteBuffer) {
        CloseHandle(hProcess);
        return false;
    }
    
    // Écrire le chemin de la DLL dans la mémoire allouée
    if (!WriteProcessMemory(
            hProcess, remoteBuffer, dllPath.c_str(),
            dllPath.length() + 1, NULL
        )) {
        VirtualFreeEx(hProcess, remoteBuffer, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return false;
    }
    
    // Obtenir l'adresse de LoadLibraryA
    LPVOID loadLibraryAddr = (LPVOID)GetProcAddress(
        GetModuleHandle("kernel32.dll"), "LoadLibraryA"
    );
    
    // Créer un thread distant qui appelle LoadLibraryA
    HANDLE hThread = CreateRemoteThread(
        hProcess, NULL, 0,
        (LPTHREAD_START_ROUTINE)loadLibraryAddr,
        remoteBuffer, 0, NULL
    );
    
    if (!hThread) {
        VirtualFreeEx(hProcess, remoteBuffer, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return false;
    }
    
    // Attendre la fin du thread
    WaitForSingleObject(hThread, INFINITE);
    
    // Nettoyer
    CloseHandle(hThread);
    VirtualFreeEx(hProcess, remoteBuffer, 0, MEM_RELEASE);
    CloseHandle(hProcess);
    
    return true;
}

Techniques d'Obfuscation

L'obfuscation est utilisée pour rendre le code plus difficile à analyser et à comprendre:

• Obfuscation de chaînes - Chiffrement des chaînes de caractères
• Obfuscation de contrôle de flux - Rendre le flux d'exécution difficile à suivre
• Métamorphisme - Modification du code à chaque exécution
• Anti-débogage - Détection et prévention des tentatives de débogage

Exemple d'obfuscation de chaînes:

// Classe pour l'obfuscation de chaînes
class ObfuscatedString {
private:
    std::vector<char> data;
    int key;
    
    void Encrypt() {
        for (size_t i = 0; i < data.size(); i++) {
            data[i] ^= (key + i) & 0xFF;
        }
    }
    
    void Decrypt() {
        for (size_t i = 0; i < data.size(); i++) {
            data[i] ^= (key + i) & 0xFF;
        }
    }
    
public:
    ObfuscatedString(const char* str, int encryptionKey) : key(encryptionKey) {
        size_t len = strlen(str);
        data.resize(len + 1, 0);
        memcpy(data.data(), str, len);
        Encrypt();
    }
    
    std::string GetString() {
        std::vector<char> temp = data;
        for (size_t i = 0; i < temp.size(); i++) {
            temp[i] ^= (key + i) & 0xFF;
        }
        return std::string(temp.data());
    }
};

// Utilisation
ObfuscatedString moduleName("kernel32.dll", 0x42);
std::string decrypted = moduleName.GetString();

Développement de Drivers

Les drivers kernel-mode permettent de contourner les protections user-mode:

Structure de base d'un driver:

#include <ntddk.h>

// Point d'entrée du driver
NTSTATUS DriverEntry(
    _In_ PDRIVER_OBJECT DriverObject,
    _In_ PUNICODE_STRING RegistryPath
) {
    UNREFERENCED_PARAMETER(RegistryPath);
    
    // Initialisation
    DbgPrint("Driver chargé\n");
    
    // Configurer les routines de traitement
    DriverObject->DriverUnload = DriverUnload;
    
    return STATUS_SUCCESS;
}

// Routine de déchargement
VOID DriverUnload(
    _In_ PDRIVER_OBJECT DriverObject
) {
    UNREFERENCED_PARAMETER(DriverObject);
    
    DbgPrint("Driver déchargé\n");
}

Exercice 1: Scanner de Mémoire

Développez un scanner de mémoire simple qui peut rechercher des valeurs spécifiques dans un processus:

1. Créez une classe MemoryScanner qui prend un handle de processus
2. Implémentez une méthode pour scanner une plage d'adresses à la recherche d'une valeur
3. Ajoutez une fonctionnalité pour filtrer les résultats (ex: alignement, permissions)
4. Testez votre scanner sur un processus simple comme Notepad