C++ Obtenir Module Adresse de Base pour 64bit Application

Bien votre code ne va jamais fonctionner correctement car vous parlez de 64 bits mais vous utilisez DWORD pour l'adresse de base! Solitaire pourrait 32 bits de l'adresse, mais vous ne pouvez pas garantir que vous ne devez jamais l'assumer.

Cette fonction. Il nécessite uniquement l'ID de processus du processus en question, et il suppose que vous voulez l'adresse de base de ce processus. c'est à dire pas un de ses Dll. Si vous ne voulez pas le processus propriétaire, alors vous devez parcourir moduleArray en utilisant quelque chose comme for (int i=0; i<moduleCount; i++ ) { //do something with moduleArray[i] } et puis vérifier le module de nom de fichier.

Si vous voulez seulement le départ du processus (l'exécutable), vous pouvez simplement faire l'hypothèse que c'est le premier élément dans le tableau.

DWORD_PTR GetProcessBaseAddress( DWORD processID )
{
DWORD_PTR   baseAddress = 0;
HANDLE      processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processID);
HMODULE     *moduleArray;
LPBYTE      moduleArrayBytes;
DWORD       bytesRequired;
if ( processHandle )
{
if ( EnumProcessModules( processHandle, NULL, 0, &bytesRequired ) )
{
if ( bytesRequired )
{
moduleArrayBytes = (LPBYTE)LocalAlloc( LPTR, bytesRequired );
if ( moduleArrayBytes )
{
unsigned int moduleCount;
moduleCount = bytesRequired / sizeof( HMODULE );
moduleArray = (HMODULE *)moduleArrayBytes;
if ( EnumProcessModules( processHandle, moduleArray, bytesRequired, &bytesRequired ) )
{
baseAddress = (DWORD_PTR)moduleArray[0];
}
LocalFree( moduleArrayBytes );
}
}
}
CloseHandle( processHandle );
}
return baseAddress;
}

Échantillon de la console demande basée sur les exemples donnés par @Nostromoo

Devrait fonctionner sur x86/x64

#include "stdafx.h"
#include <windows.h>
#include <psapi.h>
#include <vector>
#define MODULE_NAME L"TestModule"
#define WINDOW_NAME L"TestConsole"
bool GetBaseModuleInfo(MODULEINFO* baseModuleInfo);
HMODULE GetProcessBaseAddressFromProcessHandle(HANDLE processHandle);
bool EnumProcessModulesPlattform(HANDLE processHandle, HMODULE* lphModule, DWORD cb, LPDWORD bytesRequired);
DWORD GetProcessIdentifier(const wchar_t* windowName);
int main()
{
SetConsoleTitle(WINDOW_NAME);
//Wait for the title to be set otherwise the window might not be found.
Sleep(200);
MODULEINFO baseModuleInfo;
bool success = GetBaseModuleInfo(&baseModuleInfo);
if (success == false) {
wprintf(MODULE_NAME L"main() - GetBaseModuleInfo() failed.\n");
std::getchar();
return 1;
}
wchar_t buffer[2000];
#ifdef _WIN64
swprintf_s(buffer, sizeof(buffer) / sizeof(*buffer), MODULE_NAME L"main() - baseAddress: '%llX' size: '%lX'\n", baseModuleInfo.lpBaseOfDll, baseModuleInfo.SizeOfImage);
#elif _WIN32
swprintf_s(buffer, sizeof(buffer) / sizeof(*buffer), MODULE_NAME L"main() - baseAddress: '%lX' size: '%lX'\n", baseModuleInfo.lpBaseOfDll, baseModuleInfo.SizeOfImage);
#endif
wprintf(buffer);
std::getchar();
return 0;
}
bool GetBaseModuleInfo(MODULEINFO* baseModuleInfo)
{
DWORD processID = GetProcessIdentifier(WINDOW_NAME);
if (processID == NULL) {
wprintf(MODULE_NAME L"GetBaseModuleInfo() - GetProcessIdentifier() returned NULL.\n");
return false;
}
HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processID);
if (processHandle == NULL) {
wprintf(MODULE_NAME L"GetBaseModuleInfo() - OpenProcess() returned NULL.\n");
return false;
}
HMODULE baseAddress = GetProcessBaseAddressFromProcessHandle(processHandle);
if (baseAddress == NULL) {
wprintf(MODULE_NAME L"GetBaseModuleInfo() - GetProcessBaseAddressFromProcessHandle() returned NULL.\n");
return false;
}
bool resultGMI = GetModuleInformation(processHandle, baseAddress, baseModuleInfo, sizeof(*baseModuleInfo));
//NOTE: GetModuleInformation doesn't fail even if the baseAddress is wrong. Maybe it uses the nearest module?
if (resultGMI == false) {
wprintf(MODULE_NAME L"GetBaseModuleInfo() - GetModuleInformation() failed.\n");
return false;
}
CloseHandle(processHandle);
return true;
}
HMODULE GetProcessBaseAddressFromProcessHandle(HANDLE processHandle)
{
DWORD bytesRequired;
if (EnumProcessModulesPlattform(processHandle, NULL, 0, &bytesRequired) == false) {
wprintf(MODULE_NAME L"GetProcessBaseAddressFromProcessHandle() - EnumProcessModules() error.\n");
return NULL;
}
if (bytesRequired == NULL) {
wprintf(MODULE_NAME L"GetProcessBaseAddressFromProcessHandle() - EnumProcessModules() returned 0 bytesRequired.\n");
return NULL;
}
unsigned int moduleCount = bytesRequired / sizeof(HMODULE);
std::vector<HMODULE> hModules(moduleCount, 0);
if (EnumProcessModulesPlattform(processHandle, &hModules[0], bytesRequired, &bytesRequired) == false) {
wprintf(MODULE_NAME L"GetProcessBaseAddressFromProcessHandle() - EnumProcessModules(moduleArray) error.\n");
return NULL;
}
//The first item is always the baseModule.
HMODULE baseAddress = hModules[0];
return baseAddress;
}
bool EnumProcessModulesPlattform(HANDLE processHandle, HMODULE* lphModule, DWORD cb, LPDWORD bytesRequired)
{
#ifdef _WIN64
bool returnValue = EnumProcessModulesEx(processHandle, lphModule, cb, bytesRequired, LIST_MODULES_64BIT);
#elif _WIN32
bool returnValue = EnumProcessModulesEx(processHandle, lphModule, cb, bytesRequired, LIST_MODULES_32BIT);
#endif
DWORD lastError = GetLastError();
if (lastError != 0) {
wprintf(MODULE_NAME L"EnumProcessModulesPlattform() - lastError != 0 EnumProcessModulesEx().\n");
return false;
}
return returnValue;
}
DWORD GetProcessIdentifier(const wchar_t* windowName)
{
HWND windowHandle = FindWindow(NULL, windowName);
if (windowHandle == NULL) {
wprintf(MODULE_NAME L"GetProcessIdentifier() - Could not find hwnd of '%s'.\n", windowName);
return NULL;
}
DWORD processID;
GetWindowThreadProcessId(windowHandle, &processID);
return processID;
}