Цикл статей. Как создать свой чит/трейнер

static_addr = (DWORD)GetModuleHandle(0);
static_addr = *(DWORD*)(static_addr + 0x255AF150);
static_addr = *(DWORD*)(static_addr);
static_addr = *(DWORD*)(static_addr + 0xD48);
static_addr = *(DWORD*)(static_addr + 0x0C);
static_addr = (DWORD*)(static_addr + 0xC4);
static_addr = *(DWORD*)(*static_addr + 0x08);
static_addr = *(DWORD*)(static_addr + 0x44);
static_addr = *(DWORD*)(static_addr + 0x10);
drifter_hp = (double*)(DWORD*)*(DWORD*)(static_addr + 0x1FD8);
drifter_ammo = (double*)(DWORD*)*(DWORD*)(static_addr + 0x268C);

#include <windows.h>
#include <tlhelp32.h>
// Имя внедряемой dll
const char* dll_path = "internal_trainer_hld.dll";
int main(void) {
    HANDLE process;
    void* alloc_base_addr;
    HMODULE kernel32_base;
    LPTHREAD_START_ROUTINE LoadLibraryA_addr;
    HANDLE thread;
    HANDLE snapshot = 0;
    PROCESSENTRY32 pe32 = { 0 };
    DWORD exitCode = 0;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    // Получение снапшота текущих процессов
    snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    Process32First(snapshot, &pe32);
    do {
        // Мы хотим работать только с процессом HyperLightDrifter
        if (wcscmp(pe32.szExeFile, L"HyperLightDrifter.exe") == 0) {
            // Во-первых, нам нужно получить дескриптор процесса, чтобы использовать его для следующих вызовов
            process = OpenProcess(PROCESS_ALL_ACCESS, true, pe32.th32ProcessID);
            // Чтобы не повредить память, выделим дополнительную память для хранения нашего пути к DLL
            alloc_base_addr = VirtualAllocEx(process, NULL, strlen(dll_path) + 1, MEM_COMMIT, PAGE_READWRITE);
            // Записываем путь к нашей DLL в память, которую мы только что выделили внутри игры
            WriteProcessMemory(process, alloc_base_addr, dll_path, strlen(dll_path) + 1, NULL);
            // Создаем удаленный поток внутри игры, который будет выполнять LoadLibraryA
            // К этому вызову LoadLibraryA мы передадим полный путь к нашей DLL, которую мы прописали в игру
            kernel32_base = GetModuleHandle(L"kernel32.dll");
            LoadLibraryA_addr = (LPTHREAD_START_ROUTINE)GetProcAddress(kernel32_base, "LoadLibraryA");
            thread = CreateRemoteThread(process, NULL, 0, LoadLibraryA_addr, alloc_base_addr, 0, NULL);
            // Чтобы убедиться, что наша DLL внедрена, мы можем использовать следующие два вызова для синхронизации
            WaitForSingleObject(thread, INFINITE);
            GetExitCodeThread(thread, &exitCode);
            // Наконец, освобождаем память и очищаем дескрипторы процесса
            VirtualFreeEx(process, alloc_base_addr, 0, MEM_RELEASE);
            CloseHandle(thread);
            CloseHandle(process);
            break;
        }
    // Перебор процессов из снапшота
    } while (Process32Next(snapshot, &pe32));
    return 0;
}

#include "directx_hook.h"
double full_health = 6;
double full_ammo = 100;
DWORD static_addr = 0;
DWORD *drifter = 0;
// Получаем player class
void get_player_class() {
    if (drifter == NULL) {
        static_addr = (DWORD)GetModuleHandle(0);
        static_addr = *(DWORD*)(static_addr + 0x255AF150);
        static_addr = *(DWORD*)static_addr;
        static_addr = *(DWORD*)(static_addr + 0xD48);
        static_addr = *(DWORD*)(static_addr + 0x0C);
        drifter = (DWORD*)(static_addr + 0xC4);
    }
}
// Отрисовываем наше меню
void draw_menu(directx_hook* hook) {
    hook->draw_text(10, 70, D3DCOLOR_ARGB(255, 255, 255, 255), "Full health press F1");
    hook->draw_text(10, 90, D3DCOLOR_ARGB(255, 255, 255, 255), "Full ammo press F2");
}
// Изменяем по нажатию клавиш значения hp и ammo
void run(directx_hook* hook) {
    double* drifter_hp;
    double* drifter_ammo;
    draw_menu(hook);
    get_player_class();
    if (*drifter) {
        static_addr = *(DWORD*)(*drifter + 0x08);
        static_addr = *(DWORD*)(static_addr + 0x44);
        static_addr = *(DWORD*)(static_addr + 0x10);
        drifter_hp = (double*)(DWORD*)*(DWORD*)(static_addr + 0x1FD8);
        drifter_ammo = (double*)(DWORD*)*(DWORD*)(static_addr + 0x268C);
        if (GetAsyncKeyState(VK_F1) & 1) {
            *drifter_hp = full_health;
        }
        if (GetAsyncKeyState(VK_F2) & 1) {
            *drifter_ammo = full_ammo;
        }
    }
}
void injected_thread() {
    // Добавляем нашу функцию, которая будет вызываться при inline hook
    directx_hook::get_instance()->add_callback(&run);
    // Начинаем работу по установке inline hook
    directx_hook::get_instance()->initialize();
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
        case DLL_PROCESS_ATTACH:
            CreateThread(0, 0, (LPTHREAD_START_ROUTINE)injected_thread, 0, 0, 0);
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
            break;
    }
    return TRUE;
}

