From dbb06c8fd59ad9d9b2f5532d92cf0a78e6c1c103 Mon Sep 17 00:00:00 2001 From: cypherpunk Date: Wed, 12 Mar 2014 15:27:42 +0100 Subject: [PATCH] initial commit for TitanUnitTest --- TitanEngine.sln | 8 + TitanUnitTest/README | 16 + TitanUnitTest/TitanEngine.h | 928 ++++++ TitanUnitTest/TitanEngine.hpp | 2800 +++++++++++++++++++ TitanUnitTest/TitanEngine.lib | Bin 0 -> 101964 bytes TitanUnitTest/TitanScript.h | 26 + TitanUnitTest/TitanScript.hpp | 122 + TitanUnitTest/TitanUnitTest.cpp | 39 + TitanUnitTest/TitanUnitTest.vcxproj | 98 + TitanUnitTest/TitanUnitTest.vcxproj.filters | 41 + TitanUnitTest/disasm.dll | Bin 0 -> 77824 bytes TitanUnitTest/stdafx.cpp | 8 + TitanUnitTest/stdafx.h | 15 + TitanUnitTest/targetver.h | 8 + 14 files changed, 4109 insertions(+) create mode 100644 TitanUnitTest/README create mode 100644 TitanUnitTest/TitanEngine.h create mode 100644 TitanUnitTest/TitanEngine.hpp create mode 100644 TitanUnitTest/TitanEngine.lib create mode 100644 TitanUnitTest/TitanScript.h create mode 100644 TitanUnitTest/TitanScript.hpp create mode 100644 TitanUnitTest/TitanUnitTest.cpp create mode 100644 TitanUnitTest/TitanUnitTest.vcxproj create mode 100644 TitanUnitTest/TitanUnitTest.vcxproj.filters create mode 100644 TitanUnitTest/disasm.dll create mode 100644 TitanUnitTest/stdafx.cpp create mode 100644 TitanUnitTest/stdafx.h create mode 100644 TitanUnitTest/targetver.h diff --git a/TitanEngine.sln b/TitanEngine.sln index 8b4e093..b19ed88 100644 --- a/TitanEngine.sln +++ b/TitanEngine.sln @@ -3,6 +3,8 @@ Microsoft Visual Studio Solution File, Format Version 11.00 # Visual Studio 2010 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TitanEngine", "TitanEngine\TitanEngine.vcxproj", "{9C7B8246-FDDA-48C7-9634-044969701E40}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TitanUnitTest", "TitanUnitTest\TitanUnitTest.vcxproj", "{5B5AB3CD-4D32-43B0-8840-E05C9483381D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -19,6 +21,12 @@ Global {9C7B8246-FDDA-48C7-9634-044969701E40}.Release|Win32.Build.0 = Release|Win32 {9C7B8246-FDDA-48C7-9634-044969701E40}.Release|x64.ActiveCfg = Release|x64 {9C7B8246-FDDA-48C7-9634-044969701E40}.Release|x64.Build.0 = Release|x64 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Debug|Win32.ActiveCfg = Debug|Win32 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Debug|Win32.Build.0 = Debug|Win32 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Debug|x64.ActiveCfg = Debug|Win32 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|Win32.ActiveCfg = Release|Win32 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|Win32.Build.0 = Release|Win32 + {5B5AB3CD-4D32-43B0-8840-E05C9483381D}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/TitanUnitTest/README b/TitanUnitTest/README new file mode 100644 index 0000000..a496c61 --- /dev/null +++ b/TitanUnitTest/README @@ -0,0 +1,16 @@ +Setup: +- Put disasm.dll into Debug/Release folder. +- Put TitanEngine.dll into Debug/Release folder. +- Put TitanScript.dll into plugins/x86/ folder in Debug/Release folder. +(Can be found here https://bitbucket.org/cypherpunk/titanscript-update) + +Usage: +- TitanUnitTest.exe script.osc target.exe + +It understands complete OllyDbgScript language and adds additional TE commands + +Example script: +#log + +GPA "IsDebuggerPresent", "kernel32.dll" +LOG $RESULT \ No newline at end of file diff --git a/TitanUnitTest/TitanEngine.h b/TitanUnitTest/TitanEngine.h new file mode 100644 index 0000000..4db1828 --- /dev/null +++ b/TitanUnitTest/TitanEngine.h @@ -0,0 +1,928 @@ +#ifndef TITANENGINE +#define TITANENGINE + +#define TITCALL + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +#pragma pack(push, 1) + +// Global.Constant.Structure.Declaration: +// Engine.External: +const BYTE UE_ACCESS_READ = 0; +const BYTE UE_ACCESS_WRITE = 1; +const BYTE UE_ACCESS_ALL = 2; + +const BYTE UE_HIDE_PEBONLY = 0; +const BYTE UE_HIDE_BASIC = 1; + +const BYTE UE_PLUGIN_CALL_REASON_PREDEBUG = 1; +const BYTE UE_PLUGIN_CALL_REASON_EXCEPTION = 2; +const BYTE UE_PLUGIN_CALL_REASON_POSTDEBUG = 3; + +const BYTE TEE_HOOK_NRM_JUMP = 1; +const BYTE TEE_HOOK_NRM_CALL = 3; +const BYTE TEE_HOOK_IAT = 5; + +const BYTE UE_ENGINE_ALOW_MODULE_LOADING = 1; +const BYTE UE_ENGINE_AUTOFIX_FORWARDERS = 2; +const BYTE UE_ENGINE_PASS_ALL_EXCEPTIONS = 3; +const BYTE UE_ENGINE_NO_CONSOLE_WINDOW = 4; +const BYTE UE_ENGINE_BACKUP_FOR_CRITICAL_FUNCTIONS = 5; +const BYTE UE_ENGINE_CALL_PLUGIN_CALLBACK = 6; +const BYTE UE_ENGINE_RESET_CUSTOM_HANDLER = 7; +const BYTE UE_ENGINE_CALL_PLUGIN_DEBUG_CALLBACK = 8; + +const BYTE UE_OPTION_REMOVEALL = 1; +const BYTE UE_OPTION_DISABLEALL = 2; +const BYTE UE_OPTION_REMOVEALLDISABLED = 3; +const BYTE UE_OPTION_REMOVEALLENABLED = 4; + +const BYTE UE_STATIC_DECRYPTOR_XOR = 1; +const BYTE UE_STATIC_DECRYPTOR_SUB = 2; +const BYTE UE_STATIC_DECRYPTOR_ADD = 3; + +const BYTE UE_STATIC_DECRYPTOR_FOREWARD = 1; +const BYTE UE_STATIC_DECRYPTOR_BACKWARD = 2; + +const BYTE UE_STATIC_KEY_SIZE_1 = 1; +const BYTE UE_STATIC_KEY_SIZE_2 = 2; +const BYTE UE_STATIC_KEY_SIZE_4 = 4; +const BYTE UE_STATIC_KEY_SIZE_8 = 8; + +const BYTE UE_STATIC_APLIB = 1; +const BYTE UE_STATIC_APLIB_DEPACK = 2; +const BYTE UE_STATIC_LZMA = 3; + +const BYTE UE_STATIC_HASH_MD5 = 1; +const BYTE UE_STATIC_HASH_SHA1 = 2; +const BYTE UE_STATIC_HASH_CRC32 = 3; + +const DWORD UE_RESOURCE_LANGUAGE_ANY = -1; + +const BYTE UE_PE_OFFSET = 0; +const BYTE UE_IMAGEBASE = 1; +const BYTE UE_OEP = 2; +const BYTE UE_SIZEOFIMAGE = 3; +const BYTE UE_SIZEOFHEADERS = 4; +const BYTE UE_SIZEOFOPTIONALHEADER = 5; +const BYTE UE_SECTIONALIGNMENT = 6; +const BYTE UE_IMPORTTABLEADDRESS = 7; +const BYTE UE_IMPORTTABLESIZE = 8; +const BYTE UE_RESOURCETABLEADDRESS = 9; +const BYTE UE_RESOURCETABLESIZE = 10; +const BYTE UE_EXPORTTABLEADDRESS = 11; +const BYTE UE_EXPORTTABLESIZE = 12; +const BYTE UE_TLSTABLEADDRESS = 13; +const BYTE UE_TLSTABLESIZE = 14; +const BYTE UE_RELOCATIONTABLEADDRESS = 15; +const BYTE UE_RELOCATIONTABLESIZE = 16; +const BYTE UE_TIMEDATESTAMP = 17; +const BYTE UE_SECTIONNUMBER = 18; +const BYTE UE_CHECKSUM = 19; +const BYTE UE_SUBSYSTEM = 20; +const BYTE UE_CHARACTERISTICS = 21; +const BYTE UE_NUMBEROFRVAANDSIZES = 22; +const BYTE UE_BASEOFCODE = 23; +const BYTE UE_BASEOFDATA = 24; +//leaving some enum space here for future additions +const BYTE UE_SECTIONNAME = 40; +const BYTE UE_SECTIONVIRTUALOFFSET = 41; +const BYTE UE_SECTIONVIRTUALSIZE = 42; +const BYTE UE_SECTIONRAWOFFSET = 43; +const BYTE UE_SECTIONRAWSIZE = 44; +const BYTE UE_SECTIONFLAGS = 45; + +const long UE_VANOTFOUND = -2; + +const BYTE UE_CH_BREAKPOINT = 1; +const BYTE UE_CH_SINGLESTEP = 2; +const BYTE UE_CH_ACCESSVIOLATION = 3; +const BYTE UE_CH_ILLEGALINSTRUCTION = 4; +const BYTE UE_CH_NONCONTINUABLEEXCEPTION = 5; +const BYTE UE_CH_ARRAYBOUNDSEXCEPTION = 6; +const BYTE UE_CH_FLOATDENORMALOPERAND = 7; +const BYTE UE_CH_FLOATDEVIDEBYZERO = 8; +const BYTE UE_CH_INTEGERDEVIDEBYZERO = 9; +const BYTE UE_CH_INTEGEROVERFLOW = 10; +const BYTE UE_CH_PRIVILEGEDINSTRUCTION = 11; +const BYTE UE_CH_PAGEGUARD = 12; +const BYTE UE_CH_EVERYTHINGELSE = 13; +const BYTE UE_CH_CREATETHREAD = 14; +const BYTE UE_CH_EXITTHREAD = 15; +const BYTE UE_CH_CREATEPROCESS = 16; +const BYTE UE_CH_EXITPROCESS = 17; +const BYTE UE_CH_LOADDLL = 18; +const BYTE UE_CH_UNLOADDLL = 19; +const BYTE UE_CH_OUTPUTDEBUGSTRING = 20; +const BYTE UE_CH_AFTEREXCEPTIONPROCESSING = 21; +const BYTE UE_CH_ALLEVENTS = 22; +const BYTE UE_CH_SYSTEMBREAKPOINT = 23; +const BYTE UE_CH_UNHANDLEDEXCEPTION = 24; +const BYTE UE_CH_RIPEVENT = 25; + +const BYTE UE_OPTION_HANDLER_RETURN_HANDLECOUNT = 1; +const BYTE UE_OPTION_HANDLER_RETURN_ACCESS = 2; +const BYTE UE_OPTION_HANDLER_RETURN_FLAGS = 3; +const BYTE UE_OPTION_HANDLER_RETURN_TYPENAME = 4; + +const BYTE UE_BREAKPOINT_INT3 = 1; +const BYTE UE_BREAKPOINT_LONG_INT3 = 2; +const BYTE UE_BREAKPOINT_UD2 = 3; + +const BYTE UE_BPXREMOVED = 0; +const BYTE UE_BPXACTIVE = 1; +const BYTE UE_BPXINACTIVE = 2; + +const BYTE UE_BREAKPOINT = 0; +const BYTE UE_SINGLESHOOT = 1; +const BYTE UE_HARDWARE = 2; +const BYTE UE_MEMORY = 3; +const BYTE UE_MEMORY_READ = 4; +const BYTE UE_MEMORY_WRITE = 5; +const BYTE UE_MEMORY_EXECUTE = 6; +const DWORD UE_BREAKPOINT_TYPE_INT3 = 0x10000000; +const DWORD UE_BREAKPOINT_TYPE_LONG_INT3 = 0x20000000; +const DWORD UE_BREAKPOINT_TYPE_UD2 = 0x30000000; + +const BYTE UE_HARDWARE_EXECUTE = 4; +const BYTE UE_HARDWARE_WRITE = 5; +const BYTE UE_HARDWARE_READWRITE = 6; + +const BYTE UE_HARDWARE_SIZE_1 = 7; +const BYTE UE_HARDWARE_SIZE_2 = 8; +const BYTE UE_HARDWARE_SIZE_4 = 9; +const BYTE UE_HARDWARE_SIZE_8 = 10; + +const BYTE UE_ON_LIB_LOAD = 1; +const BYTE UE_ON_LIB_UNLOAD = 2; +const BYTE UE_ON_LIB_ALL = 3; + +const BYTE UE_APISTART = 0; +const BYTE UE_APIEND = 1; + +const BYTE UE_PLATFORM_x86 = 1; +const BYTE UE_PLATFORM_x64 = 2; +const BYTE UE_PLATFORM_ALL = 3; + +const BYTE UE_FUNCTION_STDCALL = 1; +const BYTE UE_FUNCTION_CCALL = 2; +const BYTE UE_FUNCTION_FASTCALL = 3; +const BYTE UE_FUNCTION_STDCALL_RET = 4; +const BYTE UE_FUNCTION_CCALL_RET = 5; +const BYTE UE_FUNCTION_FASTCALL_RET = 6; +const BYTE UE_FUNCTION_STDCALL_CALL = 7; +const BYTE UE_FUNCTION_CCALL_CALL = 8; +const BYTE UE_FUNCTION_FASTCALL_CALL = 9; +const BYTE UE_PARAMETER_BYTE = 0; +const BYTE UE_PARAMETER_WORD = 1; +const BYTE UE_PARAMETER_DWORD = 2; +const BYTE UE_PARAMETER_QWORD = 3; +const BYTE UE_PARAMETER_PTR_BYTE = 4; +const BYTE UE_PARAMETER_PTR_WORD = 5; +const BYTE UE_PARAMETER_PTR_DWORD = 6; +const BYTE UE_PARAMETER_PTR_QWORD = 7; +const BYTE UE_PARAMETER_STRING = 8; +const BYTE UE_PARAMETER_UNICODE = 9; + +const BYTE UE_EAX = 1; +const BYTE UE_EBX = 2; +const BYTE UE_ECX = 3; +const BYTE UE_EDX = 4; +const BYTE UE_EDI = 5; +const BYTE UE_ESI = 6; +const BYTE UE_EBP = 7; +const BYTE UE_ESP = 8; +const BYTE UE_EIP = 9; +const BYTE UE_EFLAGS = 10; +const BYTE UE_DR0 = 11; +const BYTE UE_DR1 = 12; +const BYTE UE_DR2 = 13; +const BYTE UE_DR3 = 14; +const BYTE UE_DR6 = 15; +const BYTE UE_DR7 = 16; +const BYTE UE_RAX = 17; +const BYTE UE_RBX = 18; +const BYTE UE_RCX = 19; +const BYTE UE_RDX = 20; +const BYTE UE_RDI = 21; +const BYTE UE_RSI = 22; +const BYTE UE_RBP = 23; +const BYTE UE_RSP = 24; +const BYTE UE_RIP = 25; +const BYTE UE_RFLAGS = 26; +const BYTE UE_R8 = 27; +const BYTE UE_R9 = 28; +const BYTE UE_R10 = 29; +const BYTE UE_R11 = 30; +const BYTE UE_R12 = 31; +const BYTE UE_R13 = 32; +const BYTE UE_R14 = 33; +const BYTE UE_R15 = 34; +const BYTE UE_CIP = 35; +const BYTE UE_CSP = 36; +#ifdef _WIN64 +const BYTE UE_CFLAGS = UE_RFLAGS; +#else +const BYTE UE_CFLAGS = UE_EFLAGS; +#endif +const BYTE UE_SEG_GS = 37; +const BYTE UE_SEG_FS = 38; +const BYTE UE_SEG_ES = 39; +const BYTE UE_SEG_DS = 40; +const BYTE UE_SEG_CS = 41; +const BYTE UE_SEG_SS = 42; + +typedef struct +{ + DWORD PE32Offset; + DWORD ImageBase; + DWORD OriginalEntryPoint; + DWORD BaseOfCode; + DWORD BaseOfData; + DWORD NtSizeOfImage; + DWORD NtSizeOfHeaders; + WORD SizeOfOptionalHeaders; + DWORD FileAlignment; + DWORD SectionAligment; + DWORD ImportTableAddress; + DWORD ImportTableSize; + DWORD ResourceTableAddress; + DWORD ResourceTableSize; + DWORD ExportTableAddress; + DWORD ExportTableSize; + DWORD TLSTableAddress; + DWORD TLSTableSize; + DWORD RelocationTableAddress; + DWORD RelocationTableSize; + DWORD TimeDateStamp; + WORD SectionNumber; + DWORD CheckSum; + WORD SubSystem; + WORD Characteristics; + DWORD NumberOfRvaAndSizes; +} PE32Struct, *PPE32Struct; + +typedef struct +{ + DWORD PE64Offset; + DWORD64 ImageBase; + DWORD OriginalEntryPoint; + DWORD BaseOfCode; + DWORD BaseOfData; + DWORD NtSizeOfImage; + DWORD NtSizeOfHeaders; + WORD SizeOfOptionalHeaders; + DWORD FileAlignment; + DWORD SectionAligment; + DWORD ImportTableAddress; + DWORD ImportTableSize; + DWORD ResourceTableAddress; + DWORD ResourceTableSize; + DWORD ExportTableAddress; + DWORD ExportTableSize; + DWORD TLSTableAddress; + DWORD TLSTableSize; + DWORD RelocationTableAddress; + DWORD RelocationTableSize; + DWORD TimeDateStamp; + WORD SectionNumber; + DWORD CheckSum; + WORD SubSystem; + WORD Characteristics; + DWORD NumberOfRvaAndSizes; +} PE64Struct, *PPE64Struct; + +#if defined(_WIN64) +typedef PE64Struct PEStruct; +#else +typedef PE32Struct PEStruct; +#endif + +typedef struct +{ + bool NewDll; + int NumberOfImports; + ULONG_PTR ImageBase; + ULONG_PTR BaseImportThunk; + ULONG_PTR ImportThunk; + char* APIName; + char* DLLName; +} ImportEnumData, *PImportEnumData; + +typedef struct +{ + HANDLE hThread; + DWORD dwThreadId; + void* ThreadStartAddress; + void* ThreadLocalBase; +} THREAD_ITEM_DATA, *PTHREAD_ITEM_DATA; + +typedef struct +{ + HANDLE hFile; + void* BaseOfDll; + HANDLE hFileMapping; + void* hFileMappingView; + char szLibraryPath[MAX_PATH]; + char szLibraryName[MAX_PATH]; +} LIBRARY_ITEM_DATA, *PLIBRARY_ITEM_DATA; + +typedef struct +{ + HANDLE hFile; + void* BaseOfDll; + HANDLE hFileMapping; + void* hFileMappingView; + wchar_t szLibraryPath[MAX_PATH]; + wchar_t szLibraryName[MAX_PATH]; +} LIBRARY_ITEM_DATAW, *PLIBRARY_ITEM_DATAW; + +typedef struct +{ + HANDLE hProcess; + DWORD dwProcessId; + HANDLE hThread; + DWORD dwThreadId; + HANDLE hFile; + void* BaseOfImage; + void* ThreadStartAddress; + void* ThreadLocalBase; +} PROCESS_ITEM_DATA, *PPROCESS_ITEM_DATA; + +typedef struct +{ + ULONG ProcessId; + HANDLE hHandle; +} HandlerArray, *PHandlerArray; + +typedef struct +{ + char PluginName[64]; + DWORD PluginMajorVersion; + DWORD PluginMinorVersion; + HMODULE PluginBaseAddress; + void* TitanDebuggingCallBack; + void* TitanRegisterPlugin; + void* TitanReleasePlugin; + void* TitanResetPlugin; + bool PluginDisabled; +} PluginInformation, *PPluginInformation; + +const size_t TEE_MAXIMUM_HOOK_SIZE = 14; +const size_t TEE_MAXIMUM_HOOK_RELOCS = 7; +#if defined(_WIN64) +const size_t TEE_MAXIMUM_HOOK_INSERT_SIZE = 14; +#else +const size_t TEE_MAXIMUM_HOOK_INSERT_SIZE = 5; +#endif + +typedef struct HOOK_ENTRY +{ + bool IATHook; + BYTE HookType; + DWORD HookSize; + void* HookAddress; + void* RedirectionAddress; + BYTE HookBytes[TEE_MAXIMUM_HOOK_SIZE]; + BYTE OriginalBytes[TEE_MAXIMUM_HOOK_SIZE]; + void* IATHookModuleBase; + DWORD IATHookNameHash; + bool HookIsEnabled; + bool HookIsRemote; + void* PatchedEntry; + DWORD RelocationInfo[TEE_MAXIMUM_HOOK_RELOCS]; + int RelocationCount; +} HOOK_ENTRY, *PHOOK_ENTRY; + +const BYTE UE_DEPTH_SURFACE = 0; +const BYTE UE_DEPTH_DEEP = 1; + +const BYTE UE_UNPACKER_CONDITION_SEARCH_FROM_EP = 1; + +const BYTE UE_UNPACKER_CONDITION_LOADLIBRARY = 1; +const BYTE UE_UNPACKER_CONDITION_GETPROCADDRESS = 2; +const BYTE UE_UNPACKER_CONDITION_ENTRYPOINTBREAK = 3; +const BYTE UE_UNPACKER_CONDITION_RELOCSNAPSHOT1 = 4; +const BYTE UE_UNPACKER_CONDITION_RELOCSNAPSHOT2 = 5; + +const BYTE UE_FIELD_OK = 0; +const BYTE UE_FIELD_BROKEN_NON_FIXABLE = 1; +const BYTE UE_FIELD_BROKEN_NON_CRITICAL = 2; +const BYTE UE_FIELD_BROKEN_FIXABLE_FOR_STATIC_USE = 3; +const BYTE UE_FIELD_BROKEN_BUT_CAN_BE_EMULATED = 4; +const BYTE UE_FIELD_FIXABLE_NON_CRITICAL = 5; +const BYTE UE_FIELD_FIXABLE_CRITICAL = 6; +const BYTE UE_FIELD_NOT_PRESET = 7; +const BYTE UE_FIELD_NOT_PRESET_WARNING = 8; + +const BYTE UE_RESULT_FILE_OK = 10; +const BYTE UE_RESULT_FILE_INVALID_BUT_FIXABLE = 11; +const BYTE UE_RESULT_FILE_INVALID_AND_NON_FIXABLE = 12; +const BYTE UE_RESULT_FILE_INVALID_FORMAT = 13; + +typedef struct +{ + BYTE OveralEvaluation; + bool EvaluationTerminatedByException; + bool FileIs64Bit; + bool FileIsDLL; + bool FileIsConsole; + bool MissingDependencies; + bool MissingDeclaredAPIs; + BYTE SignatureMZ; + BYTE SignaturePE; + BYTE EntryPoint; + BYTE ImageBase; + BYTE SizeOfImage; + BYTE FileAlignment; + BYTE SectionAlignment; + BYTE ExportTable; + BYTE RelocationTable; + BYTE ImportTable; + BYTE ImportTableSection; + BYTE ImportTableData; + BYTE IATTable; + BYTE TLSTable; + BYTE LoadConfigTable; + BYTE BoundImportTable; + BYTE COMHeaderTable; + BYTE ResourceTable; + BYTE ResourceData; + BYTE SectionTable; +} FILE_STATUS_INFO, *PFILE_STATUS_INFO; + +typedef struct +{ + BYTE OveralEvaluation; + bool FixingTerminatedByException; + bool FileFixPerformed; + bool StrippedRelocation; + bool DontFixRelocations; + DWORD OriginalRelocationTableAddress; + DWORD OriginalRelocationTableSize; + bool StrippedExports; + bool DontFixExports; + DWORD OriginalExportTableAddress; + DWORD OriginalExportTableSize; + bool StrippedResources; + bool DontFixResources; + DWORD OriginalResourceTableAddress; + DWORD OriginalResourceTableSize; + bool StrippedTLS; + bool DontFixTLS; + DWORD OriginalTLSTableAddress; + DWORD OriginalTLSTableSize; + bool StrippedLoadConfig; + bool DontFixLoadConfig; + DWORD OriginalLoadConfigTableAddress; + DWORD OriginalLoadConfigTableSize; + bool StrippedBoundImports; + bool DontFixBoundImports; + DWORD OriginalBoundImportTableAddress; + DWORD OriginalBoundImportTableSize; + bool StrippedIAT; + bool DontFixIAT; + DWORD OriginalImportAddressTableAddress; + DWORD OriginalImportAddressTableSize; + bool StrippedCOM; + bool DontFixCOM; + DWORD OriginalCOMTableAddress; + DWORD OriginalCOMTableSize; +} FILE_FIX_INFO, *PFILE_FIX_INFO; + +#ifdef __cplusplus +extern "C" { +#endif /*__cplusplus*/ + +// Global.Function.Declaration: +// TitanEngine.Dumper.functions: +__declspec(dllimport) bool TITCALL DumpProcess(HANDLE hProcess, LPVOID ImageBase, char* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessW(HANDLE hProcess, LPVOID ImageBase, wchar_t* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessEx(DWORD ProcessId, LPVOID ImageBase, char* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpProcessExW(DWORD ProcessId, LPVOID ImageBase, wchar_t* szDumpFileName, ULONG_PTR EntryPoint); +__declspec(dllimport) bool TITCALL DumpMemory(HANDLE hProcess, LPVOID MemoryStart, ULONG_PTR MemorySize, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryW(HANDLE hProcess, LPVOID MemoryStart, ULONG_PTR MemorySize, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryEx(DWORD ProcessId, LPVOID MemoryStart, ULONG_PTR MemorySize, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpMemoryExW(DWORD ProcessId, LPVOID MemoryStart, ULONG_PTR MemorySize, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpRegions(HANDLE hProcess, char* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsW(HANDLE hProcess, wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsEx(DWORD ProcessId, char* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpRegionsExW(DWORD ProcessId, wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly); +__declspec(dllimport) bool TITCALL DumpModule(HANDLE hProcess, LPVOID ModuleBase, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleW(HANDLE hProcess, LPVOID ModuleBase, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleEx(DWORD ProcessId, LPVOID ModuleBase, char* szDumpFileName); +__declspec(dllimport) bool TITCALL DumpModuleExW(DWORD ProcessId, LPVOID ModuleBase, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL PastePEHeader(HANDLE hProcess, LPVOID ImageBase, char* szDebuggedFileName); +__declspec(dllimport) bool TITCALL PastePEHeaderW(HANDLE hProcess, LPVOID ImageBase, wchar_t* szDebuggedFileName); +__declspec(dllimport) bool TITCALL ExtractSection(char* szFileName, char* szDumpFileName, DWORD SectionNumber); +__declspec(dllimport) bool TITCALL ExtractSectionW(wchar_t* szFileName, wchar_t* szDumpFileName, DWORD SectionNumber); +__declspec(dllimport) bool TITCALL ResortFileSections(char* szFileName); +__declspec(dllimport) bool TITCALL ResortFileSectionsW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL FindOverlay(char* szFileName, LPDWORD OverlayStart, LPDWORD OverlaySize); +__declspec(dllimport) bool TITCALL FindOverlayW(wchar_t* szFileName, LPDWORD OverlayStart, LPDWORD OverlaySize); +__declspec(dllimport) bool TITCALL ExtractOverlay(char* szFileName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ExtractOverlayW(wchar_t* szFileName, wchar_t* szExtractedFileName); +__declspec(dllimport) bool TITCALL AddOverlay(char* szFileName, char* szOverlayFileName); +__declspec(dllimport) bool TITCALL AddOverlayW(wchar_t* szFileName, wchar_t* szOverlayFileName); +__declspec(dllimport) bool TITCALL CopyOverlay(char* szInFileName, char* szOutFileName); +__declspec(dllimport) bool TITCALL CopyOverlayW(wchar_t* szInFileName, wchar_t* szOutFileName); +__declspec(dllimport) bool TITCALL RemoveOverlay(char* szFileName); +__declspec(dllimport) bool TITCALL RemoveOverlayW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL MakeAllSectionsRWE(char* szFileName); +__declspec(dllimport) bool TITCALL MakeAllSectionsRWEW(wchar_t* szFileName); +__declspec(dllimport) long TITCALL AddNewSectionEx(char* szFileName, char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, LPVOID SectionContent, DWORD ContentSize); +__declspec(dllimport) long TITCALL AddNewSectionExW(wchar_t* szFileName, char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, LPVOID SectionContent, DWORD ContentSize); +__declspec(dllimport) long TITCALL AddNewSection(char* szFileName, char* szSectionName, DWORD SectionSize); +__declspec(dllimport) long TITCALL AddNewSectionW(wchar_t* szFileName, char* szSectionName, DWORD SectionSize); +__declspec(dllimport) bool TITCALL ResizeLastSection(char* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData); +__declspec(dllimport) bool TITCALL ResizeLastSectionW(wchar_t* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData); +__declspec(dllimport) void TITCALL SetSharedOverlay(char* szFileName); +__declspec(dllimport) void TITCALL SetSharedOverlayW(wchar_t* szFileName); +__declspec(dllimport) char* TITCALL GetSharedOverlay(); +__declspec(dllimport) wchar_t* TITCALL GetSharedOverlayW(); +__declspec(dllimport) bool TITCALL DeleteLastSection(char* szFileName); +__declspec(dllimport) bool TITCALL DeleteLastSectionW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL DeleteLastSectionEx(char* szFileName, DWORD NumberOfSections); +__declspec(dllimport) bool TITCALL DeleteLastSectionExW(wchar_t* szFileName, DWORD NumberOfSections); +__declspec(dllimport) long long TITCALL GetPE32DataFromMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) long long TITCALL GetPE32Data(char* szFileName, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) long long TITCALL GetPE32DataW(wchar_t* szFileName, DWORD WhichSection, DWORD WhichData); +__declspec(dllimport) bool TITCALL GetPE32DataFromMappedFileEx(ULONG_PTR FileMapVA, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL GetPE32DataEx(char* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL GetPE32DataExW(wchar_t* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataForMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32Data(char* szFileName, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32DataW(wchar_t* szFileName, DWORD WhichSection, DWORD WhichData, ULONG_PTR NewDataValue); +__declspec(dllimport) bool TITCALL SetPE32DataForMappedFileEx(ULONG_PTR FileMapVA, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataEx(char* szFileName, LPVOID DataStorage); +__declspec(dllimport) bool TITCALL SetPE32DataExW(wchar_t* szFileName, LPVOID DataStorage); +__declspec(dllimport) long TITCALL GetPE32SectionNumberFromVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert); +__declspec(dllimport) long long TITCALL ConvertVAtoFileOffset(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllimport) long long TITCALL ConvertFileOffsetToVAEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool ReturnType); +__declspec(dllexport) bool TITCALL MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead); +__declspec(dllexport) bool TITCALL MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten); +// TitanEngine.Realigner.functions: +__declspec(dllimport) bool TITCALL FixHeaderCheckSum(char* szFileName); +__declspec(dllimport) bool TITCALL FixHeaderCheckSumW(wchar_t* szFileName); +__declspec(dllimport) long TITCALL RealignPE(ULONG_PTR FileMapVA, DWORD FileSize, DWORD RealingMode); +__declspec(dllimport) long TITCALL RealignPEEx(char* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment); +__declspec(dllimport) long TITCALL RealignPEExW(wchar_t* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment); +__declspec(dllimport) bool TITCALL WipeSection(char* szFileName, int WipeSectionNumber, bool RemovePhysically); +__declspec(dllimport) bool TITCALL WipeSectionW(wchar_t* szFileName, int WipeSectionNumber, bool RemovePhysically); +__declspec(dllimport) bool TITCALL IsPE32FileValidEx(char* szFileName, DWORD CheckDepth, LPVOID FileStatusInfo); +__declspec(dllimport) bool TITCALL IsPE32FileValidExW(wchar_t* szFileName, DWORD CheckDepth, LPVOID FileStatusInfo); +__declspec(dllimport) bool TITCALL FixBrokenPE32FileEx(char* szFileName, LPVOID FileStatusInfo, LPVOID FileFixInfo); +__declspec(dllimport) bool TITCALL FixBrokenPE32FileExW(wchar_t* szFileName, LPVOID FileStatusInfo, LPVOID FileFixInfo); +__declspec(dllimport) bool TITCALL IsFileDLL(char* szFileName, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL IsFileDLLW(wchar_t* szFileName, ULONG_PTR FileMapVA); +// TitanEngine.Hider.functions: +__declspec(dllimport) void* TITCALL GetPEBLocation(HANDLE hProcess); +__declspec(dllimport) void* TITCALL GetPEBLocation64(HANDLE hProcess); +__declspec(dllimport) void* TITCALL GetTEBLocation(HANDLE hThread); +__declspec(dllimport) void* TITCALL GetTEBLocation64(HANDLE hThread); +__declspec(dllimport) bool TITCALL HideDebugger(HANDLE hProcess, DWORD PatchAPILevel); +__declspec(dllimport) bool TITCALL UnHideDebugger(HANDLE hProcess, DWORD PatchAPILevel); +// TitanEngine.Relocater.functions: +__declspec(dllimport) void TITCALL RelocaterCleanup(); +__declspec(dllimport) void TITCALL RelocaterInit(DWORD MemorySize, ULONG_PTR OldImageBase, ULONG_PTR NewImageBase); +__declspec(dllimport) void TITCALL RelocaterAddNewRelocation(HANDLE hProcess, ULONG_PTR RelocateAddress, DWORD RelocateState); +__declspec(dllimport) long TITCALL RelocaterEstimatedSize(); +__declspec(dllimport) bool TITCALL RelocaterExportRelocation(ULONG_PTR StorePlace, DWORD StorePlaceRVA, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL RelocaterExportRelocationEx(char* szFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL RelocaterExportRelocationExW(wchar_t* szFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL RelocaterGrabRelocationTable(HANDLE hProcess, ULONG_PTR MemoryStart, DWORD MemorySize); +__declspec(dllimport) bool TITCALL RelocaterGrabRelocationTableEx(HANDLE hProcess, ULONG_PTR MemoryStart, ULONG_PTR MemorySize, DWORD NtSizeOfImage); +__declspec(dllimport) bool TITCALL RelocaterMakeSnapshot(HANDLE hProcess, char* szSaveFileName, LPVOID MemoryStart, ULONG_PTR MemorySize); +__declspec(dllimport) bool TITCALL RelocaterMakeSnapshotW(HANDLE hProcess, wchar_t* szSaveFileName, LPVOID MemoryStart, ULONG_PTR MemorySize); +__declspec(dllimport) bool TITCALL RelocaterCompareTwoSnapshots(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, char* szDumpFile1, char* szDumpFile2, ULONG_PTR MemStart); +__declspec(dllimport) bool TITCALL RelocaterCompareTwoSnapshotsW(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, wchar_t* szDumpFile1, wchar_t* szDumpFile2, ULONG_PTR MemStart); +__declspec(dllimport) bool TITCALL RelocaterChangeFileBase(char* szFileName, ULONG_PTR NewImageBase); +__declspec(dllimport) bool TITCALL RelocaterChangeFileBaseW(wchar_t* szFileName, ULONG_PTR NewImageBase); +__declspec(dllimport) bool TITCALL RelocaterRelocateMemoryBlock(ULONG_PTR FileMapVA, ULONG_PTR MemoryLocation, void* RelocateMemory, DWORD RelocateMemorySize, ULONG_PTR CurrentLoadedBase, ULONG_PTR RelocateBase); +__declspec(dllimport) bool TITCALL RelocaterWipeRelocationTable(char* szFileName); +__declspec(dllimport) bool TITCALL RelocaterWipeRelocationTableW(wchar_t* szFileName); +// TitanEngine.Resourcer.functions: +__declspec(dllimport) long long TITCALL ResourcerLoadFileForResourceUse(char* szFileName); +__declspec(dllimport) long long TITCALL ResourcerLoadFileForResourceUseW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL ResourcerFreeLoadedFile(LPVOID LoadedFileBase); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFileEx(ULONG_PTR FileMapVA, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFile(char* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerExtractResourceFromFileW(wchar_t* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName); +__declspec(dllimport) bool TITCALL ResourcerFindResource(char* szFileName, char* szResourceType, DWORD ResourceType, char* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) bool TITCALL ResourcerFindResourceW(wchar_t* szFileName, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) bool TITCALL ResourcerFindResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, PULONG_PTR pResourceData, LPDWORD pResourceSize); +__declspec(dllimport) void TITCALL ResourcerEnumerateResource(char* szFileName, void* CallBack); +__declspec(dllimport) void TITCALL ResourcerEnumerateResourceW(wchar_t* szFileName, void* CallBack); +__declspec(dllimport) void TITCALL ResourcerEnumerateResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, void* CallBack); +// TitanEngine.Threader.functions: +__declspec(dllimport) bool TITCALL ThreaderImportRunningThreadData(DWORD ProcessId); +__declspec(dllimport) void* TITCALL ThreaderGetThreadInfo(HANDLE hThread, DWORD ThreadId); +__declspec(dllimport) void TITCALL ThreaderEnumThreadInfo(void* EnumCallBack); +__declspec(dllimport) bool TITCALL ThreaderPauseThread(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderResumeThread(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderTerminateThread(HANDLE hThread, DWORD ThreadExitCode); +__declspec(dllimport) bool TITCALL ThreaderPauseAllThreads(bool LeaveMainRunning); +__declspec(dllimport) bool TITCALL ThreaderResumeAllThreads(bool LeaveMainPaused); +__declspec(dllimport) bool TITCALL ThreaderPauseProcess(); +__declspec(dllimport) bool TITCALL ThreaderResumeProcess(); +__declspec(dllimport) long long TITCALL ThreaderCreateRemoteThread(ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, LPVOID ThreadPassParameter, LPDWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderInjectAndExecuteCode(LPVOID InjectCode, DWORD StartDelta, DWORD InjectSize); +__declspec(dllimport) long long TITCALL ThreaderCreateRemoteThreadEx(HANDLE hProcess, ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, LPVOID ThreadPassParameter, LPDWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderInjectAndExecuteCodeEx(HANDLE hProcess, LPVOID InjectCode, DWORD StartDelta, DWORD InjectSize); +__declspec(dllimport) void TITCALL ThreaderSetCallBackForNextExitThreadEvent(LPVOID exitThreadCallBack); +__declspec(dllimport) bool TITCALL ThreaderIsThreadStillRunning(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderIsThreadActive(HANDLE hThread); +__declspec(dllimport) bool TITCALL ThreaderIsAnyThreadActive(); +__declspec(dllimport) bool TITCALL ThreaderExecuteOnlyInjectedThreads(); +__declspec(dllimport) long long TITCALL ThreaderGetOpenHandleForThread(DWORD ThreadId); +__declspec(dllimport) bool TITCALL ThreaderIsExceptionInMainThread(); +// TitanEngine.Debugger.functions: +__declspec(dllimport) void* TITCALL StaticDisassembleEx(ULONG_PTR DisassmStart, LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL StaticDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL DisassembleEx(HANDLE hProcess, LPVOID DisassmAddress, bool ReturnInstructionType); +__declspec(dllimport) void* TITCALL Disassemble(LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL StaticLengthDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL LengthDisassembleEx(HANDLE hProcess, LPVOID DisassmAddress); +__declspec(dllimport) long TITCALL LengthDisassemble(LPVOID DisassmAddress); +__declspec(dllimport) void* TITCALL InitDebug(char* szFileName, char* szCommandLine, char* szCurrentFolder); +__declspec(dllimport) void* TITCALL InitDebugW(wchar_t* szFileName, wchar_t* szCommandLine, wchar_t* szCurrentFolder); +__declspec(dllimport) void* TITCALL InitDebugEx(char* szFileName, char* szCommandLine, char* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDebugExW(wchar_t* szFileName, wchar_t* szCommandLine, wchar_t* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDLLDebug(char* szFileName, bool ReserveModuleBase, char* szCommandLine, char* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) void* TITCALL InitDLLDebugW(wchar_t* szFileName, bool ReserveModuleBase, wchar_t* szCommandLine, wchar_t* szCurrentFolder, LPVOID EntryCallBack); +__declspec(dllimport) bool TITCALL StopDebug(); +__declspec(dllimport) void TITCALL SetBPXOptions(long DefaultBreakPointType); +__declspec(dllimport) bool TITCALL IsBPXEnabled(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL EnableBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL DisableBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SetBPX(ULONG_PTR bpxAddress, DWORD bpxType, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SafeDeleteBPX(ULONG_PTR bpxAddress); +__declspec(dllimport) bool TITCALL SetAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxType, DWORD bpxPlace, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxPlace); +__declspec(dllimport) bool TITCALL SafeDeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, DWORD bpxPlace); +__declspec(dllimport) bool TITCALL SetMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL SetMemoryBPXEx(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, DWORD BreakPointType, bool RestoreOnHit, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL RemoveMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory); +__declspec(dllimport) bool TITCALL GetContextFPUDataEx(HANDLE hActiveThread, void* FPUSaveArea); +__declspec(dllimport) long long TITCALL GetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister); +__declspec(dllimport) long long TITCALL GetContextData(DWORD IndexOfRegister); +__declspec(dllimport) bool TITCALL SetContextFPUDataEx(HANDLE hActiveThread, void* FPUSaveArea); +__declspec(dllimport) bool TITCALL SetContextDataEx(HANDLE hActiveThread, DWORD IndexOfRegister, ULONG_PTR NewRegisterValue); +__declspec(dllimport) bool TITCALL SetContextData(DWORD IndexOfRegister, ULONG_PTR NewRegisterValue); +__declspec(dllimport) void TITCALL ClearExceptionNumber(); +__declspec(dllimport) long TITCALL CurrentExceptionNumber(); +__declspec(dllimport) bool TITCALL MatchPatternEx(HANDLE hProcess, void* MemoryToCheck, int SizeOfMemoryToCheck, void* PatternToMatch, int SizeOfPatternToMatch, PBYTE WildCard); +__declspec(dllimport) bool TITCALL MatchPattern(void* MemoryToCheck, int SizeOfMemoryToCheck, void* PatternToMatch, int SizeOfPatternToMatch, PBYTE WildCard); +__declspec(dllimport) long long TITCALL FindEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, LPBYTE WildCard); +__declspec(dllimport) long long TITCALL Find(LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, LPBYTE WildCard); +__declspec(dllimport) bool TITCALL FillEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte); +__declspec(dllimport) bool TITCALL Fill(LPVOID MemoryStart, DWORD MemorySize, PBYTE FillByte); +__declspec(dllimport) bool TITCALL PatchEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP); +__declspec(dllimport) bool TITCALL Patch(LPVOID MemoryStart, DWORD MemorySize, LPVOID ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP); +__declspec(dllimport) bool TITCALL ReplaceEx(HANDLE hProcess, LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, LPVOID ReplacePattern, DWORD ReplaceSize, PBYTE WildCard); +__declspec(dllimport) bool TITCALL Replace(LPVOID MemoryStart, DWORD MemorySize, LPVOID SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, LPVOID ReplacePattern, DWORD ReplaceSize, PBYTE WildCard); +__declspec(dllimport) void* TITCALL GetDebugData(); +__declspec(dllimport) void* TITCALL GetTerminationData(); +__declspec(dllimport) long TITCALL GetExitCode(); +__declspec(dllimport) long long TITCALL GetDebuggedDLLBaseAddress(); +__declspec(dllimport) long long TITCALL GetDebuggedFileBaseAddress(); +__declspec(dllimport) bool TITCALL GetRemoteString(HANDLE hProcess, LPVOID StringAddress, LPVOID StringStorage, int MaximumStringSize); +__declspec(dllimport) long long TITCALL GetFunctionParameter(HANDLE hProcess, DWORD FunctionType, DWORD ParameterNumber, DWORD ParameterType); +__declspec(dllimport) long long TITCALL GetJumpDestinationEx(HANDLE hProcess, ULONG_PTR InstructionAddress, bool JustJumps); +__declspec(dllimport) long long TITCALL GetJumpDestination(HANDLE hProcess, ULONG_PTR InstructionAddress); +__declspec(dllimport) bool TITCALL IsJumpGoingToExecuteEx(HANDLE hProcess, HANDLE hThread, ULONG_PTR InstructionAddress, ULONG_PTR RegFlags); +__declspec(dllimport) bool TITCALL IsJumpGoingToExecute(); +__declspec(dllimport) void TITCALL SetCustomHandler(DWORD ExceptionId, LPVOID CallBack); +__declspec(dllimport) void TITCALL ForceClose(); +__declspec(dllimport) void TITCALL StepInto(LPVOID traceCallBack); +__declspec(dllimport) void TITCALL StepOver(LPVOID traceCallBack); +__declspec(dllimport) void TITCALL SingleStep(DWORD StepCount, LPVOID StepCallBack); +__declspec(dllimport) bool TITCALL GetUnusedHardwareBreakPointRegister(LPDWORD RegisterIndex); +__declspec(dllimport) bool TITCALL SetHardwareBreakPointEx(HANDLE hActiveThread, ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack, LPDWORD IndexOfSelectedRegister); +__declspec(dllimport) bool TITCALL SetHardwareBreakPoint(ULONG_PTR bpxAddress, DWORD IndexOfRegister, DWORD bpxType, DWORD bpxSize, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL DeleteHardwareBreakPoint(DWORD IndexOfRegister); +__declspec(dllimport) bool TITCALL RemoveAllBreakPoints(DWORD RemoveOption); +__declspec(dllimport) void* TITCALL GetProcessInformation(); +__declspec(dllimport) void* TITCALL GetStartupInformation(); +__declspec(dllimport) void TITCALL DebugLoop(); +__declspec(dllimport) void TITCALL SetDebugLoopTimeOut(DWORD TimeOut); +__declspec(dllimport) void TITCALL SetNextDbgContinueStatus(DWORD SetDbgCode); +__declspec(dllimport) bool TITCALL AttachDebugger(DWORD ProcessId, bool KillOnExit, LPVOID DebugInfo, LPVOID CallBack); +__declspec(dllimport) bool TITCALL DetachDebugger(DWORD ProcessId); +__declspec(dllimport) bool TITCALL DetachDebuggerEx(DWORD ProcessId); +__declspec(dllimport) void TITCALL DebugLoopEx(DWORD TimeOut); +__declspec(dllimport) void TITCALL AutoDebugEx(char* szFileName, bool ReserveModuleBase, char* szCommandLine, char* szCurrentFolder, DWORD TimeOut, LPVOID EntryCallBack); +__declspec(dllimport) void TITCALL AutoDebugExW(wchar_t* szFileName, bool ReserveModuleBase, wchar_t* szCommandLine, wchar_t* szCurrentFolder, DWORD TimeOut, LPVOID EntryCallBack); +__declspec(dllimport) bool TITCALL IsFileBeingDebugged(); +__declspec(dllimport) void TITCALL SetErrorModel(bool DisplayErrorMessages); +// TitanEngine.FindOEP.functions: +__declspec(dllimport) void TITCALL FindOEPInit(); +__declspec(dllimport) bool TITCALL FindOEPGenerically(char* szFileName, LPVOID TraceInitCallBack, LPVOID CallBack); +__declspec(dllimport) bool TITCALL FindOEPGenericallyW(wchar_t* szFileName, LPVOID TraceInitCallBack, LPVOID CallBack); +// TitanEngine.Importer.functions: +__declspec(dllimport) void TITCALL ImporterAddNewDll(char* szDLLName, ULONG_PTR FirstThunk); +__declspec(dllimport) void TITCALL ImporterAddNewAPI(char* szAPIName, ULONG_PTR ThunkValue); +__declspec(dllimport) void TITCALL ImporterAddNewOrdinalAPI(ULONG_PTR OrdinalNumber, ULONG_PTR ThunkValue); +__declspec(dllimport) long TITCALL ImporterGetAddedDllCount(); +__declspec(dllimport) long TITCALL ImporterGetAddedAPICount(); +__declspec(dllimport) bool TITCALL ImporterExportIAT(ULONG_PTR StorePlace, ULONG_PTR FileMapVA, HANDLE hFileMap); +__declspec(dllimport) long TITCALL ImporterEstimatedSize(); +__declspec(dllimport) bool TITCALL ImporterExportIATEx(char* szDumpFileName, char* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ImporterExportIATExW(wchar_t* szDumpFileName, wchar_t* szExportFileName, wchar_t* szSectionName = L".RL!TEv2"); +__declspec(dllimport) long long TITCALL ImporterFindAPIWriteLocation(char* szAPIName); +__declspec(dllimport) long long TITCALL ImporterFindOrdinalAPIWriteLocation(ULONG_PTR OrdinalNumber); +__declspec(dllimport) long long TITCALL ImporterFindAPIByWriteLocation(ULONG_PTR APIWriteLocation); +__declspec(dllimport) long long TITCALL ImporterFindDLLByWriteLocation(ULONG_PTR APIWriteLocation); +__declspec(dllimport) void* TITCALL ImporterGetDLLName(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPIName(ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumber(ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPINameEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetRemoteAPIAddressEx(char* szDLLName, char* szAPIName); +__declspec(dllimport) long long TITCALL ImporterGetLocalAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetDLLNameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetAPINameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetAPIOrdinalNumberFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long TITCALL ImporterGetDLLIndexEx(ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long TITCALL ImporterGetDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetRemoteDLLBase(HANDLE hProcess, HMODULE LocalModuleBase); +__declspec(dllimport) bool TITCALL ImporterIsForwardedAPI(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetForwardedAPIName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetForwardedDLLName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long TITCALL ImporterGetForwardedDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, ULONG_PTR DLLBasesList); +__declspec(dllimport) long long TITCALL ImporterGetForwardedAPIOrdinalNumber(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) long long TITCALL ImporterGetNearestAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) void* TITCALL ImporterGetNearestAPIName(HANDLE hProcess, ULONG_PTR APIAddress); +__declspec(dllimport) bool TITCALL ImporterCopyOriginalIAT(char* szOriginalFile, char* szDumpFile); +__declspec(dllimport) bool TITCALL ImporterCopyOriginalIATW(wchar_t* szOriginalFile, wchar_t* szDumpFile); +__declspec(dllimport) bool TITCALL ImporterLoadImportTable(char* szFileName); +__declspec(dllimport) bool TITCALL ImporterLoadImportTableW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL ImporterMoveOriginalIAT(char* szOriginalFile, char* szDumpFile, char* szSectionName); +__declspec(dllimport) bool TITCALL ImporterMoveOriginalIATW(wchar_t* szOriginalFile, wchar_t* szDumpFile, char* szSectionName); +__declspec(dllimport) void TITCALL ImporterAutoSearchIAT(DWORD ProcessId, char* szFileName, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterAutoSearchIATW(DWORD ProcessIds, wchar_t* szFileName, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterAutoSearchIATEx(DWORD ProcessId, ULONG_PTR ImageBase, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize); +__declspec(dllimport) void TITCALL ImporterEnumAddedData(LPVOID EnumCallBack); +__declspec(dllimport) long TITCALL ImporterAutoFixIATEx(DWORD ProcessId, char* szDumpedFile, char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, bool TryAutoFix, bool FixEliminations, LPVOID UnknownPointerFixCallback); +__declspec(dllimport) long TITCALL ImporterAutoFixIATExW(DWORD ProcessId, wchar_t* szDumpedFile, char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, bool TryAutoFix, bool FixEliminations, LPVOID UnknownPointerFixCallback); +__declspec(dllimport) long TITCALL ImporterAutoFixIAT(DWORD ProcessId, char* szDumpedFile, ULONG_PTR SearchStart); +__declspec(dllimport) long TITCALL ImporterAutoFixIATW(DWORD ProcessId, wchar_t* szDumpedFile, ULONG_PTR SearchStart); +__declspec(dllimport) bool TITCALL ImporterDeleteAPI(DWORD_PTR apiAddr); +// Global.Engine.Hook.functions: +__declspec(dllimport) bool TITCALL HooksSafeTransitionEx(LPVOID HookAddressArray, int NumberOfHooks, bool TransitionStart); +__declspec(dllimport) bool TITCALL HooksSafeTransition(LPVOID HookAddress, bool TransitionStart); +__declspec(dllimport) bool TITCALL HooksIsAddressRedirected(LPVOID HookAddress); +__declspec(dllimport) void* TITCALL HooksGetTrampolineAddress(LPVOID HookAddress); +__declspec(dllimport) void* TITCALL HooksGetHookEntryDetails(LPVOID HookAddress); +__declspec(dllimport) bool TITCALL HooksInsertNewRedirection(LPVOID HookAddress, LPVOID RedirectTo, int HookType); +__declspec(dllimport) bool TITCALL HooksInsertNewIATRedirectionEx(ULONG_PTR FileMapVA, ULONG_PTR LoadedModuleBase, char* szHookFunction, LPVOID RedirectTo); +__declspec(dllimport) bool TITCALL HooksInsertNewIATRedirection(char* szModuleName, char* szHookFunction, LPVOID RedirectTo); +__declspec(dllimport) bool TITCALL HooksRemoveRedirection(LPVOID HookAddress, bool RemoveAll); +__declspec(dllimport) bool TITCALL HooksRemoveRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksRemoveIATRedirection(char* szModuleName, char* szHookFunction, bool RemoveAll); +__declspec(dllimport) bool TITCALL HooksDisableRedirection(LPVOID HookAddress, bool DisableAll); +__declspec(dllimport) bool TITCALL HooksDisableRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksDisableIATRedirection(char* szModuleName, char* szHookFunction, bool DisableAll); +__declspec(dllimport) bool TITCALL HooksEnableRedirection(LPVOID HookAddress, bool EnableAll); +__declspec(dllimport) bool TITCALL HooksEnableRedirectionsForModule(HMODULE ModuleBase); +__declspec(dllimport) bool TITCALL HooksEnableIATRedirection(char* szModuleName, char* szHookFunction, bool EnableAll); +__declspec(dllimport) void TITCALL HooksScanModuleMemory(HMODULE ModuleBase, LPVOID CallBack); +__declspec(dllimport) void TITCALL HooksScanEntireProcessMemory(LPVOID CallBack); +__declspec(dllimport) void TITCALL HooksScanEntireProcessMemoryEx(); +// TitanEngine.Tracer.functions: +__declspec(dllimport) void TITCALL TracerInit(); +__declspec(dllimport) long long TITCALL TracerLevel1(HANDLE hProcess, ULONG_PTR AddressToTrace); +__declspec(dllimport) long long TITCALL HashTracerLevel1(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD InputNumberOfInstructions); +__declspec(dllimport) long TITCALL TracerDetectRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace); +__declspec(dllimport) long long TITCALL TracerFixKnownRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD RedirectionId); +__declspec(dllimport) long long TITCALL TracerFixRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD IdParameter); +__declspec(dllimport) long long TITCALL TracerDetectRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, PDWORD ReturnedId); +__declspec(dllimport) long TITCALL TracerFixRedirectionViaImpRecPlugin(HANDLE hProcess, char* szPluginName, ULONG_PTR AddressToTrace); +// TitanEngine.Exporter.functions: +__declspec(dllimport) void TITCALL ExporterCleanup(); +__declspec(dllimport) void TITCALL ExporterSetImageBase(ULONG_PTR ImageBase); +__declspec(dllimport) void TITCALL ExporterInit(DWORD MemorySize, ULONG_PTR ImageBase, DWORD ExportOrdinalBase, char* szExportModuleName); +__declspec(dllimport) bool TITCALL ExporterAddNewExport(char* szExportName, DWORD ExportRelativeAddress); +__declspec(dllimport) bool TITCALL ExporterAddNewOrdinalExport(DWORD OrdinalNumber, DWORD ExportRelativeAddress); +__declspec(dllimport) long TITCALL ExporterGetAddedExportCount(); +__declspec(dllimport) long TITCALL ExporterEstimatedSize(); +__declspec(dllimport) bool TITCALL ExporterBuildExportTable(ULONG_PTR StorePlace, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL ExporterBuildExportTableEx(char* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ExporterBuildExportTableExW(wchar_t* szExportFileName, char* szSectionName); +__declspec(dllimport) bool TITCALL ExporterLoadExportTable(char* szFileName); +__declspec(dllimport) bool TITCALL ExporterLoadExportTableW(wchar_t* szFileName); +// TitanEngine.Librarian.functions: +__declspec(dllimport) bool TITCALL LibrarianSetBreakPoint(char* szLibraryName, DWORD bpxType, bool SingleShoot, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL LibrarianRemoveBreakPoint(char* szLibraryName, DWORD bpxType); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfo(char* szLibraryName); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoW(wchar_t* szLibraryName); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoEx(void* BaseOfDll); +__declspec(dllimport) void* TITCALL LibrarianGetLibraryInfoExW(void* BaseOfDll); +__declspec(dllimport) void TITCALL LibrarianEnumLibraryInfo(void* EnumCallBack); +__declspec(dllimport) void TITCALL LibrarianEnumLibraryInfoW(void* EnumCallBack); +// TitanEngine.Process.functions: +__declspec(dllimport) long TITCALL GetActiveProcessId(char* szImageName); +__declspec(dllimport) long TITCALL GetActiveProcessIdW(wchar_t* szImageName); +__declspec(dllimport) void TITCALL EnumProcessesWithLibrary(char* szLibraryName, void* EnumFunction); +// TitanEngine.TLSFixer.functions: +__declspec(dllimport) bool TITCALL TLSBreakOnCallBack(LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSGrabCallBackData(char* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSGrabCallBackDataW(wchar_t* szFileName, LPVOID ArrayOfCallBacks, LPDWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBreakOnCallBackEx(char* szFileName, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSBreakOnCallBackExW(wchar_t* szFileName, LPVOID bpxCallBack); +__declspec(dllimport) bool TITCALL TLSRemoveCallback(char* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveCallbackW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveTable(char* szFileName); +__declspec(dllimport) bool TITCALL TLSRemoveTableW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSBackupData(char* szFileName); +__declspec(dllimport) bool TITCALL TLSBackupDataW(wchar_t* szFileName); +__declspec(dllimport) bool TITCALL TLSRestoreData(); +__declspec(dllimport) bool TITCALL TLSBuildNewTable(ULONG_PTR FileMapVA, ULONG_PTR StorePlace, ULONG_PTR StorePlaceRVA, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBuildNewTableEx(char* szFileName, char* szSectionName, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +__declspec(dllimport) bool TITCALL TLSBuildNewTableExW(wchar_t* szFileName, char* szSectionName, LPVOID ArrayOfCallBacks, DWORD NumberOfCallBacks); +// TitanEngine.TranslateName.functions: +__declspec(dllimport) void* TITCALL TranslateNativeName(char* szNativeName); +__declspec(dllimport) void* TITCALL TranslateNativeNameW(wchar_t* szNativeName); +// TitanEngine.Handler.functions: +__declspec(dllimport) long TITCALL HandlerGetActiveHandleCount(DWORD ProcessId); +__declspec(dllimport) bool TITCALL HandlerIsHandleOpen(DWORD ProcessId, HANDLE hHandle); +__declspec(dllimport) void* TITCALL HandlerGetHandleName(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName); +__declspec(dllimport) void* TITCALL HandlerGetHandleNameW(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName); +__declspec(dllimport) long TITCALL HandlerEnumerateOpenHandles(DWORD ProcessId, LPVOID HandleBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long long TITCALL HandlerGetHandleDetails(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, DWORD InformationReturn); +__declspec(dllimport) bool TITCALL HandlerCloseRemoteHandle(HANDLE hProcess, HANDLE hHandle); +__declspec(dllimport) long TITCALL HandlerEnumerateLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, LPVOID HandleDataBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long TITCALL HandlerEnumerateLockHandlesW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, LPVOID HandleDataBuffer, DWORD MaxHandleCount); +__declspec(dllimport) bool TITCALL HandlerCloseAllLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerCloseAllLockHandlesW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerIsFileLocked(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +__declspec(dllimport) bool TITCALL HandlerIsFileLockedW(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated); +// TitanEngine.Handler[Mutex].functions: +__declspec(dllimport) long TITCALL HandlerEnumerateOpenMutexes(HANDLE hProcess, DWORD ProcessId, LPVOID HandleBuffer, DWORD MaxHandleCount); +__declspec(dllimport) long long TITCALL HandlerGetOpenMutexHandle(HANDLE hProcess, DWORD ProcessId, char* szMutexString); +__declspec(dllimport) long long TITCALL HandlerGetOpenMutexHandleW(HANDLE hProcess, DWORD ProcessId, wchar_t* szMutexString); +__declspec(dllimport) long TITCALL HandlerGetProcessIdWhichCreatedMutex(char* szMutexString); +__declspec(dllimport) long TITCALL HandlerGetProcessIdWhichCreatedMutexW(wchar_t* szMutexString); +// TitanEngine.Injector.functions: +__declspec(dllimport) bool TITCALL RemoteLoadLibrary(HANDLE hProcess, char* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteLoadLibraryW(HANDLE hProcess, wchar_t* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteFreeLibrary(HANDLE hProcess, HMODULE hModule, char* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteFreeLibraryW(HANDLE hProcess, HMODULE hModule, wchar_t* szLibraryFile, bool WaitForThreadExit); +__declspec(dllimport) bool TITCALL RemoteExitProcess(HANDLE hProcess, DWORD ExitCode); +// TitanEngine.StaticUnpacker.functions: +__declspec(dllimport) bool TITCALL StaticFileLoad(char* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileLoadW(wchar_t* szFileName, DWORD DesiredAccess, bool SimulateLoad, LPHANDLE FileHandle, LPDWORD LoadedSize, LPHANDLE FileMap, PULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileUnload(char* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileUnloadW(wchar_t* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA); +__declspec(dllimport) bool TITCALL StaticFileOpen(char* szFileName, DWORD DesiredAccess, LPHANDLE FileHandle, LPDWORD FileSizeLow, LPDWORD FileSizeHigh); +__declspec(dllimport) bool TITCALL StaticFileOpenW(wchar_t* szFileName, DWORD DesiredAccess, LPHANDLE FileHandle, LPDWORD FileSizeLow, LPDWORD FileSizeHigh); +__declspec(dllimport) bool TITCALL StaticFileGetContent(HANDLE FileHandle, DWORD FilePositionLow, LPDWORD FilePositionHigh, void* Buffer, DWORD Size); +__declspec(dllimport) void TITCALL StaticFileClose(HANDLE FileHandle); +__declspec(dllimport) void TITCALL StaticMemoryDecrypt(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionType, DWORD DecryptionKeySize, ULONG_PTR DecryptionKey); +__declspec(dllimport) void TITCALL StaticMemoryDecryptEx(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionKeySize, void* DecryptionCallBack); +__declspec(dllimport) void TITCALL StaticMemoryDecryptSpecial(LPVOID MemoryStart, DWORD MemorySize, DWORD DecryptionKeySize, DWORD SpecDecryptionType, void* DecryptionCallBack); +__declspec(dllimport) void TITCALL StaticSectionDecrypt(ULONG_PTR FileMapVA, DWORD SectionNumber, bool SimulateLoad, DWORD DecryptionType, DWORD DecryptionKeySize, ULONG_PTR DecryptionKey); +__declspec(dllimport) bool TITCALL StaticMemoryDecompress(void* Source, DWORD SourceSize, void* Destination, DWORD DestinationSize, int Algorithm); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopy(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, char* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticRawMemoryCopyW(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, wchar_t* szDumpFileName); +__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, char* szDumpFileName); +__declspec(dllexport) bool TITCALL StaticRawMemoryCopyExW(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, wchar_t* szDumpFileName); +__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, char* szDumpFileName); +__declspec(dllexport) bool TITCALL StaticRawMemoryCopyEx64W(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, wchar_t* szDumpFileName); +__declspec(dllimport) bool TITCALL StaticHashMemory(void* MemoryToHash, DWORD SizeOfMemory, void* HashDigest, bool OutputString, int Algorithm); +__declspec(dllimport) bool TITCALL StaticHashFile(char* szFileName, char* HashDigest, bool OutputString, int Algorithm); +__declspec(dllimport) bool TITCALL StaticHashFileW(wchar_t* szFileName, char* HashDigest, bool OutputString, int Algorithm); +// TitanEngine.Engine.functions: +__declspec(dllimport) void TITCALL SetEngineVariable(DWORD VariableId, bool VariableSet); +__declspec(dllimport) bool TITCALL EngineCreateMissingDependencies(char* szFileName, char* szOutputFolder, bool LogCreatedFiles); +__declspec(dllimport) bool TITCALL EngineCreateMissingDependenciesW(wchar_t* szFileName, wchar_t* szOutputFolder, bool LogCreatedFiles); +__declspec(dllimport) bool TITCALL EngineFakeMissingDependencies(HANDLE hProcess); +__declspec(dllimport) bool TITCALL EngineDeleteCreatedDependencies(); +__declspec(dllimport) bool TITCALL EngineCreateUnpackerWindow(char* WindowUnpackerTitle, char* WindowUnpackerLongTitle, char* WindowUnpackerName, char* WindowUnpackerAuthor, void* StartUnpackingCallBack); +__declspec(dllimport) void TITCALL EngineAddUnpackerWindowLogMessage(char* szLogMessage); +// Global.Engine.Extension.Functions: +__declspec(dllimport) bool TITCALL ExtensionManagerIsPluginLoaded(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerIsPluginEnabled(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerDisableAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerDisablePlugin(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerEnableAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerEnablePlugin(char* szPluginName); +__declspec(dllimport) bool TITCALL ExtensionManagerUnloadAllPlugins(); +__declspec(dllimport) bool TITCALL ExtensionManagerUnloadPlugin(char* szPluginName); +__declspec(dllimport) void* TITCALL ExtensionManagerGetPluginInfo(char* szPluginName); + +#ifdef __cplusplus +} +#endif /*__cplusplus*/ + +#pragma pack(pop) + +#endif /*TITANENGINE*/ diff --git a/TitanUnitTest/TitanEngine.hpp b/TitanUnitTest/TitanEngine.hpp new file mode 100644 index 0000000..82b5e15 --- /dev/null +++ b/TitanUnitTest/TitanEngine.hpp @@ -0,0 +1,2800 @@ +#ifndef TITANENGINE_CPP +#define TITANENGINE_CPP + +#define TITCALL + +#if _MSC_VER > 1000 +#pragma once +#endif + +namespace TE +{ + +#include + +namespace UE +{ +#ifdef TITANENGINE +#undef TITANENGINE +#endif + +#include "TitanEngine.h" +} + +// ---- + +enum eHideLevel : DWORD +{ + UE_HIDE_PEBONLY = UE::UE_HIDE_PEBONLY, + UE_HIDE_BASIC = UE::UE_HIDE_BASIC +}; + +enum ePluginCallReason : int +{ + UE_PLUGIN_CALL_REASON_PREDEBUG = UE::UE_PLUGIN_CALL_REASON_PREDEBUG, + UE_PLUGIN_CALL_REASON_EXCEPTION = UE::UE_PLUGIN_CALL_REASON_EXCEPTION, + UE_PLUGIN_CALL_REASON_POSTDEBUG = UE::UE_PLUGIN_CALL_REASON_POSTDEBUG +}; + +enum eHookType : int +{ + TEE_HOOK_NRM_JUMP = UE::TEE_HOOK_NRM_JUMP, + TEE_HOOK_NRM_CALL = UE::TEE_HOOK_NRM_CALL, + TEE_HOOK_IAT = UE::TEE_HOOK_IAT +}; + +enum eEngineVariable : DWORD +{ + UE_ENGINE_ALOW_MODULE_LOADING = UE::UE_ENGINE_ALOW_MODULE_LOADING, + UE_ENGINE_AUTOFIX_FORWARDERS = UE::UE_ENGINE_AUTOFIX_FORWARDERS, + UE_ENGINE_PASS_ALL_EXCEPTIONS = UE::UE_ENGINE_PASS_ALL_EXCEPTIONS, + UE_ENGINE_NO_CONSOLE_WINDOW = UE::UE_ENGINE_NO_CONSOLE_WINDOW, + UE_ENGINE_BACKUP_FOR_CRITICAL_FUNCTIONS = UE::UE_ENGINE_BACKUP_FOR_CRITICAL_FUNCTIONS, + UE_ENGINE_CALL_PLUGIN_CALLBACK = UE::UE_ENGINE_CALL_PLUGIN_CALLBACK, + UE_ENGINE_RESET_CUSTOM_HANDLER = UE::UE_ENGINE_RESET_CUSTOM_HANDLER, + UE_ENGINE_CALL_PLUGIN_DEBUG_CALLBACK = UE::UE_ENGINE_CALL_PLUGIN_DEBUG_CALLBACK +}; + +enum eBPRemoveOption : DWORD +{ + UE_OPTION_REMOVEALL = UE::UE_OPTION_REMOVEALL, + UE_OPTION_DISABLEALL = UE::UE_OPTION_DISABLEALL, + UE_OPTION_REMOVEALLDISABLED = UE::UE_OPTION_REMOVEALLDISABLED, + UE_OPTION_REMOVEALLENABLED = UE::UE_OPTION_REMOVEALLENABLED +}; + +enum eAccess : DWORD +{ + UE_ACCESS_READ = UE::UE_ACCESS_READ, + UE_ACCESS_WRITE = UE::UE_ACCESS_WRITE, + UE_ACCESS_ALL = UE::UE_ACCESS_ALL +}; + +enum eDecryptionType : DWORD +{ + UE_STATIC_DECRYPTOR_XOR = UE::UE_STATIC_DECRYPTOR_XOR, + UE_STATIC_DECRYPTOR_SUB = UE::UE_STATIC_DECRYPTOR_SUB, + UE_STATIC_DECRYPTOR_ADD = UE::UE_STATIC_DECRYPTOR_ADD +}; + +enum eDecryptionDirection : DWORD +{ + UE_STATIC_DECRYPTOR_FOREWARD = UE::UE_STATIC_DECRYPTOR_FOREWARD, + UE_STATIC_DECRYPTOR_BACKWARD = UE::UE_STATIC_DECRYPTOR_BACKWARD +}; + +enum eDecryptionKeySize : DWORD +{ + UE_STATIC_KEY_SIZE_1 = UE::UE_STATIC_KEY_SIZE_1, + UE_STATIC_KEY_SIZE_2 = UE::UE_STATIC_KEY_SIZE_2, + UE_STATIC_KEY_SIZE_4 = UE::UE_STATIC_KEY_SIZE_4, + UE_STATIC_KEY_SIZE_8 = UE::UE_STATIC_KEY_SIZE_8 +}; + +enum eCompressionAlgorithm : int +{ + UE_STATIC_APLIB = UE::UE_STATIC_APLIB, + UE_STATIC_APLIB_DEPACK = UE::UE_STATIC_APLIB_DEPACK, + UE_STATIC_LZMA = UE::UE_STATIC_LZMA +}; + +enum eHashAlgorithm : int +{ + UE_STATIC_HASH_MD5 = UE::UE_STATIC_HASH_MD5, + UE_STATIC_HASH_SHA1 = UE::UE_STATIC_HASH_SHA1, + UE_STATIC_HASH_CRC32 = UE::UE_STATIC_HASH_CRC32 +}; + +const DWORD UE_RESOURCE_LANGUAGE_ANY = UE::UE_RESOURCE_LANGUAGE_ANY; + +enum ePE32Data : DWORD +{ + UE_PE_OFFSET = UE::UE_PE_OFFSET, + UE_IMAGEBASE = UE::UE_IMAGEBASE, + UE_OEP = UE::UE_OEP, + UE_BASEOFCODE = UE::UE_BASEOFCODE, + UE_BASEOFDATA = UE::UE_BASEOFDATA, + UE_SIZEOFIMAGE = UE::UE_SIZEOFIMAGE, + UE_SIZEOFHEADERS = UE::UE_SIZEOFHEADERS, + UE_SIZEOFOPTIONALHEADER = UE::UE_SIZEOFOPTIONALHEADER, + UE_SECTIONALIGNMENT = UE::UE_SECTIONALIGNMENT, + UE_IMPORTTABLEADDRESS = UE::UE_IMPORTTABLEADDRESS, + UE_IMPORTTABLESIZE = UE::UE_IMPORTTABLESIZE, + UE_RESOURCETABLEADDRESS = UE::UE_RESOURCETABLEADDRESS, + UE_RESOURCETABLESIZE = UE::UE_RESOURCETABLESIZE, + UE_EXPORTTABLEADDRESS = UE::UE_EXPORTTABLEADDRESS, + UE_EXPORTTABLESIZE = UE::UE_EXPORTTABLESIZE, + UE_TLSTABLEADDRESS = UE::UE_TLSTABLEADDRESS, + UE_TLSTABLESIZE = UE::UE_TLSTABLESIZE, + UE_RELOCATIONTABLEADDRESS = UE::UE_RELOCATIONTABLEADDRESS, + UE_RELOCATIONTABLESIZE = UE::UE_RELOCATIONTABLESIZE, + UE_TIMEDATESTAMP = UE::UE_TIMEDATESTAMP, + UE_SECTIONNUMBER = UE::UE_SECTIONNUMBER, + UE_CHECKSUM = UE::UE_CHECKSUM, + UE_SUBSYSTEM = UE::UE_SUBSYSTEM, + UE_CHARACTERISTICS = UE::UE_CHARACTERISTICS, + UE_NUMBEROFRVAANDSIZES = UE::UE_NUMBEROFRVAANDSIZES, + UE_SECTIONNAME = UE::UE_SECTIONNAME, + UE_SECTIONVIRTUALOFFSET = UE::UE_SECTIONVIRTUALOFFSET, + UE_SECTIONVIRTUALSIZE = UE::UE_SECTIONVIRTUALSIZE, + UE_SECTIONRAWOFFSET = UE::UE_SECTIONRAWOFFSET, + UE_SECTIONRAWSIZE = UE::UE_SECTIONRAWSIZE, + UE_SECTIONFLAGS = UE::UE_SECTIONFLAGS +}; + +const long UE_VANOTFOUND = UE::UE_VANOTFOUND; + +enum eCustomException : DWORD +{ + UE_CH_BREAKPOINT = UE::UE_CH_BREAKPOINT, + UE_CH_SINGLESTEP = UE::UE_CH_SINGLESTEP, + UE_CH_ACCESSVIOLATION = UE::UE_CH_ACCESSVIOLATION, + UE_CH_ILLEGALINSTRUCTION = UE::UE_CH_ILLEGALINSTRUCTION, + UE_CH_NONCONTINUABLEEXCEPTION = UE::UE_CH_NONCONTINUABLEEXCEPTION, + UE_CH_ARRAYBOUNDSEXCEPTION = UE::UE_CH_ARRAYBOUNDSEXCEPTION, + UE_CH_FLOATDENORMALOPERAND = UE::UE_CH_FLOATDENORMALOPERAND, + UE_CH_FLOATDEVIDEBYZERO = UE::UE_CH_FLOATDEVIDEBYZERO, + UE_CH_INTEGERDEVIDEBYZERO = UE::UE_CH_INTEGERDEVIDEBYZERO, + UE_CH_INTEGEROVERFLOW = UE::UE_CH_INTEGEROVERFLOW, + UE_CH_PRIVILEGEDINSTRUCTION = UE::UE_CH_PRIVILEGEDINSTRUCTION, + UE_CH_PAGEGUARD = UE::UE_CH_PAGEGUARD, + UE_CH_EVERYTHINGELSE = UE::UE_CH_EVERYTHINGELSE, + UE_CH_CREATETHREAD = UE::UE_CH_CREATETHREAD, + UE_CH_EXITTHREAD = UE::UE_CH_EXITTHREAD, + UE_CH_CREATEPROCESS = UE::UE_CH_CREATEPROCESS, + UE_CH_EXITPROCESS = UE::UE_CH_EXITPROCESS, + UE_CH_LOADDLL = UE::UE_CH_LOADDLL, + UE_CH_UNLOADDLL = UE::UE_CH_UNLOADDLL, + UE_CH_OUTPUTDEBUGSTRING = UE::UE_CH_OUTPUTDEBUGSTRING, + UE_CH_AFTEREXCEPTIONPROCESSING = UE::UE_CH_AFTEREXCEPTIONPROCESSING, + UE_CH_ALLEVENTS = UE::UE_CH_ALLEVENTS, + UE_CH_SYSTEMBREAKPOINT = UE::UE_CH_SYSTEMBREAKPOINT, + UE_CH_UNHANDLEDEXCEPTION = UE::UE_CH_UNHANDLEDEXCEPTION, + UE_CH_RIPEVENT = UE::UE_CH_RIPEVENT +}; + +enum eHandlerReturnType : DWORD +{ + UE_OPTION_HANDLER_RETURN_HANDLECOUNT = UE::UE_OPTION_HANDLER_RETURN_HANDLECOUNT, + UE_OPTION_HANDLER_RETURN_ACCESS = UE::UE_OPTION_HANDLER_RETURN_ACCESS, + UE_OPTION_HANDLER_RETURN_FLAGS = UE::UE_OPTION_HANDLER_RETURN_FLAGS, + UE_OPTION_HANDLER_RETURN_TYPENAME = UE::UE_OPTION_HANDLER_RETURN_TYPENAME +}; + +enum eBPState +{ + UE_BPXREMOVED = UE::UE_BPXREMOVED, + UE_BPXACTIVE = UE::UE_BPXACTIVE, + UE_BPXINACTIVE = UE::UE_BPXINACTIVE +}; + +enum eBPType +{ + UE_BREAKPOINT = UE::UE_BREAKPOINT, + UE_SINGLESHOOT = UE::UE_SINGLESHOOT, + //UE_HARDWARE = UE::UE_HARDWARE, +}; + +enum eMemoryBPType +{ + UE_MEMORY = UE::UE_MEMORY, + UE_MEMORY_READ = UE::UE_MEMORY_READ, + UE_MEMORY_WRITE = UE::UE_MEMORY_WRITE, + UE_MEMORY_EXECUTE = UE::UE_MEMORY_EXECUTE +}; + +enum eHWBPType : DWORD +{ + UE_HARDWARE_EXECUTE = UE::UE_HARDWARE_EXECUTE, + UE_HARDWARE_WRITE = UE::UE_HARDWARE_WRITE, + UE_HARDWARE_READWRITE = UE::UE_HARDWARE_READWRITE +}; + +enum eHWBPSize : DWORD +{ + UE_HARDWARE_SIZE_1 = UE::UE_HARDWARE_SIZE_1, + UE_HARDWARE_SIZE_2 = UE::UE_HARDWARE_SIZE_2, + UE_HARDWARE_SIZE_4 = UE::UE_HARDWARE_SIZE_4, + UE_HARDWARE_SIZE_8 = UE::UE_HARDWARE_SIZE_8 +}; + +enum eLibraryEvent : DWORD +{ + UE_ON_LIB_LOAD = UE::UE_ON_LIB_LOAD, + UE_ON_LIB_UNLOAD = UE::UE_ON_LIB_UNLOAD, + UE_ON_LIB_ALL = UE::UE_ON_LIB_ALL +}; + +enum eBPPlace : DWORD +{ + UE_APISTART = UE::UE_APISTART, + UE_APIEND = UE::UE_APIEND +}; + +enum ePlatform : int +{ + UE_PLATFORM_x86 = UE::UE_PLATFORM_x86, + UE_PLATFORM_x64 = UE::UE_PLATFORM_x64, + UE_PLATFORM_ALL = UE::UE_PLATFORM_ALL +}; + +enum eFunctionType : DWORD +{ + UE_FUNCTION_STDCALL = UE::UE_FUNCTION_STDCALL, + UE_FUNCTION_CCALL = UE::UE_FUNCTION_CCALL, + UE_FUNCTION_FASTCALL = UE::UE_FUNCTION_FASTCALL, + UE_FUNCTION_STDCALL_RET = UE::UE_FUNCTION_STDCALL_RET, + UE_FUNCTION_CCALL_RET = UE::UE_FUNCTION_CCALL_RET, + UE_FUNCTION_FASTCALL_RET = UE::UE_FUNCTION_FASTCALL_RET, + UE_FUNCTION_STDCALL_CALL = UE::UE_FUNCTION_STDCALL_CALL, + UE_FUNCTION_CCALL_CALL = UE::UE_FUNCTION_CCALL_CALL, + UE_FUNCTION_FASTCALL_CALL = UE::UE_FUNCTION_FASTCALL_CALL +}; + +enum eParameterType : DWORD +{ + UE_PARAMETER_BYTE = UE::UE_PARAMETER_BYTE, + UE_PARAMETER_WORD = UE::UE_PARAMETER_WORD, + UE_PARAMETER_DWORD = UE::UE_PARAMETER_DWORD, + UE_PARAMETER_QWORD = UE::UE_PARAMETER_QWORD, + UE_PARAMETER_PTR_BYTE = UE::UE_PARAMETER_PTR_BYTE, + UE_PARAMETER_PTR_WORD = UE::UE_PARAMETER_PTR_WORD, + UE_PARAMETER_PTR_DWORD = UE::UE_PARAMETER_PTR_DWORD, + UE_PARAMETER_PTR_QWORD = UE::UE_PARAMETER_PTR_QWORD, + UE_PARAMETER_STRING = UE::UE_PARAMETER_STRING, + UE_PARAMETER_UNICODE = UE::UE_PARAMETER_UNICODE +}; + +enum eContextData : DWORD +{ + UE_EAX = UE::UE_EAX, + UE_EBX = UE::UE_EBX, + UE_ECX = UE::UE_ECX, + UE_EDX = UE::UE_EDX, + UE_EDI = UE::UE_EDI, + UE_ESI = UE::UE_ESI, + UE_EBP = UE::UE_EBP, + UE_ESP = UE::UE_ESP, + UE_EIP = UE::UE_EIP, + UE_EFLAGS = UE::UE_EFLAGS, + UE_DR0 = UE::UE_DR0, + UE_DR1 = UE::UE_DR1, + UE_DR2 = UE::UE_DR2, + UE_DR3 = UE::UE_DR3, + UE_DR6 = UE::UE_DR6, + UE_DR7 = UE::UE_DR7, + UE_RAX = UE::UE_RAX, + UE_RBX = UE::UE_RBX, + UE_RCX = UE::UE_RCX, + UE_RDX = UE::UE_RDX, + UE_RDI = UE::UE_RDI, + UE_RSI = UE::UE_RSI, + UE_RBP = UE::UE_RBP, + UE_RSP = UE::UE_RSP, + UE_RIP = UE::UE_RIP, + UE_RFLAGS = UE::UE_RFLAGS, + UE_R8 = UE::UE_R8, + UE_R9 = UE::UE_R9, + UE_R10 = UE::UE_R10, + UE_R11 = UE::UE_R11, + UE_R12 = UE::UE_R12, + UE_R13 = UE::UE_R13, + UE_R14 = UE::UE_R14, + UE_R15 = UE::UE_R15, + UE_CIP = UE::UE_CIP, + UE_CSP = UE::UE_CSP, + UE_SEG_GS = UE::UE_SEG_GS, + UE_SEG_FS = UE::UE_SEG_FS, + UE_SEG_ES = UE::UE_SEG_ES, + UE_SEG_DS = UE::UE_SEG_DS, + UE_SEG_CS = UE::UE_SEG_CS, + UE_SEG_SS = UE::UE_SEG_SS +}; + +enum eCheckDepth : DWORD +{ + UE_DEPTH_SURFACE = UE::UE_DEPTH_SURFACE, + UE_DEPTH_DEEP = UE::UE_DEPTH_DEEP +}; + +enum eFieldState : BYTE +{ + UE_FIELD_OK = UE::UE_FIELD_OK, + UE_FIELD_BROKEN_NON_FIXABLE = UE::UE_FIELD_BROKEN_NON_FIXABLE, + UE_FIELD_BROKEN_NON_CRITICAL = UE::UE_FIELD_BROKEN_NON_CRITICAL, + UE_FIELD_BROKEN_FIXABLE_FOR_STATIC_USE = UE::UE_FIELD_BROKEN_FIXABLE_FOR_STATIC_USE, + UE_FIELD_BROKEN_BUT_CAN_BE_EMULATED = UE::UE_FIELD_BROKEN_BUT_CAN_BE_EMULATED, + UE_FIELD_FIXABLE_NON_CRITICAL = UE::UE_FIELD_FIXABLE_NON_CRITICAL, + UE_FIELD_FIXABLE_CRITICAL = UE::UE_FIELD_FIXABLE_CRITICAL, + UE_FIELD_NOT_PRESET = UE::UE_FIELD_NOT_PRESET, + UE_FIELD_NOT_PRESET_WARNING = UE::UE_FIELD_NOT_PRESET_WARNING +}; + +enum eFileState : BYTE +{ + UE_RESULT_FILE_OK = UE::UE_RESULT_FILE_OK, + UE_RESULT_FILE_INVALID_BUT_FIXABLE = UE::UE_RESULT_FILE_INVALID_BUT_FIXABLE, + UE_RESULT_FILE_INVALID_AND_NON_FIXABLE = UE::UE_RESULT_FILE_INVALID_AND_NON_FIXABLE, + UE_RESULT_FILE_INVALID_FORMAT = UE::UE_RESULT_FILE_INVALID_FORMAT +}; + +// ---- + +class DumperA; +class DumperW; + +class DumperX +{ + friend class DumperA; + friend class DumperW; + +protected: + + typedef UE::PEStruct PEStruct; + + static long long GetPE32DataFromMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, ePE32Data WhichData) + { + return UE::GetPE32DataFromMappedFile(FileMapVA, WhichSection, WhichData); + } + static bool GetPE32DataFromMappedFileEx(ULONG_PTR FileMapVA, PEStruct* DataStorage) + { + return UE::GetPE32DataFromMappedFileEx(FileMapVA, (void*)DataStorage); + } + static bool SetPE32DataForMappedFile(ULONG_PTR FileMapVA, DWORD WhichSection, ePE32Data WhichData, ULONG_PTR NewDataValue) + { + return UE::SetPE32DataForMappedFile(FileMapVA, WhichSection, WhichData, NewDataValue); + } + static bool SetPE32DataForMappedFileEx(ULONG_PTR FileMapVA, PEStruct* DataStorage) + { + return UE::SetPE32DataForMappedFileEx(FileMapVA, (void*)DataStorage); + } + static long GetPE32SectionNumberFromVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert) + { + return UE::GetPE32SectionNumberFromVA(FileMapVA, AddressToConvert); + } + static long long ConvertVAtoFileOffset(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType) + { + return UE::ConvertVAtoFileOffset(FileMapVA, AddressToConvert, ReturnType); + } + static long long ConvertVAtoFileOffsetEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool AddressIsRVA, bool ReturnType) + { + return UE::ConvertVAtoFileOffsetEx(FileMapVA, FileSize, ImageBase, AddressToConvert, AddressIsRVA, ReturnType); + } + static long long ConvertFileOffsetToVA(ULONG_PTR FileMapVA, ULONG_PTR AddressToConvert, bool ReturnType) + { + return UE::ConvertFileOffsetToVA(FileMapVA, AddressToConvert, ReturnType); + } + static long long ConvertFileOffsetToVAEx(ULONG_PTR FileMapVA, DWORD FileSize, ULONG_PTR ImageBase, ULONG_PTR AddressToConvert, bool ReturnType) + { + return UE::ConvertFileOffsetToVAEx(FileMapVA, FileSize, ImageBase, AddressToConvert, ReturnType); + } + static bool MemoryReadSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesRead) + { + return UE::MemoryReadSafe(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead); + } + static bool MemoryWriteSafe(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T * lpNumberOfBytesWritten) + { + return UE::MemoryWriteSafe(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten); + } +}; + +class DumperA +{ +public: + + static bool DumpProcess(HANDLE hProcess, void* ImageBase, const char* szDumpFileName, ULONG_PTR EntryPoint) + { + return UE::DumpProcess(hProcess, ImageBase, (char*)szDumpFileName, EntryPoint); + } + static bool DumpProcessEx(DWORD ProcessId, void* ImageBase, const char* szDumpFileName, ULONG_PTR EntryPoint) + { + return UE::DumpProcessEx(ProcessId, ImageBase, (char*)szDumpFileName, EntryPoint); + } + static bool DumpMemory(HANDLE hProcess, void* MemoryStart, ULONG_PTR MemorySize, const char* szDumpFileName) + { + return UE::DumpMemory(hProcess, MemoryStart, MemorySize, (char*)szDumpFileName); + } + static bool DumpMemoryEx(DWORD ProcessId, void* MemoryStart, ULONG_PTR MemorySize, const char* szDumpFileName) + { + return UE::DumpMemoryEx(ProcessId, MemoryStart, MemorySize, (char*)szDumpFileName); + } + static bool DumpRegions(HANDLE hProcess, const char* szDumpFolder, bool DumpAboveImageBaseOnly) + { + return UE::DumpRegions(hProcess, (char*)szDumpFolder, DumpAboveImageBaseOnly); + } + static bool DumpRegionsEx(DWORD ProcessId, const char* szDumpFolder, bool DumpAboveImageBaseOnly) + { + return UE::DumpRegionsEx(ProcessId, (char*)szDumpFolder, DumpAboveImageBaseOnly); + } + static bool DumpModule(HANDLE hProcess, void* ModuleBase, const char* szDumpFileName) + { + return UE::DumpModule(hProcess, ModuleBase, (char*)szDumpFileName); + } + static bool DumpModuleEx(DWORD ProcessId, void* ModuleBase, const char* szDumpFileName) + { + return UE::DumpModuleEx(ProcessId, ModuleBase, (char*)szDumpFileName); + } + static bool PastePEHeader(HANDLE hProcess, void* ImageBase, const char* szDebuggedFileName) + { + return UE::PastePEHeader(hProcess, ImageBase, (char*)szDebuggedFileName); + } + static bool ExtractSection(const char* szFileName, const char* szDumpFileName, DWORD SectionNumber) + { + return UE::ExtractSection((char*)szFileName, (char*)szDumpFileName, SectionNumber); + } + static bool ResortFileSections(const char* szFileName) + { + return UE::ResortFileSections((char*)szFileName); + } + static bool FindOverlay(const char* szFileName, DWORD* OverlayStart, DWORD* OverlaySize) + { + return UE::FindOverlay((char*)szFileName, OverlayStart, OverlaySize); + } + static bool ExtractOverlay(const char* szFileName, const char* szExtractedFileName) + { + return UE::ExtractOverlay((char*)szFileName, (char*)szExtractedFileName); + } + static bool AddOverlay(const char* szFileName, const char* szOverlayFileName) + { + return UE::AddOverlay((char*)szFileName, (char*)szOverlayFileName); + } + static bool CopyOverlay(const char* szInFileName, const char* szOutFileName) + { + return UE::CopyOverlay((char*)szInFileName, (char*)szOutFileName); + } + static bool RemoveOverlay(const char* szFileName) + { + return UE::RemoveOverlay((char*)szFileName); + } + static bool MakeAllSectionsRWE(const char* szFileName) + { + return UE::MakeAllSectionsRWE((char*)szFileName); + } + static long AddNewSectionEx(const char* szFileName, const char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, const void* SectionContent, DWORD ContentSize) + { + return UE::AddNewSectionEx((char*)szFileName, (char*)szSectionName, SectionSize, SectionAttributes, (void*)SectionContent, ContentSize); + } + static long AddNewSection(const char* szFileName, const char* szSectionName, DWORD SectionSize) + { + return UE::AddNewSection((char*)szFileName, (char*)szSectionName, SectionSize); + } + static bool ResizeLastSection(const char* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData) + { + return UE::ResizeLastSection((char*)szFileName, NumberOfExpandBytes, AlignResizeData); + } + static void SetSharedOverlay(const char* szFileName) + { + return UE::SetSharedOverlay((char*)szFileName); + } + static const char* GetSharedOverlay() + { + return UE::GetSharedOverlay(); + } + static bool DeleteLastSection(const char* szFileName) + { + return UE::DeleteLastSection((char*)szFileName); + } + static bool DeleteLastSectionEx(const char* szFileName, DWORD NumberOfSections) + { + return UE::DeleteLastSectionEx((char*)szFileName, NumberOfSections); + } + static long long GetPE32Data(const char* szFileName, DWORD WhichSection, ePE32Data WhichData) + { + return UE::GetPE32Data((char*)szFileName, WhichSection, WhichData); + } + static bool GetPE32DataEx(const char* szFileName, DumperX::PEStruct* DataStorage) + { + return UE::GetPE32DataEx((char*)szFileName, DataStorage); + } + static bool SetPE32Data(const char* szFileName, DWORD WhichSection, ePE32Data WhichData, ULONG_PTR NewDataValue) + { + return UE::SetPE32Data((char*)szFileName, WhichSection, WhichData, NewDataValue); + } + static bool SetPE32DataEx(const char* szFileName, const DumperX::PEStruct* DataStorage) + { + return UE::SetPE32DataEx((char*)szFileName, (void*)DataStorage); + } +}; + +class DumperW +{ +public: + + static bool DumpProcess(HANDLE hProcess, void* ImageBase, const wchar_t* szDumpFileName, ULONG_PTR EntryPoint) + { + return UE::DumpProcessW(hProcess, ImageBase, (wchar_t*)szDumpFileName, EntryPoint); + } + static bool DumpProcessEx(DWORD ProcessId, void* ImageBase, const wchar_t* szDumpFileName, ULONG_PTR EntryPoint) + { + return UE::DumpProcessExW(ProcessId, ImageBase, (wchar_t*)szDumpFileName, EntryPoint); + } + static bool DumpMemory(HANDLE hProcess, void* MemoryStart, ULONG_PTR MemorySize, const wchar_t* szDumpFileName) + { + return UE::DumpMemoryW(hProcess, MemoryStart, MemorySize, (wchar_t*)szDumpFileName); + } + static bool DumpMemoryEx(DWORD ProcessId, void* MemoryStart, ULONG_PTR MemorySize, const wchar_t* szDumpFileName) + { + return UE::DumpMemoryExW(ProcessId, MemoryStart, MemorySize, (wchar_t*)szDumpFileName); + } + static bool DumpRegions(HANDLE hProcess, const wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly) + { + return UE::DumpRegionsW(hProcess, (wchar_t*)szDumpFolder, DumpAboveImageBaseOnly); + } + static bool DumpRegionsEx(DWORD ProcessId, const wchar_t* szDumpFolder, bool DumpAboveImageBaseOnly) + { + return UE::DumpRegionsExW(ProcessId, (wchar_t*)szDumpFolder, DumpAboveImageBaseOnly); + } + static bool DumpModule(HANDLE hProcess, void* ModuleBase, const wchar_t* szDumpFileName) + { + return UE::DumpModuleW(hProcess, ModuleBase, (wchar_t*)szDumpFileName); + } + static bool DumpModuleEx(DWORD ProcessId, void* ModuleBase, const wchar_t* szDumpFileName) + { + return UE::DumpModuleExW(ProcessId, ModuleBase, (wchar_t*)szDumpFileName); + } + static bool PastePEHeader(HANDLE hProcess, void* ImageBase, const wchar_t* szDebuggedFileName) + { + return UE::PastePEHeaderW(hProcess, ImageBase, (wchar_t*)szDebuggedFileName); + } + static bool ExtractSection(const wchar_t* szFileName, const wchar_t* szDumpFileName, DWORD SectionNumber) + { + return UE::ExtractSectionW((wchar_t*)szFileName, (wchar_t*)szDumpFileName, SectionNumber); + } + static bool ResortFileSections(const wchar_t* szFileName) + { + return UE::ResortFileSectionsW((wchar_t*)szFileName); + } + static bool FindOverlay(const wchar_t* szFileName, DWORD* OverlayStart, DWORD* OverlaySize) + { + return UE::FindOverlayW((wchar_t*)szFileName, OverlayStart, OverlaySize); + } + static bool ExtractOverlay(const wchar_t* szFileName, const wchar_t* szExtractedFileName) + { + return UE::ExtractOverlayW((wchar_t*)szFileName, (wchar_t*)szExtractedFileName); + } + static bool AddOverlay(const wchar_t* szFileName, const wchar_t* szOverlayFileName) + { + return UE::AddOverlayW((wchar_t*)szFileName, (wchar_t*)szOverlayFileName); + } + static bool CopyOverlay(const wchar_t* szInFileName, const wchar_t* szOutFileName) + { + return UE::CopyOverlayW((wchar_t*)szInFileName, (wchar_t*)szOutFileName); + } + static bool RemoveOverlay(const wchar_t* szFileName) + { + return UE::RemoveOverlayW((wchar_t*)szFileName); + } + static bool MakeAllSectionsRWE(const wchar_t* szFileName) + { + return UE::MakeAllSectionsRWEW((wchar_t*)szFileName); + } + static long AddNewSectionEx(const wchar_t* szFileName, const char* szSectionName, DWORD SectionSize, DWORD SectionAttributes, const void* SectionContent, DWORD ContentSize) + { + return UE::AddNewSectionExW((wchar_t*)szFileName, (char*)szSectionName, SectionSize, SectionAttributes, (void*)SectionContent, ContentSize); + } + static long AddNewSection(const wchar_t* szFileName, const char* szSectionName, DWORD SectionSize) + { + return UE::AddNewSectionW((wchar_t*)szFileName, (char*)szSectionName, SectionSize); + } + static bool ResizeLastSection(const wchar_t* szFileName, DWORD NumberOfExpandBytes, bool AlignResizeData) + { + return UE::ResizeLastSectionW((wchar_t*)szFileName, NumberOfExpandBytes, AlignResizeData); + } + static void SetSharedOverlay(const wchar_t* szFileName) + { + return UE::SetSharedOverlayW((wchar_t*)szFileName); + } + static const wchar_t* GetSharedOverlay() + { + return UE::GetSharedOverlayW(); + } + static bool DeleteLastSection(const wchar_t* szFileName) + { + return UE::DeleteLastSectionW((wchar_t*)szFileName); + } + static bool DeleteLastSectionEx(const wchar_t* szFileName, DWORD NumberOfSections) + { + return UE::DeleteLastSectionExW((wchar_t*)szFileName, NumberOfSections); + } + static long long GetPE32Data(const wchar_t* szFileName, DWORD WhichSection, ePE32Data WhichData) + { + return UE::GetPE32DataW((wchar_t*)szFileName, WhichSection, WhichData); + } + static bool GetPE32DataEx(const wchar_t* szFileName, DumperX::PEStruct* DataStorage) + { + return UE::GetPE32DataExW((wchar_t*)szFileName, DataStorage); + } + static bool SetPE32Data(const wchar_t* szFileName, DWORD WhichSection, ePE32Data WhichData, ULONG_PTR NewDataValue) + { + return UE::SetPE32DataW((wchar_t*)szFileName, WhichSection, WhichData, NewDataValue); + } + static bool SetPE32DataEx(const wchar_t* szFileName, const DumperX::PEStruct* DataStorage) + { + return UE::SetPE32DataExW((wchar_t*)szFileName, (void*)DataStorage); + } +}; + +class Dumper : DumperX, DumperA, DumperW +{ +public: + + using DumperX::PEStruct; + + using DumperA::DumpProcess; + using DumperW::DumpProcess; + using DumperA::DumpProcessEx; + using DumperW::DumpProcessEx; + using DumperA::DumpMemory; + using DumperW::DumpMemory; + using DumperA::DumpMemoryEx; + using DumperW::DumpMemoryEx; + using DumperA::DumpRegions; + using DumperW::DumpRegions; + using DumperA::DumpRegionsEx; + using DumperW::DumpRegionsEx; + using DumperA::DumpModule; + using DumperW::DumpModule; + using DumperA::DumpModuleEx; + using DumperW::DumpModuleEx; + using DumperA::PastePEHeader; + using DumperW::PastePEHeader; + using DumperA::ExtractSection; + using DumperW::ExtractSection; + using DumperA::ResortFileSections; + using DumperW::ResortFileSections; + using DumperA::FindOverlay; + using DumperW::FindOverlay; + using DumperA::ExtractOverlay; + using DumperW::ExtractOverlay; + using DumperA::AddOverlay; + using DumperW::AddOverlay; + using DumperA::CopyOverlay; + using DumperW::CopyOverlay; + using DumperA::RemoveOverlay; + using DumperW::RemoveOverlay; + using DumperA::MakeAllSectionsRWE; + using DumperW::MakeAllSectionsRWE; + using DumperA::AddNewSectionEx; + using DumperW::AddNewSectionEx; + using DumperA::AddNewSection; + using DumperW::AddNewSection; + using DumperA::ResizeLastSection; + using DumperW::ResizeLastSection; + using DumperA::SetSharedOverlay; + using DumperW::SetSharedOverlay; +#ifndef UNICODE + using DumperA::GetSharedOverlay; +#else + using DumperW::GetSharedOverlay; +#endif + using DumperA::DeleteLastSection; + using DumperW::DeleteLastSection; + using DumperA::DeleteLastSectionEx; + using DumperW::DeleteLastSectionEx; + using DumperX::GetPE32DataFromMappedFile; + using DumperA::GetPE32Data; + using DumperW::GetPE32Data; + using DumperX::GetPE32DataFromMappedFileEx; + using DumperA::GetPE32DataEx; + using DumperW::GetPE32DataEx; + using DumperX::SetPE32DataForMappedFile; + using DumperA::SetPE32Data; + using DumperW::SetPE32Data; + using DumperX::SetPE32DataForMappedFileEx; + using DumperA::SetPE32DataEx; + using DumperW::SetPE32DataEx; + using DumperX::GetPE32SectionNumberFromVA; + using DumperX::ConvertVAtoFileOffset; + using DumperX::ConvertVAtoFileOffsetEx; + using DumperX::ConvertFileOffsetToVA; + using DumperX::ConvertFileOffsetToVAEx; +}; + +class RealignerA; +class RealignerW; + +class RealignerX +{ + friend class RealignerA; + friend class RealignerW; + +protected: + + typedef UE::FILE_STATUS_INFO FILE_STATUS_INFO; + typedef UE::FILE_FIX_INFO FILE_FIX_INFO; + + static long RealignPE(ULONG_PTR FileMapVA, DWORD FileSize, DWORD RealingMode) + { + return UE::RealignPE(FileMapVA, FileSize, RealingMode); + } +}; + +class RealignerA +{ +public: + + static bool FixHeaderCheckSum(const char* szFileName) + { + return UE::FixHeaderCheckSum((char*)szFileName); + } + static long RealignPEEx(const char* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment) + { + return UE::RealignPEEx((char*)szFileName, RealingFileSize, ForcedFileAlignment); + } + static bool WipeSection(const char* szFileName, int WipeSectionNumber, bool RemovePhysically) + { + return UE::WipeSection((char*)szFileName, WipeSectionNumber, RemovePhysically); + } + static bool IsPE32FileValidEx(const char* szFileName, eCheckDepth CheckDepth, RealignerX::FILE_STATUS_INFO* FileStatusInfo) + { + return UE::IsPE32FileValidEx((char*)szFileName, CheckDepth, (void*)FileStatusInfo); + } + static bool FixBrokenPE32FileEx(const char* szFileName, const RealignerX::FILE_STATUS_INFO* FileStatusInfo, RealignerX::FILE_FIX_INFO* FileFixInfo) + { + return UE::FixBrokenPE32FileEx((char*)szFileName, (void*)FileStatusInfo, (void*)FileFixInfo); + } + static bool IsFileDLL(const char* szFileName, ULONG_PTR FileMapVA) + { + return UE::IsFileDLL((char*)szFileName, FileMapVA); + } +}; + +class RealignerW +{ +public: + + static bool FixHeaderCheckSum(const wchar_t* szFileName) + { + return UE::FixHeaderCheckSumW((wchar_t*)szFileName); + } + static long RealignPEEx(const wchar_t* szFileName, DWORD RealingFileSize, DWORD ForcedFileAlignment) + { + return UE::RealignPEExW((wchar_t*)szFileName, RealingFileSize, ForcedFileAlignment); + } + static bool WipeSection(const wchar_t* szFileName, int WipeSectionNumber, bool RemovePhysically) + { + return UE::WipeSectionW((wchar_t*)szFileName, WipeSectionNumber, RemovePhysically); + } + static bool IsPE32FileValidEx(const wchar_t* szFileName, eCheckDepth CheckDepth, RealignerX::FILE_STATUS_INFO* FileStatusInfo) + { + return UE::IsPE32FileValidExW((wchar_t*)szFileName, CheckDepth, FileStatusInfo); + } + static bool FixBrokenPE32FileEx(const wchar_t* szFileName, const RealignerX::FILE_STATUS_INFO* FileStatusInfo, RealignerX::FILE_FIX_INFO* FileFixInfo) + { + return UE::FixBrokenPE32FileExW((wchar_t*)szFileName, (void*)FileStatusInfo, (void*)FileFixInfo); + } + static bool IsFileDLL(const wchar_t* szFileName, ULONG_PTR FileMapVA) + { + return UE::IsFileDLLW((wchar_t*)szFileName, FileMapVA); + } +}; + +class Realigner: RealignerX, RealignerA, RealignerW +{ +public: + + using RealignerX::FILE_STATUS_INFO; + using RealignerX::FILE_FIX_INFO; + + using RealignerA::FixHeaderCheckSum; + using RealignerW::FixHeaderCheckSum; + using RealignerX::RealignPE; + using RealignerA::RealignPEEx; + using RealignerW::RealignPEEx; + using RealignerA::WipeSection; + using RealignerW::WipeSection; + using RealignerA::IsPE32FileValidEx; + using RealignerW::IsPE32FileValidEx; + using RealignerA::FixBrokenPE32FileEx; + using RealignerW::FixBrokenPE32FileEx; + using RealignerA::IsFileDLL; + using RealignerW::IsFileDLL; +}; + +class Hider +{ +public: + + static void* GetPEBLocation(HANDLE hProcess) + { + return UE::GetPEBLocation(hProcess); + } + static void* GetPEBLocation64(HANDLE hProcess) + { + return UE::GetPEBLocation64(hProcess); + } + static void* GetTEBLocation(HANDLE hProcess) + { + return UE::GetTEBLocation(hProcess); + } + static void* GetTEBLocation64(HANDLE hProcess) + { + return UE::GetTEBLocation64(hProcess); + } + static bool HideDebugger(HANDLE hProcess, eHideLevel PatchAPILevel) + { + return UE::HideDebugger(hProcess, PatchAPILevel); + } + static bool UnHideDebugger(HANDLE hProcess, eHideLevel PatchAPILevel) + { + return UE::UnHideDebugger(hProcess, PatchAPILevel); + } +}; + +class RelocaterX +{ +protected: + + static void Cleanup() + { + UE::RelocaterCleanup(); + } + static void Init(DWORD MemorySize, ULONG_PTR OldImageBase, ULONG_PTR NewImageBase) + { + UE::RelocaterInit(MemorySize, OldImageBase, NewImageBase); + } + static void AddNewRelocation(HANDLE hProcess, ULONG_PTR RelocateAddress, DWORD RelocateState) + { + UE::RelocaterAddNewRelocation(hProcess, RelocateAddress, RelocateState); + } + static long EstimatedSize() + { + return UE::RelocaterEstimatedSize(); + } + static bool ExportRelocation(ULONG_PTR StorePlace, DWORD StorePlaceRVA, ULONG_PTR FileMapVA) + { + return UE::RelocaterExportRelocation(StorePlace, StorePlaceRVA, FileMapVA); + } + static bool GrabRelocationTable(HANDLE hProcess, ULONG_PTR MemoryStart, DWORD MemorySize) + { + return UE::RelocaterGrabRelocationTable(hProcess, MemoryStart, MemorySize); + } + static bool GrabRelocationTableEx(HANDLE hProcess, ULONG_PTR MemoryStart, ULONG_PTR MemorySize, DWORD NtSizeOfImage) + { + return UE::RelocaterGrabRelocationTableEx(hProcess, MemoryStart, MemorySize, NtSizeOfImage); + } + static bool RelocateMemoryBlock(ULONG_PTR FileMapVA, ULONG_PTR MemoryLocation, void* RelocateMemory, DWORD RelocateMemorySize, ULONG_PTR CurrentLoadedBase, ULONG_PTR RelocateBase) + { + return UE::RelocaterRelocateMemoryBlock(FileMapVA, MemoryLocation, RelocateMemory, RelocateMemorySize, CurrentLoadedBase, RelocateBase); + } +}; + +class RelocaterA +{ +public: + + static bool ExportRelocationEx(const char* szFileName, const char* szSectionName) + { + return UE::RelocaterExportRelocationEx((char*)szFileName, (char*)szSectionName); + } + static bool MakeSnapshot(HANDLE hProcess, const char* szSaveFileName, void* MemoryStart, ULONG_PTR MemorySize) + { + return UE::RelocaterMakeSnapshot(hProcess, (char*)szSaveFileName, MemoryStart, MemorySize); + } + static bool CompareTwoSnapshots(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, const char* szDumpFile1, const char* szDumpFile2, ULONG_PTR MemStart) + { + return UE::RelocaterCompareTwoSnapshots(hProcess, LoadedImageBase, NtSizeOfImage, (char*)szDumpFile1, (char*)szDumpFile2, MemStart); + } + static bool ChangeFileBase(const char* szFileName, ULONG_PTR NewImageBase) + { + return UE::RelocaterChangeFileBase((char*)szFileName, NewImageBase); + } + static bool WipeRelocationTable(const char* szFileName) + { + return UE::RelocaterWipeRelocationTable((char*)szFileName); + } +}; + +class RelocaterW +{ +public: + + static bool ExportRelocationEx(const wchar_t* szFileName, char* szSectionName) + { + return UE::RelocaterExportRelocationExW((wchar_t*)szFileName, (char*)szSectionName); + } + static bool MakeSnapshot(HANDLE hProcess, const wchar_t* szSaveFileName, void* MemoryStart, ULONG_PTR MemorySize) + { + return UE::RelocaterMakeSnapshotW(hProcess, (wchar_t*)szSaveFileName, MemoryStart, MemorySize); + } + static bool CompareTwoSnapshots(HANDLE hProcess, ULONG_PTR LoadedImageBase, ULONG_PTR NtSizeOfImage, const wchar_t* szDumpFile1, const wchar_t* szDumpFile2, ULONG_PTR MemStart) + { + return UE::RelocaterCompareTwoSnapshotsW(hProcess, LoadedImageBase, NtSizeOfImage, (wchar_t*)szDumpFile1, (wchar_t*)szDumpFile2, MemStart); + } + static bool ChangeFileBase(const wchar_t* szFileName, ULONG_PTR NewImageBase) + { + return UE::RelocaterChangeFileBaseW((wchar_t*)szFileName, NewImageBase); + } + static bool WipeRelocationTable(const wchar_t* szFileName) + { + return UE::RelocaterWipeRelocationTableW((wchar_t*)szFileName); + } +}; + +class Relocater : RelocaterX, RelocaterA, RelocaterW +{ +public: + + using RelocaterX::Cleanup; + using RelocaterX::Init; + using RelocaterX::AddNewRelocation; + using RelocaterX::EstimatedSize; + using RelocaterX::ExportRelocation; + using RelocaterA::ExportRelocationEx; + using RelocaterW::ExportRelocationEx; + using RelocaterX::GrabRelocationTable; + using RelocaterX::GrabRelocationTableEx; + using RelocaterA::MakeSnapshot; + using RelocaterW::MakeSnapshot; + using RelocaterA::CompareTwoSnapshots; + using RelocaterW::CompareTwoSnapshots; + using RelocaterA::ChangeFileBase; + using RelocaterW::ChangeFileBase; + using RelocaterX::RelocateMemoryBlock; + using RelocaterA::WipeRelocationTable; + using RelocaterW::WipeRelocationTable; +}; + +class ResourcerA; +class ResourcerW; + +class ResourcerX +{ + friend class ResourcerA; + friend class ResourcerW; + +protected: + + typedef void(TITCALL *fResourceEnumCallback)(const wchar_t* szResourceType, DWORD ResourceType, const wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, DWORD ResourceData, DWORD ResourceSize); + + static bool FreeLoadedFile(void* LoadedFileBase) + { + return UE::ResourcerFreeLoadedFile(LoadedFileBase); + } + static bool ExtractResourceFromFileEx(ULONG_PTR FileMapVA, char* szResourceType, char* szResourceName, char* szExtractedFileName) + { + return UE::ResourcerExtractResourceFromFileEx(FileMapVA, szResourceType, szResourceName, szExtractedFileName); + } + static bool FindResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, ULONG_PTR* pResourceData, DWORD* pResourceSize) + { + return UE::ResourcerFindResourceEx(FileMapVA, FileSize, szResourceType, ResourceType, szResourceName, ResourceName, ResourceLanguage, pResourceData, pResourceSize); + } + static void EnumerateResourceEx(ULONG_PTR FileMapVA, DWORD FileSize, fResourceEnumCallback CallBack) + { + UE::ResourcerEnumerateResourceEx(FileMapVA, FileSize, (void*)CallBack); + } +}; + +class ResourcerA +{ +public: + + static long long LoadFileForResourceUse(char* szFileName) + { + return UE::ResourcerLoadFileForResourceUse(szFileName); + } + static bool ExtractResourceFromFile(char* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName) + { + return UE::ResourcerExtractResourceFromFile(szFileName, szResourceType, szResourceName, szExtractedFileName); + } + static bool FindResource(char* szFileName, char* szResourceType, DWORD ResourceType, char* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, ULONG_PTR* pResourceData, DWORD* pResourceSize) + { + return UE::ResourcerFindResource(szFileName, szResourceType, ResourceType, szResourceName, ResourceName, ResourceLanguage, pResourceData, pResourceSize); + } + static void EnumerateResource(char* szFileName, ResourcerX::fResourceEnumCallback CallBack) + { + UE::ResourcerEnumerateResource(szFileName, (void*)CallBack); + } +}; + +class ResourcerW +{ +public: + + static long long LoadFileForResourceUse(wchar_t* szFileName) + { + return UE::ResourcerLoadFileForResourceUseW(szFileName); + } + static bool ExtractResourceFromFile(wchar_t* szFileName, char* szResourceType, char* szResourceName, char* szExtractedFileName) + { + return UE::ResourcerExtractResourceFromFileW(szFileName, szResourceType, szResourceName, szExtractedFileName); + } + static bool FindResource(wchar_t* szFileName, wchar_t* szResourceType, DWORD ResourceType, wchar_t* szResourceName, DWORD ResourceName, DWORD ResourceLanguage, ULONG_PTR* pResourceData, DWORD* pResourceSize) + { + return UE::ResourcerFindResourceW(szFileName, szResourceType, ResourceType, szResourceName, ResourceName, ResourceLanguage, pResourceData, pResourceSize); + } + static void EnumerateResource(wchar_t* szFileName, ResourcerX::fResourceEnumCallback CallBack) + { + UE::ResourcerEnumerateResourceW(szFileName, (void*)CallBack); + } +}; + +class Resourcer : ResourcerX, ResourcerA, ResourcerW +{ +public: + + using ResourcerX::fResourceEnumCallback; + + using ResourcerA::LoadFileForResourceUse; + using ResourcerW::LoadFileForResourceUse; + using ResourcerX::FreeLoadedFile; + using ResourcerX::ExtractResourceFromFileEx; + using ResourcerA::ExtractResourceFromFile; + using ResourcerW::ExtractResourceFromFile; + using ResourcerA::FindResource; + using ResourcerW::FindResource; + using ResourcerX::FindResourceEx; + using ResourcerA::EnumerateResource; + using ResourcerW::EnumerateResource; + using ResourcerX::EnumerateResourceEx; +}; + +class Threader +{ +public: + + typedef UE::THREAD_ITEM_DATA THREAD_ITEM_DATA; + + typedef void(TITCALL *fThreadEnumCallback)(const THREAD_ITEM_DATA* fThreadDetail); + typedef void(TITCALL *fThreadExitCallback)(const EXIT_THREAD_DEBUG_INFO* SpecialDBG); + + static bool ImportRunningThreadData(DWORD ProcessId) + { + return UE::ThreaderImportRunningThreadData(ProcessId); + } + static const THREAD_ITEM_DATA* GetThreadInfo(HANDLE hThread, DWORD ThreadId) + { + return (const THREAD_ITEM_DATA*)UE::ThreaderGetThreadInfo(hThread, ThreadId); + } + static void EnumThreadInfo(fThreadEnumCallback EnumCallBack) + { + UE::ThreaderEnumThreadInfo((void*)EnumCallBack); + } + static bool PauseThread(HANDLE hThread) + { + return UE::ThreaderPauseThread(hThread); + } + static bool ResumeThread(HANDLE hThread) + { + return UE::ThreaderResumeThread(hThread); + } + static bool TerminateThread(HANDLE hThread, DWORD ThreadExitCode) + { + return UE::ThreaderTerminateThread(hThread, ThreadExitCode); + } + static bool PauseAllThreads(bool LeaveMainRunning) + { + return UE::ThreaderPauseAllThreads(LeaveMainRunning); + } + static bool ResumeAllThreads(bool LeaveMainPaused) + { + return UE::ThreaderResumeAllThreads(LeaveMainPaused); + } + static bool PauseProcess() + { + return UE::ThreaderPauseProcess(); + } + static bool ResumeProcess() + { + return UE::ThreaderResumeProcess(); + } + static long long CreateRemoteThread(ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, void* ThreadPassParameter, DWORD* ThreadId) + { + return UE::ThreaderCreateRemoteThread(ThreadStartAddress, AutoCloseTheHandle, ThreadPassParameter, ThreadId); + } + static bool InjectAndExecuteCode(void* InjectCode, DWORD StartDelta, DWORD InjectSize) + { + return UE::ThreaderInjectAndExecuteCode(InjectCode, StartDelta, InjectSize); + } + static long long CreateRemoteThreadEx(HANDLE hProcess, ULONG_PTR ThreadStartAddress, bool AutoCloseTheHandle, void* ThreadPassParameter, DWORD* ThreadId) + { + return UE::ThreaderCreateRemoteThreadEx(hProcess, ThreadStartAddress, AutoCloseTheHandle, ThreadPassParameter, ThreadId); + } + static bool InjectAndExecuteCodeEx(HANDLE hProcess, void* InjectCode, DWORD StartDelta, DWORD InjectSize) + { + return UE::ThreaderInjectAndExecuteCodeEx(hProcess, InjectCode, StartDelta, InjectSize); + } + static void SetCallBackForNextExitThreadEvent(fThreadExitCallback exitThreadCallBack) + { + UE::ThreaderSetCallBackForNextExitThreadEvent((void*)exitThreadCallBack); + } + static bool IsThreadStillRunning(HANDLE hThread) + { + return UE::ThreaderIsThreadStillRunning(hThread); + } + static bool IsThreadActive(HANDLE hThread) + { + return UE::ThreaderIsThreadActive(hThread); + } + static bool IsAnyThreadActive() + { + return UE::ThreaderIsAnyThreadActive(); + } + static bool ExecuteOnlyInjectedThreads() + { + return UE::ThreaderExecuteOnlyInjectedThreads(); + } + static long long GetOpenHandleForThread(DWORD ThreadId) + { + return UE::ThreaderGetOpenHandleForThread(ThreadId); + } + static bool IsExceptionInMainThread() + { + return UE::ThreaderIsExceptionInMainThread(); + } +}; + +// -- + +class DebuggerA; +class DebuggerW; + +class DebuggerX +{ + friend class DebuggerA; + friend class DebuggerW; + +protected: + + typedef void (TITCALL *fBreakPointCallback)(); + typedef void (TITCALL *fCustomHandlerCallback)(const void* ExceptionData); + + static const char* StaticDisassembleEx(ULONG_PTR DisassmStart, const void* DisassmAddress) + { + return (const char*)UE::StaticDisassembleEx(DisassmStart, (void*)DisassmAddress); + } + static const char* StaticDisassemble(const void* DisassmAddress) + { + return (const char*)UE::StaticDisassemble((void*)DisassmAddress); + } + static const char* DisassembleEx(HANDLE hProcess, void* DisassmAddress, bool ReturnInstructionType) + { + return (const char*)UE::DisassembleEx(hProcess, DisassmAddress, ReturnInstructionType); + } + static const char* Disassemble(void* DisassmAddress) + { + return (const char*)UE::Disassemble(DisassmAddress); + } + static long StaticLengthDisassemble(const void* DisassmAddress) + { + return UE::StaticLengthDisassemble((void*)DisassmAddress); + } + static long LengthDisassembleEx(HANDLE hProcess, void* DisassmAddress) + { + return UE::LengthDisassembleEx(hProcess, DisassmAddress); + } + static long LengthDisassemble(void* DisassmAddress) + { + return UE::LengthDisassemble(DisassmAddress); + } + static bool StopDebug() + { + return UE::StopDebug(); + } + static void SetBPXOptions(long DefaultBreakPointType) + { + UE::SetBPXOptions(DefaultBreakPointType); + } + static bool IsBPXEnabled(ULONG_PTR bpxAddress) + { + return UE::IsBPXEnabled(bpxAddress); + } + static bool EnableBPX(ULONG_PTR bpxAddress) + { + return UE::EnableBPX(bpxAddress); + } + static bool DisableBPX(ULONG_PTR bpxAddress) + { + return UE::DisableBPX(bpxAddress); + } + static bool SetBPX(ULONG_PTR bpxAddress, eBPType bpxType, fBreakPointCallback bpxCallBack) + { + return UE::SetBPX(bpxAddress, bpxType, (void*)bpxCallBack); + } + static bool DeleteBPX(ULONG_PTR bpxAddress) + { + return UE::DeleteBPX(bpxAddress); + } + static bool SafeDeleteBPX(ULONG_PTR bpxAddress) + { + return UE::SafeDeleteBPX(bpxAddress); + } + static bool SetAPIBreakPoint(const char* szDLLName, const char* szAPIName, eBPType bpxType, eBPPlace bpxPlace, fBreakPointCallback bpxCallBack) + { + return UE::SetAPIBreakPoint(szDLLName, szAPIName, bpxType, bpxPlace, (void*)bpxCallBack); + } + static bool DeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, eBPPlace bpxPlace) + { + return UE::DeleteAPIBreakPoint(szDLLName, szAPIName, bpxPlace); + } + static bool SafeDeleteAPIBreakPoint(const char* szDLLName, const char* szAPIName, eBPPlace bpxPlace) + { + return UE::SafeDeleteAPIBreakPoint(szDLLName, szAPIName, bpxPlace); + } + static bool SetMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, fBreakPointCallback bpxCallBack) + { + return UE::SetMemoryBPX(MemoryStart, SizeOfMemory, (void*)bpxCallBack); + } + static bool SetMemoryBPXEx(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory, eMemoryBPType BreakPointType, bool RestoreOnHit, fBreakPointCallback bpxCallBack) + { + return UE::SetMemoryBPXEx(MemoryStart, SizeOfMemory, BreakPointType, RestoreOnHit, (void*)bpxCallBack); + } + static bool RemoveMemoryBPX(ULONG_PTR MemoryStart, SIZE_T SizeOfMemory) + { + return UE::RemoveMemoryBPX(MemoryStart, SizeOfMemory); + } +#ifdef _WIN64 + static bool GetContextFPUDataEx(HANDLE hActiveThread, XMM_SAVE_AREA32* FPUSaveArea) +#else + static bool GetContextFPUDataEx(HANDLE hActiveThread, FLOATING_SAVE_AREA* FPUSaveArea) +#endif + { + return UE::GetContextFPUDataEx(hActiveThread, FPUSaveArea); + } + static long long GetContextDataEx(HANDLE hActiveThread, eContextData IndexOfRegister) + { + return UE::GetContextDataEx(hActiveThread, IndexOfRegister); + } + static long long GetContextData(eContextData IndexOfRegister) + { + return UE::GetContextData(IndexOfRegister); + } +#ifdef _WIN64 + static bool SetContextFPUDataEx(HANDLE hActiveThread, const XMM_SAVE_AREA32* FPUSaveArea) +#else + static bool SetContextFPUDataEx(HANDLE hActiveThread, const FLOATING_SAVE_AREA* FPUSaveArea) +#endif + { + return UE::SetContextFPUDataEx(hActiveThread, (void*)FPUSaveArea); + } + static bool SetContextDataEx(HANDLE hActiveThread, eContextData IndexOfRegister, ULONG_PTR NewRegisterValue) + { + return UE::SetContextDataEx(hActiveThread, IndexOfRegister, NewRegisterValue); + } + static bool SetContextData(eContextData IndexOfRegister, ULONG_PTR NewRegisterValue) + { + return UE::SetContextData(IndexOfRegister, NewRegisterValue); + } + static void ClearExceptionNumber() + { + UE::ClearExceptionNumber(); + } + static long CurrentExceptionNumber() + { + return UE::CurrentExceptionNumber(); + } + static bool MatchPatternEx(HANDLE hProcess, void* MemoryToCheck, int SizeOfMemoryToCheck, const void* PatternToMatch, int SizeOfPatternToMatch, const BYTE* WildCard) + { + return UE::MatchPatternEx(hProcess, MemoryToCheck, SizeOfMemoryToCheck, (void*)PatternToMatch, SizeOfPatternToMatch, (BYTE*)WildCard); + } + static bool MatchPattern(void* MemoryToCheck, int SizeOfMemoryToCheck, const void* PatternToMatch, int SizeOfPatternToMatch, const BYTE* WildCard) + { + return UE::MatchPattern(MemoryToCheck, SizeOfMemoryToCheck, (void*)PatternToMatch, SizeOfPatternToMatch, (BYTE*)WildCard); + } + static long long FindEx(HANDLE hProcess, void* MemoryStart, DWORD MemorySize, const void* SearchPattern, DWORD PatternSize, const BYTE* WildCard) + { + return UE::FindEx(hProcess, MemoryStart, MemorySize, (void*)SearchPattern, PatternSize, (BYTE*)WildCard); + } + static long long Find(void* MemoryStart, DWORD MemorySize, const void* SearchPattern, DWORD PatternSize, const BYTE* WildCard) + { + return UE::Find(MemoryStart, MemorySize, (void*)SearchPattern, PatternSize, (BYTE*)WildCard); + } + static bool FillEx(HANDLE hProcess, void* MemoryStart, DWORD MemorySize, const BYTE* FillByte) + { + return UE::FillEx(hProcess, MemoryStart, MemorySize, (BYTE*)FillByte); + } + static bool Fill(void* MemoryStart, DWORD MemorySize, const BYTE* FillByte) + { + return UE::Fill(MemoryStart, MemorySize, (BYTE*)FillByte); + } + static bool PatchEx(HANDLE hProcess, void* MemoryStart, DWORD MemorySize, const void* ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP) + { + return UE::PatchEx(hProcess, MemoryStart, MemorySize, (void*)ReplacePattern, ReplaceSize, AppendNOP, PrependNOP); + } + static bool Patch(void* MemoryStart, DWORD MemorySize, const void* ReplacePattern, DWORD ReplaceSize, bool AppendNOP, bool PrependNOP) + { + return UE::Patch(MemoryStart, MemorySize, (void*)ReplacePattern, ReplaceSize, AppendNOP, PrependNOP); + } + static bool ReplaceEx(HANDLE hProcess, void* MemoryStart, DWORD MemorySize, const void* SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, const void* ReplacePattern, DWORD ReplaceSize, const BYTE* WildCard) + { + return UE::ReplaceEx(hProcess, MemoryStart, MemorySize, (void*)SearchPattern, PatternSize, NumberOfRepetitions, (void*)ReplacePattern, ReplaceSize, (BYTE*)WildCard); + } + static bool Replace(void* MemoryStart, DWORD MemorySize, const void* SearchPattern, DWORD PatternSize, DWORD NumberOfRepetitions, const void* ReplacePattern, DWORD ReplaceSize, const BYTE* WildCard) + { + return UE::Replace(MemoryStart, MemorySize, (void*)SearchPattern, PatternSize, NumberOfRepetitions, (void*)ReplacePattern, ReplaceSize, (BYTE*)WildCard); + } + static const DEBUG_EVENT* GetDebugData() + { + return (const DEBUG_EVENT*)UE::GetDebugData(); + } + static const DEBUG_EVENT* GetTerminationData() + { + return (const DEBUG_EVENT*)UE::GetTerminationData(); + } + static long GetExitCode() + { + return UE::GetExitCode(); + } + static long long GetDebuggedDLLBaseAddress() + { + return UE::GetDebuggedDLLBaseAddress(); + } + static long long GetDebuggedFileBaseAddress() + { + return UE::GetDebuggedFileBaseAddress(); + } + static bool GetRemoteString(HANDLE hProcess, void* StringAddress, void* StringStorage, int MaximumStringSize) + { + return UE::GetRemoteString(hProcess, StringAddress, StringStorage, MaximumStringSize); + } + static long long GetFunctionParameter(HANDLE hProcess, eFunctionType FunctionType, DWORD ParameterNumber, eParameterType ParameterType) + { + return UE::GetFunctionParameter(hProcess, FunctionType, ParameterNumber, ParameterType); + } + static long long GetJumpDestinationEx(HANDLE hProcess, ULONG_PTR InstructionAddress, bool JustJumps) + { + return UE::GetJumpDestinationEx(hProcess, InstructionAddress, JustJumps); + } + static long long GetJumpDestination(HANDLE hProcess, ULONG_PTR InstructionAddress) + { + return UE::GetJumpDestination(hProcess, InstructionAddress); + } + static bool IsJumpGoingToExecuteEx(HANDLE hProcess, HANDLE hThread, ULONG_PTR InstructionAddress, ULONG_PTR RegFlags) + { + return UE::IsJumpGoingToExecuteEx(hProcess, hThread, InstructionAddress, RegFlags); + } + static bool IsJumpGoingToExecute() + { + return UE::IsJumpGoingToExecute(); + } + static void SetCustomHandler(eCustomException ExceptionId, fCustomHandlerCallback CallBack) + { + UE::SetCustomHandler(ExceptionId, (void*)CallBack); + } + static void ForceClose() + { + UE::ForceClose(); + } + static void StepInto(fBreakPointCallback traceCallBack) + { + UE::StepInto((void*)traceCallBack); + } + static void StepOver(fBreakPointCallback traceCallBack) + { + UE::StepOver((void*)traceCallBack); + } + static void SingleStep(DWORD StepCount, fBreakPointCallback StepCallBack) + { + UE::SingleStep(StepCount, (void*)StepCallBack); + } + static bool GetUnusedHardwareBreakPointRegister(DWORD* RegisterIndex) + { + return UE::GetUnusedHardwareBreakPointRegister(RegisterIndex); + } + static bool SetHardwareBreakPointEx(HANDLE hActiveThread, ULONG_PTR bpxAddress, DWORD IndexOfRegister, eHWBPType bpxType, eHWBPSize bpxSize, fBreakPointCallback bpxCallBack, DWORD* IndexOfSelectedRegister) + { + return UE::SetHardwareBreakPointEx(hActiveThread, bpxAddress, IndexOfRegister, bpxType, bpxSize, (void*)bpxCallBack, IndexOfSelectedRegister); + } + static bool SetHardwareBreakPoint(ULONG_PTR bpxAddress, DWORD IndexOfRegister, eHWBPType bpxType, eHWBPSize bpxSize, fBreakPointCallback bpxCallBack) + { + return UE::SetHardwareBreakPoint(bpxAddress, IndexOfRegister, bpxType, bpxSize, (void*)bpxCallBack); + } + static bool DeleteHardwareBreakPoint(DWORD IndexOfRegister) + { + return UE::DeleteHardwareBreakPoint(IndexOfRegister); + } + static bool RemoveAllBreakPoints(eBPRemoveOption RemoveOption) + { + return UE::RemoveAllBreakPoints(RemoveOption); + } + static const PROCESS_INFORMATION* GetProcessInformation() + { + return (const PROCESS_INFORMATION*)UE::GetProcessInformation(); + } + static const STARTUPINFOW* GetStartupInformation() + { + return (const STARTUPINFOW*)UE::GetStartupInformation(); + } + static void DebugLoop() + { + UE::DebugLoop(); + } + static void SetDebugLoopTimeOut(DWORD TimeOut) + { + UE::SetDebugLoopTimeOut(TimeOut); + } + static void SetNextDbgContinueStatus(DWORD SetDbgCode) + { + UE::SetNextDbgContinueStatus(SetDbgCode); + } + static bool AttachDebugger(DWORD ProcessId, bool KillOnExit, PROCESS_INFORMATION* DebugInfo, fBreakPointCallback CallBack) + { + return UE::AttachDebugger(ProcessId, KillOnExit, DebugInfo, (void*)CallBack); + } + static bool DetachDebugger(DWORD ProcessId) + { + return UE::DetachDebugger(ProcessId); + } + static bool DetachDebuggerEx(DWORD ProcessId) + { + return UE::DetachDebuggerEx(ProcessId); + } + static void DebugLoopEx(DWORD TimeOut) + { + UE::DebugLoopEx(TimeOut); + } + static bool IsFileBeingDebugged() + { + return UE::IsFileBeingDebugged(); + } + static void SetErrorModel(bool DisplayErrorMessages) + { + UE::SetErrorModel(DisplayErrorMessages); + } +}; + +class DebuggerA +{ +public: + + static const PROCESS_INFORMATION* InitDebug(const char* szFileName, const char* szCommandLine, const char* szCurrentFolder) + { + return (const PROCESS_INFORMATION*)UE::InitDebug((char*)szFileName, (char*)szCommandLine, (char*)szCurrentFolder); + } + static const PROCESS_INFORMATION* InitDebugEx(const char* szFileName, const char* szCommandLine, const char* szCurrentFolder, DebuggerX::fBreakPointCallback EntryCallBack) + { + return (const PROCESS_INFORMATION*)UE::InitDebugEx((char*)szFileName, (char*)szCommandLine, (char*)szCurrentFolder, (void*)EntryCallBack); + } + static const PROCESS_INFORMATION* InitDLLDebug(const char* szFileName, bool ReserveModuleBase, const char* szCommandLine, const char* szCurrentFolder, DebuggerX::fBreakPointCallback EntryCallBack) + { + return (const PROCESS_INFORMATION*)UE::InitDLLDebug((char*)szFileName, ReserveModuleBase, (char*)szCommandLine, (char*)szCurrentFolder, (void*)EntryCallBack); + } + static void AutoDebugEx(const char* szFileName, bool ReserveModuleBase, const char* szCommandLine, const char* szCurrentFolder, DWORD TimeOut, DebuggerX::fBreakPointCallback EntryCallBack) + { + UE::AutoDebugEx((char*)szFileName, ReserveModuleBase, (char*)szCommandLine, (char*)szCurrentFolder, TimeOut, (void*)EntryCallBack); + } +}; + +class DebuggerW +{ +public: + + static const PROCESS_INFORMATION* InitDebug(const wchar_t* szFileName, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder) + { + return (const PROCESS_INFORMATION*)UE::InitDebugW((wchar_t*)szFileName, (wchar_t*)szCommandLine, (wchar_t*)szCurrentFolder); + } + static const PROCESS_INFORMATION* InitDebugEx(const wchar_t* szFileName, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder, DebuggerX::fBreakPointCallback EntryCallBack) + { + return (const PROCESS_INFORMATION*)UE::InitDebugExW((wchar_t*)szFileName, (wchar_t*)szCommandLine, (wchar_t*)szCurrentFolder, (void*)EntryCallBack); + } + static const PROCESS_INFORMATION* InitDLLDebug(const wchar_t* szFileName, bool ReserveModuleBase, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder, DebuggerX::fBreakPointCallback EntryCallBack) + { + return (const PROCESS_INFORMATION*)UE::InitDLLDebugW((wchar_t*)szFileName, ReserveModuleBase, (wchar_t*)szCommandLine, (wchar_t*)szCurrentFolder, (void*)EntryCallBack); + } + static void AutoDebugEx(const wchar_t* szFileName, bool ReserveModuleBase, const wchar_t* szCommandLine, const wchar_t* szCurrentFolder, DWORD TimeOut, DebuggerX::fBreakPointCallback EntryCallBack) + { + UE::AutoDebugExW((wchar_t*)szFileName, ReserveModuleBase, (wchar_t*)szCommandLine, (wchar_t*)szCurrentFolder, TimeOut, (void*)EntryCallBack); + } +}; + +class Debugger : DebuggerX, DebuggerA, DebuggerW +{ +public: + + using DebuggerX::fBreakPointCallback; + using DebuggerX::fCustomHandlerCallback; + + using DebuggerX::StaticDisassembleEx; + using DebuggerX::StaticDisassemble; + using DebuggerX::DisassembleEx; + using DebuggerX::Disassemble; + using DebuggerX::StaticLengthDisassemble; + using DebuggerX::LengthDisassembleEx; + using DebuggerX::LengthDisassemble; + using DebuggerA::InitDebug; + using DebuggerW::InitDebug; + using DebuggerA::InitDebugEx; + using DebuggerW::InitDebugEx; + using DebuggerA::InitDLLDebug; + using DebuggerW::InitDLLDebug; + using DebuggerX::StopDebug; + using DebuggerX::SetBPXOptions; + using DebuggerX::IsBPXEnabled; + using DebuggerX::EnableBPX; + using DebuggerX::DisableBPX; + using DebuggerX::SetBPX; + using DebuggerX::DeleteBPX; + using DebuggerX::SafeDeleteBPX; + using DebuggerX::SetAPIBreakPoint; + using DebuggerX::DeleteAPIBreakPoint; + using DebuggerX::SafeDeleteAPIBreakPoint; + using DebuggerX::SetMemoryBPX; + using DebuggerX::SetMemoryBPXEx; + using DebuggerX::RemoveMemoryBPX; + using DebuggerX::GetContextFPUDataEx; + using DebuggerX::GetContextDataEx; + using DebuggerX::GetContextData; + using DebuggerX::SetContextFPUDataEx; + using DebuggerX::SetContextDataEx; + using DebuggerX::SetContextData; + using DebuggerX::ClearExceptionNumber; + using DebuggerX::CurrentExceptionNumber; + using DebuggerX::MatchPatternEx; + using DebuggerX::MatchPattern; + using DebuggerX::FindEx; + using DebuggerX::Find; + using DebuggerX::FillEx; + using DebuggerX::Fill; + using DebuggerX::PatchEx; + using DebuggerX::Patch; + using DebuggerX::ReplaceEx; + using DebuggerX::Replace; + using DebuggerX::GetDebugData; + using DebuggerX::GetTerminationData; + using DebuggerX::GetExitCode; + using DebuggerX::GetDebuggedDLLBaseAddress; + using DebuggerX::GetDebuggedFileBaseAddress; + using DebuggerX::GetRemoteString; + using DebuggerX::GetFunctionParameter; + using DebuggerX::GetJumpDestinationEx; + using DebuggerX::GetJumpDestination; + using DebuggerX::IsJumpGoingToExecuteEx; + using DebuggerX::IsJumpGoingToExecute; + using DebuggerX::SetCustomHandler; + using DebuggerX::ForceClose; + using DebuggerX::StepInto; + using DebuggerX::StepOver; + using DebuggerX::SingleStep; + using DebuggerX::GetUnusedHardwareBreakPointRegister; + using DebuggerX::SetHardwareBreakPointEx; + using DebuggerX::SetHardwareBreakPoint; + using DebuggerX::DeleteHardwareBreakPoint; + using DebuggerX::RemoveAllBreakPoints; + using DebuggerX::GetProcessInformation; + using DebuggerX::GetStartupInformation; + using DebuggerX::DebugLoop; + using DebuggerX::SetDebugLoopTimeOut; + using DebuggerX::SetNextDbgContinueStatus; + using DebuggerX::AttachDebugger; + using DebuggerX::DetachDebugger; + using DebuggerX::DetachDebuggerEx; + using DebuggerX::DebugLoopEx; + using DebuggerA::AutoDebugEx; + using DebuggerW::AutoDebugEx; + using DebuggerX::IsFileBeingDebugged; + using DebuggerX::SetErrorModel; +}; + +class FindOEPX +{ +protected: + + static void Init() + { + return UE::FindOEPInit(); + } +}; + +class FindOEPA +{ +public: + + static bool Generically(char* szFileName, Debugger::fBreakPointCallback TraceInitCallBack, Debugger::fBreakPointCallback CallBack) + { + return UE::FindOEPGenerically(szFileName, (void*)TraceInitCallBack, (void*)CallBack); + } +}; + +class FindOEPW +{ +public: + + static bool Generically(wchar_t* szFileName, Debugger::fBreakPointCallback TraceInitCallBack, Debugger::fBreakPointCallback CallBack) + { + return UE::FindOEPGenericallyW(szFileName, (void*)TraceInitCallBack, (void*)CallBack); + } +}; + +class FindOEP : FindOEPX, FindOEPA, FindOEPW +{ +public: + + using FindOEPX::Init; + using FindOEPA::Generically; + using FindOEPW::Generically; +}; + +class ImporterA; +class ImporterW; + +class ImporterX +{ + friend class ImporterA; + friend class ImporterW; + +public: + + typedef UE::ImportEnumData ImportEnumData; + +protected: + + typedef void (TITCALL *fImportEnumCallBack)(void* ptrImportEnumData); + typedef void* (TITCALL *fImportFixCallback)(void* fIATPointer); + + static void AddNewDll(const char* szDLLName, ULONG_PTR FirstThunk) + { + UE::ImporterAddNewDll((char*)szDLLName, FirstThunk); + } + static void AddNewAPI(const char* szAPIName, ULONG_PTR ThunkValue) + { + UE::ImporterAddNewAPI((char*)szAPIName, ThunkValue); + } + static void AddNewOrdinalAPI(ULONG_PTR OrdinalNumber, ULONG_PTR ThunkValue) + { + UE::ImporterAddNewOrdinalAPI(OrdinalNumber, ThunkValue); + } + static long GetAddedDllCount() + { + return UE::ImporterGetAddedDllCount(); + } + static long GetAddedAPICount() + { + return UE::ImporterGetAddedAPICount(); + } + static bool ExportIAT(ULONG_PTR StorePlace, ULONG_PTR FileMapVA, HANDLE hFileMap) + { + return UE::ImporterExportIAT(StorePlace, FileMapVA, hFileMap); + } + static long EstimatedSize() + { + return UE::ImporterEstimatedSize(); + } + static long long FindAPIWriteLocation(const char* szAPIName) + { + return UE::ImporterFindAPIWriteLocation((char*)szAPIName); + } + static long long FindOrdinalAPIWriteLocation(ULONG_PTR OrdinalNumber) + { + return UE::ImporterFindOrdinalAPIWriteLocation(OrdinalNumber); + } + static long long FindAPIByWriteLocation(ULONG_PTR APIWriteLocation) + { + return UE::ImporterFindAPIByWriteLocation(APIWriteLocation); + } + static long long FindDLLByWriteLocation(ULONG_PTR APIWriteLocation) + { + return UE::ImporterFindDLLByWriteLocation(APIWriteLocation); + } + static const char* GetDLLName(ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetDLLName(APIAddress); + } + static const char* GetAPIName(ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetAPIName(APIAddress); + } + static long long GetAPIOrdinalNumber(ULONG_PTR APIAddress) + { + return UE::ImporterGetAPIOrdinalNumber(APIAddress); + } + static const char* GetAPINameEx(ULONG_PTR APIAddress, const HMODULE* DLLBasesList) + { + return (const char*)UE::ImporterGetAPINameEx(APIAddress, (ULONG_PTR)DLLBasesList); + } + static long long GetRemoteAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterGetRemoteAPIAddress(hProcess, APIAddress); + } + static long long GetRemoteAPIAddressEx(const char* szDLLName, const char* szAPIName) + { + return UE::ImporterGetRemoteAPIAddressEx((char*)szDLLName, (char*)szAPIName); + } + static long long GetLocalAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterGetLocalAPIAddress(hProcess, APIAddress); + } + static const char* GetDLLNameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetDLLNameFromDebugee(hProcess, APIAddress); + } + static const char* GetAPINameFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetAPINameFromDebugee(hProcess, APIAddress); + } + static long long GetAPIOrdinalNumberFromDebugee(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterGetAPIOrdinalNumberFromDebugee(hProcess, APIAddress); + } + static long GetDLLIndexEx(ULONG_PTR APIAddress, const HMODULE* DLLBasesList) + { + return UE::ImporterGetDLLIndexEx(APIAddress, (ULONG_PTR)DLLBasesList); + } + static long GetDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, const HMODULE* DLLBasesList) + { + return UE::ImporterGetDLLIndex(hProcess, APIAddress, (ULONG_PTR)DLLBasesList); + } + static long long GetRemoteDLLBase(HANDLE hProcess, HMODULE LocalModuleBase) + { + return UE::ImporterGetRemoteDLLBase(hProcess, LocalModuleBase); + } + static bool IsForwardedAPI(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterIsForwardedAPI(hProcess, APIAddress); + } + static const char* GetForwardedAPIName(HANDLE hProcess, ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetForwardedAPIName(hProcess, APIAddress); + } + static const char* GetForwardedDLLName(HANDLE hProcess, ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetForwardedDLLName(hProcess, APIAddress); + } + static long GetForwardedDLLIndex(HANDLE hProcess, ULONG_PTR APIAddress, const HMODULE* DLLBasesList) + { + return UE::ImporterGetForwardedDLLIndex(hProcess, APIAddress, (ULONG_PTR)DLLBasesList); + } + static long long GetForwardedAPIOrdinalNumber(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterGetForwardedAPIOrdinalNumber(hProcess, APIAddress); + } + static long long GetNearestAPIAddress(HANDLE hProcess, ULONG_PTR APIAddress) + { + return UE::ImporterGetNearestAPIAddress(hProcess, APIAddress); + } + static const char* GetNearestAPIName(HANDLE hProcess, ULONG_PTR APIAddress) + { + return (const char*)UE::ImporterGetNearestAPIName(hProcess, APIAddress); + } + static void AutoSearchIATEx(DWORD ProcessId, ULONG_PTR ImageBase, ULONG_PTR SearchStart, ULONG_PTR* pIATStart, ULONG_PTR* pIATSize) + { + UE::ImporterAutoSearchIATEx(ProcessId, ImageBase, SearchStart, pIATStart, pIATSize); + } + static void EnumAddedData(fImportEnumCallBack EnumCallBack) + { + UE::ImporterEnumAddedData((void*)EnumCallBack); + } + static bool DeleteAPI(DWORD_PTR apiAddr) + { + return UE::ImporterDeleteAPI(apiAddr); + } +}; + +class ImporterA +{ +public: + + static bool ExportIATEx(const char* szDumpFileName, const char* szExportFileName, const char* szSectionName) + { + return UE::ImporterExportIATEx((char*)szDumpFileName, (char*)szExportFileName, (char*)szSectionName); + } + static bool CopyOriginalIAT(const char* szOriginalFile, const char* szDumpFile) + { + return UE::ImporterCopyOriginalIAT((char*)szOriginalFile, (char*)szDumpFile); + } + static bool LoadImportTable(const char* szFileName) + { + return UE::ImporterLoadImportTable((char*)szFileName); + } + static bool MoveOriginalIAT(const char* szOriginalFile, const char* szDumpFile, const char* szSectionName) + { + return UE::ImporterMoveOriginalIAT((char*)szOriginalFile, (char*)szDumpFile, (char*)szSectionName); + } + static void AutoSearchIAT(DWORD ProcessId, char* szFileName, ULONG_PTR SearchStart, LPVOID pIATStart, LPVOID pIATSize) + { + UE::ImporterAutoSearchIAT(ProcessId, (char*)szFileName, SearchStart, pIATStart, pIATSize); + } + static long AutoFixIATEx(DWORD ProcessId, const char* szDumpedFile, const char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, DWORD SearchSize, DWORD SearchStep, bool TryAutoFix, bool FixEliminations, ImporterX::fImportFixCallback UnknownPointerFixCallback) + { + return UE::ImporterAutoFixIATEx(ProcessId, (char*)szDumpedFile, (char*)szSectionName, DumpRunningProcess, RealignFile, EntryPointAddress, ImageBase, SearchStart, TryAutoFix, FixEliminations, (void*)UnknownPointerFixCallback); + } + static long AutoFixIAT(DWORD ProcessId, const char* szDumpedFile, ULONG_PTR SearchStart) + { + return UE::ImporterAutoFixIAT(ProcessId, (char*)szDumpedFile, SearchStart); + } +}; + +class ImporterW +{ +public: + + static bool ExportIATEx(const wchar_t* szDumpFileName, const wchar_t* szExportFileName, const wchar_t* szSectionName) + { + return UE::ImporterExportIATExW((wchar_t*)szDumpFileName, (wchar_t*)szExportFileName, (wchar_t*)szSectionName); + } + static bool CopyOriginalIAT(const wchar_t* szOriginalFile, const wchar_t* szDumpFile) + { + return UE::ImporterCopyOriginalIATW((wchar_t*)szOriginalFile, (wchar_t*)szDumpFile); + } + static bool LoadImportTable(const wchar_t* szFileName) + { + return UE::ImporterLoadImportTableW((wchar_t*)szFileName); + } + static bool MoveOriginalIAT(const wchar_t* szOriginalFile, const wchar_t* szDumpFile, const char* szSectionName) + { + return UE::ImporterMoveOriginalIATW((wchar_t*)szOriginalFile, (wchar_t*)szDumpFile, (char*)szSectionName); + } + static void AutoSearchIAT(DWORD ProcessId, const wchar_t* szFileName, ULONG_PTR SearchStart, ULONG_PTR* pIATStart, ULONG_PTR* pIATSize) + { + UE::ImporterAutoSearchIATW(ProcessId, (wchar_t*)szFileName, SearchStart, pIATStart, pIATSize); + } + static long AutoFixIATEx(DWORD ProcessId, const wchar_t* szDumpedFile, const char* szSectionName, bool DumpRunningProcess, bool RealignFile, ULONG_PTR EntryPointAddress, ULONG_PTR ImageBase, ULONG_PTR SearchStart, bool TryAutoFix, bool FixEliminations, ImporterX::fImportFixCallback UnknownPointerFixCallback) + { + return UE::ImporterAutoFixIATExW(ProcessId, (wchar_t*)szDumpedFile, (char*)szSectionName, DumpRunningProcess, RealignFile, EntryPointAddress, ImageBase, SearchStart, TryAutoFix, FixEliminations, (void*)UnknownPointerFixCallback); + } + static long AutoFixIAT(DWORD ProcessId, const wchar_t* szDumpedFile, ULONG_PTR SearchStart) + { + return UE::ImporterAutoFixIATW(ProcessId, (wchar_t*)szDumpedFile, SearchStart); + } +}; + +class Importer : public ImporterX, ImporterA, ImporterW +{ +public: + + using ImporterX::fImportEnumCallBack; + using ImporterX::fImportFixCallback; + + using ImporterX::AddNewDll; + using ImporterX::AddNewAPI; + using ImporterX::AddNewOrdinalAPI; + using ImporterX::GetAddedDllCount; + using ImporterX::GetAddedAPICount; + using ImporterX::ExportIAT; + using ImporterX::EstimatedSize; + using ImporterA::ExportIATEx; + using ImporterW::ExportIATEx; + using ImporterX::FindAPIWriteLocation; + using ImporterX::FindOrdinalAPIWriteLocation; + using ImporterX::FindAPIByWriteLocation; + using ImporterX::FindDLLByWriteLocation; + using ImporterX::GetDLLName; + using ImporterX::GetAPIName; + using ImporterX::GetAPIOrdinalNumber; + using ImporterX::GetAPINameEx; + using ImporterX::GetRemoteAPIAddress; + using ImporterX::GetRemoteAPIAddressEx; + using ImporterX::GetLocalAPIAddress; + using ImporterX::GetDLLNameFromDebugee; + using ImporterX::GetAPINameFromDebugee; + using ImporterX::GetAPIOrdinalNumberFromDebugee; + using ImporterX::GetDLLIndexEx; + using ImporterX::GetDLLIndex; + using ImporterX::GetRemoteDLLBase; + using ImporterX::IsForwardedAPI; + using ImporterX::GetForwardedAPIName; + using ImporterX::GetForwardedDLLName; + using ImporterX::GetForwardedDLLIndex; + using ImporterX::GetForwardedAPIOrdinalNumber; + using ImporterX::GetNearestAPIAddress; + using ImporterX::GetNearestAPIName; + using ImporterA::CopyOriginalIAT; + using ImporterW::CopyOriginalIAT; + using ImporterA::LoadImportTable; + using ImporterW::LoadImportTable; + using ImporterA::MoveOriginalIAT; + using ImporterW::MoveOriginalIAT; + using ImporterA::AutoSearchIAT; + using ImporterW::AutoSearchIAT; + using ImporterX::AutoSearchIATEx; + using ImporterX::EnumAddedData; + using ImporterX::DeleteAPI; + using ImporterA::AutoFixIATEx; + using ImporterW::AutoFixIATEx; + using ImporterA::AutoFixIAT; + using ImporterW::AutoFixIAT; +}; + +// --- + +class LibrarianX +{ +protected: + + typedef void (TITCALL *fLibraryBreakPointCallback)(const LOAD_DLL_DEBUG_INFO* SpecialDBG); + + static bool SetBreakPoint(const char* szLibraryName, eLibraryEvent bpxType, bool SingleShoot, fLibraryBreakPointCallback bpxCallBack) + { + return UE::LibrarianSetBreakPoint((char*)szLibraryName, bpxType, SingleShoot, (void*)bpxCallBack); + } + static bool RemoveBreakPoint(const char* szLibraryName, eLibraryEvent bpxType) + { + return UE::LibrarianRemoveBreakPoint((char*)szLibraryName, bpxType); + } +}; + +class LibrarianA +{ +public: + + typedef UE::LIBRARY_ITEM_DATA LIBRARY_ITEM_DATA; + + typedef void (TITCALL *fLibraryEnumCallback)(const LIBRARY_ITEM_DATA* fLibraryDetail); + + static const LIBRARY_ITEM_DATA* GetLibraryInfo(const char* szLibraryName) + { + return (const LIBRARY_ITEM_DATA*)UE::LibrarianGetLibraryInfo((char*)szLibraryName); + } + static const LIBRARY_ITEM_DATA* GetLibraryInfoEx(void* BaseOfDll) + { + return (const LIBRARY_ITEM_DATA*)UE::LibrarianGetLibraryInfoEx(BaseOfDll); + } + static void EnumLibraryInfo(fLibraryEnumCallback EnumCallBack) + { + UE::LibrarianEnumLibraryInfo((void*)EnumCallBack); + } +}; + +class LibrarianW +{ +public: + + typedef UE::LIBRARY_ITEM_DATAW LIBRARY_ITEM_DATA; + + typedef void (TITCALL *fLibraryEnumCallback)(const LIBRARY_ITEM_DATA* fLibraryDetail); + + static const LIBRARY_ITEM_DATA* GetLibraryInfo(const wchar_t* szLibraryName) + { + return (const LIBRARY_ITEM_DATA*)UE::LibrarianGetLibraryInfoW((wchar_t*)szLibraryName); + } + static const LIBRARY_ITEM_DATA* GetLibraryInfoEx(void* BaseOfDll) + { + return (const LIBRARY_ITEM_DATA*)UE::LibrarianGetLibraryInfoExW(BaseOfDll); + } + static void EnumLibraryInfo(fLibraryEnumCallback EnumCallBack) + { + UE::LibrarianEnumLibraryInfoW((void*)EnumCallBack); + } +}; + +class Librarian : LibrarianX, LibrarianA, LibrarianW +{ +public: + +#ifndef UNICODE + typedef LibrarianA::LIBRARY_ITEM_DATA LIBRARY_ITEM_DATA; +#else + typedef LibrarianW::LIBRARY_ITEM_DATA LIBRARY_ITEM_DATA; +#endif + + using LibrarianX::fLibraryBreakPointCallback; +#ifndef UNICODE + typedef LibrarianA::fLibraryEnumCallback fLibraryEnumCallback; +#else + typedef LibrarianW::fLibraryEnumCallback fLibraryEnumCallback; +#endif + + using LibrarianX::SetBreakPoint; + using LibrarianX::RemoveBreakPoint; + using LibrarianA::GetLibraryInfo; + using LibrarianW::GetLibraryInfo; +#ifndef UNICODE + using LibrarianA::GetLibraryInfoEx; +#else + using LibrarianW::GetLibraryInfoEx; +#endif + using LibrarianA::EnumLibraryInfo; + using LibrarianW::EnumLibraryInfo; +}; + +class Hooks +{ +public: + + typedef UE::HOOK_ENTRY HOOK_ENTRY; + + typedef bool(TITCALL *fHookEnumCallBack)(const HOOK_ENTRY* HookDetails, void* ptrOriginalInstructions, const LibrarianA::LIBRARY_ITEM_DATA* ModuleInformation, DWORD SizeOfImage); + + static bool SafeTransitionEx(void** HookAddressArray, int NumberOfHooks, bool TransitionStart) + { + return UE::HooksSafeTransitionEx(HookAddressArray, NumberOfHooks, TransitionStart); + } + static bool SafeTransition(void* HookAddress, bool TransitionStart) + { + return UE::HooksSafeTransition(HookAddress, TransitionStart); + } + static bool IsAddressRedirected(void* HookAddress) + { + return UE::HooksIsAddressRedirected(HookAddress); + } + static void* GetTrampolineAddress(void* HookAddress) + { + return UE::HooksGetTrampolineAddress(HookAddress); + } + static HOOK_ENTRY* GetHookEntryDetails(void* HookAddress) + { + return (HOOK_ENTRY*)UE::HooksGetHookEntryDetails(HookAddress); + } + static bool InsertNewRedirection(void* HookAddress, void* RedirectTo, eHookType HookType) + { + return UE::HooksInsertNewRedirection(HookAddress, RedirectTo, HookType); + } + static bool InsertNewIATRedirectionEx(ULONG_PTR FileMapVA, ULONG_PTR LoadedModuleBase, char* szHookFunction, void* RedirectTo) + { + return UE::HooksInsertNewIATRedirectionEx(FileMapVA, LoadedModuleBase, szHookFunction, RedirectTo); + } + static bool InsertNewIATRedirection(char* szModuleName, char* szHookFunction, void* RedirectTo) + { + return UE::HooksInsertNewIATRedirection(szModuleName, szHookFunction, RedirectTo); + } + static bool RemoveRedirection(void* HookAddress, bool RemoveAll) + { + return UE::HooksRemoveRedirection(HookAddress, RemoveAll); + } + static bool RemoveRedirectionsForModule(HMODULE ModuleBase) + { + return UE::HooksRemoveRedirectionsForModule(ModuleBase); + } + static bool RemoveIATRedirection(char* szModuleName, char* szHookFunction, bool RemoveAll) + { + return UE::HooksRemoveIATRedirection(szModuleName, szHookFunction, RemoveAll); + } + static bool DisableRedirection(void* HookAddress, bool DisableAll) + { + return UE::HooksDisableRedirection(HookAddress, DisableAll); + } + static bool DisableRedirectionsForModule(HMODULE ModuleBase) + { + return UE::HooksDisableRedirectionsForModule(ModuleBase); + } + static bool DisableIATRedirection(char* szModuleName, char* szHookFunction, bool DisableAll) + { + return UE::HooksDisableIATRedirection(szModuleName, szHookFunction, DisableAll); + } + static bool EnableRedirection(void* HookAddress, bool EnableAll) + { + return UE::HooksEnableRedirection(HookAddress, EnableAll); + } + static bool EnableRedirectionsForModule(HMODULE ModuleBase) + { + return UE::HooksEnableRedirectionsForModule(ModuleBase); + } + static bool EnableIATRedirection(char* szModuleName, char* szHookFunction, bool EnableAll) + { + return UE::HooksEnableIATRedirection(szModuleName, szHookFunction, EnableAll); + } + static void ScanModuleMemory(HMODULE ModuleBase, fHookEnumCallBack CallBack) + { + UE::HooksScanModuleMemory(ModuleBase, (void*)CallBack); + } + static void ScanEntireProcessMemory(fHookEnumCallBack CallBack) + { + UE::HooksScanEntireProcessMemory((void*)CallBack); + } + static void ScanEntireProcessMemoryEx() + { + UE::HooksScanEntireProcessMemoryEx(); + } +}; + +class Tracer +{ +public: + + static void Init() + { + UE::TracerInit(); + } + static long long Level1(HANDLE hProcess, ULONG_PTR AddressToTrace) + { + return UE::TracerLevel1(hProcess, AddressToTrace); + } + static long long HashTracerLevel1(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD InputNumberOfInstructions) + { + return UE::HashTracerLevel1(hProcess, AddressToTrace, InputNumberOfInstructions); + } + static long DetectRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace) + { + return UE::TracerDetectRedirection(hProcess, AddressToTrace); + } + static long long FixKnownRedirection(HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD RedirectionId) + { + return UE::TracerFixKnownRedirection(hProcess, AddressToTrace, RedirectionId); + } + static long long FixRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD IdParameter) + { + return UE::TracerFixRedirectionViaModule(hModuleHandle, hProcess, AddressToTrace, IdParameter); + } + static long long DetectRedirectionViaModule(HMODULE hModuleHandle, HANDLE hProcess, ULONG_PTR AddressToTrace, DWORD* ReturnedId) + { + return UE::TracerDetectRedirectionViaModule(hModuleHandle, hProcess, AddressToTrace, ReturnedId); + } + static long FixRedirectionViaImpRecPlugin(HANDLE hProcess, const char* szPluginName, ULONG_PTR AddressToTrace) + { + return UE::TracerFixRedirectionViaImpRecPlugin(hProcess, (char*)szPluginName, AddressToTrace); + } +}; + +class ExporterX +{ +protected: + + static void Cleanup() + { + UE::ExporterCleanup(); + } + static void SetImageBase(ULONG_PTR ImageBase) + { + UE::ExporterSetImageBase(ImageBase); + } + static void Init(DWORD MemorySize, ULONG_PTR ImageBase, DWORD ExportOrdinalBase, const char* szExportModuleName) + { + UE::ExporterInit(MemorySize, ImageBase, ExportOrdinalBase, (char*)szExportModuleName); + } + static bool AddNewExport(const char* szExportName, DWORD ExportRelativeAddress) + { + return UE::ExporterAddNewExport((char*)szExportName, ExportRelativeAddress); + } + static bool AddNewOrdinalExport(DWORD OrdinalNumber, DWORD ExportRelativeAddress) + { + return UE::ExporterAddNewOrdinalExport(OrdinalNumber, ExportRelativeAddress); + } + static long GetAddedExportCount() + { + return UE::ExporterGetAddedExportCount(); + } + static long EstimatedSize() + { + return UE::ExporterEstimatedSize(); + } + static bool BuildExportTable(ULONG_PTR StorePlace, ULONG_PTR FileMapVA) + { + return UE::ExporterBuildExportTable(StorePlace, FileMapVA); + } +}; + +class ExporterA +{ +public: + + static bool BuildExportTableEx(const char* szExportFileName, const char* szSectionName) + { + return UE::ExporterBuildExportTableEx((char*)szExportFileName, (char*)szSectionName); + } + static bool LoadExportTable(const char* szFileName) + { + return UE::ExporterLoadExportTable((char*)szFileName); + } +}; + +class ExporterW +{ +public: + + static bool BuildExportTableEx(const wchar_t* szExportFileName, const char* szSectionName) + { + return UE::ExporterBuildExportTableExW((wchar_t*)szExportFileName, (char*)szSectionName); + } + static bool LoadExportTable(const wchar_t* szFileName) + { + return UE::ExporterLoadExportTableW((wchar_t*)szFileName); + } +}; + +class Exporter : ExporterX, ExporterA, ExporterW +{ +public: + + using ExporterX::Cleanup; + using ExporterX::SetImageBase; + using ExporterX::Init; + using ExporterX::AddNewExport; + using ExporterX::AddNewOrdinalExport; + using ExporterX::GetAddedExportCount; + using ExporterX::EstimatedSize; + using ExporterX::BuildExportTable; + using ExporterA::BuildExportTableEx; + using ExporterW::BuildExportTableEx; + using ExporterA::LoadExportTable; + using ExporterW::LoadExportTable; +}; + +class ProcessX +{ +protected: + + typedef void(TITCALL *fProcessWithLibraryEnumCallback)(DWORD ProcessId, HMODULE ModuleBaseAddress); + + static void EnumProcessesWithLibrary(char* szLibraryName, fProcessWithLibraryEnumCallback EnumFunction) + { + UE::EnumProcessesWithLibrary(szLibraryName, (void*)EnumFunction); + } +}; + +class ProcessA +{ +public: + + static long GetActiveProcessId(char* szImageName) + { + return UE::GetActiveProcessId(szImageName); + } +}; + +class ProcessW +{ +public: + + static long GetActiveProcessId(wchar_t* szImageName) + { + return UE::GetActiveProcessIdW(szImageName); + } +}; + +class Process : ProcessX, ProcessA, ProcessW +{ +public: + + using ProcessX::fProcessWithLibraryEnumCallback; + + using ProcessA::GetActiveProcessId; + using ProcessW::GetActiveProcessId; + using ProcessX::EnumProcessesWithLibrary; +}; + +class TLSX +{ +protected: + + static bool BreakOnCallBack(const ULONG_PTR* ArrayOfCallBacks, DWORD NumberOfCallBacks, Debugger::fBreakPointCallback bpxCallBack) + { + return UE::TLSBreakOnCallBack((void*)ArrayOfCallBacks, NumberOfCallBacks, (void*)bpxCallBack); + } + static bool RestoreData() + { + return UE::TLSRestoreData(); + } + static bool BuildNewTable(ULONG_PTR FileMapVA, ULONG_PTR StorePlace, ULONG_PTR StorePlaceRVA, const ULONG_PTR* ArrayOfCallBacks, DWORD NumberOfCallBacks) + { + return UE::TLSBuildNewTable(FileMapVA, StorePlace, StorePlaceRVA, (void*)ArrayOfCallBacks, NumberOfCallBacks); + } +}; + +class TLSA +{ +public: + + static bool GrabCallBackData(const char* szFileName, ULONG_PTR* ArrayOfCallBacks, DWORD* NumberOfCallBacks) + { + return UE::TLSGrabCallBackData((char*)szFileName, (void*)ArrayOfCallBacks, NumberOfCallBacks); + } + static bool BreakOnCallBackEx(const char* szFileName, Debugger::fBreakPointCallback bpxCallBack) + { + return UE::TLSBreakOnCallBackEx((char*)szFileName, (void*)bpxCallBack); + } + static bool RemoveCallback(const char* szFileName) + { + return UE::TLSRemoveCallback((char*)szFileName); + } + static bool RemoveTable(const char* szFileName) + { + return UE::TLSRemoveTable((char*)szFileName); + } + static bool BackupData(const char* szFileName) + { + return UE::TLSBackupData((char*)szFileName); + } + static bool BuildNewTableEx(const char* szFileName, const char* szSectionName, const ULONG_PTR* ArrayOfCallBacks, DWORD NumberOfCallBacks) + { + return UE::TLSBuildNewTableEx((char*)szFileName, (char*)szSectionName, (void*)ArrayOfCallBacks, NumberOfCallBacks); + } +}; + +class TLSW +{ +public: + + static bool GrabCallBackData(const wchar_t* szFileName, ULONG_PTR* ArrayOfCallBacks, DWORD* NumberOfCallBacks) + { + return UE::TLSGrabCallBackDataW((wchar_t*)szFileName, (void*)ArrayOfCallBacks, NumberOfCallBacks); + } + static bool BreakOnCallBackEx(const wchar_t* szFileName, Debugger::fBreakPointCallback bpxCallBack) + { + return UE::TLSBreakOnCallBackExW((wchar_t*)szFileName, (void*)bpxCallBack); + } + static bool RemoveCallback(const wchar_t* szFileName) + { + return UE::TLSRemoveCallbackW((wchar_t*)szFileName); + } + static bool RemoveTable(const wchar_t* szFileName) + { + return UE::TLSRemoveTableW((wchar_t*)szFileName); + } + static bool BackupData(const wchar_t* szFileName) + { + return UE::TLSBackupDataW((wchar_t*)szFileName); + } + static bool BuildNewTableEx(const wchar_t* szFileName, const char* szSectionName, const ULONG_PTR* ArrayOfCallBacks, DWORD NumberOfCallBacks) + { + return UE::TLSBuildNewTableExW((wchar_t*)szFileName, (char*)szSectionName, (void*)ArrayOfCallBacks, NumberOfCallBacks); + } +}; + +class TLS : TLSX, TLSA, TLSW +{ +public: + + using TLSX::BreakOnCallBack; + using TLSA::GrabCallBackData; + using TLSW::GrabCallBackData; + using TLSA::BreakOnCallBackEx; + using TLSW::BreakOnCallBackEx; + using TLSA::RemoveCallback; + using TLSW::RemoveCallback; + using TLSA::RemoveTable; + using TLSW::RemoveTable; + using TLSA::BackupData; + using TLSW::BackupData; + using TLSX::RestoreData; + using TLSX::BuildNewTable; + using TLSA::BuildNewTableEx; + using TLSW::BuildNewTableEx; +}; + +class TranslateA +{ +public: + + static const char* NativeName(char* szNativeName) + { + return (const char*)UE::TranslateNativeName(szNativeName); + } +}; + +class TranslateW +{ +public: + + static const wchar_t* NativeName(wchar_t* szNativeName) + { + return (const wchar_t*)UE::TranslateNativeNameW(szNativeName); + } +}; + +class Translate : TranslateA, TranslateW +{ +public: + + using TranslateA::NativeName; + using TranslateW::NativeName; +}; + +class HandlerA; +class HandlerW; + +class HandlerX +{ + friend class HandlerA; + friend class HandlerW; + +protected: + + typedef UE::HandlerArray HandlerArray; + + static long GetActiveHandleCount(DWORD ProcessId) + { + return UE::HandlerGetActiveHandleCount(ProcessId); + } + static bool IsHandleOpen(DWORD ProcessId, HANDLE hHandle) + { + return UE::HandlerIsHandleOpen(ProcessId, hHandle); + } + static long EnumerateOpenHandles(DWORD ProcessId, HandlerArray* HandleBuffer, DWORD MaxHandleCount) + { + return UE::HandlerEnumerateOpenHandles(ProcessId, HandleBuffer, MaxHandleCount); + } + static long long GetHandleDetails(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, eHandlerReturnType InformationReturn) + { + return UE::HandlerGetHandleDetails(hProcess, ProcessId, hHandle, InformationReturn); + } + static bool CloseRemoteHandle(HANDLE hProcess, HANDLE hHandle) + { + return UE::HandlerCloseRemoteHandle(hProcess, hHandle); + } + static long EnumerateOpenMutexes(HANDLE hProcess, DWORD ProcessId, HANDLE* HandleBuffer, DWORD MaxHandleCount) + { + return UE::HandlerEnumerateOpenMutexes(hProcess, ProcessId, HandleBuffer, MaxHandleCount); + } +}; + +class HandlerA +{ +public: + + static const char* GetHandleName(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName) + { + return (const char*)UE::HandlerGetHandleName(hProcess, ProcessId, hHandle, TranslateName); + } + static long EnumerateLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, HandlerX::HandlerArray* HandleDataBuffer, DWORD MaxHandleCount) + { + return UE::HandlerEnumerateLockHandles(szFileOrFolderName, NameIsFolder, NameIsTranslated, HandleDataBuffer, MaxHandleCount); + } + static bool CloseAllLockHandles(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated) + { + return UE::HandlerCloseAllLockHandles(szFileOrFolderName, NameIsFolder, NameIsTranslated); + } + static bool IsFileLocked(char* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated) + { + return UE::HandlerIsFileLocked(szFileOrFolderName, NameIsFolder, NameIsTranslated); + } + static long long GetOpenMutexHandle(HANDLE hProcess, DWORD ProcessId, char* szMutexString) + { + return UE::HandlerGetOpenMutexHandle(hProcess, ProcessId, szMutexString); + } + static long GetProcessIdWhichCreatedMutex(char* szMutexString) + { + return UE::HandlerGetProcessIdWhichCreatedMutex(szMutexString); + } +}; + +class HandlerW +{ +public: + + static const wchar_t* GetHandleName(HANDLE hProcess, DWORD ProcessId, HANDLE hHandle, bool TranslateName) + { + return (const wchar_t*)UE::HandlerGetHandleNameW(hProcess, ProcessId, hHandle, TranslateName); + } + static long EnumerateLockHandles(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated, HandlerX::HandlerArray* HandleDataBuffer, DWORD MaxHandleCount) + { + return UE::HandlerEnumerateLockHandlesW(szFileOrFolderName, NameIsFolder, NameIsTranslated, HandleDataBuffer, MaxHandleCount); + } + static bool CloseAllLockHandles(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated) + { + return UE::HandlerCloseAllLockHandlesW(szFileOrFolderName, NameIsFolder, NameIsTranslated); + } + static bool IsFileLocked(wchar_t* szFileOrFolderName, bool NameIsFolder, bool NameIsTranslated) + { + return UE::HandlerIsFileLockedW(szFileOrFolderName, NameIsFolder, NameIsTranslated); + } + static long long GetOpenMutexHandle(HANDLE hProcess, DWORD ProcessId, wchar_t* szMutexString) + { + return UE::HandlerGetOpenMutexHandleW(hProcess, ProcessId, szMutexString); + } + static long GetProcessIdWhichCreatedMutex(wchar_t* szMutexString) + { + return UE::HandlerGetProcessIdWhichCreatedMutexW(szMutexString); + } +}; + +class Handler : HandlerX, HandlerA, HandlerW +{ +public: + + using HandlerX::HandlerArray; + + using HandlerX::GetActiveHandleCount; + using HandlerX::IsHandleOpen; +#ifndef UNICODE + using HandlerA::GetHandleName; +#else + using HandlerW::GetHandleName; +#endif + using HandlerX::EnumerateOpenHandles; + using HandlerX::GetHandleDetails; + using HandlerX::CloseRemoteHandle; + using HandlerA::EnumerateLockHandles; + using HandlerW::EnumerateLockHandles; + using HandlerA::CloseAllLockHandles; + using HandlerW::CloseAllLockHandles; + using HandlerA::IsFileLocked; + using HandlerW::IsFileLocked; + using HandlerX::EnumerateOpenMutexes; + using HandlerA::GetOpenMutexHandle; + using HandlerW::GetOpenMutexHandle; + using HandlerA::GetProcessIdWhichCreatedMutex; + using HandlerW::GetProcessIdWhichCreatedMutex; +}; + +class RemoteX +{ +protected: + + static bool ExitProcess(HANDLE hProcess, DWORD ExitCode) + { + return UE::RemoteExitProcess(hProcess, ExitCode); + } +}; + +class RemoteA +{ +public: + + static bool LoadLibrary(HANDLE hProcess, const char* szLibraryFile, bool WaitForThreadExit) + { + return UE::RemoteLoadLibrary(hProcess, (char*)szLibraryFile, WaitForThreadExit); + } + static bool FreeLibrary(HANDLE hProcess, HMODULE hModule, const char* szLibraryFile, bool WaitForThreadExit) + { + return UE::RemoteFreeLibrary(hProcess, hModule, (char*)szLibraryFile, WaitForThreadExit); + } +}; + +class RemoteW +{ +public: + + static bool LoadLibrary(HANDLE hProcess, const wchar_t* szLibraryFile, bool WaitForThreadExit) + { + return UE::RemoteLoadLibraryW(hProcess, (wchar_t*)szLibraryFile, WaitForThreadExit); + } + static bool FreeLibrary(HANDLE hProcess, HMODULE hModule, const wchar_t* szLibraryFile, bool WaitForThreadExit) + { + return UE::RemoteFreeLibraryW(hProcess, hModule, (wchar_t*)szLibraryFile, WaitForThreadExit); + } +}; + +class Remote : RemoteX, RemoteA, RemoteW +{ +public: + + using RemoteA::LoadLibrary; + using RemoteW::LoadLibrary; + using RemoteA::FreeLibrary; + using RemoteW::FreeLibrary; + using RemoteX::ExitProcess; +}; + +class StaticX +{ +protected: + + typedef bool (__stdcall *fStaticDecryptCallback)(void* sMemoryStart, int sKeySize); + + static bool FileGetContent(HANDLE FileHandle, DWORD FilePositionLow, const DWORD* FilePositionHigh, void* Buffer, DWORD Size) + { + return UE::StaticFileGetContent(FileHandle, FilePositionLow, (DWORD*)FilePositionHigh, Buffer, Size); + } + static void FileClose(HANDLE FileHandle) + { + UE::StaticFileClose(FileHandle); + } + static void MemoryDecrypt(void* MemoryStart, DWORD MemorySize, eDecryptionType DecryptionType, eDecryptionKeySize DecryptionKeySize, ULONG_PTR DecryptionKey) + { + UE::StaticMemoryDecrypt(MemoryStart, MemorySize, DecryptionType, DecryptionKeySize, DecryptionKey); + } + static void MemoryDecryptEx(void* MemoryStart, DWORD MemorySize, eDecryptionKeySize DecryptionKeySize, fStaticDecryptCallback DecryptionCallBack) + { + UE::StaticMemoryDecryptEx(MemoryStart, MemorySize, DecryptionKeySize, (void*)DecryptionCallBack); + } + static void MemoryDecryptSpecial(void* MemoryStart, DWORD MemorySize, eDecryptionKeySize DecryptionKeySize, eDecryptionDirection SpecDecryptionType, fStaticDecryptCallback DecryptionCallBack) + { + UE::StaticMemoryDecryptSpecial(MemoryStart, MemorySize, DecryptionKeySize, SpecDecryptionType, (void*)DecryptionCallBack); + } + static void SectionDecrypt(ULONG_PTR FileMapVA, DWORD SectionNumber, bool SimulateLoad, eDecryptionType DecryptionType, eDecryptionKeySize DecryptionKeySize, ULONG_PTR DecryptionKey) + { + UE::StaticSectionDecrypt(FileMapVA, SectionNumber, SimulateLoad, DecryptionType, DecryptionKeySize, DecryptionKey); + } + static bool MemoryDecompress(const void* Source, DWORD SourceSize, void* Destination, DWORD DestinationSize, eCompressionAlgorithm Algorithm) + { + return UE::StaticMemoryDecompress((void*)Source, SourceSize, Destination, DestinationSize, Algorithm); + } + static bool HashMemory(const void* MemoryToHash, DWORD SizeOfMemory, void* HashDigest, bool OutputString, eHashAlgorithm Algorithm) + { + return UE::StaticHashMemory((void*)MemoryToHash, SizeOfMemory, HashDigest, OutputString, Algorithm); + } +}; + +class StaticA +{ +public: + + static bool FileLoad(const char* szFileName, eAccess DesiredAccess, bool SimulateLoad, HANDLE* FileHandle, DWORD* LoadedSize, HANDLE* FileMap, ULONG_PTR* FileMapVA) + { + return UE::StaticFileLoad((char*)szFileName, DesiredAccess, SimulateLoad, FileHandle, LoadedSize, FileMap, FileMapVA); + } + static bool FileUnload(const char* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA) + { + return UE::StaticFileUnload((char*)szFileName, CommitChanges, FileHandle, LoadedSize, FileMap, FileMapVA); + } + static bool FileOpen(const char* szFileName, DWORD DesiredAccess, HANDLE* FileHandle, DWORD* FileSizeLow, DWORD* FileSizeHigh) + { + return UE::StaticFileOpen((char*)szFileName, DesiredAccess, FileHandle, FileSizeLow, FileSizeHigh); + } + static bool RawMemoryCopy(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, const char* szDumpFileName) + { + return UE::StaticRawMemoryCopy(hFile, FileMapVA, VitualAddressToCopy, Size, AddressIsRVA, (char*)szDumpFileName); + } + static bool RawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, const char* szDumpFileName) + { + return UE::StaticRawMemoryCopyEx(hFile, RawAddressToCopy, Size, (char*)szDumpFileName); + } + static bool RawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, const char* szDumpFileName) + { + return UE::StaticRawMemoryCopyEx64(hFile, RawAddressToCopy, Size, (char*)szDumpFileName); + } + static bool HashFile(const char* szFileName, void* HashDigest, bool OutputString, eHashAlgorithm Algorithm) + { + return UE::StaticHashFile((char*)szFileName, (char*)HashDigest, OutputString, Algorithm); + } +}; + +class StaticW +{ +public: + + static bool FileLoad(const wchar_t* szFileName, eAccess DesiredAccess, bool SimulateLoad, HANDLE* FileHandle, DWORD* LoadedSize, HANDLE* FileMap, ULONG_PTR* FileMapVA) + { + return UE::StaticFileLoadW((wchar_t*)szFileName, DesiredAccess, SimulateLoad, FileHandle, LoadedSize, FileMap, FileMapVA); + } + static bool FileUnload(const wchar_t* szFileName, bool CommitChanges, HANDLE FileHandle, DWORD LoadedSize, HANDLE FileMap, ULONG_PTR FileMapVA) + { + return UE::StaticFileUnloadW((wchar_t*)szFileName, CommitChanges, FileHandle, LoadedSize, FileMap, FileMapVA); + } + static bool FileOpen(const wchar_t* szFileName, DWORD DesiredAccess, HANDLE* FileHandle, DWORD* FileSizeLow, DWORD* FileSizeHigh) + { + return UE::StaticFileOpenW((wchar_t*)szFileName, DesiredAccess, FileHandle, FileSizeLow, FileSizeHigh); + } + static bool RawMemoryCopy(HANDLE hFile, ULONG_PTR FileMapVA, ULONG_PTR VitualAddressToCopy, DWORD Size, bool AddressIsRVA, const wchar_t* szDumpFileName) + { + return UE::StaticRawMemoryCopyW(hFile, FileMapVA, VitualAddressToCopy, Size, AddressIsRVA, (wchar_t*)szDumpFileName); + } + static bool RawMemoryCopyEx(HANDLE hFile, DWORD RawAddressToCopy, DWORD Size, const wchar_t* szDumpFileName) + { + return UE::StaticRawMemoryCopyExW(hFile, RawAddressToCopy, Size, (wchar_t*)szDumpFileName); + } + static bool RawMemoryCopyEx64(HANDLE hFile, DWORD64 RawAddressToCopy, DWORD64 Size, const wchar_t* szDumpFileName) + { + return UE::StaticRawMemoryCopyEx64W(hFile, RawAddressToCopy, Size, (wchar_t*)szDumpFileName); + } + static bool HashFile(const wchar_t* szFileName, void* HashDigest, bool OutputString, eHashAlgorithm Algorithm) + { + return UE::StaticHashFileW((wchar_t*)szFileName, (char*)HashDigest, OutputString, Algorithm); + } +}; + +class Static : StaticX, StaticA, StaticW +{ +public: + + using StaticX::fStaticDecryptCallback; + + using StaticA::FileLoad; + using StaticW::FileLoad; + using StaticA::FileUnload; + using StaticW::FileUnload; + using StaticA::FileOpen; + using StaticW::FileOpen; + using StaticX::FileGetContent; + using StaticX::FileClose; + using StaticX::MemoryDecrypt; + using StaticX::MemoryDecryptEx; + using StaticX::MemoryDecryptSpecial; + using StaticX::SectionDecrypt; + using StaticX::MemoryDecompress; + using StaticA::RawMemoryCopy; + using StaticW::RawMemoryCopy; + using StaticA::RawMemoryCopyEx; + using StaticW::RawMemoryCopyEx; + using StaticA::RawMemoryCopyEx64; + using StaticW::RawMemoryCopyEx64; + using StaticX::HashMemory; + using StaticA::HashFile; + using StaticW::HashFile; +}; + +class EngineX +{ +protected: + + static void SetEngineVariable(eEngineVariable VariableId, bool VariableSet) + { + UE::SetEngineVariable(VariableId, VariableSet); + } + static bool FakeMissingDependencies(HANDLE hProcess) + { + return UE::EngineFakeMissingDependencies(hProcess); + } + static bool DeleteCreatedDependencies() + { + return UE::EngineDeleteCreatedDependencies(); + } + static bool CreateUnpackerWindow(char* WindowUnpackerTitle, char* WindowUnpackerLongTitle, char* WindowUnpackerName, char* WindowUnpackerAuthor, void* StartUnpackingCallBack) + { + return UE::EngineCreateUnpackerWindow(WindowUnpackerTitle, WindowUnpackerLongTitle, WindowUnpackerName, WindowUnpackerAuthor, StartUnpackingCallBack); + } + static void AddUnpackerWindowLogMessage(char* szLogMessage) + { + return UE::EngineAddUnpackerWindowLogMessage(szLogMessage); + } +}; + +class EngineA +{ +public: + + static bool CreateMissingDependencies(char* szFileName, char* szOutputFolder, bool LogCreatedFiles) + { + return UE::EngineCreateMissingDependencies(szFileName, szOutputFolder, LogCreatedFiles); + } +}; + +class EngineW +{ +public: + + static bool CreateMissingDependencies(wchar_t* szFileName, wchar_t* szOutputFolder, bool LogCreatedFiles) + { + return UE::EngineCreateMissingDependenciesW(szFileName, szOutputFolder, LogCreatedFiles); + } +}; + +class Engine : EngineX, EngineA, EngineW +{ +public: + + using EngineX::SetEngineVariable; + using EngineA::CreateMissingDependencies; + using EngineW::CreateMissingDependencies; + using EngineX::FakeMissingDependencies; + using EngineX::DeleteCreatedDependencies; + using EngineX::CreateUnpackerWindow; + using EngineX::AddUnpackerWindowLogMessage; +}; + +class ExtensionManager +{ +public: + + typedef UE::PluginInformation PluginInformation; + + static bool IsPluginLoaded(char* szPluginName) + { + return UE::ExtensionManagerIsPluginLoaded(szPluginName); + } + static bool IsPluginEnabled(char* szPluginName) + { + return UE::ExtensionManagerIsPluginEnabled(szPluginName); + } + static bool DisableAllPlugins() + { + return UE::ExtensionManagerDisableAllPlugins(); + } + static bool DisablePlugin(char* szPluginName) + { + return UE::ExtensionManagerDisablePlugin(szPluginName); + } + static bool EnableAllPlugins() + { + return UE::ExtensionManagerEnableAllPlugins(); + } + static bool EnablePlugin(char* szPluginName) + { + return UE::ExtensionManagerEnablePlugin(szPluginName); + } + static bool UnloadAllPlugins() + { + return UE::ExtensionManagerUnloadAllPlugins(); + } + static bool UnloadPlugin(char* szPluginName) + { + return UE::ExtensionManagerUnloadPlugin(szPluginName); + } + static PluginInformation* GetPluginInfo(char* szPluginName) + { + return (PluginInformation*)UE::ExtensionManagerGetPluginInfo(szPluginName); + } +}; + +} /* namespace TE */ + +#endif /*TITANENGINE_CPP*/ diff --git a/TitanUnitTest/TitanEngine.lib b/TitanUnitTest/TitanEngine.lib new file mode 100644 index 0000000000000000000000000000000000000000..4b6174a5b30ae41aa0e9a1fc065f0534111e40aa GIT binary patch literal 101964 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 literal 0 HcmV?d00001 diff --git a/TitanUnitTest/TitanScript.h b/TitanUnitTest/TitanScript.h new file mode 100644 index 0000000..4eb75e2 --- /dev/null +++ b/TitanUnitTest/TitanScript.h @@ -0,0 +1,26 @@ +#ifndef TITANSCRIPT_H +#define TITANSCRIPT_H + +#if _MSC_VER > 1000 +//#pragma once +#endif + +#include + +enum eLogType {TS_LOG_NORMAL, TS_LOG_ERROR, TS_LOG_COMMAND, TS_LOG_DEBUG}; +typedef void(*fLogCallback)(const char* szString, eLogType Type); + +typedef bool (*tScripterLoadFileA)(const char*); +typedef bool (*tScripterLoadFileW)(const wchar_t*); +typedef bool (*tScripterLoadBuffer)(const char*); +typedef bool (*tScripterResume)(); +typedef bool (*tScripterPause)(); +typedef bool (*tScripterAutoDebugA)(const char*); +typedef bool (*tScripterAutoDebugW)(const wchar_t*); +typedef void (*tScripterSetLogCallback)(fLogCallback Callback); +typedef bool (*tScripterExecuteWithTitanMistA)(const char*, const char*); + +// use like this: tScripterResume foo = GetTSFunctionPointer(Resume); +#define GetTSFunctionPointer(x) ((tScripter ## x)GetProcAddress(GetModuleHandleA("TitanScript"), "Scripter" #x)) + +#endif /*TITANSCRIPT_H*/ diff --git a/TitanUnitTest/TitanScript.hpp b/TitanUnitTest/TitanScript.hpp new file mode 100644 index 0000000..3a0311d --- /dev/null +++ b/TitanUnitTest/TitanScript.hpp @@ -0,0 +1,122 @@ +#ifndef TITANSCRIPT_CPP +#define TITANSCRIPT_CPP + +#if _MSC_VER > 1000 + #pragma once +#endif + +namespace TS +{ + +namespace TSH +{ + #ifdef TITANSCRIPT_H + #undef TITANSCRIPT_H + #endif + + #include "TitanScript.h" +} + +typedef TSH::eLogType eLogType; + +class ScripterX +{ +protected: + + static TSH::tScripterLoadBuffer pLoadBuffer; + static TSH::tScripterResume pResume; + static TSH::tScripterPause pPause; + static TSH::tScripterSetLogCallback pSetLogCallback; + + typedef TSH::fLogCallback fLogCallback; + + //static bool Loaded; + + static bool LoadBuffer(const char* szScript) + { + return pLoadBuffer ? pLoadBuffer(szScript) : false; + } + static bool Resume() + { + return pResume ? pResume() : false; + } + static bool Pause() + { + return pPause ? pPause() : false; + } + static void SetLogCallback(fLogCallback Callback) + { + if(pSetLogCallback) pSetLogCallback(Callback); + } +}; + +class ScripterA +{ +private: + + static TSH::tScripterLoadFileA pLoadFile; + static TSH::tScripterAutoDebugA pAutoDebug; + +public: + + //static bool Loaded; + + static bool LoadFile(const char* szFileName) + { + return pLoadFile ? pLoadFile(szFileName) : false; + } + bool AutoDebug(const char* Debuggee) + { + return pAutoDebug ? pAutoDebug(Debuggee) : false; + } +}; + +class ScripterW +{ +private: + + static TSH::tScripterLoadFileW pLoadFile; + static TSH::tScripterAutoDebugW pAutoDebug; + +public: + + //static bool Loaded; + + static bool LoadFile(const wchar_t* szFileName) + { + return pLoadFile ? pLoadFile(szFileName) : false; + } + bool AutoDebug(const wchar_t* Debuggee) + { + return pAutoDebug ? pAutoDebug(Debuggee) : false; + } +}; + +class Scripter : ScripterX, ScripterA, ScripterW +{ +public: + + using ScripterX::fLogCallback; + + using ScripterA::LoadFile; + using ScripterW::LoadFile; + using ScripterX::LoadBuffer; + using ScripterX::Resume; + using ScripterX::Pause; + using ScripterA::AutoDebug; + using ScripterW::AutoDebug; + using ScripterX::SetLogCallback; +}; + +TSH::tScripterLoadFileA ScripterA::pLoadFile = GetTSFunctionPointer(LoadFileA); +TSH::tScripterLoadFileW ScripterW::pLoadFile = GetTSFunctionPointer(LoadFileW); +TSH::tScripterLoadBuffer ScripterX::pLoadBuffer = GetTSFunctionPointer(LoadBuffer); +TSH::tScripterResume ScripterX::pResume = GetTSFunctionPointer(Resume); +TSH::tScripterPause ScripterX::pPause = GetTSFunctionPointer(Pause); +TSH::tScripterAutoDebugA ScripterA::pAutoDebug = GetTSFunctionPointer(AutoDebugA); +TSH::tScripterAutoDebugW ScripterW::pAutoDebug = GetTSFunctionPointer(AutoDebugW); +TSH::tScripterSetLogCallback ScripterX::pSetLogCallback = GetTSFunctionPointer(SetLogCallback); + +} /* namespace TS */ + +#endif /*TITANSCRIPT_CPP*/ diff --git a/TitanUnitTest/TitanUnitTest.cpp b/TitanUnitTest/TitanUnitTest.cpp new file mode 100644 index 0000000..11c915a --- /dev/null +++ b/TitanUnitTest/TitanUnitTest.cpp @@ -0,0 +1,39 @@ +#include "stdafx.h" +#include "TitanEngine.h" +#include "TitanScript.h" +#include + +void log_callback( const char* str, eLogType log_type ); + +int main(int argc, char* argv[]) +{ + if(argc < 3) { + log_callback("Usage: titan_unittest.exe script.osc target.exe", TS_LOG_ERROR); + return -1; + } + + if ( !ExtensionManagerIsPluginLoaded( "TitanScript" ) || !ExtensionManagerIsPluginEnabled( "TitanScript" ) ) { + throw std::runtime_error( "TitanScript failed to load!" ); + } + + tScripterLoadFileA load_file = GetTSFunctionPointer( LoadFileA ); + tScripterExecuteWithTitanMistA exec = GetTSFunctionPointer( ExecuteWithTitanMistA ); + tScripterSetLogCallback set_log_callback = GetTSFunctionPointer( SetLogCallback ); + + set_log_callback(&log_callback ); + + if(!load_file(argv[1])) { + log_callback("Error loading script", TS_LOG_ERROR); + return -1; + } + + exec(argv[2], "dump.exe" ); + + return 0; +} + + +void log_callback( const char* str, eLogType log_type ) { + std::cout << str << "\n" << std::flush; +} + diff --git a/TitanUnitTest/TitanUnitTest.vcxproj b/TitanUnitTest/TitanUnitTest.vcxproj new file mode 100644 index 0000000..af59b54 --- /dev/null +++ b/TitanUnitTest/TitanUnitTest.vcxproj @@ -0,0 +1,98 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {5B5AB3CD-4D32-43B0-8840-E05C9483381D} + Win32Proj + titan_unittest + + + + Application + true + Unicode + true + + + Application + false + true + Unicode + + + + + + + + + + + + + true + + + false + + + + Use + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + MultiThreadedDebugDLL + + + Console + true + TitanEngine.lib;%(AdditionalDependencies) + + + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + MultiThreadedDLL + + + Console + true + true + true + + + + + + + + + + + + + Create + Create + + + + + + + \ No newline at end of file diff --git a/TitanUnitTest/TitanUnitTest.vcxproj.filters b/TitanUnitTest/TitanUnitTest.vcxproj.filters new file mode 100644 index 0000000..573b3a2 --- /dev/null +++ b/TitanUnitTest/TitanUnitTest.vcxproj.filters @@ -0,0 +1,41 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + + + Quelldateien + + + Quelldateien + + + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + Headerdateien + + + \ No newline at end of file diff --git a/TitanUnitTest/disasm.dll b/TitanUnitTest/disasm.dll new file mode 100644 index 0000000000000000000000000000000000000000..ef17bf19e260ff04add2982beee52c359955833f GIT binary patch literal 77824 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 +#include + + + +// TODO: Hier auf zusätzliche Header, die das Programm erfordert, verweisen. diff --git a/TitanUnitTest/targetver.h b/TitanUnitTest/targetver.h new file mode 100644 index 0000000..a765413 --- /dev/null +++ b/TitanUnitTest/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// Durch Einbeziehen von"SDKDDKVer.h" wird die höchste verfügbare Windows-Plattform definiert. + +// Wenn Sie die Anwendung für eine frühere Windows-Plattform erstellen möchten, schließen Sie "WinSDKVer.h" ein, und +// legen Sie das _WIN32_WINNT-Makro auf die zu unterstützende Plattform fest, bevor Sie "SDKDDKVer.h" einschließen. + +#include