Гайд Принцип чтения памяти игры используя механики ядра ОС Windows (Virtual Memory, Physical Memory)

[Antoxa1337]

кого я продаю, емае, что ты пишешь, я не понимаю. такой же бред как и в теме про фейсит
к тому же причем здесь "Vac Bypass best hack 2026 cs 2&"

Привет почему ты мне не отвечаешь в личных сообщениях форума yougame

 

[TheXSVV]

#include <Windows.h>
#include <stdio.h>
#include <string.h>
#include <TlHelp32.h>
#include <psapi.h>
#include <conio.h>
#include <iomanip>




DWORD pid = 0;

struct HookData {
    DWORD_PTR targetAddr;
    BYTE originalBytes[20];
    bool installed;
    DWORD oldProtect;
    DWORD_PTR trampolineAddr;
    int overwrittenBytes;
};

HookData g_hookData = { 0 };
HANDLE g_hProcess = NULL;

void realHandler(DWORD eaxValue) {
    if (eaxValue == 0) {
        printf("Некорректное значение EAX\n");
        return;
    }
    DWORD accessedAddr = eaxValue + 0x60;
    printf("Обращаемый адрес: 0x%p\n", (void*)accessedAddr);
}

__declspec(naked) void CppHookHandler() {
    __asm {
        push ebp
        mov ebp, esp

        pushad
        pushfd

        mov eax, [ebp + 8]
        call realHandler

        popfd
        popad

        mov eax, [eax + 0x60]
        jmp[g_hookData.targetAddr + 5]

        pop ebp
        ret
    }
}

bool ValidateMemory(HANDLE hProcess, DWORD_PTR addr, DWORD size) {
    MEMORY_BASIC_INFORMATION mbi;
    if (!VirtualQueryEx(hProcess, (LPCVOID)addr, &mbi, sizeof(mbi))) {
        return false;
    }
    return mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_EXECUTE);
}

bool CreateTrampoline(HookData* hook) {
    if (!ReadProcessMemory(g_hProcess, (LPCVOID)hook->targetAddr,
        hook->originalBytes, 20, NULL)) {
        printf("Ошибка чтения байтов: %lu\n", GetLastError());
        return false;
    }

    MEMORY_BASIC_INFORMATION mbi;
    if (!VirtualQueryEx(g_hProcess, (LPCVOID)hook->targetAddr, &mbi, sizeof(mbi))) {
        return false;
    }

    hook->trampolineAddr = (DWORD_PTR)VirtualAllocEx(
        g_hProcess, NULL, 128, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

    if (!hook->trampolineAddr) {
        printf("Ошибка выделения памяти: %lu\n", GetLastError());
        return false;
    }

    BYTE trampoline[128] = { 0 };
    int bytesCopied = 0;

    for (int i = 0; i < 20; i++) {
        trampoline[i] = hook->originalBytes[i];
        bytesCopied++;
        if (i >= 2 &&
            hook->originalBytes[i - 2] == 0x8B &&
            hook->originalBytes[i - 1] == 0x40 &&
            hook->originalBytes[i] == 0x60) {
            break;
        }
    }

    DWORD_PTR returnAddr = hook->targetAddr + bytesCopied;
    INT64 returnOffset = (INT64)returnAddr - (INT64)(hook->trampolineAddr + bytesCopied) - 5;

    if (abs(returnOffset) > 0x7FFFFFFF) {
        printf("Слишком большое смещение для JMP\n");
        return false;
    }

    trampoline[bytesCopied] = 0xE9;
    memcpy(&trampoline[bytesCopied + 1], &returnOffset, 4);

    if (!WriteProcessMemory(g_hProcess, (LPVOID)hook->trampolineAddr,
        trampoline, 128, NULL)) {
        return false;
    }

    hook->overwrittenBytes = bytesCopied;
    return true;
}


bool InstallInlineHook(DWORD_PTR targetFunc) {
    g_hookData.targetAddr = targetFunc;

    MEMORY_BASIC_INFORMATION mbi;
    if (!VirtualQueryEx(g_hProcess, (LPCVOID)targetFunc, &mbi, sizeof(mbi))) {
        printf("Ошибка VirtualQueryEx: %lu\n", GetLastError());
        return false;
    }
    g_hookData.oldProtect = mbi.Protect;

    if (!CreateTrampoline(&g_hookData)) {
        return false;
    }

    INT64 offset = (INT64)g_hookData.trampolineAddr - (INT64)targetFunc - 5;
    if (abs(offset) > 0x7FFFFFFF) {
        printf("Слишком большое смещение: 0x%llX\n", offset);
        return false;
    }

    BYTE patch[5] = { 0xE9 };
    memcpy(&patch[1], &offset, 4);

    DWORD tempProtect;
    if (!VirtualProtectEx(g_hProcess, mbi.BaseAddress, mbi.RegionSize,
        PAGE_EXECUTE_READWRITE, &tempProtect)) {
        printf("Ошибка VirtualProtectEx: %lu\n", GetLastError());
        return false;
    }

    if (!WriteProcessMemory(g_hProcess, (LPVOID)targetFunc, patch, 5, NULL)) {
        printf("Ошибка записи патча: %lu\n", GetLastError());
        return false;
    }

    Sleep(100);
    if (!VirtualProtectEx(g_hProcess, mbi.BaseAddress, mbi.RegionSize,
        g_hookData.oldProtect, NULL)) {
        DWORD error = GetLastError();
        if (error == ERROR_NOACCESS) {
            printf("Античит блокирует восстановление прав\n");
        }
        else {
            printf("Ошибка восстановления прав: %lu\n", error);
            return false;
        }
    }

    g_hookData.installed = true;
    printf("Хук установлен на адрес 0x%p\n", (void*)targetFunc);
    return true;
}

void RemoveInlineHook() {
    if (g_hookData.installed) {
        MEMORY_BASIC_INFORMATION mbi;
        if (!VirtualQueryEx(g_hProcess, (LPCVOID)g_hookData.targetAddr, &mbi, sizeof(mbi))) {
            printf("Ошибка получения информации о памяти\n");
            return;
        }

        if (!WriteProcessMemory(g_hProcess, (LPVOID)g_hookData.targetAddr,
            g_hookData.originalBytes, g_hookData.overwrittenBytes, NULL)) {
            printf("Ошибка восстановления оригинальных байтов\n");
            return;
        }

        if (g_hookData.trampolineAddr) {
            VirtualFreeEx(g_hProcess, (LPVOID)g_hookData.trampolineAddr, 0, MEM_RELEASE);
        }

        g_hookData.installed = false;
        printf("Хук удален\n");
    }
}

DWORD GetProcId(const char* ProcName) {
    PROCESSENTRY32 pe32;
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return 0;
    }

    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, ProcName) == 0) {
                CloseHandle(hSnapshot);
                return pe32.th32ProcessID;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }

    CloseHandle(hSnapshot);
    return 0;
}