#pragma once
#include <windows.h>
#include <stdint.h>
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
typedef HRESULT(WINAPI* _endscene)(LPDIRECT3DDEVICE9 pDevice);
class directx_hook;
typedef void (*_callback_run)(directx_hook* hook);
class directx_hook {
private:
    static directx_hook* instance;
    static uint8_t* orig_endscene_code;
    static uint32_t endscene_addr;
    static LPDIRECT3DDEVICE9 hooked_device;
    static bool hook_ready_pre, hook_ready;
    _callback_run callback_run;
    LPD3DXFONT font;
    void set_hooks();
    uint32_t locate_endscene();
public:
    static _endscene orig_endscene;
    static directx_hook* get_instance() {
        if (!directx_hook::instance) {
            directx_hook::instance = new directx_hook();
        }
        return directx_hook::instance;
    }
    static void delete_instance() {
        if (directx_hook::instance) {
            delete directx_hook::instance;
            directx_hook::instance = NULL;
        }
    }
    void initialize();
    void add_callback(_callback_run cb);
    void draw_text(uint32_t x, uint32_t y, D3DCOLOR color, const char* text);
    uint32_t init_hook_callback(LPDIRECT3DDEVICE9 device);
    HRESULT WINAPI endscene_hook_callback(LPDIRECT3DDEVICE9 pDevice);
};

#include "directx_hook.h"
#include "directx_hook_callbacks.h"
#include "memory.h"
directx_hook* directx_hook::instance = NULL;
uint8_t* directx_hook::orig_endscene_code = NULL;
uint32_t directx_hook::endscene_addr = NULL;
LPDIRECT3DDEVICE9 directx_hook::hooked_device = NULL;
_endscene directx_hook::orig_endscene = NULL;
bool directx_hook::hook_ready = false;
bool directx_hook::hook_ready_pre = false;
void directx_hook::initialize() {
    // Проверяем, находится ли в адресном пространстве d3d9.dll
    while (!GetModuleHandleA("d3d9.dll")) {
        Sleep(10);
    }
    // Получаем адрес функции endscene
    directx_hook::endscene_addr = this->locate_endscene();
    // Проверяем, успешно ли получен адрес EndScene
    // Если да, то устанавливаем наш inline hook
    if (directx_hook::endscene_addr) {
        directx_hook::orig_endscene_code = hook_jmp(directx_hook::endscene_addr, (uint32_t)&endscene_trampoline);
    }
    // Ждем
    while (!directx_hook::hook_ready_pre) {
        Sleep(10);
    }
    // Сигнализируем, что наш хук готов
    directx_hook::hook_ready = true;
}
// Заменить присвоением
// Как только наш хук будет установлен
void directx_hook::add_callback(_callback_run cb) {
    if (!directx_hook::hook_ready)
        callback_run = cb;
}
// Обертка для отрисовки текста
void directx_hook::draw_text(uint32_t x, uint32_t y, D3DCOLOR color, const char* text) {
    RECT rect;
    rect.left = x + 1;
    rect.top = y + 1;
    rect.right = rect.left + 1000;
    rect.bottom = rect.top + 1000;
    this->font->DrawTextA(NULL, text, -1, &rect, 0, color);
}
uint32_t directx_hook::init_hook_callback(LPDIRECT3DDEVICE9 device) {
    directx_hook::hooked_device = device;
    while (directx_hook::orig_endscene_code == NULL) {}
    unhook_jmp(directx_hook::endscene_addr, orig_endscene_code);
    D3DXCreateFont(directx_hook::hooked_device, 15, 0, FW_BOLD, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &this->font);
    this->set_hooks();
    directx_hook::hook_ready_pre = true;
    return directx_hook::endscene_addr;
}
HRESULT WINAPI directx_hook::endscene_hook_callback(LPDIRECT3DDEVICE9 pDevice) {
    HRESULT result;
    callback_run(this);
    result = orig_endscene(pDevice);
    this->set_hooks();
    return result;
}
void directx_hook::set_hooks() {
    uint32_t ret;
    // Устанавливаем хук
    ret = hook_vf((uint32_t)directx_hook::hooked_device, 42, (uint32_t)&my_endscene);
    if (ret != (uint32_t)&my_endscene) {
        *(uint32_t*)&directx_hook::orig_endscene = ret;
    }
}
uint32_t directx_hook::locate_endscene() {
    LPDIRECT3D9 pD3D;
    D3DPRESENT_PARAMETERS d3dpp;
    LPDIRECT3DDEVICE9 pd3dDevice;
    uint32_t endscene_addr;
    // Cоздаем временный объект D3D9 и проходимся по виртуальной таблице, чтобы получить адрес метода EndScene
    pD3D = Direct3DCreate9(D3D_SDK_VERSION);
    if (!pD3D) {
        return 0;
    }
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = GetForegroundWindow();
    HRESULT result = pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, d3dpp.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pd3dDevice);
    if (FAILED(result) || !pd3dDevice) {
        pD3D->Release();
        return 0;
    }
    // Получаем адрес, который хранится в rdata
    endscene_addr = get_vf((uint32_t)pd3dDevice, 42);
    // Очищаем
    pD3D->Release();
    pd3dDevice->Release();
    return endscene_addr;
}

