如何使用MODULEENTRY32获取进程的基址？

Question

我希望在这个例子中做一些事情：Python - How to get the start/base address of a process?。我和那个主题中的人有同样的问题，因为作弊引擎提供的指针是引用进程本身的基地址。在

我到处看看，似乎最好的解决方案是使用ctypes和MODULEENTRY32来存储进程的快照并分析它们的modBaseAddr。在

这是我当前的代码

import os.path, ctypes, ctypes.wintypes
from ctypes import *
from ctypes.wintypes import *

PROCESS_QUERY_INFORMATION = (0x0400)
PROCESS_VM_OPERATION = (0x0008)
PROCESS_VM_READ = (0x0010)
PROCESS_VM_WRITE = (0x0020)
TH32CS_SNAPMODULE = (0x00000008)

CreateToolhelp32Snapshot= ctypes.windll.kernel32.CreateToolhelp32Snapshot
Process32First = ctypes.windll.kernel32.Process32First
Process32Next = ctypes.windll.kernel32.Process32Next
Module32First = ctypes.windll.kernel32.Module32First
Module32Next = ctypes.windll.kernel32.Module32Next
GetLastError = ctypes.windll.kernel32.GetLastError
OpenProcess = ctypes.windll.kernel32.OpenProcess
GetPriorityClass = ctypes.windll.kernel32.GetPriorityClass
CloseHandle = ctypes.windll.kernel32.CloseHandle

class MODULEENTRY32(Structure):
       _fields_ = [ ( 'dwSize' , DWORD ) , 
                ( 'th32ModuleID' , DWORD ),
                ( 'th32ProcessID' , DWORD ),
                ( 'GlblcntUsage' , DWORD ),
                ( 'ProccntUsage' , DWORD ) ,
                ( 'modBaseAddr' , POINTER(BYTE)) ,
                ( 'modBaseSize' , DWORD ) , 
                ( 'hModule' , HMODULE ) ,
                ( 'szModule' , c_char * 256 ),
                ( 'szExePath' , c_char * 260 ) ]



def GetBaseAddr(ProcId, ProcName):
       me32 = MODULEENTRY32()
       me32.dwSize = sizeof(me32)
       hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, ProcId)
       if GetLastError() != 0:
              CloseHandle(hSnapshot)
              print 'Handle Error %s' % WinError()
              return 'Error'

       else:
              if Module32First(hSnapshot, byref(me32)):
                     if me32.szModule == ProcName:
                            CloseHandle(hSnapshot)
                            return id(me32.modBaseAddr)

                     else:
                            Module32Next(hSnapshot, byref(me32))
                            while int(GetLastError())!= 18:
                                   if me32.szModule == ProcName:
                                          CloseHandle(hSnapshot)
                                          return id(me32.modBaseAddr)

                                   else:
                                          Module32Next(hSnapshot, byref(me32))

                            CloseHandle(hSnapshot)
                            print 'Couldn\'t find Process with name %s' % ProcName

              else:
                     print 'Module32First is False %s' % WinError()
                     CloseHandle(hSnapshot)

def GetProcessIdByName( pName):
       if pName.endswith('.exe'):
              pass
       else:
              pName = pName+'.exe'

       ProcessIds, BytesReturned = EnumProcesses()

       for index in range(BytesReturned / ctypes.sizeof(ctypes.wintypes.DWORD)):
              ProcessId = ProcessIds[index]
              hProcess = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION, False, ProcessId)
              if hProcess:
                     ImageFileName = (ctypes.c_char*MAX_PATH)()
                     if ctypes.windll.psapi.GetProcessImageFileNameA(hProcess, ImageFileName, MAX_PATH)>0:
                            filename = os.path.basename(ImageFileName.value)
                            if filename == pName:
                                   return ProcessId
                     CloseHandle(hProcess)

def EnumProcesses():
       count = 32
       while True:
              ProcessIds = (ctypes.wintypes.DWORD*count)()
              cb = ctypes.sizeof(ProcessIds)
              BytesReturned = ctypes.wintypes.DWORD()
              if ctypes.windll.Psapi.EnumProcesses(ctypes.byref(ProcessIds), cb, ctypes.byref(BytesReturned)):
                     if BytesReturned.value<cb:
                            return ProcessIds, BytesReturned.value
                            break
                     else:
                            count *= 2
              else:
                     return None



if __name__ == '__main__':
       ProcId = GetProcessIdByName('RocketLeague.exe')
       #print ProcId
       print hex(GetBaseAddr(ProcId, 'RocketLeague.exe'))
       #print hex(GetBaseAddr(8252,'RocketLeague.exe'))

现在我对内存的理解不是最好的，但是我认为在程序运行时基址应该是静态的。当我运行这段代码时，每次运行它时，我得到的ModBaseAddr都会更改。另一个奇怪的问题是，如果没有print ProcId语句，运行程序会从第41行返回一个ERROR\u ACCESS_DENIED（错误5）（这与CreateToolhelp32Snapshot函数有关，因为我在计算机上有管理权限）。但是，对于print语句，程序每次都会给我一个不同的ModBaseAddr。如果我手动给GetBaseAddr函数输入ProcessId，它也可以在没有print语句的情况下工作，不过，它每次都会给我一个随机地址。 如果有人能为我提供帮助或指引我正确的方向，我将非常感激！在

Answer 1

说明：MODULEENTRY32存储有关模块的信息，而不是进程。当您使用TH32CS_SNAPMODULE调用CreateToolhelp32Snapshot时，您将获得由进程加载的模块，而不是进程本身。在

不需要将MODULEENTRY32与EnumProcesses结合使用，您可以使用CreateToolHelp32Snapshot与TH32CS_SNAPPROCESS一起使用，以获得PROCESSENRTY32结构形式的进程列表，该结构还包含进程标识符。在

尽管您是具有管理员权限的用户，但您还必须以管理员身份运行进程。在

您还应该确保将MODULEENTRY32初始化为{0}，以便正确处理错误，并且不会遇到返回值受到未初始化内存未定义行为的影响的问题。在

我不知道您的问题的具体原因，但我为此使用了一个非常健壮的源代码，它可能是您当前使用的东西的即插即用的替代品，下面是重要的片段，但是完整的源代码是可用的here。在

def ListProcessModules( ProcessID ):
    hModuleSnap = c_void_p(0)
    me32 = MODULEENTRY32()
    me32.dwSize = sizeof( MODULEENTRY32 )
    hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, ProcessID )

    ret = Module32First( hModuleSnap, pointer(me32) )
    if ret == 0 :
        print 'ListProcessModules() Error on Module32First[%d]' % GetLastError()
        CloseHandle( hModuleSnap )
        return False 

    while ret :
        print "   MODULE NAME:     %s"%             me32.szModule 
        print "   executable     = %s"%             me32.szExePath 
        print "   process ID     = 0x%08X"%         me32.th32ProcessID 
        print "   ref count (g)  =     0x%04X"%     me32.GlblcntUsage 
        print "   ref count (p)  =     0x%04X"%     me32.ProccntUsage 
        print "   base address   = 0x%08X"%         me32.modBaseAddr 
        print "   base size      = %d"%             me32.modBaseSize 

        ret = Module32Next( hModuleSnap , pointer(me32) )

    CloseHandle( hModuleSnap )
    return True