DWORD_PTR GetModuleBaseAddress(DWORD processId, const char* moduleName) {
    HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processId);
    if (!hProcess) return 0;

    HMODULE hMods[1024];
    DWORD cbNeeded;
    if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {
        for (int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
            char szModName[MAX_PATH];
            if (GetModuleBaseNameA(hProcess, hMods[i], szModName, sizeof(szModName))) {
                if (_stricmp(szModName, moduleName) == 0) {
                    DWORD_PTR baseAddr = (DWORD_PTR)hMods[i];
                    CloseHandle(hProcess);
                    return baseAddr;
                }
            }
        }
    }
    CloseHandle(hProcess);
    return 0;
}

int main() {
    setlocale(LC_ALL, "Russian");
    const char* processName = "gta_sa.exe";
   

    DWORD instructionOffset = 0x2008BF;
   

    printf("Ищем процесс: %s\n", processName);

    pid = GetProcId(processName);
    if (pid == 0) {
        printf("Процесс не найден!\n");
        return 1;
    }

    g_hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (!g_hProcess) {
        printf("Не удалось открыть процесс\n");
        return 1;
    }

    DWORD_PTR baseAddr = GetModuleBaseAddress(pid, processName);
    if (baseAddr == 0) {
        printf("Не удалось получить базовый адрес\n");
        CloseHandle(g_hProcess);
        return 1;
    }

    DWORD_PTR targetAddr = baseAddr + instructionOffset;
    printf("Базовый адрес: 0x%p\n", (void*)baseAddr);
    printf("Целевой адрес: 0x%p\n", (void*)targetAddr);

    MEMORY_BASIC_INFORMATION mbi;
    if (VirtualQueryEx(g_hProcess, (LPCVOID)targetAddr, &mbi, sizeof(mbi))) {
        printf("Информация о регионе:\n");
        printf("  BaseAddress: 0x%p\n", mbi.BaseAddress);
        printf("  RegionSize: %lu байт\n", mbi.RegionSize);
        printf("  Protect: 0x%lx\n", mbi.Protect);
        printf("  State: 0x%lx\n", mbi.State);
    }

    if (!InstallInlineHook(targetAddr)) {
        printf("Не удалось установить хук\n");
        CloseHandle(g_hProcess);
        return 1;
    }

    printf("Хук установлен. Ожидание...\n");

    while (true) {
        if (_kbhit()) {
            int ch = _getch();
            if (ch == '\r' || ch == '\n') {
                break;
            }
        }
        Sleep(100);
    }

    RemoveInlineHook();
    CloseHandle(g_hProcess);
    printf("Программа завершена\n");
    return 0;
}

Всем Привет, кто может подсказсть что как прочитать eax?

ахахахахахаххааххаХАХАХАХАХАХАХАХАХХА Я ЕБАЛ ЧТО ТЫ КУРИЛ НАХУЙ