#include "directx_hook.h"
DWORD WINAPI init_endscene(LPDIRECT3DDEVICE9 device_addr) {
    return directx_hook::get_instance()->init_hook_callback(device_addr);
}
HRESULT WINAPI my_endscene(LPDIRECT3DDEVICE9 pDevice) {
    return directx_hook::get_instance()->endscene_hook_callback(pDevice);
}
// Наш inline hook
__declspec(naked) void endscene_trampoline() {
    __asm {
        MOV EAX, DWORD PTR SS:[ESP + 0x4]
        PUSH EAX
        CALL init_endscene
        JMP EAX
    }
}

#pragma once
#include <windows.h>
#include <stdint.h>
// Чтение из памяти
template<typename T>
T read_memory(uint32_t address) {
    return *((T*)address);
}
// Запись в память
template<typename T>
void write_memory(uint32_t address, T value) {
    *((T*)address) = value;
}
template<typename T>
uint32_t protect_memory(uint32_t address, uint32_t prot) {
    DWORD old_prot;
    VirtualProtect((LPVOID)address, sizeof(T), prot, &old_prot);
    return old_prot;
}
// Получение адреса EndScene в VMT
uint32_t get_vf(uint32_t class_inst, uint32_t func_idx) {
    uint32_t vf_table;
    uint32_t hook_addr;
    vf_table = read_memory<uint32_t>(class_inst);
    hook_addr = vf_table + func_idx * sizeof(uint32_t);
    return read_memory<uint32_t>(hook_addr);
}
// Получение адреса EndScene из VMT
uint32_t hook_vf(uint32_t class_inst, uint32_t func_idx, uint32_t new_func) {
    uint32_t vf_table;
    uint32_t hook_addr;
    uint32_t old_prot;
    uint32_t orig_func;
    vf_table = read_memory<uint32_t>(class_inst);
    hook_addr = vf_table + func_idx * sizeof(uint32_t);
    old_prot = protect_memory<uint32_t>(hook_addr, PAGE_READWRITE);
    orig_func = read_memory<uint32_t>(hook_addr);
    write_memory<uint32_t>(hook_addr, new_func);
    protect_memory<uint32_t>(hook_addr, old_prot);
    return orig_func;
}
// Установка хука
unsigned char* hook_jmp(uint32_t hook, uint32_t new_func) {
    uint32_t new_offest;
    uint32_t old_prot;
    uint8_t* originals = new uint8_t[5];
    // Вычисляем смещение до нашего inline hook
    new_offest = new_func - hook - 5;
    // Чтобы не произошло краша, так как все виртуальные функции
    // хранятся в rdata, изменяем права доступа по адресу функции
    old_prot = protect_memory<uint8_t[5]>(hook, PAGE_EXECUTE_READWRITE);
    // Сохраняем оригинальный адрес
    for (uint8_t i = 0; i < 5; i++) {
        originals[i] = read_memory<uint8_t>(hook + i);
    }
    // Перезаписываем нашим кодом
    write_memory<uint8_t>(hook, 0xE9);
    write_memory<uint32_t>(hook + 1, new_offest);
    // Восстанавливаем прежние права
    protect_memory<uint8_t[5]>(hook + 1, old_prot);
    return originals;
}
// Снимаем хук
void unhook_jmp(uint32_t hook, uint8_t* originals) {
    uint32_t old_prot;
    // Чтобы не произошло краша, изменяем права доступа по адресу функции
    old_prot = protect_memory<uint8_t[5]>(hook, PAGE_EXECUTE_READWRITE);
    // Записываем прежний адрес
    for (unsigned int i = 0; i < 5; i++) {
        write_memory<uint8_t>(hook + i, originals[i]);
    }
    // Восстанавливаем прежние права
    protect_memory<uint8_t[5]>(hook + 1, old_prot);
    delete[] originals;
}

#include <windows.h>
#include <tlhelp32.h>
// Имя внедряемой DLL
const char* dll_path = "internal_cheat_ac.dll";
int main(void) {
    HANDLE process;
    void* alloc_base_addr;
    HMODULE kernel32_base;
    LPTHREAD_START_ROUTINE LoadLibraryA_addr;
    HANDLE thread;
    HANDLE snapshot = 0;
    PROCESSENTRY32 pe32 = { 0 };
    DWORD exitCode = 0;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    // Получение снапшота текущих процессов
    snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    Process32First(snapshot, &pe32);
    do {
        // Мы хотим работать только с процессом AC
        if (wcscmp(pe32.szExeFile, L"ac_client.exe") == 0) {
            // Во-первых, нам нужно получить дескриптор процесса, чтобы использовать его для следующих вызовов
            process = OpenProcess(PROCESS_ALL_ACCESS, true, pe32.th32ProcessID);
            // Чтобы не повредить память, выделим дополнительную память для хранения нашего пути к DLL
            alloc_base_addr = VirtualAllocEx(process, NULL, strlen(dll_path) + 1, MEM_COMMIT, PAGE_READWRITE);
            // Записываем путь к нашей DLL в память, которую мы только что выделили внутри игры
            WriteProcessMemory(process, alloc_base_addr, dll_path, strlen(dll_path) + 1, NULL);
            // Создаем удаленный поток внутри игры, который будет выполнять LoadLibraryA
            // Этому вызову LoadLibraryA мы передадим полный путь к нашей DLL, которую мы прописали в игру
            kernel32_base = GetModuleHandle(L"kernel32.dll");
            LoadLibraryA_addr = (LPTHREAD_START_ROUTINE)GetProcAddress(kernel32_base, "LoadLibraryA");
            thread = CreateRemoteThread(process, NULL, 0, LoadLibraryA_addr, alloc_base_addr, 0, NULL);
            // Чтобы убедиться, что наша DLL внедрена, мы можем использовать следующие два вызова для синхронизации
            WaitForSingleObject(thread, INFINITE);
            GetExitCodeThread(thread, &exitCode);
            // Наконец, освобождаем память и очищаем дескрипторы процесса
            VirtualFreeEx(process, alloc_base_addr, 0, MEM_RELEASE);
            CloseHandle(thread);
            CloseHandle(process);
            break;
        }
    // Перебор процессов из снапшота
    } while (Process32Next(snapshot, &pe32));
    return 0;
}

