C / C++, как я могу получить базовый адрес.exe запущенного процесса?

Question

Я ищу метод / функцию, которую я могу использовать, чтобы получить базовый адрес "program.exe"+03262C08 -> B4895A0, Этот адрес от Cheat Engine и базовый адрес был найден с помощью сканера указателя. В сканере указателя я могу нажать show module list и есть адрес program.exe начиная с адреса 00400000 program.exe, Сканер указателей был отсканирован на адрес 09c3000(Адрес, который я хочу получить после базового адреса + много смещений [конечный адрес]). Этот адрес является базовым для определенного объекта, но я не могу добраться до адреса. Я могу получить только базовый адрес exe-файла в 00400000, Я пытаюсь добавить смещения от указателя 03262C08(и другие), но я все еще не могу добраться до адреса. Я не могу использовать функцию FindWindow(), Поскольку название программы будет изменяться, и оно будет избыточным, чтобы придерживаться его. я использую OpenProcess(), EnumProcessModulesEx(), GetModuleFileNameEx() функции. Я пробовал и других, как GetModuleInformation(),... с тем же результатом. GetModuleHandle() закончился с результатом 0x126 [ERROR_MOD_NOT_FOUND], Я использую 64-битную ОС и пытаюсь получить базовый адрес другого процесса. Я вижу все процессы на локальной машине и модули "программного" процесса.

if (!K32EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded)) {
    return 1;
}

cProcesses = cbNeeded / sizeof(DWORD);

cout << setw(15) << left << "Process ID" << setw(10) << left << "Modules";
cout << setw(30) << left << "Process Name" << endl;
for (i = 0; i < cProcesses; i++) {
    if (aProcesses[i] != 0) {
        ProcessView::GetProccesses(aProcesses[i], modules, sizeModules, &cModules, &hCurrProcess);
        if (hCurrProcess != NULL) {
            cout << endl << setw(15) << left << aProcesses[i] << setw(10) << left << cModules;
            ProcessView::PrintModuleName(hCurrProcess, modules);
            CloseHandle(hCurrProcess);
        }

    }
}
ProcessView::GetProccesses(cProcesses, modules, sizeModules, &cModules, &hCurrProcess);

system("cls");
ProcessView::PrintModuleNameAll(hCurrProcess, modules, cModules);

Я добавил здесь определение функции в примере из файла ProcessView.h, который я создал.

static void GetProccesses(_In_ DWORD processID, _Inout_ HMODULE ahModules[], _In_ int sizeModules, _Out_ DWORD* cModules, _Out_ HANDLE* hProcess);
static void PrintModuleName(_In_ HANDLE processID, _In_ HMODULE* modules);
static void PrintModuleNameAll(_In_ HANDLE hProcess, _In_ HMODULE * modules, _In_ DWORD cModules);

Answer 1

Windows использует рандомизацию адресного пространства уже около десяти лет, но база модулей в EXE-файлах намного старше. Просто игнорируйте это, теперь это бессмысленно.

И не забывайте: у каждого процесса есть свое адресное пространство. Указатель в одном процессе не имеет смысла в другом.

Answer 2

Чтобы использовать ReadProcessMemory или WriteProcessMemory по адресу, который находится через цепочку указателей в процессе, и динамически получать базовый адрес модуля во время выполнения, вам необходимо выполнить следующие шаги:

• Найдите процесс с помощью ToolHelp32Snapshot
• Найдите модуль с помощью ToolHelp32Snapsho
• Получите доступ к процессу с правильными разрешениями
• Прогулка по цепочке указателей, снятие ссылок и добавление смещений
• Затем вы можете вызвать ReadProcessMemory или WriteProcessMemory
• Вы должны работать как администратор

В этом примере я буду использовать простой чит для штурмового куба, который я сделал.

#include <iostream>
#include <vector>
#include <Windows.h>
#include "proc.h"

int main()
{
    //Get ProcId of the target process
    DWORD procId = GetProcId(L"ac_client.exe");

    //Getmodulebaseaddress
    uintptr_t moduleBase = GetModuleBaseAddress(procId, L"ac_client.exe");

    //Get Handle to Process
    HANDLE hProcess = 0;
    hProcess = OpenProcess(PROCESS_ALL_ACCESS, NULL, procId);

    //Resolve base address of the pointer chain
    uintptr_t dynamicPtrBaseAddr = moduleBase + 0x10f4f4;

    std::cout << "DynamicPtrBaseAddr = " << "0x" << std::hex << dynamicPtrBaseAddr << std::endl;

    //Resolve our ammo pointer chain
    std::vector<unsigned int> ammoOffsets = { 0x374, 0x14, 0x0 };
    uintptr_t ammoAddr = FindDMAAddy(hProcess, dynamicPtrBaseAddr, ammoOffsets);

    std::cout << "ammoAddr = " << "0x" << std::hex << ammoAddr << std::endl;

    //Read Ammo value
    int ammoValue = 0;

    ReadProcessMemory(hProcess, (BYTE*)ammoAddr, &ammoValue, sizeof(ammoValue), nullptr);
    std::cout << "Curent ammo = " << std::dec << ammoValue << std::endl;

    //Write to it
    int newAmmo = 1337;
    WriteProcessMemory(hProcess, (BYTE*)ammoAddr, &newAmmo, sizeof(newAmmo), nullptr);

    //Read out again
    ReadProcessMemory(hProcess, (BYTE*)ammoAddr, &ammoValue, sizeof(ammoValue), nullptr);

    std::cout << "New ammo = " << std::dec << ammoValue << std::endl;

    getchar();
    return 0;
}

Заголовочный файл proc.cpp:

DWORD GetProcId(const wchar_t* procName)
{
    DWORD procId = 0;
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 procEntry;
        procEntry.dwSize = sizeof(procEntry);

        if (Process32First(hSnap, &procEntry))
        {
            do
            {
                if (!_wcsicmp(procEntry.szExeFile, procName))
                {
                    procId = procEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(hSnap, &procEntry));

        }
    }
    CloseHandle(hSnap);
    return procId;
}

uintptr_t GetModuleBaseAddress(DWORD procId, const wchar_t* modName)
{
    uintptr_t modBaseAddr = 0;
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, procId);
    if (hSnap != INVALID_HANDLE_VALUE)
    {
        MODULEENTRY32 modEntry;
        modEntry.dwSize = sizeof(modEntry);
        if (Module32First(hSnap, &modEntry))
        {
            do
            {
                if (!_wcsicmp(modEntry.szModule, modName))
                {
                    modBaseAddr = (uintptr_t)modEntry.modBaseAddr;
                    break;
                }
            } while (Module32Next(hSnap, &modEntry));
        }
    }
    CloseHandle(hSnap);
    return modBaseAddr;
}

uintptr_t FindDMAAddy(HANDLE hProc, uintptr_t ptr, std::vector<unsigned int> offsets)
{
    uintptr_t addr = ptr;
    for (unsigned int i = 0; i < offsets.size(); ++i)
    {
        ReadProcessMemory(hProc, (BYTE*)addr, &addr, sizeof(addr), 0);
        addr += offsets[i];
    }
    return addr;
}