#include <iostream>
#include <string>
#include <tchar.h>
#include <thread>
#include <mutex>
#define _USE_MATH_DEFINES
#include <math.h>
#include "hook.h"
#include "structures.h"
#include "gl_draw.h"
// Переменная игрока
Player* player;
// Переменная синхронизации
std::mutex hook_mutex;
// Typedef для функции wglSwapBuffers
typedef BOOL(__stdcall* twglSwapBuffers) (HDC hDc);
Tramp_Hook* esp_hook;
Player** player_list = nullptr;
int* player_list_size = nullptr;
static int list_size = 0;
static Vector3 screen_position;
static Vector3 world_position;
static Vector3 player_position;
static float* view_matrix;
bool aimbot_enabled = false;
// Меню
void draw_menu(bool flag_esp) {
    std::string esp = "ESP is ";
    std::string aimbot = "Aimbot is ";
    if (flag_esp) {
        esp += "ON press F1 to OFF";
    }
    else {
        esp += "OFF press F1 to ON";
    }
    if (aimbot_enabled) {
        aimbot += "ON press F2 to OFF";
    }
    else {
        aimbot += "OFF press F2 to ON";
    }
    GL::print_gl(50, 1200, rgb::gray, esp.c_str());
    GL::print_gl(50, 1300, rgb::gray, aimbot.c_str());
    GL::print_gl(50, 1400, rgb::gray, "Exit cheat press F3");
}
// Наша функция, которую вызывает установленный хук
BOOL _stdcall hooked_wglSwapBuffers(HDC hDc) {
    hook_mutex.lock();
    draw_menu(esp_hook->is_enabled());
    if (esp_hook->is_enabled()) {
     // Настроить орфографический режим
        GL::setup_orthographic();
        if (*player_list_size == list_size) {
            for (int i = 0; i < list_size; ++i) {
                // Проверить, действителен ли адрес игрока
                if (!player_list[i]) {
                    continue;
                }
                if (player_list[i]->hp > 0 && player_list[i]->hp < 200) {
                    // Сохранить позицию других игроков в Vector3
                    world_position.x = player_list[i]->x_y_z_player.x;
                    world_position.y = player_list[i]->x_y_z_player.y;
                    world_position.z = player_list[i]->x_y_z_player.z;
                    // Сохранить позицию головы других игроков в Vector3
                    player_position.x = player->x_y_z_head.x;
                    player_position.y = player->x_y_z_head.y;
                    player_position.z = player->x_y_z_head.z;
                    // Рассчитать расстояние до другого игрока
                    float distance = sqrtf((player_position.x - world_position.x) * (player_position.x - world_position.x) + (player_position.y - world_position.y) * (player_position.y - world_position.y) + (player_position.z - world_position.z) * (player_position.z - world_position.z));
                    // Проверить, находится ли игрок в зоне обзора
                    if (distance > 5.0f && GL::world_to_screen(world_position, screen_position, view_matrix)) {
                        // Проверить, находится ли другой игрок в той же команде, что и мы
                        if (player_list[i]->team != player->team) {
                            // Команда врага
                            GL::draw_esp_box(screen_position.x, screen_position.y, distance, rgb::red, player_list[i]->name, player_list[i]->hp, player_list[i]->armor);
                        }
                        else {
                            // Наша команда
                            GL::draw_esp_box(screen_position.x, screen_position.y, distance, rgb::green, player_list[i]->name, player_list[i]->hp, player_list[i]->armor);
                        }
                    }
                }
            }
        }
        else {
            list_size = *player_list_size;
        }
        GL::restore_gl(); // Восстановить исходный режим
    }
    if (aimbot_enabled && GetAsyncKeyState(VK_RBUTTON)) {
        if (*player_list_size == list_size) {
            // Эти переменные будут использоваться для удержания ближайшего к нам врага
            float closest_player = -1.0f;
            float closest_yaw = 0.0f;
            float closest_pitch = 0.0f;
            // Выбор ближайшего игрока в качестве цели
            for (int i = 0; i < list_size; ++i) {
                // Проверить, действителен ли адрес игрока, при этом пропускаем игроков из нашей команды и проверяем показатель здоровья
                if (!player_list[i] || (player_list[i]->team == player->team) || (player_list[i]->hp < 0)) {
                    continue;
                }
                // Расчет абсолютного положения врага вдали от нас. Позволяет убедиться, что наши будущие расчеты верны и основаны на исходной точке
                float abspos_x = player_list[i]->x_y_z_player.x - player->x_y_z_player.x;
                float abspos_y = player_list[i]->x_y_z_player.y - player->x_y_z_player.y;
                float abspos_z = player_list[i]->x_y_z_player.z - player->x_y_z_player.z;
                // Расчет дистанции до врага
                float temp_distance = sqrtf((abspos_x * abspos_x) + (abspos_y * abspos_y));
                // Если это ближайший враг, рассчитываем рыскание и тангаж, чтобы нацелиться на него
                if (closest_player == -1.0f || temp_distance < closest_player) {
                    closest_player = temp_distance;
                    // Рассчитываем рыскание
                    float azimuth_xy = atan2f(abspos_y, abspos_x);
                    // Переводим в градусы
                    float yaw = (float)(azimuth_xy * (180.0 / M_PI));
                    // Добавляем 90, так как игра предполагает, что прямой север равен 90 градусам
                    closest_yaw = yaw + 90;
                    // Рассчитываем тангаж
                    // Поскольку значения Z настолько ограничены, выбирай большее значение между X и Y, чтобы убедиться, что мы не смотрим прямо в небо, когда находимся рядом с врагом
                    if (abspos_y < 0) {
                        abspos_y *= -1;
                    }
                    if (abspos_y < 5) {
                        if (abspos_x < 0) {
                            abspos_x *= -1;
                        }
                        abspos_y = abspos_x;
                    }
                    float azimuth_z = atan2f(abspos_z, abspos_y);
                    // Преобразовываем значение в градусы
                    closest_pitch = (float)(azimuth_z * (180.0 / M_PI));
                }
            }
            // Когда наш цикл завершится, устанавливаем для рысканья и тангажа самые близкие значения
            player->yaw_pitch_roll.x = closest_yaw;
            player->yaw_pitch_roll.y = closest_pitch;
        }
        else {
            list_size = *player_list_size;
        }
    }
    // Вызов перехваченной функции
    BOOL ret_value = ((twglSwapBuffers)esp_hook->get_gateway())(hDc);
    hook_mutex.unlock();
    return ret_value;
}
DWORD WINAPI injected_thread(HMODULE hMod) {
    // Получить адрес, по которому .exe был загружен внутри нашего игрового процесса
    uintptr_t moduleBase = (uintptr_t)GetModuleHandle(0);
    // Где находится указатель на нашего игрока
    player = *reinterpret_cast<Player**>(moduleBase + player_offset);
    // Указатель на список игроков
    player_list = *reinterpret_cast<Player***>(moduleBase + entity_offset);
    // Указатель на размер списка игроков
    player_list_size = reinterpret_cast<int*>(moduleBase + entity_count_offset);
    // Указатель на матрицу вида
    view_matrix = reinterpret_cast<float*>(moduleBase + view_matrix_offset);
    // Получить дескриптор модуля OpenGL
    HMODULE open_gl = GetModuleHandleA("opengl32.dll");
    if (!open_gl) {
        return -1; // OpenGL не загружен
    }
    // Получить адрес wglSwapBuffers
    void* orig_wglSwapBuffers = GetProcAddress(open_gl, "wglSwapBuffers");
    // Установка хука на wglSwapBuffers
    esp_hook = new Tramp_Hook(orig_wglSwapBuffers, hooked_wglSwapBuffers, 5);
    while (!GetAsyncKeyState(VK_F3)) {
        if (GetAsyncKeyState(VK_F1) & 1) { // Включить ESP
            esp_hook->is_enabled() ? esp_hook->disable() : esp_hook->enable();
        }
        if (GetAsyncKeyState(VK_F2) & 1) { // Включить aimbot
            aimbot_enabled = !aimbot_enabled;
        }
        Sleep(50);
    }
    hook_mutex.lock();
    // Удаление хука
    delete esp_hook;
    hook_mutex.unlock();
    // Извлечение нашей библиотеки
    FreeLibraryAndExitThread(hMod, 0);
    return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        CreateThread(0, 0, (LPTHREAD_START_ROUTINE)injected_thread, hModule, 0, 0);
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

#pragma once
#include "gl_draw.h"
class Player {
public:
    DWORD* vftable; // 0x00
    Vector3 x_y_z_head; // 0x04
    BYTE pad_0010[24]; // 0x10
    Vector3 x_y_z_player; // 0x28
    Vector3 yaw_pitch_roll; // 0x34
    BYTE pad_0040[172]; // 0x40
    DWORD hp; // 0xEC
    DWORD armor; // 0xF0
    BYTE pad_00F4[273]; // 0xF4
    BYTE name[16]; // 0x205
    BYTE pad_0215[247]; // 0x215
    BYTE team; // 0x30C
};
DWORD player_offset = 0x018AC00;
DWORD entity_offset = 0x018AC04;
DWORD entity_count_offset = 0x018AC0C;
DWORD view_matrix_offset = 0x17DFD0;

#pragma once
#include <windows.h>
#include <memory>
// Класс перехватчика
class Hook {
    // Указатель на перехватчик
    void* this_to_hook;
    // Сохраненные старые опкоды
    std::unique_ptr<char[]> old_opcodes;
    // Длина перезаписанных инструкций
    int this_len;
    // Включен ли перехватчик
    bool enabled;
public:
    // Конструктор для перехватчика
    Hook(void* to_hook, void* our_func, int len);
    // Деструктор для восстановления исходного кода
    ~Hook();
    // Включить перехватчик
    void enable();
    // Отключить перехватчик
    void disable();
    // Включен ли перехватчик
    bool is_enabled();
};
// Класс для реализации инлайн-перехватчика
class Tramp_Hook {
    void* gateway;
    Hook* managed_hook;
public:
    Tramp_Hook(void* to_hook, void* our_func, int len);
    // Восстанавливает исходный код
    ~Tramp_Hook();
    void enable();
    void disable();
    bool is_enabled();
    void* get_gateway();
};

#include "hook.h"
Hook::Hook(void* to_hook, void* our_func, int len) : this_to_hook{to_hook }, old_opcodes{ nullptr }, this_len{ len }, enabled{ false } {
    // Инструкция jmp имеет размер 5 байт. Место, которое мы перезаписываем, должно быть как минимум такого размера
    if (len < 5) {
        return;
    }
    DWORD curr_protection;
    // Сделать доступной для записи память с кодом, который мы хотим перезаписать
    VirtualProtect(to_hook, len, PAGE_EXECUTE_READWRITE, &curr_protection);
    // Сохранить текущие байты в массив символов
    old_opcodes = std::make_unique<char[]>(len);
    if (old_opcodes != nullptr) {
        for (int i = 0; i < len; ++i) {
            old_opcodes[i] = ((char*)to_hook)[i];
        }
    }
    // Перезапишем место, которое хотим перехватить, инструкциями nop
    memset(to_hook, 0x90, len);
    // Вычислить относительный адрес для перехода
    DWORD rva_addr = ((DWORD)our_func - (DWORD)to_hook) - 5;
    // Поместить опкод для инструкции jmp
    *(BYTE*)to_hook = 0xE9;
    // Поместить адрес для перехода
    *(DWORD*)((DWORD)to_hook + 1) = rva_addr;
    // Восстановить старую защиту кода
    VirtualProtect(to_hook, len, curr_protection, &curr_protection);
}
Hook::~Hook() {
    if (old_opcodes != nullptr) {
        DWORD curr_protection;
        // Сделать память доступной для записи
        VirtualProtect(this_to_hook, this_len, PAGE_EXECUTE_READWRITE, &curr_protection);
        // Записать старые опкоды обратно в перехваченное место
        for (int i = 0; i < this_len; ++i) {
            ((char*)this_to_hook)[i] = Hook::old_opcodes[i];
        }
        // Восстановить старую защиту памяти
        VirtualProtect(this_to_hook, this_len, curr_protection, &curr_protection);
    }
}
void Hook::enable() {
    this->enabled = true;
}
void Hook::disable() {
    this->enabled = false;
}
bool Hook::is_enabled() {
    return enabled;
}
Tramp_Hook::Tramp_Hook(void* to_hook, void* our_func, int len) : gateway{ nullptr }, managed_hook{ nullptr } {
    // jmp имеет размер 5 байт
    if (len < 5) {
        return;
    }
    // Выделяем память для нашего трамплина
    gateway = VirtualAlloc(0, len + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    // Сохранение байтов, которые мы будем перезаписывать в трамплин
    memcpy_s(gateway, len, to_hook, len);
    // Получить адрес возврата
    uintptr_t ret_addr = (BYTE*)to_hook - (BYTE*)gateway - 5;
    // Разместить опкод jmp в конец трамплина
    *(BYTE*)((uintptr_t)gateway + len) = 0xE9;
    // Разместить адрес возврата после jmp
    *(uintptr_t*)((uintptr_t)gateway + len + 1) = ret_addr;
    // Создание перехватчика
    managed_hook = new Hook(to_hook, our_func, len);
}
Tramp_Hook::~Tramp_Hook() {
    managed_hook->disable();
    delete managed_hook;
    VirtualFree(gateway, 0, MEM_RELEASE);
}
void Tramp_Hook::enable() {
    managed_hook->enable();
}
void Tramp_Hook::disable() {
    managed_hook->disable();
}
bool Tramp_Hook::is_enabled() {
    return managed_hook->is_enabled();
}
void* Tramp_Hook::get_gateway() {
    return gateway;
}

#pragma once
#pragma comment(lib, "OpenGL32.lib")
#include <windows.h>
#include<gl/GL.h>
struct Vector3 {
    float x, y, z;
};
struct Vector4 {
    float x, y, z, w;
};
// Пространство имен цветов для рисования
namespace rgb {
    const GLubyte red[3] = { 255,0,0 };
    const GLubyte green[3] = { 0,255,0 };
    const GLubyte blue[3] = { 0,0,255 };
    const GLubyte gray[3] = { 55,55,55 };
    const GLubyte light_gray[3] = { 192,192,192 };
    const GLubyte yellow[3] = { 255, 255, 0 };
    const GLubyte black[3] = { 0,0,0 };
}
// Пространство имен функций для отрисовки меню и ESP-хака
namespace GL {
    void setup_orthographic();
    void restore_gl();
    void build_font();
    void draw_filled_rectangle(float x, float y, float width, float height, const GLubyte color[3]);
    void draw_out_line(float x, float y, float width, float height, float line_width, const GLubyte color[3]);
    void draw_line(float fromX, float fromY, float toX, float toY, float line_width, const GLubyte color[3]);
    void draw_esp_box(float pos_x, float pos_y, float distance, const GLubyte color[3], const BYTE* text, const int health_percent = -1, const int armor_percent = -1);
    void print_gl(float x, float y, const GLubyte color[3], const char* fmt, ...);
    bool world_to_screen(Vector3 pos, Vector3& screen, float matrix[16]);
}

#include "gl_draw.h"
#include <corecrt_math.h>
#include <stdio.h>
HDC     h_DC;
HFONT   h_old_font;
HFONT   h_font;
UINT    font_base;
bool    b_font_build = 0;
void GL::setup_orthographic() {
    // Cохранение атрибутов
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    // Сохранение матрицы вида
    glPushMatrix();
    // Размеры экрана
    GLint view_port[4];
    // Получение размеров экрана
    glGetIntegerv(GL_VIEWPORT, view_port);
    // Установка размера экрана
    glViewport(0, 0, view_port[2], view_port[3]);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    // Настройка орфографического режима
    glOrtho(0, view_port[2], view_port[3], 0, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    // Отключение проверки глубины
    glDisable(GL_DEPTH_TEST);
}
void GL::restore_gl() {
    // Восстановление матрицы вида
    glPopMatrix();
    // Восстановление всех атрибутов
    glPopAttrib();
}
void GL::draw_filled_rectangle(float x, float y, float width, float height, const GLubyte color[3]) {
    glColor3ub(color[0], color[1], color[2]);
    glBegin(GL_QUADS);
    glVertex2f(x, y);
    glVertex2f(x + width, y);
    glVertex2f(x + width, y + height);
    glVertex2f(x, y + height);
    glEnd();
}
void GL::draw_out_line(float x, float y, float width, float height, float line_width, const GLubyte color[3]) {
    glLineWidth(line_width);
    glBegin(GL_LINE_STRIP);
    glColor3ub(color[0], color[1], color[2]);
    glVertex2f(x - 0.5f, y - 0.5f);
    glVertex2f(x + width + 0.5f, y - 0.5f);
    glVertex2f(x + width + 0.5f, y + height + 0.5f);
    glVertex2f(x - 0.5f, y + height + 0.5f);
    glVertex2f(x - 0.5f, y - 0.5f);
    glEnd();
}
void GL::draw_line(float fromX, float fromY, float toX, float toY, float line_width, const GLubyte color[3]) {
    glLineWidth(line_width);
    glBegin(GL_LINES);
    glColor3ub(color[0], color[1], color[2]);
    glVertex2f(fromX, fromY);
    glVertex2f(toX, toY);
    glEnd();
}
void GL::build_font()
{
    h_DC = wglGetCurrentDC();
    font_base = glGenLists(96);
    h_font = CreateFont(-12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, FF_DONTCARE | DEFAULT_PITCH, L"Courier");
    h_old_font = (HFONT)SelectObject(h_DC, h_font);
    wglUseFontBitmaps(h_DC, 32, 96, font_base);
    SelectObject(h_DC, h_old_font);
    DeleteObject(h_font);
    b_font_build = true;
}
void GL::print_gl(float x, float y, const GLubyte color[3], const char* fmt, ...)
{
    if (!b_font_build) {
        GL::build_font();
    }
    if (fmt == NULL) {
        return;
    }
    glColor3f(color[0], color[1], color[2]);
    glRasterPos2i(x, y);
    char        text[256];
    va_list     ap;
    va_start(ap, fmt);
    vsprintf(text, fmt, ap);
    va_end(ap);
    glPushAttrib(GL_LIST_BIT);
    glListBase(font_base - 32);
    glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);
    glPopAttrib();
}
void GL::draw_esp_box(float pos_x, float pos_y, float distance, const GLubyte color[3], const BYTE* text, const int health, const int armor) {
    float line_width = 0.5f; // Толщина линии
    GLint view_port[4];
    glGetIntegerv(GL_VIEWPORT, view_port);
    float height = (view_port[3] / distance) * 3; // Высота бокса
    float width = (view_port[2] / distance); // Ширина бокса
    // Snap lines
    GL::draw_line(view_port[2] / 2.0f, (float)view_port[3], pos_x, pos_y, line_width + 2.0f, rgb::black);
    GL::draw_line(view_port[2] / 2.0f, (float)view_port[3], pos_x, pos_y, line_width, color);
    // Очертания
    GL::draw_out_line(pos_x - (width / 2), pos_y - height, width, height, line_width + 2.0f, rgb::black);
    GL::draw_out_line(pos_x - (width / 2), pos_y - height, width, height, line_width, color);
    // Здоровье
    if (health != -1) {
        float perc = (width / 100);
        float curr = perc * health;
        GL::draw_filled_rectangle(pos_x - (width / 2) - 1, ((pos_y - (height / 10)) - 1) - height, width + 2, (height / 15) + 2, rgb::black);
        GL::draw_filled_rectangle(pos_x - (width / 2), (pos_y - (height / 10)) - height, width, height / 15, rgb::light_gray);
        GLubyte Hcolor[3]{ static_cast<GLubyte>(255 - (2.5f * health)), static_cast<GLubyte>(health * 2.5f), 0 };
        GL::draw_filled_rectangle(pos_x - (width / 2), (pos_y - (height / 10)) - height, curr, height / 15, Hcolor);
    }
    // Броня
    if (armor != -1) {
        float perc = (width / 100);
        float curr = perc * armor;
        GL::draw_filled_rectangle(pos_x - (width / 2) - 1, ((pos_y - (height / 5)) - 1) - height, width + 2, (height / 15) + 2, rgb::black);
        GL::draw_filled_rectangle(pos_x - (width / 2), (pos_y - (height / 5)) - height, width, height / 15, rgb::light_gray);
        GL::draw_filled_rectangle(pos_x - (width / 2), (pos_y - (height / 5)) - height, curr, height / 15, rgb::blue);
    }
    // Имя
    GL::print_gl(pos_x - (width / 2), (pos_y - (height / 4)) - height, rgb::yellow,(char *)text);
}
bool GL::world_to_screen(Vector3 pos, Vector3& screen, float matrix[16]) {
    // Получение ширины и высоты экрана
    GLint view_port[4];
    glGetIntegerv(GL_VIEWPORT, view_port);
    int window_width = view_port[2];
    int window_height = view_port[3];
    // Матрично-векторный результат, умножающий мировые (глазные) координаты на проекционную матрицу (clip_coords)
    Vector4 clip_coords;
    clip_coords.x = pos.x * matrix[0] + pos.y * matrix[4] + pos.z * matrix[8] + matrix[12];
    clip_coords.y = pos.x * matrix[1] + pos.y * matrix[5] + pos.z * matrix[9] + matrix[13];
    clip_coords.z = pos.x * matrix[2] + pos.y * matrix[6] + pos.z * matrix[10] + matrix[14];
    clip_coords.w = pos.x * matrix[3] + pos.y * matrix[7] + pos.z * matrix[11] + matrix[15];
    // Если координаты не на экране
    if (clip_coords.w < 0.1f) {
        return false;
    }
    // Перспективное деление, деление на clip.W, то есть нормализованные координаты устройства
    Vector3 NDC;
    NDC.x = clip_coords.x / clip_coords.w;
    NDC.y = clip_coords.y / clip_coords.w;
    NDC.z = clip_coords.z / clip_coords.w;
    // Преобразование в координаты экрана
    screen.x = (window_width / 2 * NDC.x) + (NDC.x + window_width / 2);
    screen.y = -(window_height / 2 * NDC.y) + (NDC.y + window_height / 2);
    return true;
}

std::optional<Player> GetPlayer() {
    auto start_point = reinterpret_cast<std::uintptr_t>(GetModuleHandleA("UnityPlayer.dll"));
    start_point += offsets::player.start_point;

    // Get a pointer to health
    const auto health_ptr = TraverseChain(start_point, offsets::player.ptr_chain).value_or(0u);

    if (!health_ptr)
        return std::nullopt;

    const auto ammo_ptr = health_ptr - 0x4;

    const Player player{
        .health = reinterpret_cast<std::int32_t*>(health_ptr),
        .ammo = reinterpret_cast<std::int32_t*>(ammo_ptr)
    };

    return player;
}

namespace offsets {
    PointerChain player = {
        .start_point = 0x13A1340,
        .ptr_chain { 0xC2C, 0xDC8, 0xEA8, 0x18, 0x38 }
    };
}

symchk.exe /r UnityPlayer.dll /s srv*http://symbolserver.unity3d.com /v

// Определение экспортируемой функции GetHWID
extern "C" {
    void __declspec(dllexport) GetHWID(char* message) {
        // Объявление переменной для хеша
        SHA256 sha;
        // Инициализация сида от текущего времени для рандома
        srand((unsigned)time(NULL));
        // Получение рандомного значения
        std::string random = std::to_string(rand());
        // Получение SHA-256 для рандомного значения
        sha.update(random);
        // Получение значения хеша
        std::array<uint8_t, 32> digest = sha.digest();
        // Получение шестнадцатеричной строки хеша
        std::string sha256 = SHA256::toString(digest);
        // Присвоение аргументу значения хеша
        for (int i = 0u; i < sha256.length(); ++i) {
            message[i] = sha256[i];
        }
    }
}

import requests
r = requests.get('https://aimware.net')

// Определение экспортируемой функции GetHWID
extern "C" {
    void __declspec(dllexport) GetHWID(char* message) {
        // Определение переменной хеша
        std::string sha256 = "6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b";
        // Присвоение аргументу значения хеша
        for (int i = 0u; i < sha256.length(); ++i) {
            message[i] = sha256[i];
        }
    }
}
Код для нашего Quack-internal.dll.



#include "pch.h"

#include <chrono>
#include <thread>

#include<nlohmann/json.hpp>
#include<httplib.h>

// Для работы с секундами
using namespace std::chrono_literals;

// Функция потока
DWORD WINAPI run(LPVOID lpParam) {
    // Объявление переменных
    httplib::Result res;
    nlohmann::json body{};
    long long uptime;
    // Определение клиента сервера и порта
    httplib::Client cli{ "localhost", 7982 };
    // Время
    std::chrono::time_point<std::chrono::system_clock> time_start = std::chrono::system_clock::now();
    // Задержка
    std::chrono::seconds delay = 1s;
    // Цикл
    for (std::chrono::seconds seconds = 0s; ; ++seconds) {
        // Вычисление времени соединения
        uptime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - time_start).count();
        // Пакет
        body["heartbeat"] = {
            {"uuid", "6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b"},
            {"name", "Placeholder"},
            {"arp", ""},
            {"risk", "0"},
            {"uptime", uptime},
            {"blob", {{"Game position", "[Placeholder]"}}}
        };
        // Post-запрос к серверу
        if (res = cli.Post("/", body.dump(), "application/json")) {
            // Успешно ли соединение?
            if (res->status == 200) {
                // В случае успеха заснуть
                std::this_thread::sleep_for(delay);
                // и продолжить выполнение
                continue;
            }
        }
        // Завершение процесса в том случае, если не получается установить соединение с сервером
        ExitProcess(0);
    }
}

// Главная функция
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        // Запуск потока
        if (HANDLE thread = CreateThread(nullptr,0,run,hModule,0,nullptr))
            CloseHandle(thread);
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}