├── .vs └── qt5_resolver │ ├── FileContentIndex │ ├── ee8a07f7-73f5-4db4-8ea4-7d40c8649a61.vsidx │ └── read.lock │ └── v17 │ ├── .suo │ ├── Browse.VC.db │ └── ipch │ └── AutoPCH │ └── 681d648fcf85235d │ └── PLUGIN.ipch ├── README.md ├── qt5_resolver.sln └── qt5_resolver ├── plugin.cpp ├── plugin.h ├── pluginmain.cpp ├── pluginmain.h ├── pluginsdk ├── DeviceNameResolver │ └── DeviceNameResolver.h ├── TitanEngine │ └── TitanEngine.h ├── XEDParse │ └── XEDParse.h ├── _dbgfunctions.h ├── _plugin_types.h ├── _plugins.h ├── _scriptapi.h ├── _scriptapi_argument.h ├── _scriptapi_assembler.h ├── _scriptapi_bookmark.h ├── _scriptapi_comment.h ├── _scriptapi_debug.h ├── _scriptapi_flag.h ├── _scriptapi_function.h ├── _scriptapi_gui.h ├── _scriptapi_label.h ├── _scriptapi_memory.h ├── _scriptapi_misc.h ├── _scriptapi_module.h ├── _scriptapi_pattern.h ├── _scriptapi_register.h ├── _scriptapi_stack.h ├── _scriptapi_symbol.h ├── bridgegraph.h ├── bridgelist.h ├── bridgemain.h ├── dbghelp │ └── dbghelp.h ├── godzilla │ ├── Godzilla_x64.lib │ ├── Godzilla_x64_debug.lib │ ├── Godzilla_x86.lib │ ├── Godzilla_x86_debug.lib │ ├── config.h │ ├── gasm │ │ └── gasm.h │ ├── gerror.h │ ├── gfile │ │ └── pe │ │ │ ├── pedefs.h │ │ │ └── pefile.h │ ├── ghook │ │ └── ghook.h │ ├── gmemory │ │ └── gmemory.h │ ├── godzilla.h │ ├── gprocess │ │ └── gprocess.h │ └── gsystem │ │ ├── gsystemdefs.h │ │ └── gsystemexp.h ├── jansson │ ├── jansson.h │ ├── jansson_config.h │ └── jansson_x64dbg.h └── lz4 │ ├── lz4.h │ ├── lz4file.h │ └── lz4hc.h ├── qt5_resolver.vcxproj ├── qt5_resolver.vcxproj.filters └── qt5_resolver.vcxproj.user /.vs/qt5_resolver/FileContentIndex/ee8a07f7-73f5-4db4-8ea4-7d40c8649a61.vsidx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/.vs/qt5_resolver/FileContentIndex/ee8a07f7-73f5-4db4-8ea4-7d40c8649a61.vsidx -------------------------------------------------------------------------------- /.vs/qt5_resolver/FileContentIndex/read.lock: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/.vs/qt5_resolver/FileContentIndex/read.lock -------------------------------------------------------------------------------- /.vs/qt5_resolver/v17/.suo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/.vs/qt5_resolver/v17/.suo -------------------------------------------------------------------------------- /.vs/qt5_resolver/v17/Browse.VC.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/.vs/qt5_resolver/v17/Browse.VC.db -------------------------------------------------------------------------------- /.vs/qt5_resolver/v17/ipch/AutoPCH/681d648fcf85235d/PLUGIN.ipch: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/.vs/qt5_resolver/v17/ipch/AutoPCH/681d648fcf85235d/PLUGIN.ipch -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # qt5_resolver 2 | X32DBG QT5 parsing scripts,You can get some usage information by using the -h option 3 | -------------------------------------------------------------------------------- /qt5_resolver.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 17 4 | VisualStudioVersion = 17.2.32526.322 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "qt5_resolver", "qt5_resolver\qt5_resolver.vcxproj", "{CB5D5370-9C17-4530-A15B-54AFBEBDB36A}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Debug|x64.ActiveCfg = Debug|x64 17 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Debug|x64.Build.0 = Debug|x64 18 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Debug|x86.ActiveCfg = Debug|Win32 19 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Debug|x86.Build.0 = Debug|Win32 20 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Release|x64.ActiveCfg = Release|x64 21 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Release|x64.Build.0 = Release|x64 22 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Release|x86.ActiveCfg = Release|Win32 23 | {CB5D5370-9C17-4530-A15B-54AFBEBDB36A}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {A27E5E4F-2E36-41D2-BB77-275ECA444BD1} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /qt5_resolver/plugin.cpp: -------------------------------------------------------------------------------- 1 | #include "plugin.h" 2 | 3 | static std::wstring Utf8ToUtf16(const std::string & str) 4 | { 5 | std::wstring convertedString; 6 | int requiredSize = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, nullptr, 0); 7 | if(requiredSize > 0) 8 | { 9 | std::vector buffer(requiredSize); 10 | MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, &buffer[0], requiredSize); 11 | convertedString.assign(buffer.begin(), buffer.end() - 1); 12 | } 13 | return convertedString; 14 | } 15 | 16 | static bool ReadAllData(const std::string & fileName, std::vector & content) 17 | { 18 | auto hFile = CreateFileW(Utf8ToUtf16(fileName).c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr); 19 | auto result = false; 20 | if(hFile != INVALID_HANDLE_VALUE) 21 | { 22 | unsigned int filesize = GetFileSize(hFile, nullptr); 23 | if(!filesize) 24 | { 25 | content.clear(); 26 | result = true; 27 | } 28 | else 29 | { 30 | content.resize(filesize); 31 | DWORD read = 0; 32 | result = !!ReadFile(hFile, content.data(), filesize, &read, nullptr); 33 | } 34 | CloseHandle(hFile); 35 | } 36 | return result; 37 | } 38 | 39 | 40 | 41 | //Initialize your plugin data here. 42 | bool pluginInit(PLUG_INITSTRUCT* initStruct) 43 | { 44 | if(!_plugin_registercommand(pluginHandle, PLUGIN_NAME, cbCommand, false)) 45 | _plugin_logputs("[" PLUGIN_NAME "] Error registering the \"" PLUGIN_NAME "\" command!"); 46 | return true; //Return false to cancel loading the plugin. 47 | } 48 | 49 | //Deinitialize your plugin data here (clearing menus optional). 50 | bool pluginStop() 51 | { 52 | return true; 53 | } 54 | 55 | //Do GUI/Menu related things here. 56 | void pluginSetup() 57 | { 58 | } 59 | 60 | 61 | bool cbCommand(int argc, char* argv[]) 62 | { 63 | LogPrintf("success"); 64 | return true; 65 | } -------------------------------------------------------------------------------- /qt5_resolver/plugin.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pluginmain.h" 4 | 5 | 6 | 7 | //plugin data 8 | #define PLUGIN_NAME "qt5_resolver" 9 | #define PLUGIN_VERSION 2 10 | 11 | //functions 12 | bool pluginInit(PLUG_INITSTRUCT* initStruct); 13 | bool pluginStop(); 14 | void pluginSetup(); 15 | 16 | static bool cbCommand(int argc, char* argv[]); -------------------------------------------------------------------------------- /qt5_resolver/pluginmain.cpp: -------------------------------------------------------------------------------- 1 | #include "pluginmain.h" 2 | #include "plugin.h" 3 | 4 | int pluginHandle; 5 | HWND hwndDlg; 6 | int hMenu; 7 | int hMenuDisasm; 8 | int hMenuDump; 9 | int hMenuStack; 10 | 11 | PLUG_EXPORT bool pluginit(PLUG_INITSTRUCT* initStruct) 12 | { 13 | initStruct->pluginVersion = PLUGIN_VERSION; 14 | initStruct->sdkVersion = PLUG_SDKVERSION; 15 | strncpy_s(initStruct->pluginName, PLUGIN_NAME, _TRUNCATE); 16 | pluginHandle = initStruct->pluginHandle; 17 | return pluginInit(initStruct); 18 | } 19 | 20 | PLUG_EXPORT bool plugstop() 21 | { 22 | return pluginStop(); 23 | } 24 | 25 | PLUG_EXPORT void plugsetup(PLUG_SETUPSTRUCT* setupStruct) 26 | { 27 | hwndDlg = setupStruct->hwndDlg; 28 | hMenu = setupStruct->hMenu; 29 | hMenuDisasm = setupStruct->hMenuDisasm; 30 | hMenuDump = setupStruct->hMenuDump; 31 | hMenuStack = setupStruct->hMenuStack; 32 | pluginSetup(); 33 | } 34 | 35 | BOOL WINAPI DllMain( 36 | _In_ HINSTANCE hinstDLL, 37 | _In_ DWORD fdwReason, 38 | _In_ LPVOID lpvReserved 39 | ) 40 | { 41 | return TRUE; 42 | } 43 | -------------------------------------------------------------------------------- /qt5_resolver/pluginmain.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pluginsdk/bridgemain.h" 4 | #include "pluginsdk/_plugins.h" 5 | 6 | #include "pluginsdk/_scriptapi_argument.h" 7 | #include "pluginsdk/_scriptapi_assembler.h" 8 | #include "pluginsdk/_scriptapi_bookmark.h" 9 | #include "pluginsdk/_scriptapi_comment.h" 10 | #include "pluginsdk/_scriptapi_debug.h" 11 | #include "pluginsdk/_scriptapi_flag.h" 12 | #include "pluginsdk/_scriptapi_function.h" 13 | #include "pluginsdk/_scriptapi_gui.h" 14 | #include "pluginsdk/_scriptapi_label.h" 15 | #include "pluginsdk/_scriptapi_memory.h" 16 | #include "pluginsdk/_scriptapi_misc.h" 17 | #include "pluginsdk/_scriptapi_module.h" 18 | #include "pluginsdk/_scriptapi_pattern.h" 19 | #include "pluginsdk/_scriptapi_register.h" 20 | #include "pluginsdk/_scriptapi_stack.h" 21 | #include "pluginsdk/_scriptapi_symbol.h" 22 | 23 | #include "pluginsdk/DeviceNameResolver/DeviceNameResolver.h" 24 | #include "pluginsdk/jansson/jansson.h" 25 | #include "pluginsdk/lz4/lz4file.h" 26 | #include "pluginsdk/TitanEngine/TitanEngine.h" 27 | #include "pluginsdk/XEDParse/XEDParse.h" 28 | 29 | #ifdef _WIN64 30 | #pragma comment(lib, "pluginsdk/x64dbg.lib") 31 | #pragma comment(lib, "pluginsdk/x64bridge.lib") 32 | #pragma comment(lib, "pluginsdk/DeviceNameResolver/DeviceNameResolver_x64.lib") 33 | #pragma comment(lib, "pluginsdk/jansson/jansson_x64.lib") 34 | #pragma comment(lib, "pluginsdk/lz4/lz4_x64.lib") 35 | #pragma comment(lib, "pluginsdk/TitanEngine/TitanEngine_x64.lib") 36 | #pragma comment(lib, "pluginsdk/XEDParse/XEDParse_x64.lib") 37 | 38 | #ifdef _DEBUG 39 | #pragma comment(lib, "pluginsdk/godzilla/Godzilla_debug_x64.lib") 40 | #endif 41 | 42 | #ifndef _DEBUG 43 | #pragma comment(lib, "pluginsdk/godzilla/Godzilla_x64.lib") 44 | #else 45 | #pragma comment(lib, "pluginsdk/x32dbg.lib") 46 | #pragma comment(lib, "pluginsdk/x32bridge.lib") 47 | #pragma comment(lib, "pluginsdk/DeviceNameResolver/DeviceNameResolver_x86.lib") 48 | #pragma comment(lib, "pluginsdk/jansson/jansson_x86.lib") 49 | #pragma comment(lib, "pluginsdk/lz4/lz4_x86.lib") 50 | #pragma comment(lib, "pluginsdk/TitanEngine/TitanEngine_x86.lib") 51 | #pragma comment(lib, "pluginsdk/XEDParse/XEDParse_x86.lib") 52 | #ifdef _DEBUG 53 | #pragma comment(lib, "pluginsdk/godzilla/Godzilla_debug_x86.lib") 54 | #endif 55 | 56 | #ifndef _DEBUG 57 | #pragma comment(lib, "pluginsdk/godzilla/Godzilla_x86.lib") 58 | #endif //_WIN64 59 | 60 | #define Cmd(x) DbgCmdExecDirect(x) 61 | #define Eval(x) DbgValFromString(x) 62 | #define PLUG_EXPORT extern "C" __declspec(dllexport) 63 | #define LogPrintf(message)\ 64 | _plugin_logprintf(message) 65 | 66 | //superglobal variables 67 | extern int pluginHandle; 68 | extern HWND hwndDlg; 69 | extern int hMenu; 70 | extern int hMenuDisasm; 71 | extern int hMenuDump; 72 | extern int hMenuStack; -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/DeviceNameResolver/DeviceNameResolver.h: -------------------------------------------------------------------------------- 1 | #ifndef _DEVICENAMERESOLVER_H 2 | #define _DEVICENAMERESOLVER_H 3 | 4 | #include 5 | 6 | #ifdef __cplusplus 7 | extern "C" 8 | { 9 | #endif 10 | 11 | __declspec(dllexport) bool DevicePathToPathW(const wchar_t* szDevicePath, wchar_t* szPath, size_t nSizeInChars); 12 | __declspec(dllexport) bool DevicePathToPathA(const char* szDevicePath, char* szPath, size_t nSizeInChars); 13 | __declspec(dllexport) bool DevicePathFromFileHandleW(HANDLE hFile, wchar_t* szDevicePath, size_t nSizeInChars); 14 | __declspec(dllexport) bool DevicePathFromFileHandleA(HANDLE hFile, char* szDevicePath, size_t nSizeInChars); 15 | __declspec(dllexport) bool PathFromFileHandleW(HANDLE hFile, wchar_t* szPath, size_t nSizeInChars); 16 | __declspec(dllexport) bool PathFromFileHandleA(HANDLE hFile, char* szPath, size_t nSizeInChars); 17 | 18 | #ifdef __cplusplus 19 | } 20 | #endif 21 | 22 | #endif // _DEVICENAMERESOLVER_H 23 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/XEDParse/XEDParse.h: -------------------------------------------------------------------------------- 1 | #ifndef _XEDPARSE_H 2 | #define _XEDPARSE_H 3 | 4 | #include 5 | 6 | //XEDParse defines 7 | #ifdef XEDPARSE_BUILD 8 | #define XEDPARSE_EXPORT __declspec(dllexport) 9 | #else 10 | #define XEDPARSE_EXPORT __declspec(dllimport) 11 | #endif //XEDPARSE_BUILD 12 | 13 | #define XEDPARSE_CALL //calling convention 14 | 15 | #define XEDPARSE_MAXBUFSIZE 256 16 | #define XEDPARSE_MAXASMSIZE 16 17 | 18 | //typedefs 19 | typedef bool (XEDPARSE_CALL* CBXEDPARSE_UNKNOWN)(const char* text, ULONGLONG* value); 20 | 21 | //XEDParse enums 22 | enum XEDPARSE_STATUS 23 | { 24 | XEDPARSE_ERROR = 0, 25 | XEDPARSE_OK = 1 26 | }; 27 | 28 | //XEDParse structs 29 | #pragma pack(push,8) 30 | struct XEDPARSE 31 | { 32 | bool x64; // use 64-bit instructions 33 | ULONGLONG cip; //instruction pointer (for relative addressing) 34 | unsigned int dest_size; //destination size (returned by XEDParse) 35 | CBXEDPARSE_UNKNOWN cbUnknown; //unknown operand callback 36 | unsigned char dest[XEDPARSE_MAXASMSIZE]; //destination buffer 37 | char instr[XEDPARSE_MAXBUFSIZE]; //instruction text 38 | char error[XEDPARSE_MAXBUFSIZE]; //error text (in case of an error) 39 | }; 40 | #pragma pack(pop) 41 | 42 | #ifdef __cplusplus 43 | extern "C" 44 | { 45 | #endif 46 | 47 | XEDPARSE_EXPORT XEDPARSE_STATUS XEDPARSE_CALL XEDParseAssemble(XEDPARSE* XEDParse); 48 | 49 | #ifdef __cplusplus 50 | } 51 | #endif 52 | 53 | #endif // _XEDPARSE_H 54 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_dbgfunctions.h: -------------------------------------------------------------------------------- 1 | #ifndef _DBGFUNCTIONS_H 2 | #define _DBGFUNCTIONS_H 3 | 4 | #ifndef __cplusplus 5 | #include 6 | #endif 7 | 8 | typedef struct 9 | { 10 | char mod[MAX_MODULE_SIZE]; 11 | duint addr; 12 | unsigned char oldbyte; 13 | unsigned char newbyte; 14 | } DBGPATCHINFO; 15 | 16 | typedef struct 17 | { 18 | duint addr; 19 | duint from; 20 | duint to; 21 | char comment[MAX_COMMENT_SIZE]; 22 | } DBGCALLSTACKENTRY; 23 | 24 | typedef struct 25 | { 26 | int total; 27 | DBGCALLSTACKENTRY* entries; 28 | } DBGCALLSTACK; 29 | 30 | typedef struct 31 | { 32 | duint addr; 33 | duint handler; 34 | } DBGSEHRECORD; 35 | 36 | typedef struct 37 | { 38 | duint total; 39 | DBGSEHRECORD* records; 40 | } DBGSEHCHAIN; 41 | 42 | typedef struct 43 | { 44 | DWORD dwProcessId; 45 | char szExeFile[MAX_PATH]; 46 | char szExeMainWindowTitle[MAX_PATH]; 47 | char szExeArgs[MAX_COMMAND_LINE_SIZE]; 48 | } DBGPROCESSINFO; 49 | 50 | typedef struct 51 | { 52 | DWORD rva; 53 | BYTE type; 54 | WORD size; 55 | } DBGRELOCATIONINFO; 56 | 57 | typedef enum 58 | { 59 | InstructionBody = 0, 60 | InstructionHeading = 1, 61 | InstructionTailing = 2, 62 | InstructionOverlapped = 3, // The byte was executed with differing instruction base addresses 63 | DataByte, // This and the following is not implemented yet. 64 | DataWord, 65 | DataDWord, 66 | DataQWord, 67 | DataFloat, 68 | DataDouble, 69 | DataLongDouble, 70 | DataXMM, 71 | DataYMM, 72 | DataMMX, 73 | DataMixed, //the byte is accessed in multiple ways 74 | InstructionDataMixed //the byte is both executed and written 75 | } TRACERECORDBYTETYPE; 76 | 77 | typedef enum 78 | { 79 | TraceRecordNone, 80 | TraceRecordBitExec, 81 | TraceRecordByteWithExecTypeAndCounter, 82 | TraceRecordWordWithExecTypeAndCounter 83 | } TRACERECORDTYPE; 84 | 85 | typedef struct 86 | { 87 | duint Handle; 88 | unsigned char TypeNumber; 89 | unsigned int GrantedAccess; 90 | } HANDLEINFO; 91 | 92 | // The longest ip address is 1234:6789:1234:6789:1234:6789:123.567.901.345 (46 bytes) 93 | #define TCP_ADDR_SIZE 50 94 | 95 | typedef struct 96 | { 97 | char RemoteAddress[TCP_ADDR_SIZE]; 98 | unsigned short RemotePort; 99 | char LocalAddress[TCP_ADDR_SIZE]; 100 | unsigned short LocalPort; 101 | char StateText[TCP_ADDR_SIZE]; 102 | unsigned int State; 103 | } TCPCONNECTIONINFO; 104 | 105 | typedef struct 106 | { 107 | duint handle; 108 | duint parent; 109 | DWORD threadId; 110 | DWORD style; 111 | DWORD styleEx; 112 | duint wndProc; 113 | bool enabled; 114 | RECT position; 115 | char windowTitle[MAX_COMMENT_SIZE]; 116 | char windowClass[MAX_COMMENT_SIZE]; 117 | } WINDOW_INFO; 118 | 119 | typedef struct 120 | { 121 | duint addr; 122 | duint size; 123 | duint flags; 124 | } HEAPINFO; 125 | 126 | typedef struct 127 | { 128 | const char* name; 129 | duint value; 130 | } CONSTANTINFO; 131 | 132 | typedef enum 133 | { 134 | MODSYMUNLOADED = 0, 135 | MODSYMLOADING, 136 | MODSYMLOADED 137 | } MODULESYMBOLSTATUS; 138 | 139 | typedef bool (*ASSEMBLEATEX)(duint addr, const char* instruction, char* error, bool fillnop); 140 | typedef bool (*SECTIONFROMADDR)(duint addr, char* section); 141 | typedef bool (*MODNAMEFROMADDR)(duint addr, char* modname, bool extension); 142 | typedef duint(*MODBASEFROMADDR)(duint addr); 143 | typedef duint(*MODBASEFROMNAME)(const char* modname); 144 | typedef duint(*MODSIZEFROMADDR)(duint addr); 145 | typedef bool (*ASSEMBLE)(duint addr, unsigned char* dest, int* size, const char* instruction, char* error); 146 | typedef bool (*PATCHGET)(duint addr); 147 | typedef bool (*PATCHINRANGE)(duint start, duint end); 148 | typedef bool (*MEMPATCH)(duint va, const unsigned char* src, duint size); 149 | typedef void (*PATCHRESTORERANGE)(duint start, duint end); 150 | typedef bool (*PATCHENUM)(DBGPATCHINFO* patchlist, size_t* cbsize); 151 | typedef bool (*PATCHRESTORE)(duint addr); 152 | typedef int (*PATCHFILE)(DBGPATCHINFO* patchlist, int count, const char* szFileName, char* error); 153 | typedef int (*MODPATHFROMADDR)(duint addr, char* path, int size); 154 | typedef int (*MODPATHFROMNAME)(const char* modname, char* path, int size); 155 | typedef bool (*DISASMFAST)(const unsigned char* data, duint addr, BASIC_INSTRUCTION_INFO* basicinfo); 156 | typedef void (*MEMUPDATEMAP)(); 157 | typedef void (*GETCALLSTACK)(DBGCALLSTACK* callstack); 158 | typedef void (*GETSEHCHAIN)(DBGSEHCHAIN* sehchain); 159 | typedef void (*SYMBOLDOWNLOADALLSYMBOLS)(const char* szSymbolStore); 160 | typedef bool (*GETJIT)(char* jit, bool x64); 161 | typedef bool (*GETJITAUTO)(bool* jitauto); 162 | typedef bool (*GETDEFJIT)(char* defjit); 163 | typedef bool (*GETPROCESSLIST)(DBGPROCESSINFO** entries, int* count); 164 | typedef bool (*GETPAGERIGHTS)(duint addr, char* rights); 165 | typedef bool (*SETPAGERIGHTS)(duint addr, const char* rights); 166 | typedef bool (*PAGERIGHTSTOSTRING)(DWORD protect, char* rights); 167 | typedef bool (*ISPROCESSELEVATED)(); 168 | typedef bool (*GETCMDLINE)(char* cmdline, size_t* cbsize); 169 | typedef bool (*SETCMDLINE)(const char* cmdline); 170 | typedef duint(*FILEOFFSETTOVA)(const char* modname, duint offset); 171 | typedef duint(*VATOFILEOFFSET)(duint va); 172 | typedef duint(*GETADDRFROMLINE)(const char* szSourceFile, int line, duint* displacement); 173 | typedef bool (*GETSOURCEFROMADDR)(duint addr, char* szSourceFile, int* line); 174 | typedef bool (*VALFROMSTRING)(const char* string, duint* value); 175 | typedef bool (*PATCHGETEX)(duint addr, DBGPATCHINFO* info); 176 | typedef bool (*GETBRIDGEBP)(BPXTYPE type, duint addr, BRIDGEBP* bp); 177 | typedef bool (*STRINGFORMATINLINE)(const char* format, size_t resultSize, char* result); 178 | typedef void (*GETMNEMONICBRIEF)(const char* mnem, size_t resultSize, char* result); 179 | typedef unsigned int (*GETTRACERECORDHITCOUNT)(duint address); 180 | typedef TRACERECORDBYTETYPE(*GETTRACERECORDBYTETYPE)(duint address); 181 | typedef bool (*SETTRACERECORDTYPE)(duint pageAddress, TRACERECORDTYPE type); 182 | typedef TRACERECORDTYPE(*GETTRACERECORDTYPE)(duint pageAddress); 183 | typedef bool (*ENUMHANDLES)(ListOf(HANDLEINFO) handles); 184 | typedef bool (*GETHANDLENAME)(duint handle, char* name, size_t nameSize, char* typeName, size_t typeNameSize); 185 | typedef bool (*ENUMTCPCONNECTIONS)(ListOf(TCPCONNECTIONINFO) connections); 186 | typedef duint(*GETDBGEVENTS)(); 187 | typedef MODULEPARTY(*MODGETPARTY)(duint base); 188 | typedef void (*MODSETPARTY)(duint base, MODULEPARTY party); 189 | typedef bool(*WATCHISWATCHDOGTRIGGERED)(unsigned int id); 190 | typedef bool(*MEMISCODEPAGE)(duint addr, bool refresh); 191 | typedef bool(*ANIMATECOMMAND)(const char* command); 192 | typedef void(*DBGSETDEBUGGEEINITSCRIPT)(const char* fileName); 193 | typedef const char* (*DBGGETDEBUGGEEINITSCRIPT)(); 194 | typedef bool(*HANDLESENUMWINDOWS)(ListOf(WINDOW_INFO) windows); 195 | typedef bool(*HANDLESENUMHEAPS)(ListOf(HEAPINFO) heaps); 196 | typedef bool(*THREADGETNAME)(DWORD tid, char* name); 197 | typedef bool(*ISDEPENABLED)(); 198 | typedef void(*GETCALLSTACKEX)(DBGCALLSTACK* callstack, bool cache); 199 | typedef bool(*GETUSERCOMMENT)(duint addr, char* comment); 200 | typedef void(*ENUMCONSTANTS)(ListOf(CONSTANTINFO) constants); 201 | typedef duint(*MEMBPSIZE)(duint addr); 202 | typedef bool(*MODRELOCATIONSFROMADDR)(duint addr, ListOf(DBGRELOCATIONINFO) relocations); 203 | typedef bool(*MODRELOCATIONATADDR)(duint addr, DBGRELOCATIONINFO* relocation); 204 | typedef bool(*MODRELOCATIONSINRANGE)(duint addr, duint size, ListOf(DBGRELOCATIONINFO) relocations); 205 | typedef duint(*DBGETHASH)(); 206 | typedef int(*SYMAUTOCOMPLETE)(const char* Search, char** Buffer, int MaxSymbols); 207 | typedef void(*REFRESHMODULELIST)(); 208 | typedef duint(*GETADDRFROMLINEEX)(duint mod, const char* szSourceFile, int line); 209 | typedef MODULESYMBOLSTATUS(*MODSYMBOLSTATUS)(duint mod); 210 | typedef void(*GETCALLSTACKBYTHREAD)(HANDLE thread, DBGCALLSTACK* callstack); 211 | 212 | //The list of all the DbgFunctions() return value. 213 | //WARNING: This list is append only. Do not insert things in the middle or plugins would break. 214 | typedef struct DBGFUNCTIONS_ 215 | { 216 | ASSEMBLEATEX AssembleAtEx; 217 | SECTIONFROMADDR SectionFromAddr; 218 | MODNAMEFROMADDR ModNameFromAddr; 219 | MODBASEFROMADDR ModBaseFromAddr; 220 | MODBASEFROMNAME ModBaseFromName; 221 | MODSIZEFROMADDR ModSizeFromAddr; 222 | ASSEMBLE Assemble; 223 | PATCHGET PatchGet; 224 | PATCHINRANGE PatchInRange; 225 | MEMPATCH MemPatch; 226 | PATCHRESTORERANGE PatchRestoreRange; 227 | PATCHENUM PatchEnum; 228 | PATCHRESTORE PatchRestore; 229 | PATCHFILE PatchFile; 230 | MODPATHFROMADDR ModPathFromAddr; 231 | MODPATHFROMNAME ModPathFromName; 232 | DISASMFAST DisasmFast; 233 | MEMUPDATEMAP MemUpdateMap; 234 | GETCALLSTACK GetCallStack; 235 | GETSEHCHAIN GetSEHChain; 236 | SYMBOLDOWNLOADALLSYMBOLS SymbolDownloadAllSymbols; 237 | GETJITAUTO GetJitAuto; 238 | GETJIT GetJit; 239 | GETDEFJIT GetDefJit; 240 | GETPROCESSLIST GetProcessList; 241 | GETPAGERIGHTS GetPageRights; 242 | SETPAGERIGHTS SetPageRights; 243 | PAGERIGHTSTOSTRING PageRightsToString; 244 | ISPROCESSELEVATED IsProcessElevated; 245 | GETCMDLINE GetCmdline; 246 | SETCMDLINE SetCmdline; 247 | FILEOFFSETTOVA FileOffsetToVa; 248 | VATOFILEOFFSET VaToFileOffset; 249 | GETADDRFROMLINE GetAddrFromLine; 250 | GETSOURCEFROMADDR GetSourceFromAddr; 251 | VALFROMSTRING ValFromString; 252 | PATCHGETEX PatchGetEx; 253 | GETBRIDGEBP GetBridgeBp; 254 | STRINGFORMATINLINE StringFormatInline; 255 | GETMNEMONICBRIEF GetMnemonicBrief; 256 | GETTRACERECORDHITCOUNT GetTraceRecordHitCount; 257 | GETTRACERECORDBYTETYPE GetTraceRecordByteType; 258 | SETTRACERECORDTYPE SetTraceRecordType; 259 | GETTRACERECORDTYPE GetTraceRecordType; 260 | ENUMHANDLES EnumHandles; 261 | GETHANDLENAME GetHandleName; 262 | ENUMTCPCONNECTIONS EnumTcpConnections; 263 | GETDBGEVENTS GetDbgEvents; 264 | MODGETPARTY ModGetParty; 265 | MODSETPARTY ModSetParty; 266 | WATCHISWATCHDOGTRIGGERED WatchIsWatchdogTriggered; 267 | MEMISCODEPAGE MemIsCodePage; 268 | ANIMATECOMMAND AnimateCommand; 269 | DBGSETDEBUGGEEINITSCRIPT DbgSetDebuggeeInitScript; 270 | DBGGETDEBUGGEEINITSCRIPT DbgGetDebuggeeInitScript; 271 | HANDLESENUMWINDOWS EnumWindows; 272 | HANDLESENUMHEAPS EnumHeaps; 273 | THREADGETNAME ThreadGetName; 274 | ISDEPENABLED IsDepEnabled; 275 | GETCALLSTACKEX GetCallStackEx; 276 | GETUSERCOMMENT GetUserComment; 277 | ENUMCONSTANTS EnumConstants; 278 | ENUMCONSTANTS EnumErrorCodes; 279 | ENUMCONSTANTS EnumExceptions; 280 | MEMBPSIZE MemBpSize; 281 | MODRELOCATIONSFROMADDR ModRelocationsFromAddr; 282 | MODRELOCATIONATADDR ModRelocationAtAddr; 283 | MODRELOCATIONSINRANGE ModRelocationsInRange; 284 | DBGETHASH DbGetHash; 285 | SYMAUTOCOMPLETE SymAutoComplete; 286 | REFRESHMODULELIST RefreshModuleList; 287 | GETADDRFROMLINEEX GetAddrFromLineEx; 288 | MODSYMBOLSTATUS ModSymbolStatus; 289 | GETCALLSTACKBYTHREAD GetCallStackByThread; 290 | } DBGFUNCTIONS; 291 | 292 | #ifdef BUILD_DBG 293 | 294 | const DBGFUNCTIONS* dbgfunctionsget(); 295 | void dbgfunctionsinit(); 296 | 297 | #endif //BUILD_DBG 298 | 299 | #endif //_DBGFUNCTIONS_H 300 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_plugin_types.h: -------------------------------------------------------------------------------- 1 | #ifndef _PLUGIN_DATA_H 2 | #define _PLUGIN_DATA_H 3 | 4 | #ifdef BUILD_DBG 5 | 6 | #include "_global.h" 7 | #include "jansson/jansson.h" 8 | #pragma warning(push) 9 | #pragma warning(disable:4091) 10 | #include 11 | #pragma warning(pop) 12 | 13 | #else 14 | 15 | #ifdef __GNUC__ 16 | #include "dbghelp/dbghelp.h" 17 | #else 18 | #pragma warning(push) 19 | #pragma warning(disable:4091) 20 | #include 21 | #pragma warning(pop) 22 | #endif // __GNUC__ 23 | 24 | #ifndef deflen 25 | #define deflen 1024 26 | #endif // deflen 27 | 28 | #include "bridgemain.h" 29 | #include "_dbgfunctions.h" 30 | #include "jansson/jansson.h" 31 | 32 | #endif // BUILD_DBG 33 | 34 | #endif // _PLUGIN_DATA_H 35 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_plugins.h: -------------------------------------------------------------------------------- 1 | #ifndef _PLUGINS_H 2 | #define _PLUGINS_H 3 | 4 | #ifndef __cplusplus 5 | #include 6 | #endif 7 | 8 | #ifndef PLUG_IMPEXP 9 | #ifdef BUILD_DBG 10 | #define PLUG_IMPEXP __declspec(dllexport) 11 | #else 12 | #define PLUG_IMPEXP __declspec(dllimport) 13 | #endif //BUILD_DBG 14 | #endif //PLUG_IMPEXP 15 | 16 | #include "_plugin_types.h" 17 | 18 | //default structure alignments forced 19 | #ifdef _WIN64 20 | #pragma pack(push, 16) 21 | #else //x86 22 | #pragma pack(push, 8) 23 | #endif //_WIN64 24 | 25 | //defines 26 | #define PLUG_SDKVERSION 1 27 | 28 | #define PLUG_DB_LOADSAVE_DATA 1 29 | #define PLUG_DB_LOADSAVE_ALL 2 30 | 31 | //structures 32 | typedef struct 33 | { 34 | //provided by the debugger 35 | int pluginHandle; 36 | //provided by the pluginit function 37 | int sdkVersion; 38 | int pluginVersion; 39 | char pluginName[256]; 40 | } PLUG_INITSTRUCT; 41 | 42 | typedef struct 43 | { 44 | //provided by the debugger 45 | HWND hwndDlg; //gui window handle 46 | int hMenu; //plugin menu handle 47 | int hMenuDisasm; //plugin disasm menu handle 48 | int hMenuDump; //plugin dump menu handle 49 | int hMenuStack; //plugin stack menu handle 50 | int hMenuGraph; //plugin graph menu handle 51 | int hMenuMemmap; //plugin memory map menu handle 52 | int hMenuSymmod; //plugin symbol module menu handle 53 | } PLUG_SETUPSTRUCT; 54 | 55 | typedef struct 56 | { 57 | void* data; //user data 58 | } PLUG_SCRIPTSTRUCT; 59 | 60 | //callback structures 61 | typedef struct 62 | { 63 | const char* szFileName; 64 | } PLUG_CB_INITDEBUG; 65 | 66 | typedef struct 67 | { 68 | void* reserved; 69 | } PLUG_CB_STOPDEBUG; 70 | 71 | typedef struct 72 | { 73 | void* reserved; 74 | } PLUG_CB_STOPPINGDEBUG; 75 | 76 | typedef struct 77 | { 78 | CREATE_PROCESS_DEBUG_INFO* CreateProcessInfo; 79 | IMAGEHLP_MODULE64* modInfo; 80 | const char* DebugFileName; 81 | PROCESS_INFORMATION* fdProcessInfo; 82 | } PLUG_CB_CREATEPROCESS; 83 | 84 | typedef struct 85 | { 86 | EXIT_PROCESS_DEBUG_INFO* ExitProcess; 87 | } PLUG_CB_EXITPROCESS; 88 | 89 | typedef struct 90 | { 91 | CREATE_THREAD_DEBUG_INFO* CreateThread; 92 | DWORD dwThreadId; 93 | } PLUG_CB_CREATETHREAD; 94 | 95 | typedef struct 96 | { 97 | EXIT_THREAD_DEBUG_INFO* ExitThread; 98 | DWORD dwThreadId; 99 | } PLUG_CB_EXITTHREAD; 100 | 101 | typedef struct 102 | { 103 | void* reserved; 104 | } PLUG_CB_SYSTEMBREAKPOINT; 105 | 106 | typedef struct 107 | { 108 | LOAD_DLL_DEBUG_INFO* LoadDll; 109 | IMAGEHLP_MODULE64* modInfo; 110 | const char* modname; 111 | } PLUG_CB_LOADDLL; 112 | 113 | typedef struct 114 | { 115 | UNLOAD_DLL_DEBUG_INFO* UnloadDll; 116 | } PLUG_CB_UNLOADDLL; 117 | 118 | typedef struct 119 | { 120 | OUTPUT_DEBUG_STRING_INFO* DebugString; 121 | } PLUG_CB_OUTPUTDEBUGSTRING; 122 | 123 | typedef struct 124 | { 125 | EXCEPTION_DEBUG_INFO* Exception; 126 | } PLUG_CB_EXCEPTION; 127 | 128 | typedef struct 129 | { 130 | BRIDGEBP* breakpoint; 131 | } PLUG_CB_BREAKPOINT; 132 | 133 | typedef struct 134 | { 135 | void* reserved; 136 | } PLUG_CB_PAUSEDEBUG; 137 | 138 | typedef struct 139 | { 140 | void* reserved; 141 | } PLUG_CB_RESUMEDEBUG; 142 | 143 | typedef struct 144 | { 145 | void* reserved; 146 | } PLUG_CB_STEPPED; 147 | 148 | typedef struct 149 | { 150 | DWORD dwProcessId; 151 | } PLUG_CB_ATTACH; 152 | 153 | typedef struct 154 | { 155 | PROCESS_INFORMATION* fdProcessInfo; 156 | } PLUG_CB_DETACH; 157 | 158 | typedef struct 159 | { 160 | DEBUG_EVENT* DebugEvent; 161 | } PLUG_CB_DEBUGEVENT; 162 | 163 | typedef struct 164 | { 165 | int hEntry; 166 | } PLUG_CB_MENUENTRY; 167 | 168 | typedef struct 169 | { 170 | MSG* message; 171 | long* result; 172 | bool retval; 173 | } PLUG_CB_WINEVENT; 174 | 175 | typedef struct 176 | { 177 | MSG* message; 178 | bool retval; 179 | } PLUG_CB_WINEVENTGLOBAL; 180 | 181 | typedef struct 182 | { 183 | json_t* root; 184 | int loadSaveType; 185 | } PLUG_CB_LOADSAVEDB; 186 | 187 | typedef struct 188 | { 189 | const char* symbol; 190 | bool retval; 191 | } PLUG_CB_FILTERSYMBOL; 192 | 193 | typedef struct 194 | { 195 | duint cip; 196 | bool stop; 197 | } PLUG_CB_TRACEEXECUTE; 198 | 199 | typedef struct 200 | { 201 | int hWindow; 202 | duint VA; 203 | } PLUG_CB_SELCHANGED; 204 | 205 | typedef struct 206 | { 207 | BridgeCFGraphList graph; 208 | } PLUG_CB_ANALYZE; 209 | 210 | typedef struct 211 | { 212 | duint addr; 213 | BRIDGE_ADDRINFO* addrinfo; 214 | bool retval; 215 | } PLUG_CB_ADDRINFO; 216 | 217 | typedef struct 218 | { 219 | const char* string; 220 | duint value; 221 | int* value_size; 222 | bool* isvar; 223 | bool* hexonly; 224 | bool retval; 225 | } PLUG_CB_VALFROMSTRING; 226 | 227 | typedef struct 228 | { 229 | const char* string; 230 | duint value; 231 | bool retval; 232 | } PLUG_CB_VALTOSTRING; 233 | 234 | typedef struct 235 | { 236 | GUIMENUTYPE hMenu; 237 | } PLUG_CB_MENUPREPARE; 238 | 239 | typedef enum 240 | { 241 | ValueTypeNumber, 242 | ValueTypeString, 243 | ValueTypeAny 244 | } ValueType; 245 | 246 | typedef struct 247 | { 248 | const char* ptr; 249 | bool isOwner; 250 | } StringValue; 251 | 252 | typedef struct 253 | { 254 | ValueType type; 255 | duint number; 256 | StringValue string; 257 | } ExpressionValue; 258 | 259 | //enums 260 | typedef enum 261 | { 262 | CB_INITDEBUG, //PLUG_CB_INITDEBUG 263 | CB_STOPDEBUG, //PLUG_CB_STOPDEBUG 264 | CB_CREATEPROCESS, //PLUG_CB_CREATEPROCESS 265 | CB_EXITPROCESS, //PLUG_CB_EXITPROCESS 266 | CB_CREATETHREAD, //PLUG_CB_CREATETHREAD 267 | CB_EXITTHREAD, //PLUG_CB_EXITTHREAD 268 | CB_SYSTEMBREAKPOINT, //PLUG_CB_SYSTEMBREAKPOINT 269 | CB_LOADDLL, //PLUG_CB_LOADDLL 270 | CB_UNLOADDLL, //PLUG_CB_UNLOADDLL 271 | CB_OUTPUTDEBUGSTRING, //PLUG_CB_OUTPUTDEBUGSTRING 272 | CB_EXCEPTION, //PLUG_CB_EXCEPTION 273 | CB_BREAKPOINT, //PLUG_CB_BREAKPOINT 274 | CB_PAUSEDEBUG, //PLUG_CB_PAUSEDEBUG 275 | CB_RESUMEDEBUG, //PLUG_CB_RESUMEDEBUG 276 | CB_STEPPED, //PLUG_CB_STEPPED 277 | CB_ATTACH, //PLUG_CB_ATTACHED (before attaching, after CB_INITDEBUG) 278 | CB_DETACH, //PLUG_CB_DETACH (before detaching, before CB_STOPDEBUG) 279 | CB_DEBUGEVENT, //PLUG_CB_DEBUGEVENT (called on any debug event) 280 | CB_MENUENTRY, //PLUG_CB_MENUENTRY 281 | CB_WINEVENT, //PLUG_CB_WINEVENT 282 | CB_WINEVENTGLOBAL, //PLUG_CB_WINEVENTGLOBAL 283 | CB_LOADDB, //PLUG_CB_LOADSAVEDB 284 | CB_SAVEDB, //PLUG_CB_LOADSAVEDB 285 | CB_FILTERSYMBOL, //PLUG_CB_FILTERSYMBOL 286 | CB_TRACEEXECUTE, //PLUG_CB_TRACEEXECUTE 287 | CB_SELCHANGED, //PLUG_CB_SELCHANGED 288 | CB_ANALYZE, //PLUG_CB_ANALYZE 289 | CB_ADDRINFO, //PLUG_CB_ADDRINFO 290 | CB_VALFROMSTRING, //PLUG_CB_VALFROMSTRING 291 | CB_VALTOSTRING, //PLUG_CB_VALTOSTRING 292 | CB_MENUPREPARE, //PLUG_CB_MENUPREPARE 293 | CB_STOPPINGDEBUG, //PLUG_CB_STOPDEBUG 294 | CB_LAST 295 | } CBTYPE; 296 | 297 | typedef enum 298 | { 299 | FORMAT_ERROR, //generic failure (no message) 300 | FORMAT_SUCCESS, //success 301 | FORMAT_ERROR_MESSAGE, //formatting failed but an error was put in the buffer (there are always at least 511 characters available). 302 | FORMAT_BUFFER_TOO_SMALL //buffer too small (x64dbg will retry until the buffer is big enough) 303 | } FORMATRESULT; 304 | 305 | //typedefs 306 | typedef void (*CBPLUGIN)(CBTYPE cbType, void* callbackInfo); 307 | typedef bool (*CBPLUGINCOMMAND)(int argc, char** argv); 308 | typedef void (*CBPLUGINSCRIPT)(); 309 | typedef duint(*CBPLUGINEXPRFUNCTION)(int argc, const duint* argv, void* userdata); 310 | typedef bool(*CBPLUGINEXPRFUNCTIONEX)(ExpressionValue* result, int argc, const ExpressionValue* argv, void* userdata); 311 | typedef FORMATRESULT(*CBPLUGINFORMATFUNCTION)(char* dest, size_t destCount, int argc, char* argv[], duint value, void* userdata); 312 | typedef bool (*CBPLUGINPREDICATE)(void* userdata); 313 | 314 | //exports 315 | #ifdef __cplusplus 316 | extern "C" 317 | { 318 | #endif 319 | 320 | PLUG_IMPEXP void _plugin_registercallback(int pluginHandle, CBTYPE cbType, CBPLUGIN cbPlugin); 321 | PLUG_IMPEXP bool _plugin_unregistercallback(int pluginHandle, CBTYPE cbType); 322 | PLUG_IMPEXP bool _plugin_registercommand(int pluginHandle, const char* command, CBPLUGINCOMMAND cbCommand, bool debugonly); 323 | PLUG_IMPEXP bool _plugin_unregistercommand(int pluginHandle, const char* command); 324 | PLUG_IMPEXP void _plugin_logprintf(const char* format, ...); 325 | PLUG_IMPEXP void _plugin_logputs(const char* text); 326 | PLUG_IMPEXP void _plugin_logprint(const char* text); 327 | PLUG_IMPEXP void _plugin_debugpause(); 328 | PLUG_IMPEXP void _plugin_debugskipexceptions(bool skip); 329 | PLUG_IMPEXP int _plugin_menuadd(int hMenu, const char* title); 330 | PLUG_IMPEXP bool _plugin_menuaddentry(int hMenu, int hEntry, const char* title); 331 | PLUG_IMPEXP bool _plugin_menuaddseparator(int hMenu); 332 | PLUG_IMPEXP bool _plugin_menuclear(int hMenu); 333 | PLUG_IMPEXP void _plugin_menuseticon(int hMenu, const ICONDATA* icon); 334 | PLUG_IMPEXP void _plugin_menuentryseticon(int pluginHandle, int hEntry, const ICONDATA* icon); 335 | PLUG_IMPEXP void _plugin_menuentrysetchecked(int pluginHandle, int hEntry, bool checked); 336 | PLUG_IMPEXP void _plugin_menusetvisible(int pluginHandle, int hMenu, bool visible); 337 | PLUG_IMPEXP void _plugin_menuentrysetvisible(int pluginHandle, int hEntry, bool visible); 338 | PLUG_IMPEXP void _plugin_menusetname(int pluginHandle, int hMenu, const char* name); 339 | PLUG_IMPEXP void _plugin_menuentrysetname(int pluginHandle, int hEntry, const char* name); 340 | PLUG_IMPEXP void _plugin_menuentrysethotkey(int pluginHandle, int hEntry, const char* hotkey); 341 | PLUG_IMPEXP bool _plugin_menuremove(int hMenu); 342 | PLUG_IMPEXP bool _plugin_menuentryremove(int pluginHandle, int hEntry); 343 | PLUG_IMPEXP void _plugin_startscript(CBPLUGINSCRIPT cbScript); 344 | PLUG_IMPEXP bool _plugin_waituntilpaused(); 345 | PLUG_IMPEXP bool _plugin_registerexprfunction(int pluginHandle, const char* name, int argc, CBPLUGINEXPRFUNCTION cbFunction, void* userdata); 346 | PLUG_IMPEXP bool _plugin_registerexprfunctionex(int pluginHandle, const char* name, const ValueType & returnType, const ValueType* argTypes, size_t argCount, CBPLUGINEXPRFUNCTIONEX cbFunction, void* userdata); 347 | PLUG_IMPEXP bool _plugin_unregisterexprfunction(int pluginHandle, const char* name); 348 | PLUG_IMPEXP bool _plugin_unload(const char* pluginName); 349 | PLUG_IMPEXP bool _plugin_load(const char* pluginName); 350 | PLUG_IMPEXP duint _plugin_hash(const void* data, duint size); 351 | PLUG_IMPEXP bool _plugin_registerformatfunction(int pluginHandle, const char* type, CBPLUGINFORMATFUNCTION cbFunction, void* userdata); 352 | PLUG_IMPEXP bool _plugin_unregisterformatfunction(int pluginHandle, const char* type); 353 | 354 | #ifdef __cplusplus 355 | } 356 | #endif 357 | 358 | #pragma pack(pop) 359 | 360 | #endif // _PLUGINS_H 361 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPT_API_H 2 | #define _SCRIPT_API_H 3 | 4 | #include "_plugins.h" 5 | 6 | #define SCRIPT_EXPORT PLUG_IMPEXP 7 | 8 | #endif //_SCRIPT_API_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_argument.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_ARGUMENT_H 2 | #define _SCRIPTAPI_ARGUMENT_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Argument 9 | { 10 | struct ArgumentInfo 11 | { 12 | char mod[MAX_MODULE_SIZE]; 13 | duint rvaStart; 14 | duint rvaEnd; 15 | bool manual; 16 | duint instructioncount; 17 | }; 18 | 19 | SCRIPT_EXPORT bool Add(duint start, duint end, bool manual, duint instructionCount = 0); 20 | SCRIPT_EXPORT bool Add(const ArgumentInfo* info); 21 | SCRIPT_EXPORT bool Get(duint addr, duint* start = nullptr, duint* end = nullptr, duint* instructionCount = nullptr); 22 | SCRIPT_EXPORT bool GetInfo(duint addr, ArgumentInfo* info); 23 | SCRIPT_EXPORT bool Overlaps(duint start, duint end); 24 | SCRIPT_EXPORT bool Delete(duint address); 25 | SCRIPT_EXPORT void DeleteRange(duint start, duint end, bool deleteManual = false); 26 | SCRIPT_EXPORT void Clear(); 27 | SCRIPT_EXPORT bool GetList(ListOf(ArgumentInfo) list); //caller has the responsibility to free the list 28 | }; //Argument 29 | }; //Script 30 | 31 | #endif //_SCRIPTAPI_ARGUMENT_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_assembler.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_ASSEMBLER_H 2 | #define _SCRIPTAPI_ASSEMBLER_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Assembler 9 | { 10 | SCRIPT_EXPORT bool Assemble(duint addr, unsigned char* dest, int* size, const char* instruction); //dest[16] 11 | SCRIPT_EXPORT bool AssembleEx(duint addr, unsigned char* dest, int* size, const char* instruction, char* error); //dest[16], error[MAX_ERROR_SIZE] 12 | SCRIPT_EXPORT bool AssembleMem(duint addr, const char* instruction); 13 | SCRIPT_EXPORT bool AssembleMemEx(duint addr, const char* instruction, int* size, char* error, bool fillnop); //error[MAX_ERROR_SIZE] 14 | }; //Assembler 15 | }; //Script 16 | 17 | #endif //_SCRIPTAPI_ASSEMBLER_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_bookmark.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_BOOKMARK_H 2 | #define _SCRIPTAPI_BOOKMARK_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Bookmark 9 | { 10 | struct BookmarkInfo 11 | { 12 | char mod[MAX_MODULE_SIZE]; 13 | duint rva; 14 | bool manual; 15 | }; 16 | 17 | SCRIPT_EXPORT bool Set(duint addr, bool manual = false); 18 | SCRIPT_EXPORT bool Set(const BookmarkInfo* info); 19 | SCRIPT_EXPORT bool Get(duint addr); 20 | SCRIPT_EXPORT bool GetInfo(duint addr, BookmarkInfo* info); 21 | SCRIPT_EXPORT bool Delete(duint addr); 22 | SCRIPT_EXPORT void DeleteRange(duint start, duint end); 23 | SCRIPT_EXPORT void Clear(); 24 | SCRIPT_EXPORT bool GetList(ListOf(BookmarkInfo) list); //caller has the responsibility to free the list 25 | }; //Bookmark 26 | }; //Script 27 | 28 | #endif //_SCRIPTAPI_BOOKMARK_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_comment.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_COMMENT_H 2 | #define _SCRIPTAPI_COMMENT_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Comment 9 | { 10 | struct CommentInfo 11 | { 12 | char mod[MAX_MODULE_SIZE]; 13 | duint rva; 14 | char text[MAX_LABEL_SIZE]; 15 | bool manual; 16 | }; 17 | 18 | SCRIPT_EXPORT bool Set(duint addr, const char* text, bool manual = false); 19 | SCRIPT_EXPORT bool Set(const CommentInfo* info); 20 | SCRIPT_EXPORT bool Get(duint addr, char* text); //text[MAX_COMMENT_SIZE] 21 | SCRIPT_EXPORT bool GetInfo(duint addr, CommentInfo* info); 22 | SCRIPT_EXPORT bool Delete(duint addr); 23 | SCRIPT_EXPORT void DeleteRange(duint start, duint end); 24 | SCRIPT_EXPORT void Clear(); 25 | SCRIPT_EXPORT bool GetList(ListOf(CommentInfo) list); //caller has the responsibility to free the list 26 | }; //Comment 27 | }; //Script 28 | 29 | #endif //_SCRIPTAPI_COMMENT_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_debug.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_DEBUG_H 2 | #define _SCRIPTAPI_DEBUG_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Debug 9 | { 10 | enum HardwareType 11 | { 12 | HardwareAccess, 13 | HardwareWrite, 14 | HardwareExecute 15 | }; 16 | 17 | SCRIPT_EXPORT void Wait(); 18 | SCRIPT_EXPORT void Run(); 19 | SCRIPT_EXPORT void Pause(); 20 | SCRIPT_EXPORT void Stop(); 21 | SCRIPT_EXPORT void StepIn(); 22 | SCRIPT_EXPORT void StepOver(); 23 | SCRIPT_EXPORT void StepOut(); 24 | SCRIPT_EXPORT bool SetBreakpoint(duint address); 25 | SCRIPT_EXPORT bool DeleteBreakpoint(duint address); 26 | SCRIPT_EXPORT bool DisableBreakpoint(duint address); 27 | SCRIPT_EXPORT bool SetHardwareBreakpoint(duint address, HardwareType type = HardwareExecute); 28 | SCRIPT_EXPORT bool DeleteHardwareBreakpoint(duint address); 29 | }; //Debug 30 | }; //Script 31 | 32 | #endif //_SCRIPTAPI_DEBUG_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_flag.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_FLAG_H 2 | #define _SCRIPTAPI_FLAG_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Flag 9 | { 10 | enum FlagEnum 11 | { 12 | ZF, 13 | OF, 14 | CF, 15 | PF, 16 | SF, 17 | TF, 18 | AF, 19 | DF, 20 | IF 21 | }; 22 | 23 | SCRIPT_EXPORT bool Get(FlagEnum flag); 24 | SCRIPT_EXPORT bool Set(FlagEnum flag, bool value); 25 | 26 | SCRIPT_EXPORT bool GetZF(); 27 | SCRIPT_EXPORT bool SetZF(bool value); 28 | SCRIPT_EXPORT bool GetOF(); 29 | SCRIPT_EXPORT bool SetOF(bool value); 30 | SCRIPT_EXPORT bool GetCF(); 31 | SCRIPT_EXPORT bool SetCF(bool value); 32 | SCRIPT_EXPORT bool GetPF(); 33 | SCRIPT_EXPORT bool SetPF(bool value); 34 | SCRIPT_EXPORT bool GetSF(); 35 | SCRIPT_EXPORT bool SetSF(bool value); 36 | SCRIPT_EXPORT bool GetTF(); 37 | SCRIPT_EXPORT bool SetTF(bool value); 38 | SCRIPT_EXPORT bool GetAF(); 39 | SCRIPT_EXPORT bool SetAF(bool value); 40 | SCRIPT_EXPORT bool GetDF(); 41 | SCRIPT_EXPORT bool SetDF(bool value); 42 | SCRIPT_EXPORT bool GetIF(); 43 | SCRIPT_EXPORT bool SetIF(bool value); 44 | }; 45 | }; 46 | 47 | #endif //_SCRIPTAPI_FLAG_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_function.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_FUNCTION_H 2 | #define _SCRIPTAPI_FUNCTION_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Function 9 | { 10 | struct FunctionInfo 11 | { 12 | char mod[MAX_MODULE_SIZE]; 13 | duint rvaStart; 14 | duint rvaEnd; 15 | bool manual; 16 | duint instructioncount; 17 | }; 18 | 19 | SCRIPT_EXPORT bool Add(duint start, duint end, bool manual, duint instructionCount = 0); 20 | SCRIPT_EXPORT bool Add(const FunctionInfo* info); 21 | SCRIPT_EXPORT bool Get(duint addr, duint* start = nullptr, duint* end = nullptr, duint* instructionCount = nullptr); 22 | SCRIPT_EXPORT bool GetInfo(duint addr, FunctionInfo* info); 23 | SCRIPT_EXPORT bool Overlaps(duint start, duint end); 24 | SCRIPT_EXPORT bool Delete(duint address); 25 | SCRIPT_EXPORT void DeleteRange(duint start, duint end, bool deleteManual); 26 | SCRIPT_EXPORT void DeleteRange(duint start, duint end); 27 | SCRIPT_EXPORT void Clear(); 28 | SCRIPT_EXPORT bool GetList(ListOf(FunctionInfo) list); //caller has the responsibility to free the list 29 | }; //Function 30 | }; //Script 31 | 32 | #endif //_SCRIPTAPI_FUNCTION_H 33 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_gui.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_GUI_H 2 | #define _SCRIPTAPI_GUI_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Gui 9 | { 10 | namespace Disassembly 11 | { 12 | SCRIPT_EXPORT bool SelectionGet(duint* start, duint* end); 13 | SCRIPT_EXPORT bool SelectionSet(duint start, duint end); 14 | SCRIPT_EXPORT duint SelectionGetStart(); 15 | SCRIPT_EXPORT duint SelectionGetEnd(); 16 | }; //Disassembly 17 | 18 | namespace Dump 19 | { 20 | SCRIPT_EXPORT bool SelectionGet(duint* start, duint* end); 21 | SCRIPT_EXPORT bool SelectionSet(duint start, duint end); 22 | SCRIPT_EXPORT duint SelectionGetStart(); 23 | SCRIPT_EXPORT duint SelectionGetEnd(); 24 | }; //Dump 25 | 26 | namespace Stack 27 | { 28 | SCRIPT_EXPORT bool SelectionGet(duint* start, duint* end); 29 | SCRIPT_EXPORT bool SelectionSet(duint start, duint end); 30 | SCRIPT_EXPORT duint SelectionGetStart(); 31 | SCRIPT_EXPORT duint SelectionGetEnd(); 32 | }; //Stack 33 | 34 | namespace Graph 35 | { 36 | SCRIPT_EXPORT duint SelectionGetStart(); 37 | }; //Graph 38 | 39 | namespace MemMap 40 | { 41 | SCRIPT_EXPORT duint SelectionGetStart(); 42 | }; //MemoryMap 43 | 44 | namespace SymMod 45 | { 46 | SCRIPT_EXPORT duint SelectionGetStart(); 47 | }; //SymMod 48 | }; //Gui 49 | 50 | namespace Gui 51 | { 52 | enum Window 53 | { 54 | DisassemblyWindow, 55 | DumpWindow, 56 | StackWindow, 57 | GraphWindow, 58 | MemMapWindow, 59 | SymModWindow 60 | }; 61 | 62 | SCRIPT_EXPORT bool SelectionGet(Window window, duint* start, duint* end); 63 | SCRIPT_EXPORT bool SelectionSet(Window window, duint start, duint end); 64 | SCRIPT_EXPORT duint SelectionGetStart(Window window); 65 | SCRIPT_EXPORT duint SelectionGetEnd(Window window); 66 | SCRIPT_EXPORT void Message(const char* message); 67 | SCRIPT_EXPORT bool MessageYesNo(const char* message); 68 | SCRIPT_EXPORT bool InputLine(const char* title, char* text); //text[GUI_MAX_LINE_SIZE] 69 | SCRIPT_EXPORT bool InputValue(const char* title, duint* value); 70 | SCRIPT_EXPORT void Refresh(); 71 | SCRIPT_EXPORT void AddQWidgetTab(void* qWidget); 72 | SCRIPT_EXPORT void ShowQWidgetTab(void* qWidget); 73 | SCRIPT_EXPORT void CloseQWidgetTab(void* qWidget); 74 | 75 | }; //Gui 76 | }; //Script 77 | 78 | #endif //_SCRIPTAPI_GUI_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_label.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_LABEL_H 2 | #define _SCRIPTAPI_LABEL_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Label 9 | { 10 | struct LabelInfo 11 | { 12 | char mod[MAX_MODULE_SIZE]; 13 | duint rva; 14 | char text[MAX_LABEL_SIZE]; 15 | bool manual; 16 | }; 17 | 18 | SCRIPT_EXPORT bool Set(duint addr, const char* text, bool manual = false); 19 | SCRIPT_EXPORT bool Set(duint addr, const char* text, bool manual = false, bool temporary = false); 20 | SCRIPT_EXPORT bool Set(const LabelInfo* info); 21 | SCRIPT_EXPORT bool FromString(const char* label, duint* addr); 22 | SCRIPT_EXPORT bool Get(duint addr, char* text); //text[MAX_LABEL_SIZE] 23 | SCRIPT_EXPORT bool IsTemporary(duint addr); 24 | SCRIPT_EXPORT bool GetInfo(duint addr, LabelInfo* info); 25 | SCRIPT_EXPORT bool Delete(duint addr); 26 | SCRIPT_EXPORT void DeleteRange(duint start, duint end); 27 | SCRIPT_EXPORT void Clear(); 28 | SCRIPT_EXPORT bool GetList(ListOf(LabelInfo) list); //caller has the responsibility to free the list 29 | }; //Label 30 | }; //Script 31 | 32 | #endif //_SCRIPTAPI_LABEL_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_memory.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_MEMORY_H 2 | #define _SCRIPTAPI_MEMORY_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Memory 9 | { 10 | SCRIPT_EXPORT bool Read(duint addr, void* data, duint size, duint* sizeRead); 11 | SCRIPT_EXPORT bool Write(duint addr, const void* data, duint size, duint* sizeWritten); 12 | SCRIPT_EXPORT bool IsValidPtr(duint addr); 13 | SCRIPT_EXPORT duint RemoteAlloc(duint addr, duint size); 14 | SCRIPT_EXPORT bool RemoteFree(duint addr); 15 | SCRIPT_EXPORT unsigned int GetProtect(duint addr, bool reserved = false, bool cache = true); 16 | SCRIPT_EXPORT bool SetProtect(duint addr, unsigned int protect, duint size); 17 | SCRIPT_EXPORT duint GetBase(duint addr, bool reserved = false, bool cache = true); 18 | SCRIPT_EXPORT duint GetSize(duint addr, bool reserved = false, bool cache = true); 19 | 20 | SCRIPT_EXPORT unsigned char ReadByte(duint addr); 21 | SCRIPT_EXPORT bool WriteByte(duint addr, unsigned char data); 22 | SCRIPT_EXPORT unsigned short ReadWord(duint addr); 23 | SCRIPT_EXPORT bool WriteWord(duint addr, unsigned short data); 24 | SCRIPT_EXPORT unsigned int ReadDword(duint addr); 25 | SCRIPT_EXPORT bool WriteDword(duint addr, unsigned int data); 26 | SCRIPT_EXPORT unsigned long long ReadQword(duint addr); 27 | SCRIPT_EXPORT bool WriteQword(duint addr, unsigned long long data); 28 | SCRIPT_EXPORT duint ReadPtr(duint addr); 29 | SCRIPT_EXPORT bool WritePtr(duint addr, duint data); 30 | }; //Memory 31 | }; //Script 32 | 33 | #endif //_SCRIPTAPI_MEMORY_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_misc.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_MISC_H 2 | #define _SCRIPTAPI_MISC_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Misc 9 | { 10 | /// 11 | /// Evaluates an expression and returns the result. Analagous to using the Command field in x64dbg. 12 | /// 13 | /// Expressions can consist of memory locations, registers, flags, API names, labels, symbols, variables etc. 14 | /// 15 | /// Example: bool success = ParseExpression("[esp+8]", &val) 16 | /// 17 | /// The expression to evaluate. 18 | /// The result of the expression. 19 | /// True on success, False on failure. 20 | SCRIPT_EXPORT bool ParseExpression(const char* expression, duint* value); 21 | 22 | /// 23 | /// Returns the address of a function in the debuggee's memory space. 24 | /// 25 | /// Example: duint addr = RemoteGetProcAddress("kernel32.dll", "GetProcAddress") 26 | /// 27 | /// The name of the module. 28 | /// The name of the function. 29 | /// The address of the function in the debuggee. 30 | SCRIPT_EXPORT duint RemoteGetProcAddress(const char* module, const char* api); 31 | 32 | /// 33 | /// Returns the address for a label created in the disassembly window. 34 | /// 35 | /// Example: duint addr = ResolveLabel("sneaky_crypto") 36 | /// 37 | /// The name of the label to resolve. 38 | /// The memory address for the label. 39 | SCRIPT_EXPORT duint ResolveLabel(const char* label); 40 | 41 | /// 42 | /// Allocates the requested number of bytes from x64dbg's default process heap. 43 | /// 44 | /// Note: this allocation is in the debugger, not the debuggee. 45 | /// 46 | /// Memory allocated using this function should be Free'd after use. 47 | /// 48 | /// Example: void* addr = Alloc(0x100000) 49 | /// 50 | /// Number of bytes to allocate. 51 | /// A pointer to the newly allocated memory. 52 | SCRIPT_EXPORT void* Alloc(duint size); 53 | 54 | /// 55 | /// Frees memory previously allocated by Alloc. 56 | /// 57 | /// Example: Free(addr) 58 | /// 59 | /// Pointer returned by Alloc. 60 | /// Nothing. 61 | SCRIPT_EXPORT void Free(void* ptr); 62 | }; //Misc 63 | }; //Script 64 | 65 | #endif //_SCRIPTAPI_MISC_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_module.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_MODULE_H 2 | #define _SCRIPTAPI_MODULE_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Module 9 | { 10 | struct ModuleInfo 11 | { 12 | duint base; 13 | duint size; 14 | duint entry; 15 | int sectionCount; 16 | char name[MAX_MODULE_SIZE]; 17 | char path[MAX_PATH]; 18 | }; 19 | 20 | struct ModuleSectionInfo 21 | { 22 | duint addr; 23 | duint size; 24 | char name[MAX_SECTION_SIZE * 5]; 25 | }; 26 | 27 | struct ModuleExport 28 | { 29 | duint ordinal; 30 | duint rva; 31 | duint va; 32 | bool forwarded; 33 | char forwardName[MAX_STRING_SIZE]; 34 | char name[MAX_STRING_SIZE]; 35 | char undecoratedName[MAX_STRING_SIZE]; 36 | }; 37 | 38 | struct ModuleImport 39 | { 40 | duint iatRva; 41 | duint iatVa; 42 | duint ordinal; //equal to -1 if imported by name 43 | char name[MAX_STRING_SIZE]; 44 | char undecoratedName[MAX_STRING_SIZE]; 45 | }; 46 | 47 | SCRIPT_EXPORT bool InfoFromAddr(duint addr, ModuleInfo* info); 48 | SCRIPT_EXPORT bool InfoFromName(const char* name, ModuleInfo* info); 49 | SCRIPT_EXPORT duint BaseFromAddr(duint addr); 50 | SCRIPT_EXPORT duint BaseFromName(const char* name); 51 | SCRIPT_EXPORT duint SizeFromAddr(duint addr); 52 | SCRIPT_EXPORT duint SizeFromName(const char* name); 53 | SCRIPT_EXPORT bool NameFromAddr(duint addr, char* name); //name[MAX_MODULE_SIZE] 54 | SCRIPT_EXPORT bool PathFromAddr(duint addr, char* path); //path[MAX_PATH] 55 | SCRIPT_EXPORT bool PathFromName(const char* name, char* path); //path[MAX_PATH] 56 | SCRIPT_EXPORT duint EntryFromAddr(duint addr); 57 | SCRIPT_EXPORT duint EntryFromName(const char* name); 58 | SCRIPT_EXPORT int SectionCountFromAddr(duint addr); 59 | SCRIPT_EXPORT int SectionCountFromName(const char* name); 60 | SCRIPT_EXPORT bool SectionFromAddr(duint addr, int number, ModuleSectionInfo* section); 61 | SCRIPT_EXPORT bool SectionFromName(const char* name, int number, ModuleSectionInfo* section); 62 | SCRIPT_EXPORT bool SectionListFromAddr(duint addr, ListOf(ModuleSectionInfo) list); 63 | SCRIPT_EXPORT bool SectionListFromName(const char* name, ListOf(ModuleSectionInfo) list); 64 | SCRIPT_EXPORT bool GetMainModuleInfo(ModuleInfo* info); 65 | SCRIPT_EXPORT duint GetMainModuleBase(); 66 | SCRIPT_EXPORT duint GetMainModuleSize(); 67 | SCRIPT_EXPORT duint GetMainModuleEntry(); 68 | SCRIPT_EXPORT int GetMainModuleSectionCount(); 69 | SCRIPT_EXPORT bool GetMainModuleName(char* name); //name[MAX_MODULE_SIZE] 70 | SCRIPT_EXPORT bool GetMainModulePath(char* path); //path[MAX_PATH] 71 | SCRIPT_EXPORT bool GetMainModuleSectionList(ListOf(ModuleSectionInfo) list); //caller has the responsibility to free the list 72 | SCRIPT_EXPORT bool GetList(ListOf(ModuleInfo) list); //caller has the responsibility to free the list 73 | SCRIPT_EXPORT bool GetExports(const ModuleInfo* mod, ListOf(ModuleExport) list); //caller has the responsibility to free the list 74 | SCRIPT_EXPORT bool GetImports(const ModuleInfo* mod, ListOf(ModuleImport) list); //caller has the responsibility to free the list 75 | }; //Module 76 | }; //Script 77 | 78 | #endif //_SCRIPTAPI_MODULE_H 79 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_pattern.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_PATTERN_H 2 | #define _SCRIPTAPI_PATTERN_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Pattern 9 | { 10 | SCRIPT_EXPORT duint Find(unsigned char* data, duint datasize, const char* pattern); 11 | SCRIPT_EXPORT duint FindMem(duint start, duint size, const char* pattern); 12 | SCRIPT_EXPORT void Write(unsigned char* data, duint datasize, const char* pattern); 13 | SCRIPT_EXPORT void WriteMem(duint start, duint size, const char* pattern); 14 | SCRIPT_EXPORT bool SearchAndReplace(unsigned char* data, duint datasize, const char* searchpattern, const char* replacepattern); 15 | SCRIPT_EXPORT bool SearchAndReplaceMem(duint start, duint size, const char* searchpattern, const char* replacepattern); 16 | }; 17 | }; 18 | 19 | #endif //_SCRIPTAPI_FIND_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_register.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_REGISTER_H 2 | #define _SCRIPTAPI_REGISTER_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Register 9 | { 10 | enum RegisterEnum 11 | { 12 | DR0, 13 | DR1, 14 | DR2, 15 | DR3, 16 | DR6, 17 | DR7, 18 | 19 | EAX, 20 | AX, 21 | AH, 22 | AL, 23 | EBX, 24 | BX, 25 | BH, 26 | BL, 27 | ECX, 28 | CX, 29 | CH, 30 | CL, 31 | EDX, 32 | DX, 33 | DH, 34 | DL, 35 | EDI, 36 | DI, 37 | ESI, 38 | SI, 39 | EBP, 40 | BP, 41 | ESP, 42 | SP, 43 | EIP, 44 | 45 | #ifdef _WIN64 46 | RAX, 47 | RBX, 48 | RCX, 49 | RDX, 50 | RSI, 51 | SIL, 52 | RDI, 53 | DIL, 54 | RBP, 55 | BPL, 56 | RSP, 57 | SPL, 58 | RIP, 59 | R8, 60 | R8D, 61 | R8W, 62 | R8B, 63 | R9, 64 | R9D, 65 | R9W, 66 | R9B, 67 | R10, 68 | R10D, 69 | R10W, 70 | R10B, 71 | R11, 72 | R11D, 73 | R11W, 74 | R11B, 75 | R12, 76 | R12D, 77 | R12W, 78 | R12B, 79 | R13, 80 | R13D, 81 | R13W, 82 | R13B, 83 | R14, 84 | R14D, 85 | R14W, 86 | R14B, 87 | R15, 88 | R15D, 89 | R15W, 90 | R15B, 91 | #endif //_WIN64 92 | 93 | CIP, 94 | CSP, 95 | CAX, 96 | CBX, 97 | CCX, 98 | CDX, 99 | CDI, 100 | CSI, 101 | CBP, 102 | CFLAGS 103 | }; //RegisterEnum 104 | 105 | SCRIPT_EXPORT duint Get(RegisterEnum reg); 106 | SCRIPT_EXPORT bool Set(RegisterEnum reg, duint value); 107 | SCRIPT_EXPORT int Size(); //gets architecture register size in bytes 108 | 109 | SCRIPT_EXPORT duint GetDR0(); 110 | SCRIPT_EXPORT bool SetDR0(duint value); 111 | SCRIPT_EXPORT duint GetDR1(); 112 | SCRIPT_EXPORT bool SetDR1(duint value); 113 | SCRIPT_EXPORT duint GetDR2(); 114 | SCRIPT_EXPORT bool SetDR2(duint value); 115 | SCRIPT_EXPORT duint GetDR3(); 116 | SCRIPT_EXPORT bool SetDR3(duint value); 117 | SCRIPT_EXPORT duint GetDR6(); 118 | SCRIPT_EXPORT bool SetDR6(duint value); 119 | SCRIPT_EXPORT duint GetDR7(); 120 | SCRIPT_EXPORT bool SetDR7(duint value); 121 | 122 | SCRIPT_EXPORT unsigned int GetEAX(); 123 | SCRIPT_EXPORT bool SetEAX(unsigned int value); 124 | SCRIPT_EXPORT unsigned short GetAX(); 125 | SCRIPT_EXPORT bool SetAX(unsigned short value); 126 | SCRIPT_EXPORT unsigned char GetAH(); 127 | SCRIPT_EXPORT bool SetAH(unsigned char value); 128 | SCRIPT_EXPORT unsigned char GetAL(); 129 | SCRIPT_EXPORT bool SetAL(unsigned char value); 130 | SCRIPT_EXPORT unsigned int GetEBX(); 131 | SCRIPT_EXPORT bool SetEBX(unsigned int value); 132 | SCRIPT_EXPORT unsigned short GetBX(); 133 | SCRIPT_EXPORT bool SetBX(unsigned short value); 134 | SCRIPT_EXPORT unsigned char GetBH(); 135 | SCRIPT_EXPORT bool SetBH(unsigned char value); 136 | SCRIPT_EXPORT unsigned char GetBL(); 137 | SCRIPT_EXPORT bool SetBL(unsigned char value); 138 | SCRIPT_EXPORT unsigned int GetECX(); 139 | SCRIPT_EXPORT bool SetECX(unsigned int value); 140 | SCRIPT_EXPORT unsigned short GetCX(); 141 | SCRIPT_EXPORT bool SetCX(unsigned short value); 142 | SCRIPT_EXPORT unsigned char GetCH(); 143 | SCRIPT_EXPORT bool SetCH(unsigned char value); 144 | SCRIPT_EXPORT unsigned char GetCL(); 145 | SCRIPT_EXPORT bool SetCL(unsigned char value); 146 | SCRIPT_EXPORT unsigned int GetEDX(); 147 | SCRIPT_EXPORT bool SetEDX(unsigned int value); 148 | SCRIPT_EXPORT unsigned short GetDX(); 149 | SCRIPT_EXPORT bool SetDX(unsigned short value); 150 | SCRIPT_EXPORT unsigned char GetDH(); 151 | SCRIPT_EXPORT bool SetDH(unsigned char value); 152 | SCRIPT_EXPORT unsigned char GetDL(); 153 | SCRIPT_EXPORT bool SetDL(unsigned char value); 154 | SCRIPT_EXPORT unsigned int GetEDI(); 155 | SCRIPT_EXPORT bool SetEDI(unsigned int value); 156 | SCRIPT_EXPORT unsigned short GetDI(); 157 | SCRIPT_EXPORT bool SetDI(unsigned short value); 158 | SCRIPT_EXPORT unsigned int GetESI(); 159 | SCRIPT_EXPORT bool SetESI(unsigned int value); 160 | SCRIPT_EXPORT unsigned short GetSI(); 161 | SCRIPT_EXPORT bool SetSI(unsigned short value); 162 | SCRIPT_EXPORT unsigned int GetEBP(); 163 | SCRIPT_EXPORT bool SetEBP(unsigned int value); 164 | SCRIPT_EXPORT unsigned short GetBP(); 165 | SCRIPT_EXPORT bool SetBP(unsigned short value); 166 | SCRIPT_EXPORT unsigned int GetESP(); 167 | SCRIPT_EXPORT bool SetESP(unsigned int value); 168 | SCRIPT_EXPORT unsigned short GetSP(); 169 | SCRIPT_EXPORT bool SetSP(unsigned short value); 170 | SCRIPT_EXPORT unsigned int GetEIP(); 171 | SCRIPT_EXPORT bool SetEIP(unsigned int value); 172 | 173 | #ifdef _WIN64 174 | SCRIPT_EXPORT unsigned long long GetRAX(); 175 | SCRIPT_EXPORT bool SetRAX(unsigned long long value); 176 | SCRIPT_EXPORT unsigned long long GetRBX(); 177 | SCRIPT_EXPORT bool SetRBX(unsigned long long value); 178 | SCRIPT_EXPORT unsigned long long GetRCX(); 179 | SCRIPT_EXPORT bool SetRCX(unsigned long long value); 180 | SCRIPT_EXPORT unsigned long long GetRDX(); 181 | SCRIPT_EXPORT bool SetRDX(unsigned long long value); 182 | SCRIPT_EXPORT unsigned long long GetRSI(); 183 | SCRIPT_EXPORT bool SetRSI(unsigned long long value); 184 | SCRIPT_EXPORT unsigned char GetSIL(); 185 | SCRIPT_EXPORT bool SetSIL(unsigned char value); 186 | SCRIPT_EXPORT unsigned long long GetRDI(); 187 | SCRIPT_EXPORT bool SetRDI(unsigned long long value); 188 | SCRIPT_EXPORT unsigned char GetDIL(); 189 | SCRIPT_EXPORT bool SetDIL(unsigned char value); 190 | SCRIPT_EXPORT unsigned long long GetRBP(); 191 | SCRIPT_EXPORT bool SetRBP(unsigned long long value); 192 | SCRIPT_EXPORT unsigned char GetBPL(); 193 | SCRIPT_EXPORT bool SetBPL(unsigned char value); 194 | SCRIPT_EXPORT unsigned long long GetRSP(); 195 | SCRIPT_EXPORT bool SetRSP(unsigned long long value); 196 | SCRIPT_EXPORT unsigned char GetSPL(); 197 | SCRIPT_EXPORT bool SetSPL(unsigned char value); 198 | SCRIPT_EXPORT unsigned long long GetRIP(); 199 | SCRIPT_EXPORT bool SetRIP(unsigned long long value); 200 | SCRIPT_EXPORT unsigned long long GetR8(); 201 | SCRIPT_EXPORT bool SetR8(unsigned long long value); 202 | SCRIPT_EXPORT unsigned int GetR8D(); 203 | SCRIPT_EXPORT bool SetR8D(unsigned int value); 204 | SCRIPT_EXPORT unsigned short GetR8W(); 205 | SCRIPT_EXPORT bool SetR8W(unsigned short value); 206 | SCRIPT_EXPORT unsigned char GetR8B(); 207 | SCRIPT_EXPORT bool SetR8B(unsigned char value); 208 | SCRIPT_EXPORT unsigned long long GetR9(); 209 | SCRIPT_EXPORT bool SetR9(unsigned long long value); 210 | SCRIPT_EXPORT unsigned int GetR9D(); 211 | SCRIPT_EXPORT bool SetR9D(unsigned int value); 212 | SCRIPT_EXPORT unsigned short GetR9W(); 213 | SCRIPT_EXPORT bool SetR9W(unsigned short value); 214 | SCRIPT_EXPORT unsigned char GetR9B(); 215 | SCRIPT_EXPORT bool SetR9B(unsigned char value); 216 | SCRIPT_EXPORT unsigned long long GetR10(); 217 | SCRIPT_EXPORT bool SetR10(unsigned long long value); 218 | SCRIPT_EXPORT unsigned int GetR10D(); 219 | SCRIPT_EXPORT bool SetR10D(unsigned int value); 220 | SCRIPT_EXPORT unsigned short GetR10W(); 221 | SCRIPT_EXPORT bool SetR10W(unsigned short value); 222 | SCRIPT_EXPORT unsigned char GetR10B(); 223 | SCRIPT_EXPORT bool SetR10B(unsigned char value); 224 | SCRIPT_EXPORT unsigned long long GetR11(); 225 | SCRIPT_EXPORT bool SetR11(unsigned long long value); 226 | SCRIPT_EXPORT unsigned int GetR11D(); 227 | SCRIPT_EXPORT bool SetR11D(unsigned int value); 228 | SCRIPT_EXPORT unsigned short GetR11W(); 229 | SCRIPT_EXPORT bool SetR11W(unsigned short value); 230 | SCRIPT_EXPORT unsigned char GetR11B(); 231 | SCRIPT_EXPORT bool SetR11B(unsigned char value); 232 | SCRIPT_EXPORT unsigned long long GetR12(); 233 | SCRIPT_EXPORT bool SetR12(unsigned long long value); 234 | SCRIPT_EXPORT unsigned int GetR12D(); 235 | SCRIPT_EXPORT bool SetR12D(unsigned int value); 236 | SCRIPT_EXPORT unsigned short GetR12W(); 237 | SCRIPT_EXPORT bool SetR12W(unsigned short value); 238 | SCRIPT_EXPORT unsigned char GetR12B(); 239 | SCRIPT_EXPORT bool SetR12B(unsigned char value); 240 | SCRIPT_EXPORT unsigned long long GetR13(); 241 | SCRIPT_EXPORT bool SetR13(unsigned long long value); 242 | SCRIPT_EXPORT unsigned int GetR13D(); 243 | SCRIPT_EXPORT bool SetR13D(unsigned int value); 244 | SCRIPT_EXPORT unsigned short GetR13W(); 245 | SCRIPT_EXPORT bool SetR13W(unsigned short value); 246 | SCRIPT_EXPORT unsigned char GetR13B(); 247 | SCRIPT_EXPORT bool SetR13B(unsigned char value); 248 | SCRIPT_EXPORT unsigned long long GetR14(); 249 | SCRIPT_EXPORT bool SetR14(unsigned long long value); 250 | SCRIPT_EXPORT unsigned int GetR14D(); 251 | SCRIPT_EXPORT bool SetR14D(unsigned int value); 252 | SCRIPT_EXPORT unsigned short GetR14W(); 253 | SCRIPT_EXPORT bool SetR14W(unsigned short value); 254 | SCRIPT_EXPORT unsigned char GetR14B(); 255 | SCRIPT_EXPORT bool SetR14B(unsigned char value); 256 | SCRIPT_EXPORT unsigned long long GetR15(); 257 | SCRIPT_EXPORT bool SetR15(unsigned long long value); 258 | SCRIPT_EXPORT unsigned int GetR15D(); 259 | SCRIPT_EXPORT bool SetR15D(unsigned int value); 260 | SCRIPT_EXPORT unsigned short GetR15W(); 261 | SCRIPT_EXPORT bool SetR15W(unsigned short value); 262 | SCRIPT_EXPORT unsigned char GetR15B(); 263 | SCRIPT_EXPORT bool SetR15B(unsigned char value); 264 | #endif //_WIN64 265 | 266 | SCRIPT_EXPORT duint GetCAX(); 267 | SCRIPT_EXPORT bool SetCAX(duint value); 268 | SCRIPT_EXPORT duint GetCBX(); 269 | SCRIPT_EXPORT bool SetCBX(duint value); 270 | SCRIPT_EXPORT duint GetCCX(); 271 | SCRIPT_EXPORT bool SetCCX(duint value); 272 | SCRIPT_EXPORT duint GetCDX(); 273 | SCRIPT_EXPORT bool SetCDX(duint value); 274 | SCRIPT_EXPORT duint GetCDI(); 275 | SCRIPT_EXPORT bool SetCDI(duint value); 276 | SCRIPT_EXPORT duint GetCSI(); 277 | SCRIPT_EXPORT bool SetCSI(duint value); 278 | SCRIPT_EXPORT duint GetCBP(); 279 | SCRIPT_EXPORT bool SetCBP(duint value); 280 | SCRIPT_EXPORT duint GetCSP(); 281 | SCRIPT_EXPORT bool SetCSP(duint value); 282 | SCRIPT_EXPORT duint GetCIP(); 283 | SCRIPT_EXPORT bool SetCIP(duint value); 284 | SCRIPT_EXPORT duint GetCFLAGS(); 285 | SCRIPT_EXPORT bool SetCFLAGS(duint value); 286 | }; //Register 287 | }; //Script 288 | 289 | #endif //_SCRIPTAPI_REGISTER_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_stack.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_STACK_H 2 | #define _SCRIPTAPI_STACK_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Stack 9 | { 10 | SCRIPT_EXPORT duint Pop(); 11 | SCRIPT_EXPORT duint Push(duint value); //returns the previous top, equal to Peek(1) 12 | SCRIPT_EXPORT duint Peek(int offset = 0); //offset is in multiples of Register::Size(), for easy x32/x64 portability 13 | }; //Stack 14 | }; //Script 15 | 16 | #endif //_SCRIPTAPI_STACK_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/_scriptapi_symbol.h: -------------------------------------------------------------------------------- 1 | #ifndef _SCRIPTAPI_SYMBOL_H 2 | #define _SCRIPTAPI_SYMBOL_H 3 | 4 | #include "_scriptapi.h" 5 | 6 | namespace Script 7 | { 8 | namespace Symbol 9 | { 10 | enum SymbolType 11 | { 12 | Function, //user-defined function 13 | Import, //IAT entry 14 | Export //export 15 | }; 16 | 17 | struct SymbolInfo 18 | { 19 | char mod[MAX_MODULE_SIZE]; 20 | duint rva; 21 | char name[MAX_LABEL_SIZE]; 22 | bool manual; 23 | SymbolType type; 24 | }; 25 | 26 | SCRIPT_EXPORT bool GetList(ListOf(SymbolInfo) list); //caller has the responsibility to free the list 27 | }; //Symbol 28 | }; //Script 29 | 30 | #endif //_SCRIPTAPI_SYMBOL_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/bridgegraph.h: -------------------------------------------------------------------------------- 1 | #ifndef _GRAPH_H 2 | #define _GRAPH_H 3 | 4 | typedef struct 5 | { 6 | duint addr; //virtual address of the instruction 7 | unsigned char data[15]; //instruction bytes 8 | } BridgeCFInstruction; 9 | 10 | typedef struct 11 | { 12 | duint parentGraph; //function of which this node is a part 13 | duint start; //start of the block 14 | duint end; //end of the block (inclusive) 15 | duint brtrue; //destination if condition is true 16 | duint brfalse; //destination if condition is false 17 | duint icount; //number of instructions in node 18 | bool terminal; //node is a RET 19 | bool split; //node is a split (brtrue points to the next node) 20 | bool indirectcall; //node contains indirect calls (call reg, call [reg+X]) 21 | void* userdata; //user data 22 | ListInfo exits; //exits (including brtrue and brfalse, duint) 23 | ListInfo instrs; //block instructions 24 | } BridgeCFNodeList; 25 | 26 | typedef struct 27 | { 28 | duint entryPoint; //graph entry point 29 | void* userdata; //user data 30 | ListInfo nodes; //graph nodes (BridgeCFNodeList) 31 | } BridgeCFGraphList; 32 | 33 | #ifdef __cplusplus 34 | #if _MSC_VER >= 1700 && !defined(NO_CPP11) 35 | 36 | #include 37 | #include 38 | #include 39 | #include 40 | 41 | struct BridgeCFNode 42 | { 43 | duint parentGraph = 0; //function of which this node is a part 44 | duint start = 0; //va of the first instruction in the block 45 | duint end = 0; //va of the last instruction in the block (inclusive) 46 | duint brtrue = 0; //destination if condition is true 47 | duint brfalse = 0; //destination if condition is false 48 | duint icount = 0; //number of instructions in node 49 | bool terminal = false; //node is a RET 50 | bool split = false; //node is a split (brtrue points to the next node) 51 | bool indirectcall = false; //node contains indirect calls (call reg, call [reg+X]) 52 | void* userdata = nullptr; //user data 53 | std::vector exits; //exits (including brtrue and brfalse) 54 | std::vector instrs; //block instructions 55 | 56 | static void Free(const BridgeCFNodeList* nodeList) 57 | { 58 | if(!BridgeList::Free(&nodeList->exits)) 59 | __debugbreak(); 60 | if(!BridgeList::Free(&nodeList->instrs)) 61 | __debugbreak(); 62 | } 63 | 64 | BridgeCFNode() = default; 65 | 66 | BridgeCFNode(const BridgeCFNodeList* nodeList, bool freedata) 67 | { 68 | if(!nodeList) 69 | __debugbreak(); 70 | parentGraph = nodeList->parentGraph; 71 | start = nodeList->start; 72 | end = nodeList->end; 73 | brtrue = nodeList->brtrue; 74 | brfalse = nodeList->brfalse; 75 | icount = nodeList->icount; 76 | terminal = nodeList->terminal; 77 | indirectcall = nodeList->indirectcall; 78 | split = nodeList->split; 79 | userdata = nodeList->userdata; 80 | if(!BridgeList::ToVector(&nodeList->exits, exits, freedata)) 81 | __debugbreak(); 82 | if(!BridgeList::ToVector(&nodeList->instrs, instrs, freedata)) 83 | __debugbreak(); 84 | } 85 | 86 | BridgeCFNode(duint parentGraph, duint start, duint end) 87 | : parentGraph(parentGraph), 88 | start(start), 89 | end(end) 90 | { 91 | } 92 | 93 | BridgeCFNodeList ToNodeList() const 94 | { 95 | BridgeCFNodeList out; 96 | out.parentGraph = parentGraph; 97 | out.start = start; 98 | out.end = end; 99 | out.brtrue = brtrue; 100 | out.brfalse = brfalse; 101 | out.icount = icount; 102 | out.terminal = terminal; 103 | out.indirectcall = indirectcall; 104 | out.split = split; 105 | out.userdata = userdata; 106 | BridgeList::CopyData(&out.exits, exits); 107 | BridgeList::CopyData(&out.instrs, instrs); 108 | return std::move(out); 109 | } 110 | }; 111 | 112 | struct BridgeCFGraph 113 | { 114 | duint entryPoint; //graph entry point 115 | void* userdata; //user data 116 | std::unordered_map nodes; //CFNode.start -> CFNode 117 | std::unordered_map> parents; //CFNode.start -> parents 118 | 119 | static void Free(const BridgeCFGraphList* graphList) 120 | { 121 | if(!graphList || graphList->nodes.size != graphList->nodes.count * sizeof(BridgeCFNodeList)) 122 | __debugbreak(); 123 | auto data = (BridgeCFNodeList*)graphList->nodes.data; 124 | for(int i = 0; i < graphList->nodes.count; i++) 125 | BridgeCFNode::Free(&data[i]); 126 | BridgeFree(data); 127 | } 128 | 129 | explicit BridgeCFGraph(const BridgeCFGraphList* graphList, bool freedata) 130 | { 131 | if(!graphList || graphList->nodes.size != graphList->nodes.count * sizeof(BridgeCFNodeList)) 132 | __debugbreak(); 133 | entryPoint = graphList->entryPoint; 134 | userdata = graphList->userdata; 135 | auto data = (BridgeCFNodeList*)graphList->nodes.data; 136 | for(int i = 0; i < graphList->nodes.count; i++) 137 | AddNode(BridgeCFNode(&data[i], freedata)); 138 | if(freedata && data) 139 | BridgeFree(data); 140 | } 141 | 142 | explicit BridgeCFGraph(duint entryPoint) 143 | : entryPoint(entryPoint), 144 | userdata(nullptr) 145 | { 146 | } 147 | 148 | void AddNode(const BridgeCFNode & node) 149 | { 150 | nodes[node.start] = node; 151 | AddParent(node.start, node.brtrue); 152 | AddParent(node.start, node.brfalse); 153 | } 154 | 155 | void AddParent(duint child, duint parent) 156 | { 157 | if(!child || !parent) 158 | return; 159 | auto found = parents.find(child); 160 | if(found == parents.end()) 161 | { 162 | parents[child] = std::unordered_set(); 163 | parents[child].insert(parent); 164 | } 165 | else 166 | found->second.insert(parent); 167 | } 168 | 169 | BridgeCFGraphList ToGraphList() const 170 | { 171 | BridgeCFGraphList out; 172 | out.entryPoint = entryPoint; 173 | out.userdata = userdata; 174 | std::vector nodeList; 175 | nodeList.reserve(nodes.size()); 176 | for(const auto & nodeIt : nodes) 177 | nodeList.push_back(nodeIt.second.ToNodeList()); 178 | BridgeList::CopyData(&out.nodes, nodeList); 179 | return std::move(out); 180 | } 181 | }; 182 | 183 | #endif //_MSC_VER 184 | #endif //__cplusplus 185 | 186 | #endif //_GRAPH_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/bridgelist.h: -------------------------------------------------------------------------------- 1 | #ifndef _LIST_H 2 | #define _LIST_H 3 | 4 | typedef struct 5 | { 6 | int count; //Number of element in the list. 7 | size_t size; //Size of list in bytes (used for type checking). 8 | void* data; //Pointer to the list contents. Must be deleted by the caller using BridgeFree (or BridgeList::Free). 9 | } ListInfo; 10 | 11 | #define ListOf(Type) ListInfo* 12 | 13 | #ifdef __cplusplus 14 | 15 | #include 16 | 17 | /** 18 | \brief A list object. This object is NOT thread safe. 19 | \tparam Type BridgeList contents type. 20 | */ 21 | template 22 | class BridgeList 23 | { 24 | public: 25 | /** 26 | \brief BridgeList constructor. 27 | \param _freeData (Optional) the free function. 28 | */ 29 | explicit BridgeList() 30 | { 31 | memset(&_listInfo, 0, sizeof(_listInfo)); 32 | } 33 | 34 | /** 35 | \brief BridgeList destructor. 36 | */ 37 | ~BridgeList() 38 | { 39 | Cleanup(); 40 | } 41 | 42 | /** 43 | \brief Gets the list data. 44 | \return Returns ListInfo->data. Can be null if the list was never initialized. Will be destroyed once this object goes out of scope! 45 | */ 46 | Type* Data() const 47 | { 48 | return reinterpret_cast(_listInfo.data); 49 | } 50 | 51 | /** 52 | \brief Gets the number of elements in the list. This will crash the program if the data is not consistent with the specified template argument. 53 | \return The number of elements in the list. 54 | */ 55 | int Count() const 56 | { 57 | if(_listInfo.size != _listInfo.count * sizeof(Type)) //make sure the user is using the correct type. 58 | __debugbreak(); 59 | return _listInfo.count; 60 | } 61 | 62 | /** 63 | \brief Cleans up the list, freeing the list data when it is not null. 64 | */ 65 | void Cleanup() 66 | { 67 | if(_listInfo.data) 68 | { 69 | BridgeFree(_listInfo.data); 70 | _listInfo.data = nullptr; 71 | } 72 | } 73 | 74 | /** 75 | \brief Reference operator (cleans up the previous list) 76 | \return Pointer to the ListInfo. 77 | */ 78 | ListInfo* operator&() 79 | { 80 | Cleanup(); 81 | return &_listInfo; 82 | } 83 | 84 | /** 85 | \brief Array indexer operator. This will crash if you try to access out-of-bounds. 86 | \param index Zero-based index of the item you want to get. 87 | \return Reference to a value at that index. 88 | */ 89 | Type & operator[](size_t index) const 90 | { 91 | if(index >= size_t(Count())) //make sure the out-of-bounds access is caught as soon as possible. 92 | __debugbreak(); 93 | return Data()[index]; 94 | } 95 | 96 | /** 97 | \brief Copies data to a ListInfo structure.. 98 | \param [out] listInfo If non-null, information describing the list. 99 | \param listData Data to copy in the ListInfo structure. 100 | \return true if it succeeds, false if it fails. 101 | */ 102 | static bool CopyData(ListInfo* listInfo, const std::vector & listData) 103 | { 104 | if(!listInfo) 105 | return false; 106 | listInfo->count = int(listData.size()); 107 | listInfo->size = listInfo->count * sizeof(Type); 108 | if(listInfo->count) 109 | { 110 | listInfo->data = BridgeAlloc(listInfo->size); 111 | Type* curItem = reinterpret_cast(listInfo->data); 112 | for(const auto & item : listData) 113 | { 114 | *curItem = item; 115 | ++curItem; 116 | } 117 | } 118 | else 119 | listInfo->data = nullptr; 120 | return true; 121 | } 122 | 123 | static bool Free(const ListInfo* listInfo) 124 | { 125 | if(!listInfo || listInfo->size != listInfo->count * sizeof(Type) || (listInfo->count && !listInfo->data)) 126 | return false; 127 | BridgeFree(listInfo->data); 128 | return true; 129 | } 130 | 131 | static bool ToVector(const ListInfo* listInfo, std::vector & listData, bool freedata = true) 132 | { 133 | if(!listInfo || listInfo->size != listInfo->count * sizeof(Type) || (listInfo->count && !listInfo->data)) 134 | return false; 135 | listData.resize(listInfo->count); 136 | for(int i = 0; i < listInfo->count; i++) 137 | listData[i] = ((Type*)listInfo->data)[i]; 138 | if(freedata && listInfo->data) 139 | BridgeFree(listInfo->data); 140 | return true; 141 | } 142 | 143 | private: 144 | ListInfo _listInfo; 145 | }; 146 | 147 | #endif //__cplusplus 148 | 149 | #endif //_LIST_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/Godzilla_x64.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/qt5_resolver/pluginsdk/godzilla/Godzilla_x64.lib -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/Godzilla_x64_debug.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/qt5_resolver/pluginsdk/godzilla/Godzilla_x64_debug.lib -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/Godzilla_x86.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/qt5_resolver/pluginsdk/godzilla/Godzilla_x86.lib -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/Godzilla_x86_debug.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/qt5_resolver/pluginsdk/godzilla/Godzilla_x86_debug.lib -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/config.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_CONFIG_H_ 2 | 3 | #define _WINDOWS_SYSTEM_ 4 | 5 | #ifdef _WIN64 6 | #define _ARCH_64_ 7 | #endif 8 | 9 | #ifndef _WIN64 10 | #define _ARCH_86_ 11 | #endif 12 | 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gasm/gasm.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GASM_GASM_H_ 2 | #define _GODZILLA_GASM_GASM_H_ 3 | #include 4 | #include 5 | 6 | #include "godzilla.h" 7 | 8 | 9 | #include "capstone.h" 10 | 11 | #include "keystone.h" 12 | 13 | 14 | size_t LengthDisasm( 15 | const csh& handle, 16 | const std::vector& buffer, 17 | size_t expected_size 18 | ); 19 | 20 | 21 | std::vector Asm( 22 | ks_engine* handle, 23 | Fword baseAddress, 24 | const std::string& opcode 25 | ); 26 | 27 | std::vector Disasm( 28 | const csh& handle, 29 | Fword baseAddress, 30 | const std::vector& buffer 31 | ); 32 | 33 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gerror.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GERROR_H_ 2 | #define _GODZILLA_GERROR_H_ 3 | 4 | #ifdef _WINDOWS_SYSTEM_ 5 | #define GetErrCode GetLastError 6 | #endif 7 | 8 | #ifdef _LINUX_SYSTEM_ 9 | #define GetErrCode errno 10 | #endif 11 | 12 | 13 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gfile/pe/pedefs.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GFILE_PEDEFS_H_ 2 | #define _GODZILLA_GFILE_PEDEFS_H_ 3 | 4 | #include "config.h" 5 | 6 | #ifndef _WINDOWS_SYSTEM_ 7 | 8 | 9 | #endif 10 | 11 | #ifdef _WINDOWS_SYSTEM_ 12 | #include 13 | #endif 14 | 15 | 16 | 17 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gfile/pe/pefile.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GFILE_PEFILE_H_ 2 | #define _GODZILLA_GFILE_PEFILE_H_ 3 | 4 | #include 5 | #include 6 | 7 | #include "pedefs.h" 8 | 9 | #include "godzilla.h" 10 | 11 | 12 | 13 | Gauge FoaToVoa(Gauge foa_addr); 14 | 15 | Gauge VoaToFoa(Gauge voa_addr); 16 | 17 | class PEFile { 18 | 19 | public: 20 | 21 | }; 22 | 23 | 24 | 25 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/ghook/ghook.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/retn-ux/qt5_resolver/697ed98b05c619f38daa7726252048bf15034fc2/qt5_resolver/pluginsdk/godzilla/ghook/ghook.h -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gmemory/gmemory.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GMEMORY_GMEMORY_H_ 2 | #define _GODZILLA_GMEMORY_GMEMORY_H_ 3 | 4 | #include "godzilla.h" 5 | 6 | bool ReadMemory( 7 | gpins_t ins, 8 | Gauge address, 9 | void* buffer, 10 | size_t size 11 | ); 12 | 13 | 14 | bool WriteMemory( 15 | gpins_t ins, 16 | Gauge address, 17 | const void* const buffer, 18 | size_t size 19 | ); 20 | 21 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/godzilla.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_GODZILLA_H_ 2 | #define _GODZILLA_GODZILLA_H_ 3 | 4 | #include "config.h" 5 | 6 | #ifdef _WINDOWS_SYSTEM_ 7 | #include 8 | 9 | 10 | 11 | 12 | typedef DWORD pid_t; 13 | 14 | typedef HANDLE gpins_t; 15 | 16 | #define GPINS_INVALID(ins)\ 17 | (ins == INVALID_HANDLE_VALUE || ins == nullptr) 18 | 19 | 20 | #define INVALID_GPINS_T nullptr 21 | 22 | typedef DWORD64 Fword; 23 | typedef DWORD Dword; 24 | typedef WORD Word; 25 | typedef BYTE Byte; 26 | 27 | #endif 28 | 29 | #ifdef _LINUX_SYSTEM_ 30 | #include 31 | 32 | typedef uint64_t Fword; 33 | typedef uint32_t Dword; 34 | typedef uint16_t Word; 35 | typedef uint8_t Byte; 36 | 37 | typedef pid_t gpins_t; 38 | 39 | #define GPINS_INVALID(ins)\ 40 | (ins == 0) 41 | 42 | #define INVALID_GPINS_T 0 43 | 44 | #endif 45 | 46 | 47 | typedef unsigned long ulong; 48 | 49 | #ifdef _ARCH_86_ 50 | typedef Dword Gauge; 51 | #endif 52 | 53 | 54 | #ifdef _ARCH_64_ 55 | typedef Fword Gauge; 56 | #endif 57 | 58 | 59 | #define GAUGE_CAST(value)\ 60 | reinterpret_cast(value) 61 | 62 | 63 | #define VOID_PTR_CAST(value)\ 64 | reinterpret_cast(value) 65 | 66 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gprocess/gprocess.h: -------------------------------------------------------------------------------- 1 | #ifndef _GODZILLA_PROCESS_GPROCESS_H_ 2 | #define _GODZILLA_PROCESS_GPROCESS_H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using std::vector; 9 | using std::wstring; 10 | 11 | #include "config.h" 12 | 13 | #ifdef _WINDOWS_SYSTEM_ 14 | #include 15 | #include 16 | #pragma comment(lib,"Psapi.lib") 17 | 18 | #include 19 | #endif 20 | 21 | #include "godzilla.h" 22 | 23 | #include "gsystem/gsystemexp.h" 24 | 25 | struct ProcessDesc { 26 | gpins_t process_ins; 27 | pid_t pid; 28 | wstring exe_file_path; 29 | }; 30 | 31 | 32 | enum class ModuleType { 33 | ModuleList32Bit = 1, 34 | ModuleList64Bit = 2, 35 | ModuleListAll = (ModuleList32Bit | ModuleList64Bit) 36 | }; 37 | 38 | struct ModuleInfo { 39 | void* lpBaseOfDll; //模块基地址 40 | Dword SizeOfImage; //模块大小 41 | void* EntryPoint; //模块入口地址 42 | wstring theBaseName; 43 | wstring thePath; 44 | }; 45 | 46 | enum class ProcessAccess { 47 | #ifdef _WINDOWS_SYSTEM_ 48 | Query=PROCESS_QUERY_INFORMATION, 49 | ReadMemory=PROCESS_VM_READ, 50 | All_Access=PROCESS_ALL_ACCESS 51 | #endif 52 | }; 53 | 54 | 55 | vector EnumProcessId(); 56 | vector EnumProcess(ProcessAccess access); 57 | 58 | 59 | gpins_t OpenProcess(const std::wstring& path,ProcessAccess access); 60 | gpins_t GetProcessIns(pid_t pid, ProcessAccess access); 61 | 62 | 63 | vector GetProcessModules(gpins_t ins, ModuleType type); 64 | 65 | Gauge GetPebAddress(gpins_t ins); 66 | 67 | Gauge GetProcAddressEx( 68 | gpins_t ins, 69 | const std::wstring& module_name, 70 | const std::string& func_name 71 | ); 72 | 73 | //#ifdef _WINDOWS_SYSTEM_ 74 | //vector GetThreadList(gpins_t ins); 75 | //#endif 76 | 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gsystem/gsystemdefs.h: -------------------------------------------------------------------------------- 1 | #ifndef __GOJIRA_GSYSTEMDEFS_H__ 2 | #define __GOJIRA_GSYSTEMDEFS_H__ 3 | 4 | #include "godzilla.h" 5 | #ifdef _WINDOWS_SYSTEM_ 6 | 7 | #define STATIC_UNICODE_BUFFER_LENGTH 261 8 | #define WIN32_CLIENT_INFO_LENGTH 0x1F 9 | #define TEB_ACTIVE_FRAME_FLAG_EXTENDED (0x00000001) 10 | #define GDI_BATCH_BUFFER_SIZE 310 11 | 12 | 13 | //RtlAdjustPrivilege 14 | #define SeCreateTokenPrivilege 0x2 15 | #define SeAssignPrimaryTokenPrivilege 0x3 16 | #define SeLockMemoryPrivilege 0x4 17 | #define SeIncreaseQuotaPrivilege 0x5 18 | #define SeUnsolicitedInputPrivilege 0x0 19 | #define SeMachineAccountPrivilege 0x6 20 | #define SeTcbPrivilege 0x7 21 | #define SeSecurityPrivilege 0x8 22 | #define SeTakeOwnershipPrivilege 0x9 23 | #define SeLoadDriverPrivilege 0xa 24 | #define SeSystemProfilePrivilege 0xb 25 | #define SeSystemtimePrivilege 0xc 26 | #define SeProfileSingleProcessPrivilege 0xd 27 | #define SeIncreaseBasePriorityPrivilege 0xe 28 | #define SeCreatePagefilePrivilege 0xf 29 | #define SeCreatePermanentPrivilege 0x10 30 | #define SeBackupPrivilege 0x11 31 | #define SeRestorePrivilege 0x12 32 | #define SeShutdownPrivilege 0x13 33 | #define SeDebugPrivilege 0x14 34 | #define SeAuditPrivilege 0x15 35 | #define SeSystemEnvironmentPrivilege 0x16 36 | #define SeChangeNotifyPrivilege 0x17 37 | #define SeRemoteShutdownPrivilege 0x18 38 | #define SeUndockPrivilege 0x19 39 | #define SeSyncAgentPrivilege 0x1a 40 | #define SeEnableDelegationPrivilege 0x1b 41 | #define SeManageVolumePrivilege 0x1c 42 | #define SeImpersonatePrivilege 0x1d 43 | #define SeCreateGlobalPrivilege 0x1e 44 | #define SeTrustedCredManAccessPrivilege 0x1f 45 | #define SeRelabelPrivilege 0x20 46 | #define SeIncreaseWorkingSetPrivilege 0x21 47 | #define SeTimeZonePrivilege 0x22 48 | #define SeCreateSymbolicLinkPrivilege 0x23 49 | 50 | 51 | //ZwShutdownSystem 52 | typedef enum _SHUTDOWN_ACTION { 53 | ShutdownNoReboot, 54 | ShutdownReboot, 55 | ShutdownPowerOff 56 | }SHUTDOWN_ACTION; 57 | 58 | 59 | //NtRaiseHardError 60 | typedef enum _HARDERROR_RESPONSE_OPTION { 61 | OptionAbortRetryIgnore, 62 | OptionOk, 63 | OptionOkCancel, 64 | OptionRetryCancel, 65 | OptionYesNo, 66 | OptionYesNoCancel, 67 | OptionShutdownSystem 68 | } HARDERROR_RESPONSE_OPTION, * PHARDERROR_RESPONSE_OPTION; 69 | 70 | 71 | 72 | typedef enum _HARDERROR_RESPONSE { 73 | ResponseReturnToCaller, 74 | ResponseNotHandled, 75 | ResponseAbort, 76 | ResponseCancel, 77 | ResponseIgnore, 78 | ResponseNo, 79 | ResponseOk, 80 | ResponseRetry, 81 | ResponseYes 82 | } HARDERROR_RESPONSE, * PHARDERROR_RESPONSE; 83 | 84 | 85 | 86 | typedef ULONG PPS_POST_PROCESS_INIT_ROUTINE; 87 | 88 | typedef LONG KPRIORITY; 89 | 90 | typedef enum _PROCESSINFOCLASS 91 | { 92 | ProcessBasicInformation = 0, ProcessDebugPort = 7, ProcessWow64Information = 26, ProcessImageFileName = 27, 93 | ProcessBreakOnTermination = 29, ProcessSubsystemInformation = 75 94 | }PROCESSINFOCLASS; 95 | 96 | 97 | 98 | 99 | 100 | /* 101 | typedef struct _TEB_ACTIVE_FRAME { 102 | ULONG Flags; 103 | TYPE3(struct _TEB_ACTIVE_FRAME*) Previous; 104 | PCTEB_ACTIVE_FRAME_CONTEXT Context; 105 | } TEB_ACTIVE_FRAME, *PTEB_ACTIVE_FRAME; 106 | typedef const struct _TEB_ACTIVE_FRAME *PCTEB_ACTIVE_FRAME; 107 | */ 108 | 109 | 110 | /*enum MSYSTEM_INFORMATION_CLASS { 111 | SystemBasicInformation = 0, 112 | SystemPerformanceInformation = 2, 113 | SystemTimeOfDayInformation = 3, 114 | SystemProcessInformation = 5, 115 | SystemProcessorPerformanceInformation = 8, 116 | SystemInterruptInformation = 23, 117 | SystemExceptionInformation = 33, 118 | SystemRegistryQuotaInformation = 37, 119 | SystemLookasideInformation = 45 120 | };*/ 121 | 122 | typedef enum _SYSTEM_INFORMATION_CLASS { 123 | SystemBasicInformation, 124 | SystemProcessorInformation, 125 | SystemPerformanceInformation, 126 | SystemTimeOfDayInformation, 127 | SystemPathInformation, 128 | SystemProcessInformation, 129 | SystemCallCountInformation, 130 | SystemDeviceInformation, 131 | SystemProcessorPerformanceInformation, 132 | SystemFlagsInformation, 133 | SystemCallTimeInformation, 134 | SystemModuleInformation, 135 | SystemLocksInformation, 136 | SystemStackTraceInformation, 137 | SystemPagedPoolInformation, 138 | SystemNonPagedPoolInformation, 139 | SystemHandleInformation, 140 | SystemObjectInformation, 141 | SystemPageFileInformation, 142 | SystemVdmInstemulInformation, 143 | SystemVdmBopInformation, 144 | SystemFileCacheInformation, 145 | SystemPoolTagInformation, 146 | SystemInterruptInformation, 147 | SystemDpcBehaviorInformation, 148 | SystemFullMemoryInformation, 149 | SystemLoadGdiDriverInformation, 150 | SystemUnloadGdiDriverInformation, 151 | SystemTimeAdjustmentInformation, 152 | SystemSummaryMemoryInformation, 153 | SystemMirrorMemoryInformation, 154 | SystemPerformanceTraceInformation, 155 | SystemObsolete0, 156 | SystemExceptionInformation, 157 | SystemCrashDumpStateInformation, 158 | SystemKernelDebuggerInformation, 159 | SystemContextSwitchInformation, 160 | SystemRegistryQuotaInformation, 161 | SystemExtendServiceTableInformation, 162 | SystemPrioritySeperation, 163 | SystemVerifierAddDriverInformation, 164 | SystemVerifierRemoveDriverInformation, 165 | SystemProcessorIdleInformation, 166 | SystemLegacyDriverInformation, 167 | SystemCurrentTimeZoneInformation, 168 | SystemLookasideInformation, 169 | SystemTimeSlipNotification, 170 | SystemSessionCreate, 171 | SystemSessionDetach, 172 | SystemSessionInformation, 173 | SystemRangeStartInformation, 174 | SystemVerifierInformation, 175 | SystemVerifierThunkExtend, 176 | SystemSessionProcessInformation, 177 | SystemLoadGdiDriverInSystemSpace, 178 | SystemNumaProcessorMap, 179 | SystemPrefetcherInformation, 180 | SystemExtendedProcessInformation, 181 | SystemRecommendedSharedDataAlignment, 182 | SystemComPlusPackage, 183 | SystemNumaAvailableMemory, 184 | SystemProcessorPowerInformation, 185 | SystemEmulationBasicInformation, 186 | SystemEmulationProcessorInformation, 187 | SystemExtendedHandleInformation, 188 | SystemLostDelayedWriteInformation, 189 | SystemBigPoolInformation, 190 | SystemSessionPoolTagInformation, 191 | SystemSessionMappedViewInformation, 192 | SystemHotpatchInformation, 193 | SystemObjectSecurityMode, 194 | SystemWatchdogTimerHandler, 195 | SystemWatchdogTimerInformation, 196 | SystemLogicalProcessorInformation, 197 | SystemWow64SharedInformation, 198 | SystemRegisterFirmwareTableInformationHandler, 199 | SystemFirmwareTableInformation, 200 | SystemModuleInformationEx, 201 | SystemVerifierTriageInformation, 202 | SystemSuperfetchInformation, 203 | SystemMemoryListInformation, 204 | SystemFileCacheInformationEx, 205 | MaxSystemInfoClass // MaxSystemInfoClass should always be the last enum 206 | } SYSTEM_INFORMATION_CLASS; 207 | 208 | typedef enum _THREADINFOCLASS 209 | { 210 | ThreadBasicInformation, // q: THREAD_BASIC_INFORMATION 211 | ThreadTimes, // q: KERNEL_USER_TIMES 212 | ThreadPriority, // s: KPRIORITY 213 | ThreadBasePriority, // s: LONG 214 | ThreadAffinityMask, // s: KAFFINITY 215 | ThreadImpersonationToken, // s: HANDLE 216 | ThreadDescriptorTableEntry, // q: DESCRIPTOR_TABLE_ENTRY (or WOW64_DESCRIPTOR_TABLE_ENTRY) 217 | ThreadEnableAlignmentFaultFixup, // s: BOOLEAN 218 | ThreadEventPair, 219 | ThreadQuerySetWin32StartAddress, // q: PVOID 220 | ThreadZeroTlsCell, // 10 221 | ThreadPerformanceCount, // q: LARGE_INTEGER 222 | ThreadAmILastThread, // q: ULONG 223 | ThreadIdealProcessor, // s: ULONG 224 | ThreadPriorityBoost, // qs: ULONG 225 | ThreadSetTlsArrayAddress, 226 | ThreadIsIoPending, // q: ULONG 227 | ThreadHideFromDebugger, // s: void 228 | ThreadBreakOnTermination, // qs: ULONG 229 | ThreadSwitchLegacyState, 230 | ThreadIsTerminated, // q: ULONG // 20 231 | ThreadLastSystemCall, // q: THREAD_LAST_SYSCALL_INFORMATION 232 | ThreadIoPriority, // qs: IO_PRIORITY_HINT 233 | ThreadCycleTime, // q: THREAD_CYCLE_TIME_INFORMATION 234 | ThreadPagePriority, // q: ULONG 235 | ThreadActualBasePriority, 236 | ThreadTebInformation, // q: THREAD_TEB_INFORMATION (requires THREAD_GET_CONTEXT + THREAD_SET_CONTEXT) 237 | ThreadCSwitchMon, 238 | ThreadCSwitchPmu, 239 | ThreadWow64Context, // q: WOW64_CONTEXT 240 | ThreadGroupInformation, // q: GROUP_AFFINITY // 30 241 | ThreadUmsInformation, // q: THREAD_UMS_INFORMATION 242 | ThreadCounterProfiling, 243 | ThreadIdealProcessorEx, // q: PROCESSOR_NUMBER 244 | ThreadCpuAccountingInformation, // since WIN8 245 | ThreadSuspendCount, // since WINBLUE 246 | ThreadHeterogeneousCpuPolicy, // q: KHETERO_CPU_POLICY // since THRESHOLD 247 | ThreadContainerId, // q: GUID 248 | ThreadNameInformation, // qs: THREAD_NAME_INFORMATION 249 | ThreadSelectedCpuSets, 250 | ThreadSystemThreadInformation, // q: SYSTEM_THREAD_INFORMATION // 40 251 | ThreadActualGroupAffinity, // since THRESHOLD2 252 | ThreadDynamicCodePolicyInfo, 253 | ThreadExplicitCaseSensitivity, 254 | ThreadWorkOnBehalfTicket, 255 | ThreadSubsystemInformation, // q: SUBSYSTEM_INFORMATION_TYPE // since REDSTONE2 256 | ThreadDbgkWerReportActive, 257 | ThreadAttachContainer, 258 | MaxThreadInfoClass 259 | } THREADINFOCLASS; 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | template 271 | struct _GDI_TEB_BATCH { 272 | ULONG Offset; 273 | T HDC; 274 | ULONG Buffer[GDI_BATCH_BUFFER_SIZE]; 275 | }; 276 | 277 | typedef _GDI_TEB_BATCH GDI_TEB_BATCH32, * PGDI_TEB_BATCH32; 278 | typedef _GDI_TEB_BATCH GDI_TEB_BATCH64, * PGDI_TEB_BATCH64; 279 | 280 | #ifdef _ARCH_86_ 281 | #define GDI_TEB_BATCH GDI_TEB_BATCH32 282 | #endif 283 | #ifdef _ARCH_64_ 284 | #define GDI_TEB_BATCH GDI_TEB_BATCH64 285 | #endif 286 | 287 | template 288 | struct _STRING { 289 | USHORT Length; 290 | USHORT MaximumLength; 291 | T Buffer; 292 | }; 293 | 294 | 295 | typedef _STRING STRING32, PSTRING32; 296 | typedef _STRING STRING64, PSTRING64; 297 | 298 | template 299 | struct _RTL_DRIVE_LETTER_CURDIR { 300 | WORD Flags; 301 | WORD Length; 302 | DWORD TimeStamp; 303 | _STRING DosPath; 304 | }; 305 | 306 | typedef _RTL_DRIVE_LETTER_CURDIR RTL_DRIVE_LETTER_CURDIR32, * PRTL_DRIVE_LETTER_CURDIR32; 307 | typedef _RTL_DRIVE_LETTER_CURDIR RTL_DRIVE_LETTER_CURDIR64, * PRTL_DRIVE_LETTER_CURDIR64; 308 | 309 | 310 | //unicode�ַ� 311 | template 312 | struct _UNICODE_STRING { 313 | USHORT Length; 314 | USHORT MaximumLength; 315 | T Buffer; 316 | }; 317 | typedef _UNICODE_STRING UNICODE_STRING32, PUNICODE_STRING32; 318 | typedef _UNICODE_STRING UNICODE_STRING64, PUNICODE_STRING64; 319 | 320 | #ifdef _ARCH_86_ 321 | #define UNICODE_STRING UNICODE_STRING32 322 | #endif 323 | #ifdef _ARCH_64_ 324 | #define UNICODE_STRING UNICODE_STRING64 325 | #endif 326 | 327 | 328 | 329 | template 330 | struct _CLIENT_ID { 331 | T UniqueProcess; 332 | T UniqueThread; 333 | }; 334 | typedef _CLIENT_ID CLIENT_ID32, * PCLIENT_ID32; 335 | typedef _CLIENT_ID CLIENT_ID64, * PCLIENT_ID64; 336 | 337 | #ifdef _ARCH_86_ 338 | #define CLIENT_ID CLIENT_ID32 339 | #endif 340 | #ifdef _ARCH_64_ 341 | #define CLIENT_ID CLIENT_ID64 342 | #endif 343 | 344 | 345 | template 346 | struct _CURDIR { 347 | _UNICODE_STRING DosPath; 348 | T Handle; 349 | }; 350 | typedef _CURDIR CURDIR32, PCURDIR32; 351 | typedef _CURDIR CURDIR64, PCURDIR64; 352 | 353 | 354 | //�ýṹ�������̲�����Ϣ�����������У� 355 | template 356 | struct _RTL_USER_PROCESS_PARAMETERS 357 | { 358 | ULONG MaximumLength; 359 | ULONG Length; 360 | ULONG Flags; 361 | ULONG DebugFlags; 362 | TPVOID ConsoleHandle; 363 | ULONG ConsoleFlags; 364 | TPVOID StandardInput; 365 | TPVOID StandardOutput; 366 | TPVOID StandardError; 367 | _CURDIR CurrentDirectory; 368 | _UNICODE_STRING DllPath; 369 | _UNICODE_STRING ImagePathName; 370 | _UNICODE_STRING CommandLine; 371 | TPVOID Environment; 372 | ULONG StartingX; 373 | ULONG StartingY; 374 | ULONG CountX; 375 | ULONG CountY; 376 | ULONG CountCharsX; 377 | ULONG CountCharsY; 378 | ULONG FillAttribute; 379 | ULONG WindowFlags; 380 | ULONG ShowWindowFlags; 381 | _UNICODE_STRING WindowTitle; 382 | _UNICODE_STRING DesktopInfo; 383 | _UNICODE_STRING ShellInfo; 384 | _UNICODE_STRING RuntimeData; 385 | _RTL_DRIVE_LETTER_CURDIR CurrentDirectores[32]; 386 | TULONG EnvironmentSize; 387 | TULONG EnvironmentVersion; 388 | TPVOID PackageDependencyData; 389 | ULONG ProcessGroupId; 390 | ULONG LoaderThreads; 391 | _UNICODE_STRING RedirectionDllName; 392 | }; 393 | 394 | typedef _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS32, * PRTL_USER_PROCESS_PARAMETERS32; 395 | typedef _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS64, * PRTL_USER_PROCESS_PARAMETERS64; 396 | 397 | 398 | 399 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | typedef struct _SYSTEM_SPECULATION_CONTROL_INFORMATION { 409 | struct { 410 | ULONG BpbEnabled : 1; 411 | ULONG BpbDisabledSystemPolicy : 1; 412 | ULONG BpbDisabledNoHardwareSupport : 1; 413 | ULONG SpecCtrlEnumerated : 1; 414 | ULONG SpecCmdEnumerated : 1; 415 | ULONG IbrsPresent : 1; 416 | ULONG StibpPresent : 1; 417 | ULONG SmepPresent : 1; 418 | ULONG SpeculativeStoreBypassDisableAvailable : 1; 419 | ULONG SpeculativeStoreBypassDisableSupported : 1; 420 | ULONG SpeculativeStoreBypassDisabledSystemWide : 1; 421 | ULONG SpeculativeStoreBypassDisabledKernel : 1; 422 | ULONG SpeculativeStoreBypassDisableRequired : 1; 423 | ULONG BpbDisabledKernelToUser : 1; 424 | ULONG SpecCtrlRetpolineEnabled : 1; 425 | ULONG SpecCtrlImportOptimizationEnabled : 1; 426 | ULONG Reserved : 16; 427 | } SpeculationControlFlags; 428 | } SYSTEM_SPECULATION_CONTROL_INFORMATION, * PSYSTEM_SPECULATION_CONTROL_INFORMATION; 429 | 430 | 431 | 432 | typedef struct _SYSTEM_CODEINTEGRITY_INFORMATION { 433 | ULONG Length; 434 | ULONG CodeIntegrityOptions; 435 | } SYSTEM_CODEINTEGRITY_INFORMATION, * PSYSTEM_CODEINTEGRITY_INFORMATION; 436 | 437 | typedef struct 438 | _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { 439 | LARGE_INTEGER IdleTime; 440 | LARGE_INTEGER KernelTime; 441 | LARGE_INTEGER UserTime; 442 | LARGE_INTEGER Reserved1[2]; 443 | ULONG Reserved2; 444 | } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; 445 | 446 | typedef struct _QUERY_PERFORMANCE_COUNTER_FLAGS { 447 | union { 448 | struct { 449 | ULONG KernelTransition : 1; 450 | ULONG Reserved : 31; 451 | }; 452 | ULONG ul; 453 | }; 454 | } QUERY_PERFORMANCE_COUNTER_FLAGS; 455 | 456 | 457 | 458 | typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION { 459 | ULONG RegistryQuotaAllowed; 460 | ULONG RegistryQuotaUsed; 461 | PVOID Reserved1; 462 | } SYSTEM_REGISTRY_QUOTA_INFORMATION; 463 | 464 | 465 | typedef struct _SYSTEM_PROCESS_INFORMATION { 466 | ULONG NextEntryOffset; 467 | ULONG NumberOfThreads; 468 | LARGE_INTEGER SpareLi1; 469 | LARGE_INTEGER SpareLi2; 470 | LARGE_INTEGER SpareLi3; 471 | LARGE_INTEGER CreateTime; 472 | LARGE_INTEGER UserTime; 473 | LARGE_INTEGER KernelTime; 474 | UNICODE_STRING32 ImageName; 475 | KPRIORITY BasePriority; 476 | HANDLE UniqueProcessId; 477 | HANDLE InheritedFromUniqueProcessId; 478 | ULONG HandleCount; 479 | ULONG SessionId; 480 | ULONG_PTR PageDirectoryBase; 481 | SIZE_T PeakVirtualSize; 482 | SIZE_T VirtualSize; 483 | ULONG PageFaultCount; 484 | SIZE_T PeakWorkingSetSize; 485 | SIZE_T WorkingSetSize; 486 | SIZE_T QuotaPeakPagedPoolUsage; 487 | SIZE_T QuotaPagedPoolUsage; 488 | SIZE_T QuotaPeakNonPagedPoolUsage; 489 | SIZE_T QuotaNonPagedPoolUsage; 490 | SIZE_T PagefileUsage; 491 | SIZE_T PeakPagefileUsage; 492 | SIZE_T PrivatePageCount; 493 | LARGE_INTEGER ReadOperationCount; 494 | LARGE_INTEGER WriteOperationCount; 495 | LARGE_INTEGER OtherOperationCount; 496 | LARGE_INTEGER ReadTransferCount; 497 | LARGE_INTEGER WriteTransferCount; 498 | LARGE_INTEGER OtherTransferCount; 499 | } SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION; 500 | 501 | // WinDbg> dt -v ntdll!_PEB_FREE_BLOCK 502 | typedef struct _PEB_FREE_BLOCK // 2 elements, 0x8 bytes 503 | { 504 | struct _PEB_FREE_BLOCK* pNext; 505 | DWORD dwSize; 506 | } PEB_FREE_BLOCK, * PPEB_FREE_BLOCK; 507 | 508 | 509 | 510 | template 511 | struct _PEB_LDR_DATA 512 | { 513 | ULONG Length; 514 | BOOLEAN Initialized; 515 | BYTE padding[3]; 516 | TPVOID SsHandle; 517 | TLIST_ENTRY InLoadOrderModuleList; 518 | TLIST_ENTRY InMemoryOrderModuleList; 519 | TLIST_ENTRY InInitializationOrderModuleList; 520 | TPVOID EntryInProgress; 521 | BYTE ShutdownInProgress; 522 | TPVOID ShutdownThreadId; 523 | 524 | }; 525 | 526 | typedef _PEB_LDR_DATA PEB_LDR_DATA32, * PPEB_LDR_DATA32; 527 | typedef _PEB_LDR_DATA PEB_LDR_DATA64, * PPEB_LDR_DATA64; 528 | 529 | 530 | 531 | 532 | //�ýṹ�����йؽ��̵��Ѽ���ģ�����Ϣ 533 | //PEB_LDR_DATA��InMemoryOrderModuleListÿһ�ָ������ṹ 534 | template 535 | struct _LDR_DATA_TABLE_ENTRY 536 | { 537 | TLIST_ENTRY InLoadOrderLinks; 538 | TLIST_ENTRY InMemoryOrderLinks; 539 | TLIST_ENTRY InInitializationOrderLinks; 540 | TPVOID DllBase; 541 | TPVOID EntryPoint; 542 | ULONG SizeOfImage; 543 | _UNICODE_STRING FullDllName; 544 | _UNICODE_STRING BaseDllName; 545 | union 546 | { 547 | BYTE FlagGroup[4]; 548 | ULONG Flags; 549 | }; 550 | USHORT LoadCount; 551 | USHORT TlsIndex; 552 | union 553 | { 554 | LIST_ENTRY HashLinks; 555 | struct 556 | { 557 | PVOID SectionPointer; 558 | ULONG CheckSum; 559 | }; 560 | }; 561 | ULONG TimeDateStamp; 562 | TPVOID EntryPointActivationContext; //ָ��_ACTIVATION_CONTEXT 563 | TPVOID Lock; 564 | TPVOID DdagNode; //ָ�� _LDR_DDAG_NODE 565 | TLIST_ENTRY NodeModuleLink; 566 | TPVOID LoadContext; //ָ�� _LDRP_LOAD_CONTEXT 567 | TPVOID ParentDllBase; 568 | TPVOID SwitchBackContext; 569 | BYTE BaseAddressIndexNode[Size]; //_RTL_BALANCED_NODE 570 | BYTE MappingInfoIndexNode[Size]; //_RTL_BALANCED_NODE 571 | TULONG OriginalBase; 572 | LARGE_INTEGER LoadTime; 573 | ULONG BaseNameHashValue; 574 | BYTE LoadReason[0x4]; //_LDR_DLL_LOAD_REASON 575 | ULONG ImplicitPathOptions; 576 | ULONG ReferenceCount; 577 | ULONG DependentLoadFlags; 578 | BYTE SigningLevel; 579 | }; 580 | 581 | typedef _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY32, * PLDR_DATA_TABLE_ENTRY32; 582 | typedef _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY64, * PLDR_DATA_TABLE_ENTRY64; 583 | 584 | 585 | struct BITFIELD { 586 | BYTE ImageUsesLargePages : 1; 587 | BYTE IsProtectedProcess : 1; 588 | BYTE IsImageDynamicallyRelocated : 1; 589 | BYTE SkipPatchingUser32Forwarders : 1; 590 | BYTE IsPackagedProcess : 1; 591 | BYTE IsAppContainer : 1; 592 | BYTE IsProtectedProcessLight : 1; 593 | BYTE IsLongPathAwareProcess : 1; 594 | }; 595 | 596 | struct TRACEFLAG { 597 | ULONG HeapTracingEnabled : 1; 598 | ULONG CritSecTracingEnabled : 1; 599 | ULONG LibLoaderTracingEnabled : 1; 600 | ULONG SpareTracingBits : 29; 601 | }; 602 | 603 | struct LEAPSECONDFLAGS { 604 | ULONG SixtySecondEnabled : 1; 605 | ULONG Reserved : 31; 606 | 607 | }; 608 | 609 | 610 | struct CROSSPROCESSFLAGS { 611 | ULONG ProcessInJob : 1; 612 | ULONG ProcessInitializing : 1; 613 | ULONG ProcessUsingVEH : 1; 614 | ULONG ProcessUsingVCH : 1; 615 | ULONG ProcessUsingFTH : 1; 616 | ULONG ProcessPreviouslyThrottled : 1; 617 | ULONG ProcessCurrentlyThrottled : 1; 618 | ULONG ProcessImagesHotPatched : 1; 619 | ULONG ReservedBits0 : 24; 620 | }; 621 | 622 | template 623 | struct PADDING { 624 | META meta; 625 | BYTE padding[size]; 626 | }; 627 | 628 | 629 | 630 | template 631 | struct _PEB // 65 elements, 0x210 bytes 632 | { 633 | BYTE bInheritedAddressSpace; 634 | BYTE bReadImageFileExecOptions; 635 | BYTE bBeingDebugged; 636 | TBITFIELD BitField; 637 | TPVOID lpMutant; 638 | TPVOID lpImageBaseAddress; 639 | _PEB_LDR_DATA* pLdr; 640 | _RTL_USER_PROCESS_PARAMETERS* lpProcessParameters; 641 | TPVOID lpSubSystemData; 642 | TPVOID lpProcessHeap; 643 | TPVOID pFastPebLock; //ָ��_RTL_CRITICAL_SECTION 644 | TPVOID AtlThunkSListPtr; //ָ��_SLIST_HEADER 645 | TPVOID IFEOKey; 646 | TCROSSPROCESSFLAGS CrossProcessFlags; 647 | union { 648 | TPVOID lpKernelCallbackTable; 649 | TPVOID UserSharedInfoPtr; 650 | }; 651 | DWORD dwSystemReserved; 652 | DWORD dwAtlThunkSListPtr32; //32λϵͳ��ָ��_SLIST_HEADER 653 | TPVOID ApiSetMap; 654 | TDWORDPAD dwTlsExpansionCounter;//TLS�������� 655 | TPVOID lpTlsBitmap;//TLSλͼ 656 | DWORD dwTlsBitmapBits[2];//��̬Tls���̱�־λ 657 | TPVOID lpReadOnlySharedMemoryBase; 658 | TPVOID lpReadOnlySharedMemoryHeap; 659 | TPVOID lpReadOnlyStaticServerData; 660 | TPVOID lpAnsiCodePageData; 661 | TPVOID lpOemCodePageData; 662 | TPVOID lpUnicodeCaseTableData; 663 | DWORD dwNumberOfProcessors; 664 | DWORD dwNtGlobalFlag; 665 | LARGE_INTEGER liCriticalSectionTimeout; 666 | TULONG dwHeapSegmentReserve; 667 | TULONG dwHeapSegmentCommit; 668 | TULONG dwHeapDeCommitTotalFreeThreshold; 669 | TULONG dwHeapDeCommitFreeBlockThreshold; 670 | DWORD dwNumberOfHeaps; 671 | DWORD dwMaximumNumberOfHeaps; 672 | TPVOID lpProcessHeaps; 673 | TPVOID lpGdiSharedHandleTable; 674 | TPVOID lpProcessStarterHelper; 675 | TDWORDPAD dwGdiDCAttributeList; 676 | TPVOID lpLoaderLock; //ָ�� _RTL_CRITICAL_SECTION 677 | DWORD dwOSMajorVersion; 678 | DWORD dwOSMinorVersion; 679 | WORD wOSBuildNumber; 680 | WORD wOSCSDVersion; 681 | DWORD dwOSPlatformId; 682 | DWORD dwImageSubsystem; 683 | DWORD dwImageSubsystemMajorVersion; 684 | TDWORDPAD dwImageSubsystemMinorVersion; 685 | DWORD ActiveProcessAffinityMask; 686 | DWORD dwGdiHandleBuffer[Size]; 687 | TPVOID lpPostProcessInitRoutine; 688 | TPVOID lpTlsExpansionBitmap; 689 | DWORD dwTlsExpansionBitmapBits[32]; 690 | TDWORDPAD dwSessionId; 691 | ULARGE_INTEGER liAppCompatFlags; 692 | ULARGE_INTEGER liAppCompatFlagsUser; 693 | TPVOID lppShimData; 694 | TPVOID lpAppCompatInfo; 695 | _UNICODE_STRING usCSDVersion; 696 | TPVOID lpActivationContextData; 697 | TPVOID lpProcessAssemblyStorageMap; 698 | TPVOID lpSystemDefaultActivationContextData; 699 | TPVOID lpSystemAssemblyStorageMap; 700 | DWORD dwMinimumStackCommit; 701 | TPVOID FlsCallback; //_FLS_CALLBACK_INFO 702 | TLIST_ENTRY FlsListHead; 703 | TPVOID FlsBitmap; 704 | DWORD FlsBitmapBits[4]; 705 | DWORD FlsHighIndex; 706 | TPVOID WerRegistrationData; 707 | TPVOID WerShipAssertPtr; 708 | TPVOID pUnused; 709 | TPVOID pImageHeaderHash; 710 | TTRACEFLAG TracingFlags; 711 | DWORD64 CsrServerReadOnlySharedMemoryBase; 712 | TULONG TppWorkerpListLock; 713 | TLIST_ENTRY TppWorkerpList; 714 | TPVOID WaitOnAddressHashTable[128]; 715 | TPVOID TelemetryCoverageHeader; 716 | ULONG CloudFileFlags; 717 | ULONG CloudFileDiagFlags; 718 | char PlaceholderCompatibilityMode; 719 | char PlaceholderCompatibilityModeReserved[0x7]; 720 | TPVOID LeapSecondData;//_LEAP_SECOND_DATA 721 | ULONG LeapSecondFlags; 722 | DWORD NtGlobalFlag2; 723 | }; 724 | 725 | typedef _PEB> PEB32, * PPEB32; 726 | typedef _PEB, PADDING, PADDING, 60, LIST_ENTRY64, PADDING> PEB64, * PPEB64; 727 | 728 | 729 | 730 | template 731 | struct _PROCESS_BASIC_INFORMATION 732 | { 733 | 734 | TDWORD ExitStatus; // ���ս�����ֹ״̬ 735 | 736 | TDWORD PebBaseAddress; // ���ս��̻������ַ 737 | 738 | TDWORD AffinityMask; // ���ս��̹������� 739 | 740 | TDWORD BasePriority; // ���ս��̵����ȼ��� 741 | 742 | TDWORD UniqueProcessId; // ���ս���ID 743 | 744 | TDWORD InheritedFromUniqueProcessId; //���ո�����ID 745 | 746 | }; 747 | 748 | typedef _PROCESS_BASIC_INFORMATION PROCESS_BASIC_INFORMATION32, * PPROCESS_BASIC_INFORMATION32; 749 | typedef _PROCESS_BASIC_INFORMATION PROCESS_BASIC_INFORMATION64, * PPROCESS_BASIC_INFORMATION64; 750 | 751 | //����ṹ�����и����̵�ID����Ӧ�Ĺٷ��� Reserved3�ֶΣ� 752 | //���н��̵�PEB����һ�½��̻�������Ķ��壺*/ 753 | 754 | 755 | typedef struct _THREAD_BASIC_INFORMATION32 756 | { 757 | NTSTATUS ExitStatus; 758 | PVOID TebBaseAddress; 759 | CLIENT_ID ClientId; 760 | KAFFINITY AffinityMask; 761 | KPRIORITY Priority; 762 | KPRIORITY BasePriority; 763 | } THREAD_BASIC_INFORMATION32, * PTHREAD_BASIC_INFORMATION32; 764 | 765 | typedef struct _THREAD_BASIC_INFORMATION64 766 | { 767 | NTSTATUS ExitStatus; 768 | DWORD Padding; 769 | PVOID TebBaseAddress; 770 | CLIENT_ID ClientId; 771 | KAFFINITY AffinityMask; 772 | KPRIORITY Priority; 773 | KPRIORITY BasePriority; 774 | } THREAD_BASIC_INFORMATION64, * PTHREAD_BASIC_INFORMATION64; 775 | 776 | 777 | #ifdef _WRK_ 778 | typedef struct _SYSTEM_PROCESS_INFORMATION { 779 | ULONG NextEntryOffset; 780 | ULONG NumberOfThreads; 781 | LARGE_INTEGER SpareLi1; 782 | LARGE_INTEGER SpareLi2; 783 | LARGE_INTEGER SpareLi3; 784 | LARGE_INTEGER CreateTime; 785 | LARGE_INTEGER UserTime; 786 | LARGE_INTEGER KernelTime; 787 | UNICODE_STRING ImageName; 788 | KPRIORITY BasePriority; 789 | HANDLE UniqueProcessId; 790 | HANDLE InheritedFromUniqueProcessId; 791 | ULONG HandleCount; 792 | ULONG SessionId; 793 | ULONG_PTR PageDirectoryBase; 794 | SIZE_T PeakVirtualSize; 795 | SIZE_T VirtualSize; 796 | ULONG PageFaultCount; 797 | SIZE_T PeakWorkingSetSize; 798 | SIZE_T WorkingSetSize; 799 | SIZE_T QuotaPeakPagedPoolUsage; 800 | SIZE_T QuotaPagedPoolUsage; 801 | SIZE_T QuotaPeakNonPagedPoolUsage; 802 | SIZE_T QuotaNonPagedPoolUsage; 803 | SIZE_T PagefileUsage; 804 | SIZE_T PeakPagefileUsage; 805 | SIZE_T PrivatePageCount; 806 | LARGE_INTEGER ReadOperationCount; 807 | LARGE_INTEGER WriteOperationCount; 808 | LARGE_INTEGER OtherOperationCount; 809 | LARGE_INTEGER ReadTransferCount; 810 | LARGE_INTEGER WriteTransferCount; 811 | LARGE_INTEGER OtherTransferCount; 812 | } SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION; 813 | 814 | #endif 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | /* 823 | //�ж����������� 824 | typedef struct _KIDTENTRY { 825 | USHORT Offset; 826 | USHORT Selector; 827 | USHORT Access; 828 | USHORT ExtendedOffset; 829 | }KIDTENTRY; 830 | typedef KIDTENTRY *PKIDTENTRY; 831 | 832 | 833 | //SYSTEM SERVER DESCRIPTOR TABLE(KeServiceDescriptorTable) 834 | typedef struct _KSERVER_TABLE_DESCRIPTOR { 835 | PULONG Base; //����ַ ָ��KeServiceTable 836 | PULONG Count; 837 | ULONG Limit; //�ܸ��� 838 | PUCHAR Number; //���������� 839 | }KSERVER_TABLE_DESCRIPTOR, *PKSERVER_TABLE_DESCRIPTOR; 840 | 841 | 842 | //SYSTEM SERVER DESCRIPTOR SHADOW(KeServiceDescriptorTableShadow) 843 | typedef struct _KSERVER_TABLE_DESCRIPTOR_SHADOW{ 844 | //������KeServiceDescriptorTable��ȫһ�� 845 | PULONG Base; //����ַ ָ��KeServiceTable 846 | PULONG Count; 847 | ULONG Limit; //�ܸ��� 848 | PUCHAR Number; //���������� 849 | //����ʱShadow�Ķ��б��� 850 | PULONG BaseOfShadow; //����ַ ָ��W32pServiceTable 851 | PULONG CountOfShadow; 852 | ULONG LimitOfShadow; //�ܸ��� 853 | PUCHAR NumberOfShadow; //���������� 854 | }KSERVER_TABLE_DESCRIPTOR_SHADOW, *PKSERVER_TABLE_DESCRIPTOR_SHADOW; 855 | 856 | 857 | 858 | 859 | 860 | 861 | typedef NTSYSCALLAPI NTSTATUS (NTAPI *PNTQUERYINFOMATIONTHREAD)( 862 | _In_ HANDLE , 863 | _In_ THREADINFOCLASS , 864 | _Out_ PVOID , 865 | _In_ ULONG , 866 | _Out_opt_ PULONG 867 | ); 868 | */ 869 | /*typedef struct _CLIENTINFO { 870 | DWORD CI_flags; // Needs to be first because CSR 871 | DWORD cSpins; 872 | DWORD dwExpWinVer; 873 | DWORD dwCompatFlags; 874 | DWORD dwTIFlags; 875 | PDESKTOPINFO pDeskInfo; 876 | ULONG ulClientDelta; 877 | struct tagHOOK *phkCurrent; 878 | DWORD fsHooks; 879 | CALLBACKWND CallbackWnd; 880 | DWORD dwHookCurrent; 881 | int cInDDEMLCallback; 882 | HANDLE hDdemlCallbackInst; 883 | PCLIENTTHREADINFO pClientThreadInfo; 884 | DWORD dwHookData; 885 | DWORD dwKeyCache; 886 | BYTE afKeyState[CBKEYCACHE]; 887 | DWORD dwAsyncKeyCache; 888 | BYTE afAsyncKeyState[CBASYNCKEYCACHE]; 889 | BYTE afAsyncKeyStateRecentDown[CBASYNCKEYCACHE]; 890 | WORD CodePage; 891 | HKL hKL; 892 | 893 | BYTE achDbcsCF[2]; // Save ANSI DBCS LeadByte character code 894 | // in this field for ANSI to Unicode. 895 | // Uses SendMessageA/PostMessageA from CLIENT 896 | // to SERVER (index 0) 897 | // And... 898 | // Uses SendMessageA/DispatchMessageA 899 | // for CLIENT to CLIENT (index 1) 900 | MSG msgDbcsCB; // Save ANSI DBCS character message in 901 | // this field for convert Unicode to ANSI. 902 | // Uses GetMessageA/PeekMessageA from 903 | // SERVER to CLIENT 904 | } CLIENTINFO, *PCLIENTINFO;*/ 905 | /*typedef struct _KPCR 906 | { 907 | _ANONYMOUS_UNION union 908 | { 909 | NT_TIB NtTib;//�����ǵ�ǰ�̵߳Ŀ��ƿ� 910 | _ANONYMOUS_STRUCT struct 911 | { 912 | union _KGDTENTRY64 *GdtBase;///gdt�� 913 | struct _KTSS64 *TssBase; 914 | ULONG64 UserRsp; 915 | struct _KPCR *Self; 916 | struct _KPRCB *CurrentPrcb; 917 | PKSPIN_LOCK_QUEUE LockArray; 918 | PVOID Used_Self; 919 | }; 920 | }; 921 | union _KIDTENTRY64 *IdtBase; 922 | ULONG64 Unused[2]; 923 | KIRQL Irql; 924 | UCHAR SecondLevelCacheAssociativity; 925 | UCHAR ObsoleteNumber; 926 | UCHAR Fill0; 927 | ULONG Unused0[3]; 928 | USHORT MajorVersion; 929 | USHORT MinorVersion; 930 | ULONG StallScaleFactor; 931 | PVOID Unused1[3]; 932 | ULONG KernelReserved[15]; 933 | ULONG SecondLevelCacheSize; 934 | ULONG HalReserved[16]; 935 | ULONG Unused2; 936 | PVOID KdVersionBlock; 937 | PVOID Unused3; 938 | ULONG PcrAlign1[24]; 939 | } KPCR, *PKPCR;*/ 940 | 941 | typedef struct _ACTIVATION_CONTEXT_STACK { 942 | PVOID ActiveFrame; //_RTL_ACTIVATION_CONTEXT_STACK_FRAME 943 | LIST_ENTRY FrameListCache; 944 | DWORD Flags; 945 | DWORD NextCookieSequenceNumber; 946 | DWORD StackId; 947 | }ACTIVATION_CONTEXT_STACK, * PACTIVATION_CONTEXT_STACK; 948 | 949 | typedef struct _TXFSCONTEXTBLOCK32 { 950 | UCHAR InstrumentationCallbackDisabled; 951 | UCHAR SpareBytes[23]; 952 | DWORD TxFsContext; 953 | }TXFSCONTEXTBLOCK32; 954 | 955 | typedef struct _TXFSCONTEXTBLOCK64 { 956 | DWORD TxFsContext; 957 | BYTE InstrumentationCallbackDisabled; 958 | BYTE UnalignedLoadStoreExceptions; 959 | BYTE Padding[2]; 960 | }TXFSCONTEXTBLOCK64; 961 | 962 | struct PADSTATICNICODEBUFFER32 { 963 | BYTE StaticUnicodeBuffer[261]; 964 | }; 965 | 966 | struct PADSTATICNICODEBUFFER64 { 967 | BYTE StaticUnicodeBuffer[261]; 968 | BYTE padding[6]; 969 | }; 970 | 971 | /************************************************************* 972 | *TEB 973 | ***********************************************************/ 974 | template 975 | struct __TEB { 976 | NT_TIB NtTib; 977 | PVOID EnvironmentPointer; 978 | CLIENT_ID ClientId; 979 | PVOID ActiveRpcHandle; 980 | PVOID ThreadLocalStoragePointer;// //ָ���ž�̬TLS���ݵĵ�ַ��ָ��ĵ�ַ 981 | PVOID ProcessEnvironmentBlock; 982 | ULONG LastErrorValue; 983 | ULONG CountOfOwnedCriticalSections; 984 | PVOID CsrClientThread; 985 | PVOID Win32ThreadInfo;// PtiCurrent 986 | DWORD User32Reserved[26];// User32 Client Info 987 | DWORD UserReserved[5]; 988 | PVOID WOW32Reserved;// used by WOW 989 | LCID CurrentLocale; 990 | ULONG FpSoftwareStatusRegister; 991 | PVOID ReservedForDebuggerInstrumentation[16];// Used by FP emulator 992 | PVOID SystemReserved1[SystemReserved1Size]; 993 | CHAR PlaceholderCompatibilityMode; 994 | BYTE PlaceholderHydrationAlwaysExplicit; 995 | CHAR PlaceholderReserved[10]; 996 | DWORD ProxiedProcessId; 997 | ACTIVATION_CONTEXT_STACK _ActivationStack; 998 | BYTE WorkingOnBehalfTicket[0x8]; 999 | TPADINT ExceptionCode; 1000 | PVOID ActivationContextStackPointer;// _ACTIVATION_CONTEXT_STACK 1001 | TDWORD InstrumentationCallbackSp; 1002 | TDWORD InstrumentationCallbackPreviousPc; 1003 | TDWORD InstrumentationCallbackPreviousSp; 1004 | TXFSCONTEXTBLOCK TxFsContext; 1005 | GDI_TEB_BATCH GdiTebBatch;// Gdi batching 1006 | CLIENT_ID RealClientId; 1007 | PVOID GdiCachedProcessHandle; 1008 | DWORD GdiClientPID; 1009 | DWORD GdiClientTID; 1010 | PVOID GdiThreadLocalInfo; 1011 | TDWORD Win32ClientInfo[62]; 1012 | PVOID glDispatchTable[233]; 1013 | TDWORD glReserved1[29]; 1014 | PVOID glReserved2; 1015 | PVOID glSectionInfo; 1016 | PVOID glSection; 1017 | PVOID glTable; 1018 | PVOID glCurrentRC; 1019 | PVOID glContext; 1020 | TPADDWORD PadLastStatusValue; 1021 | UNICODE_STRING StaticUnicodeString; 1022 | TPADStaticUnicodeBuffer PadStaticUnicodeBuffer; 1023 | PVOID DeallocationStack; 1024 | PVOID TlsSlots[TLS_MINIMUM_AVAILABLE]; //ָ���Ŷ�̬TLS���ݵ�TLS Slot���� 1025 | LIST_ENTRY TlsLinks; 1026 | PVOID Vdm; 1027 | PVOID ReservedForNtRpc; 1028 | PVOID DbgSsReserved[2]; 1029 | TPADDWORD PadHardErrorsAreDisabled; 1030 | PVOID Instrumentation[InstrumentationSize]; 1031 | GUID ActivityId; 1032 | PVOID SubProcessTag; 1033 | PVOID PerflibData; 1034 | PVOID EtwTraceData; 1035 | PVOID WinSockData;// WinSock 1036 | ULONG GdiBatchCount; 1037 | union { 1038 | PROCESSOR_NUMBER CurrentIdealProcessor; 1039 | DWORD IdealProcessorValue; 1040 | struct { 1041 | BYTE ReservedPad0; 1042 | BYTE ReservedPad1; 1043 | BYTE ReservedPad2; 1044 | BYTE IdealProcessor; 1045 | }; 1046 | }; 1047 | TPADDWORD PadGuaranteedStackBytes; 1048 | PVOID ReservedForPerf; 1049 | PVOID ReservedForOle; 1050 | TPADDWORD PadWaitingOnLoaderLock; 1051 | PVOID SavedPriorityState; 1052 | TDWORD ReservedForCodeCoverage; 1053 | PVOID ThreadPoolData; 1054 | PVOID TlsExpansionSlots; 1055 | PVOID DeallocationBStore; 1056 | PVOID BStoreLimit; 1057 | DWORD MuiGeneration; 1058 | DWORD IsImpersonating; 1059 | PVOID NlsCache; 1060 | PVOID pShimData; 1061 | TPADDWORD PadHeapData; 1062 | PVOID CurrentTransactionHandle; 1063 | PVOID ActiveFrame;// _TEB_ACTIVE_FRAME 1064 | PVOID FlsData; 1065 | PVOID PreferredLanguages; 1066 | PVOID UserPrefLanguages; 1067 | PVOID MergedPrefLanguages; 1068 | DWORD MuiImpersonation; 1069 | union { 1070 | WORD CrossTebFlags; 1071 | WORD SpareCrossTebBits; 1072 | }; 1073 | union { 1074 | WORD SameTebFlags; 1075 | struct { 1076 | WORD SafeThunkCall : 1; 1077 | WORD InDebugPrint : 1; 1078 | WORD HasFiberData : 1; 1079 | WORD SkipThreadAttach : 1; 1080 | WORD WerInShipAssertCode : 1; 1081 | WORD RanProcessInit : 1; 1082 | WORD ClonedThread : 1; 1083 | WORD SuppressDebugMsg : 1; 1084 | WORD DisableUserStackWalk : 1; 1085 | WORD RtlExceptionAttached : 1; 1086 | WORD InitialThread : 1; 1087 | WORD SessionAware : 1; 1088 | WORD LoadOwner : 1; 1089 | WORD LoaderWorker : 1; 1090 | WORD SkipLoaderInit : 1; 1091 | WORD SpareSameTebBits : 1; 1092 | }; 1093 | 1094 | }; 1095 | PVOID TxnScopeEnterCallback; 1096 | PVOID TxnScopeExitCallback; 1097 | PVOID TxnScopeContext; 1098 | DWORD LockCount; 1099 | int WowTebOffset; 1100 | PVOID ResourceRetValue; 1101 | PVOID ReservedForWdf; 1102 | TDWORD ReservedForCrt; 1103 | GUID EffectiveContainerId; 1104 | 1105 | }; 1106 | 1107 | typedef __TEB<26, int, DWORD, TXFSCONTEXTBLOCK32, DWORD, PADSTATICNICODEBUFFER32, 11> TEB32, * PTEB32; 1108 | typedef __TEB<30, PADDING, DWORD64, TXFSCONTEXTBLOCK64, PADDING, PADSTATICNICODEBUFFER64, 9> TEB64, * PTEB64; 1109 | 1110 | #ifdef _ARCH_86_ 1111 | 1112 | #define TEB TEB32 1113 | #define PTEB PTEB32 1114 | #define PEB PEB32 1115 | #define PPEB PPEB32 1116 | #define PROCESS_BASIC_INFORMATION PROCESS_BASIC_INFORMATION32 1117 | #define CLIENT_ID CLIENT_ID32 1118 | #define PCLIENT_ID PCLIENT_ID32 1119 | #define THREAD_BASIC_INFORMATION THREAD_BASIC_INFORMATION32 1120 | #define UNICODE_STRING UNICODE_STRING32 1121 | #endif 1122 | 1123 | #ifdef _ARCH_64_ 1124 | #define PEB PEB64 1125 | #define PPEB PPEB64 1126 | #define PROCESS_BASIC_INFORMATION PROCESS_BASIC_INFORMATION64 1127 | #define TEB TEB64 1128 | #define PTEB PTEB64; 1129 | #define CLIENT_ID CLIENT_ID64 1130 | #define PCLIENT_ID PCLIENT_ID64 1131 | #define THREAD_BASIC_INFORMATION THREAD_BASIC_INFORMATION64 1132 | #define UNICODE_STRING UNICODE_STRING64 1133 | #endif 1134 | 1135 | typedef UNICODE_STRING* PUNICODE_STRING; 1136 | 1137 | struct _TEB { 1138 | TEB teb; 1139 | }; 1140 | #endif 1141 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/godzilla/gsystem/gsystemexp.h: -------------------------------------------------------------------------------- 1 | #ifndef __GOJIRA_GSYSTEMEXP_H__ 2 | #define __GOJIRA_GSYSTEMEXP_H__ 3 | 4 | #include "godzilla.h" 5 | #include "gsystemdefs.h" 6 | 7 | #ifdef _WINDOWS_SYSTEM_ 8 | 9 | #define NTSTATUS_SUCCESS BCRYPT_SUCCESS 10 | #define NTDLL_LIB_NAME "ntdll.dll" 11 | 12 | typedef NTSTATUS 13 | (CALLBACK* PfnNtQueryInformatioProcess)( 14 | IN HANDLE, 15 | IN PROCESSINFOCLASS, 16 | OUT PVOID, 17 | IN ULONG, 18 | OUT PULONG 19 | ); 20 | 21 | typedef NTSTATUS 22 | (WINAPI* PfnRtlCreateProcess) ( 23 | IN HANDLE, 24 | IN PSECURITY_DESCRIPTOR, 25 | IN BOOLEAN, 26 | IN ULONG, 27 | IN OUT PULONG, 28 | IN OUT PULONG, 29 | IN PVOID, 30 | IN PVOID, 31 | OUT PHANDLE, 32 | OUT PCLIENT_ID 33 | ); 34 | 35 | typedef NTSTATUS 36 | (WINAPI* PfnZwTerminateThread)( 37 | HANDLE, 38 | ULONG 39 | ); 40 | 41 | typedef __kernel_entry NTSTATUS 42 | (NTAPI* PfnNtQueryInformationThread)( 43 | IN HANDLE, 44 | IN THREADINFOCLASS, 45 | OUT PVOID, 46 | IN ULONG, 47 | OUT PULONG 48 | ); 49 | 50 | typedef __kernel_entry NTSTATUS 51 | (NTAPI* PfnNtQuerySystemInformation)( 52 | IN SYSTEM_INFORMATION_CLASS, 53 | OUT PVOID, 54 | IN ULONG, 55 | OUT PULONG 56 | ); 57 | 58 | typedef NTSTATUS 59 | (NTAPI* PfnRtlAdjustPrivilege)( 60 | IN ULONG Privilege, 61 | IN BOOLEAN Enable, 62 | IN BOOLEAN CurrentThread, 63 | OUT PBOOLEAN Enabled 64 | ); 65 | 66 | typedef NTSTATUS 67 | (NTAPI* PfnZwShutdownSystem)( 68 | IN SHUTDOWN_ACTION action 69 | ); 70 | 71 | typedef void 72 | (NTAPI* PfnNtRaiseHardError)( 73 | IN NTSTATUS, 74 | IN ULONG, 75 | IN PUNICODE_STRING, 76 | IN PVOID, 77 | IN HARDERROR_RESPONSE_OPTION, 78 | OUT PHARDERROR_RESPONSE 79 | ); 80 | 81 | 82 | 83 | //x86���� 84 | bool NtQueryInformationProcess( 85 | IN HANDLE ProcessHandle, 86 | IN PROCESSINFOCLASS ProcessInformationClass, 87 | OUT PVOID ProcessInformation, 88 | IN ULONG ProcessInformationLength, 89 | OUT PULONG ReturnLength); 90 | 91 | bool RtlCreateThread( 92 | IN HANDLE ProcessHandle, 93 | IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, 94 | IN BOOLEAN CreateSuspended, 95 | IN ULONG StackZeroBits, 96 | IN OUT PULONG StackReserved, 97 | IN OUT PULONG StackCommit, 98 | IN PVOID StartAddress, 99 | IN PVOID StartParameter OPTIONAL, 100 | OUT PHANDLE ThreadHandle, 101 | OUT PCLIENT_ID ClientID); 102 | 103 | bool ZwTerminateThread(HANDLE hThread, ULONG uExitCode); 104 | 105 | bool NtQueryInformationThread( 106 | IN HANDLE ThreadHandle, 107 | IN THREADINFOCLASS ThreadInformationClass, 108 | OUT PVOID ThreadInformation, 109 | IN ULONG ThreadInformationLength, 110 | OUT PULONG ReturnLength 111 | ); 112 | 113 | bool NtQuerySystemInformation( 114 | IN SYSTEM_INFORMATION_CLASS SystemInformationClass, 115 | OUT PVOID SystemInformation, 116 | IN ULONG SystemInformationLength, 117 | OUT PULONG ReturnLength 118 | ); 119 | 120 | 121 | bool RtlAdjustPrivilege 122 | ( 123 | ULONG Privilege, 124 | BOOLEAN Enable, 125 | BOOLEAN CurrentThread, 126 | PBOOLEAN Enabled 127 | ); 128 | 129 | bool ZwShutdownSystem(SHUTDOWN_ACTION action); 130 | 131 | 132 | //����ֻ����false 133 | bool NtRaiseHardError 134 | ( 135 | IN NTSTATUS ErrorStatus, 136 | IN ULONG NumberOfParameters, 137 | IN PUNICODE_STRING UnicodeStringParameterMask OPTIONAL, 138 | IN PVOID* Parameters, 139 | IN HARDERROR_RESPONSE_OPTION ResponseOption, 140 | OUT PHARDERROR_RESPONSE Response 141 | ); 142 | 143 | #endif 144 | #endif -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/jansson/jansson.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2009-2016 Petri Lehtinen 3 | * 4 | * Jansson is free software; you can redistribute it and/or modify 5 | * it under the terms of the MIT license. See LICENSE for details. 6 | */ 7 | 8 | #ifndef JANSSON_H 9 | #define JANSSON_H 10 | 11 | #include 12 | #include /* for size_t */ 13 | #include 14 | 15 | #include "jansson_config.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /* version */ 22 | 23 | #define JANSSON_MAJOR_VERSION 2 24 | #define JANSSON_MINOR_VERSION 9 25 | #define JANSSON_MICRO_VERSION 0 26 | 27 | /* Micro version is omitted if it's 0 */ 28 | #define JANSSON_VERSION "2.9" 29 | 30 | /* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this 31 | for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */ 32 | #define JANSSON_VERSION_HEX ((JANSSON_MAJOR_VERSION << 16) | \ 33 | (JANSSON_MINOR_VERSION << 8) | \ 34 | (JANSSON_MICRO_VERSION << 0)) 35 | 36 | 37 | /* types */ 38 | 39 | typedef enum 40 | { 41 | JSON_OBJECT, 42 | JSON_ARRAY, 43 | JSON_STRING, 44 | JSON_INTEGER, 45 | JSON_REAL, 46 | JSON_TRUE, 47 | JSON_FALSE, 48 | JSON_NULL 49 | } json_type; 50 | 51 | typedef struct json_t 52 | { 53 | json_type type; 54 | size_t refcount; 55 | } json_t; 56 | 57 | #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */ 58 | #if JSON_INTEGER_IS_LONG_LONG 59 | #ifdef _WIN32 60 | #define JSON_INTEGER_FORMAT "I64d" 61 | #else 62 | #define JSON_INTEGER_FORMAT "lld" 63 | #endif 64 | typedef long long json_int_t; 65 | #else 66 | #define JSON_INTEGER_FORMAT "ld" 67 | typedef long json_int_t; 68 | #endif /* JSON_INTEGER_IS_LONG_LONG */ 69 | #endif 70 | 71 | #define json_typeof(json) ((json)->type) 72 | #define json_is_object(json) ((json) && json_typeof(json) == JSON_OBJECT) 73 | #define json_is_array(json) ((json) && json_typeof(json) == JSON_ARRAY) 74 | #define json_is_string(json) ((json) && json_typeof(json) == JSON_STRING) 75 | #define json_is_integer(json) ((json) && json_typeof(json) == JSON_INTEGER) 76 | #define json_is_real(json) ((json) && json_typeof(json) == JSON_REAL) 77 | #define json_is_number(json) (json_is_integer(json) || json_is_real(json)) 78 | #define json_is_true(json) ((json) && json_typeof(json) == JSON_TRUE) 79 | #define json_is_false(json) ((json) && json_typeof(json) == JSON_FALSE) 80 | #define json_boolean_value json_is_true 81 | #define json_is_boolean(json) (json_is_true(json) || json_is_false(json)) 82 | #define json_is_null(json) ((json) && json_typeof(json) == JSON_NULL) 83 | 84 | /* construction, destruction, reference counting */ 85 | 86 | __declspec(dllimport) json_t* json_object(void); 87 | __declspec(dllimport) json_t* json_array(void); 88 | __declspec(dllimport) json_t* json_string(const char* value); 89 | __declspec(dllimport) json_t* json_stringn(const char* value, size_t len); 90 | __declspec(dllimport) json_t* json_string_nocheck(const char* value); 91 | __declspec(dllimport) json_t* json_stringn_nocheck(const char* value, size_t len); 92 | __declspec(dllimport) json_t* json_integer(json_int_t value); 93 | __declspec(dllimport) json_t* json_real(double value); 94 | __declspec(dllimport) json_t* json_true(void); 95 | __declspec(dllimport) json_t* json_false(void); 96 | #define json_boolean(val) ((val) ? json_true() : json_false()) 97 | __declspec(dllimport) json_t* json_null(void); 98 | 99 | static JSON_INLINE 100 | json_t* json_incref(json_t* json) 101 | { 102 | if(json && json->refcount != (size_t) - 1) 103 | ++json->refcount; 104 | return json; 105 | } 106 | 107 | /* do not call json_delete directly */ 108 | __declspec(dllimport) void json_delete(json_t* json); 109 | 110 | static JSON_INLINE 111 | void json_decref(json_t* json) 112 | { 113 | if(json && json->refcount != (size_t) - 1 && --json->refcount == 0) 114 | json_delete(json); 115 | } 116 | 117 | #if defined(__GNUC__) || defined(__clang__) 118 | static JSON_INLINE 119 | void json_decrefp(json_t** json) 120 | { 121 | if(json) 122 | { 123 | json_decref(*json); 124 | *json = NULL; 125 | } 126 | } 127 | 128 | #define json_auto_t json_t __attribute__((cleanup(json_decrefp))) 129 | #endif 130 | 131 | 132 | /* error reporting */ 133 | 134 | #define JSON_ERROR_TEXT_LENGTH 160 135 | #define JSON_ERROR_SOURCE_LENGTH 80 136 | 137 | typedef struct 138 | { 139 | int line; 140 | int column; 141 | int position; 142 | char source[JSON_ERROR_SOURCE_LENGTH]; 143 | char text[JSON_ERROR_TEXT_LENGTH]; 144 | } json_error_t; 145 | 146 | 147 | /* getters, setters, manipulation */ 148 | 149 | __declspec(dllimport) void json_object_seed(size_t seed); 150 | __declspec(dllimport) size_t json_object_size(const json_t* object); 151 | __declspec(dllimport) json_t* json_object_get(const json_t* object, const char* key); 152 | __declspec(dllimport) int json_object_set_new(json_t* object, const char* key, json_t* value); 153 | __declspec(dllimport) int json_object_set_new_nocheck(json_t* object, const char* key, json_t* value); 154 | __declspec(dllimport) int json_object_del(json_t* object, const char* key); 155 | __declspec(dllimport) int json_object_clear(json_t* object); 156 | __declspec(dllimport) int json_object_update(json_t* object, json_t* other); 157 | __declspec(dllimport) int json_object_update_existing(json_t* object, json_t* other); 158 | __declspec(dllimport) int json_object_update_missing(json_t* object, json_t* other); 159 | __declspec(dllimport) void* json_object_iter(json_t* object); 160 | __declspec(dllimport) void* json_object_iter_at(json_t* object, const char* key); 161 | __declspec(dllimport) void* json_object_key_to_iter(const char* key); 162 | __declspec(dllimport) void* json_object_iter_next(json_t* object, void* iter); 163 | __declspec(dllimport) const char* json_object_iter_key(void* iter); 164 | __declspec(dllimport) json_t* json_object_iter_value(void* iter); 165 | __declspec(dllimport) int json_object_iter_set_new(json_t* object, void* iter, json_t* value); 166 | 167 | #define json_object_foreach(object, key, value) \ 168 | for(key = json_object_iter_key(json_object_iter(object)); \ 169 | key && (value = json_object_iter_value(json_object_key_to_iter(key))); \ 170 | key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key)))) 171 | 172 | #define json_object_foreach_safe(object, n, key, value) \ 173 | for(key = json_object_iter_key(json_object_iter(object)), \ 174 | n = json_object_iter_next(object, json_object_key_to_iter(key)); \ 175 | key && (value = json_object_iter_value(json_object_key_to_iter(key))); \ 176 | key = json_object_iter_key(n), \ 177 | n = json_object_iter_next(object, json_object_key_to_iter(key))) 178 | 179 | #define json_array_foreach(array, index, value) \ 180 | for(index = 0; \ 181 | index < json_array_size(array) && (value = json_array_get(array, index)); \ 182 | index++) 183 | 184 | static JSON_INLINE 185 | int json_object_set(json_t* object, const char* key, json_t* value) 186 | { 187 | return json_object_set_new(object, key, json_incref(value)); 188 | } 189 | 190 | static JSON_INLINE 191 | int json_object_set_nocheck(json_t* object, const char* key, json_t* value) 192 | { 193 | return json_object_set_new_nocheck(object, key, json_incref(value)); 194 | } 195 | 196 | static JSON_INLINE 197 | int json_object_iter_set(json_t* object, void* iter, json_t* value) 198 | { 199 | return json_object_iter_set_new(object, iter, json_incref(value)); 200 | } 201 | 202 | __declspec(dllimport) size_t json_array_size(const json_t* array); 203 | __declspec(dllimport) json_t* json_array_get(const json_t* array, size_t index); 204 | __declspec(dllimport) int json_array_set_new(json_t* array, size_t index, json_t* value); 205 | __declspec(dllimport) int json_array_append_new(json_t* array, json_t* value); 206 | __declspec(dllimport) int json_array_insert_new(json_t* array, size_t index, json_t* value); 207 | __declspec(dllimport) int json_array_remove(json_t* array, size_t index); 208 | __declspec(dllimport) int json_array_clear(json_t* array); 209 | __declspec(dllimport) int json_array_extend(json_t* array, json_t* other); 210 | 211 | static JSON_INLINE 212 | int json_array_set(json_t* array, size_t ind, json_t* value) 213 | { 214 | return json_array_set_new(array, ind, json_incref(value)); 215 | } 216 | 217 | static JSON_INLINE 218 | int json_array_append(json_t* array, json_t* value) 219 | { 220 | return json_array_append_new(array, json_incref(value)); 221 | } 222 | 223 | static JSON_INLINE 224 | int json_array_insert(json_t* array, size_t ind, json_t* value) 225 | { 226 | return json_array_insert_new(array, ind, json_incref(value)); 227 | } 228 | 229 | __declspec(dllimport) const char* json_string_value(const json_t* string); 230 | __declspec(dllimport) size_t json_string_length(const json_t* string); 231 | __declspec(dllimport) json_int_t json_integer_value(const json_t* integer); 232 | __declspec(dllimport) double json_real_value(const json_t* real); 233 | __declspec(dllimport) double json_number_value(const json_t* json); 234 | 235 | __declspec(dllimport) int json_string_set(json_t* string, const char* value); 236 | __declspec(dllimport) int json_string_setn(json_t* string, const char* value, size_t len); 237 | __declspec(dllimport) int json_string_set_nocheck(json_t* string, const char* value); 238 | __declspec(dllimport) int json_string_setn_nocheck(json_t* string, const char* value, size_t len); 239 | __declspec(dllimport) int json_integer_set(json_t* integer, json_int_t value); 240 | __declspec(dllimport) int json_real_set(json_t* real, double value); 241 | 242 | /* pack, unpack */ 243 | 244 | __declspec(dllimport) json_t* json_pack(const char* fmt, ...); 245 | __declspec(dllimport) json_t* json_pack_ex(json_error_t* error, size_t flags, const char* fmt, ...); 246 | __declspec(dllimport) json_t* json_vpack_ex(json_error_t* error, size_t flags, const char* fmt, va_list ap); 247 | 248 | #define JSON_VALIDATE_ONLY 0x1 249 | #define JSON_STRICT 0x2 250 | 251 | __declspec(dllimport) int json_unpack(json_t* root, const char* fmt, ...); 252 | __declspec(dllimport) int json_unpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, ...); 253 | __declspec(dllimport) int json_vunpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, va_list ap); 254 | 255 | 256 | /* equality */ 257 | 258 | __declspec(dllimport) int json_equal(json_t* value1, json_t* value2); 259 | 260 | 261 | /* copying */ 262 | 263 | __declspec(dllimport) json_t* json_copy(json_t* value); 264 | __declspec(dllimport) json_t* json_deep_copy(const json_t* value); 265 | 266 | 267 | /* decoding */ 268 | 269 | #define JSON_REJECT_DUPLICATES 0x1 270 | #define JSON_DISABLE_EOF_CHECK 0x2 271 | #define JSON_DECODE_ANY 0x4 272 | #define JSON_DECODE_INT_AS_REAL 0x8 273 | #define JSON_ALLOW_NUL 0x10 274 | 275 | typedef size_t (*json_load_callback_t)(void* buffer, size_t buflen, void* data); 276 | 277 | __declspec(dllimport) json_t* json_loads(const char* input, size_t flags, json_error_t* error); 278 | __declspec(dllimport) json_t* json_loadb(const char* buffer, size_t buflen, size_t flags, json_error_t* error); 279 | __declspec(dllimport) json_t* json_loadf(FILE* input, size_t flags, json_error_t* error); 280 | __declspec(dllimport) json_t* json_load_file(const char* path, size_t flags, json_error_t* error); 281 | __declspec(dllimport) json_t* json_load_callback(json_load_callback_t callback, void* data, size_t flags, json_error_t* error); 282 | 283 | 284 | /* encoding */ 285 | 286 | #define JSON_MAX_INDENT 0x1F 287 | #define JSON_INDENT(n) ((n) & JSON_MAX_INDENT) 288 | #define JSON_COMPACT 0x20 289 | #define JSON_ENSURE_ASCII 0x40 290 | #define JSON_SORT_KEYS 0x80 291 | #define JSON_PRESERVE_ORDER 0x100 292 | #define JSON_ENCODE_ANY 0x200 293 | #define JSON_ESCAPE_SLASH 0x400 294 | #define JSON_REAL_PRECISION(n) (((n) & 0x1F) << 11) 295 | 296 | typedef int (*json_dump_callback_t)(const char* buffer, size_t size, void* data); 297 | 298 | __declspec(dllimport) char* json_dumps(const json_t* json, size_t flags); 299 | __declspec(dllimport) int json_dumpf(const json_t* json, FILE* output, size_t flags); 300 | __declspec(dllimport) int json_dump_file(const json_t* json, const char* path, size_t flags); 301 | __declspec(dllimport) int json_dump_callback(const json_t* json, json_dump_callback_t callback, void* data, size_t flags); 302 | 303 | /* custom memory allocation */ 304 | 305 | typedef void* (*json_malloc_t)(size_t); 306 | typedef void (*json_free_t)(void*); 307 | 308 | __declspec(dllimport) void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn); 309 | __declspec(dllimport) void json_get_alloc_funcs(json_malloc_t* malloc_fn, json_free_t* free_fn); 310 | 311 | #ifdef __cplusplus 312 | } 313 | #endif 314 | 315 | #endif 316 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/jansson/jansson_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2010-2016 Petri Lehtinen 3 | * 4 | * Jansson is free software; you can redistribute it and/or modify 5 | * it under the terms of the MIT license. See LICENSE for details. 6 | * 7 | * 8 | * This file specifies a part of the site-specific configuration for 9 | * Jansson, namely those things that affect the public API in 10 | * jansson.h. 11 | * 12 | * The CMake system will generate the jansson_config.h file and 13 | * copy it to the build and install directories. 14 | */ 15 | 16 | #ifndef JANSSON_CONFIG_H 17 | #define JANSSON_CONFIG_H 18 | 19 | /* Define this so that we can disable scattered automake configuration in source files */ 20 | #ifndef JANSSON_USING_CMAKE 21 | #define JANSSON_USING_CMAKE 22 | #endif 23 | 24 | /* Note: when using cmake, JSON_INTEGER_IS_LONG_LONG is not defined nor used, 25 | * as we will also check for __int64 etc types. 26 | * (the definition was used in the automake system) */ 27 | 28 | /* Bring in the cmake-detected defines */ 29 | #define HAVE_STDINT_H 1 30 | /* #undef HAVE_INTTYPES_H */ 31 | /* #undef HAVE_SYS_TYPES_H */ 32 | 33 | /* Include our standard type header for the integer typedef */ 34 | 35 | #if defined(HAVE_STDINT_H) 36 | # include 37 | #elif defined(HAVE_INTTYPES_H) 38 | # include 39 | #elif defined(HAVE_SYS_TYPES_H) 40 | # include 41 | #endif 42 | 43 | 44 | /* If your compiler supports the inline keyword in C, JSON_INLINE is 45 | defined to `inline', otherwise empty. In C++, the inline is always 46 | supported. */ 47 | #ifdef __cplusplus 48 | #define JSON_INLINE inline 49 | #else 50 | #define JSON_INLINE __inline 51 | #endif 52 | 53 | 54 | #define json_int_t long long 55 | #define json_strtoint strtoll 56 | #define JSON_INTEGER_FORMAT "I64d" 57 | 58 | 59 | /* If locale.h and localeconv() are available, define to 1, otherwise to 0. */ 60 | #define JSON_HAVE_LOCALECONV 1 61 | 62 | 63 | /* Maximum recursion depth for parsing JSON input. 64 | This limits the depth of e.g. array-within-array constructions. */ 65 | #define JSON_PARSER_MAX_DEPTH 2048 66 | 67 | 68 | #endif 69 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/jansson/jansson_x64dbg.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "jansson.h" 4 | 5 | typedef json_t* JSON; 6 | 7 | static JSON_INLINE 8 | json_t* json_hex(unsigned json_int_t value) 9 | { 10 | char hexvalue[20]; 11 | sprintf_s(hexvalue, "0x%llX", value); 12 | return json_string(hexvalue); 13 | } 14 | 15 | static JSON_INLINE 16 | unsigned json_int_t json_hex_value(const json_t* hex) 17 | { 18 | unsigned json_int_t ret = 0; 19 | const char* hexvalue; 20 | hexvalue = json_string_value(hex); 21 | if(!hexvalue) 22 | return 0; 23 | sscanf_s(hexvalue, "0x%llX", &ret); 24 | return ret; 25 | } 26 | -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/lz4/lz4.h: -------------------------------------------------------------------------------- 1 | /* 2 | LZ4 - Fast LZ compression algorithm 3 | Header File 4 | Copyright (C) 2011-2014, Yann Collet. 5 | BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 6 | 7 | Redistribution and use in source and binary forms, with or without 8 | modification, are permitted provided that the following conditions are 9 | met: 10 | 11 | * Redistributions of source code must retain the above copyright 12 | notice, this list of conditions and the following disclaimer. 13 | * Redistributions in binary form must reproduce the above 14 | copyright notice, this list of conditions and the following disclaimer 15 | in the documentation and/or other materials provided with the 16 | distribution. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | 30 | You can contact the author at : 31 | - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html 32 | - LZ4 source repository : http://code.google.com/p/lz4/ 33 | */ 34 | #ifndef _LZ4_H 35 | #define _LZ4_H 36 | 37 | #if defined (__cplusplus) 38 | extern "C" 39 | { 40 | #endif 41 | 42 | 43 | /************************************** 44 | Version 45 | **************************************/ 46 | #define LZ4_VERSION_MAJOR 1 /* for major interface/format changes */ 47 | #define LZ4_VERSION_MINOR 1 /* for minor interface/format changes */ 48 | #define LZ4_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */ 49 | 50 | 51 | /************************************** 52 | Compiler Options 53 | **************************************/ 54 | #if (defined(__GNUC__) && defined(__STRICT_ANSI__)) || (defined(_MSC_VER) && !defined(__cplusplus)) /* Visual Studio */ 55 | # define inline __inline /* Visual C is not C99, but supports some kind of inline */ 56 | #endif 57 | 58 | 59 | /************************************** 60 | Simple Functions 61 | **************************************/ 62 | 63 | __declspec(dllimport) int LZ4_compress(const char* source, char* dest, int inputSize); 64 | __declspec(dllimport) int LZ4_decompress_safe(const char* source, char* dest, int inputSize, int maxOutputSize); 65 | 66 | /* 67 | LZ4_compress() : 68 | Compresses 'inputSize' bytes from 'source' into 'dest'. 69 | Destination buffer must be already allocated, 70 | and must be sized to handle worst cases situations (input data not compressible) 71 | Worst case size evaluation is provided by function LZ4_compressBound() 72 | inputSize : Max supported value is LZ4_MAX_INPUT_VALUE 73 | return : the number of bytes written in buffer dest 74 | or 0 if the compression fails 75 | 76 | LZ4_decompress_safe() : 77 | maxOutputSize : is the size of the destination buffer (which must be already allocated) 78 | return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize) 79 | If the source stream is detected malformed, the function will stop decoding and return a negative result. 80 | This function is protected against buffer overflow exploits (never writes outside of output buffer, and never reads outside of input buffer). Therefore, it is protected against malicious data packets 81 | */ 82 | 83 | 84 | /************************************** 85 | Advanced Functions 86 | **************************************/ 87 | #define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */ 88 | #define LZ4_COMPRESSBOUND(isize) ((unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16) 89 | 90 | /* 91 | LZ4_compressBound() : 92 | Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible) 93 | primarily useful for memory allocation of output buffer. 94 | inline function is recommended for the general case, 95 | macro is also provided when result needs to be evaluated at compilation (such as stack memory allocation). 96 | 97 | isize : is the input size. Max supported value is LZ4_MAX_INPUT_SIZE 98 | return : maximum output size in a "worst case" scenario 99 | or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE) 100 | */ 101 | __declspec(dllimport) int LZ4_compressBound(int isize); 102 | 103 | 104 | /* 105 | LZ4_compress_limitedOutput() : 106 | Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. 107 | If it cannot achieve it, compression will stop, and result of the function will be zero. 108 | This function never writes outside of provided output buffer. 109 | 110 | inputSize : Max supported value is LZ4_MAX_INPUT_VALUE 111 | maxOutputSize : is the size of the destination buffer (which must be already allocated) 112 | return : the number of bytes written in buffer 'dest' 113 | or 0 if the compression fails 114 | */ 115 | __declspec(dllimport) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize); 116 | 117 | 118 | /* 119 | LZ4_decompress_fast() : 120 | originalSize : is the original and therefore uncompressed size 121 | return : the number of bytes read from the source buffer (in other words, the compressed size) 122 | If the source stream is malformed, the function will stop decoding and return a negative result. 123 | note : This function is a bit faster than LZ4_decompress_safe() 124 | This function never writes outside of output buffers, but may read beyond input buffer in case of malicious data packet. 125 | Use this function preferably into a trusted environment (data to decode comes from a trusted source). 126 | Destination buffer must be already allocated. Its size must be a minimum of 'outputSize' bytes. 127 | */ 128 | __declspec(dllimport) int LZ4_decompress_fast(const char* source, char* dest, int originalSize); 129 | 130 | 131 | /* 132 | LZ4_decompress_safe_partial() : 133 | This function decompress a compressed block of size 'inputSize' at position 'source' 134 | into output buffer 'dest' of size 'maxOutputSize'. 135 | The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached, 136 | reducing decompression time. 137 | return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize) 138 | Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller. 139 | Always control how many bytes were decoded. 140 | If the source stream is detected malformed, the function will stop decoding and return a negative result. 141 | This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets 142 | */ 143 | __declspec(dllimport) int LZ4_decompress_safe_partial(const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize); 144 | 145 | 146 | /* 147 | These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods. 148 | To know how much memory must be allocated for the compression tables, use : 149 | int LZ4_sizeofState(); 150 | 151 | Note that tables must be aligned on 4-bytes boundaries, otherwise compression will fail (return code 0). 152 | 153 | The allocated memory can be provided to the compressions functions using 'void* state' parameter. 154 | LZ4_compress_withState() and LZ4_compress_limitedOutput_withState() are equivalent to previously described functions. 155 | They just use the externally allocated memory area instead of allocating their own (on stack, or on heap). 156 | */ 157 | __declspec(dllimport) int LZ4_sizeofState(void); 158 | __declspec(dllimport) int LZ4_compress_withState(void* state, const char* source, char* dest, int inputSize); 159 | __declspec(dllimport) int LZ4_compress_limitedOutput_withState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize); 160 | 161 | 162 | /************************************** 163 | Streaming Functions 164 | **************************************/ 165 | __declspec(dllimport) void* LZ4_create(const char* inputBuffer); 166 | __declspec(dllimport) int LZ4_compress_continue(void* LZ4_Data, const char* source, char* dest, int inputSize); 167 | __declspec(dllimport) int LZ4_compress_limitedOutput_continue(void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize); 168 | __declspec(dllimport) char* LZ4_slideInputBuffer(void* LZ4_Data); 169 | __declspec(dllimport) int LZ4_free(void* LZ4_Data); 170 | 171 | /* 172 | These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks. 173 | In order to achieve this, it is necessary to start creating the LZ4 Data Structure, thanks to the function : 174 | 175 | void* LZ4_create (const char* inputBuffer); 176 | The result of the function is the (void*) pointer on the LZ4 Data Structure. 177 | This pointer will be needed in all other functions. 178 | If the pointer returned is NULL, then the allocation has failed, and compression must be aborted. 179 | The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. 180 | The input buffer must be already allocated, and size at least 192KB. 181 | 'inputBuffer' will also be the 'const char* source' of the first block. 182 | 183 | All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'. 184 | To compress each block, use either LZ4_compress_continue() or LZ4_compress_limitedOutput_continue(). 185 | Their behavior are identical to LZ4_compress() or LZ4_compress_limitedOutput(), 186 | but require the LZ4 Data Structure as their first argument, and check that each block starts right after the previous one. 187 | If next block does not begin immediately after the previous one, the compression will fail (return 0). 188 | 189 | When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : 190 | char* LZ4_slideInputBuffer(void* LZ4_Data); 191 | must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer. 192 | Note that, for this function to work properly, minimum size of an input buffer must be 192KB. 193 | ==> The memory position where the next input data block must start is provided as the result of the function. 194 | 195 | Compression can then resume, using LZ4_compress_continue() or LZ4_compress_limitedOutput_continue(), as usual. 196 | 197 | When compression is completed, a call to LZ4_free() will release the memory used by the LZ4 Data Structure. 198 | */ 199 | 200 | 201 | __declspec(dllimport) int LZ4_sizeofStreamState(void); 202 | __declspec(dllimport) int LZ4_resetStreamState(void* state, const char* inputBuffer); 203 | 204 | /* 205 | These functions achieve the same result as : 206 | void* LZ4_create (const char* inputBuffer); 207 | 208 | They are provided here to allow the user program to allocate memory using its own routines. 209 | 210 | To know how much space must be allocated, use LZ4_sizeofStreamState(); 211 | Note also that space must be 4-bytes aligned. 212 | 213 | Once space is allocated, you must initialize it using : LZ4_resetStreamState(void* state, const char* inputBuffer); 214 | void* state is a pointer to the space allocated. 215 | It must be aligned on 4-bytes boundaries, and be large enough. 216 | The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. 217 | The input buffer must be already allocated, and size at least 192KB. 218 | 'inputBuffer' will also be the 'const char* source' of the first block. 219 | 220 | The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState(). 221 | return value of LZ4_resetStreamState() must be 0 is OK. 222 | Any other value means there was an error (typically, pointer is not aligned on 4-bytes boundaries). 223 | */ 224 | 225 | 226 | __declspec(dllimport) int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int inputSize, int maxOutputSize); 227 | __declspec(dllimport) int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int outputSize); 228 | 229 | /* 230 | *_withPrefix64k() : 231 | These decoding functions work the same as their "normal name" versions, 232 | but can use up to 64KB of data in front of 'char* dest'. 233 | These functions are necessary to decode inter-dependant blocks. 234 | */ 235 | 236 | 237 | /************************************** 238 | Obsolete Functions 239 | **************************************/ 240 | /* 241 | These functions are deprecated and should no longer be used. 242 | They are provided here for compatibility with existing user programs. 243 | */ 244 | __declspec(dllimport) int LZ4_uncompress(const char* source, char* dest, int outputSize); 245 | __declspec(dllimport) int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize, int maxOutputSize); 246 | 247 | 248 | #if defined (__cplusplus) 249 | } 250 | #endif 251 | 252 | #endif //_LZ4_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/lz4/lz4file.h: -------------------------------------------------------------------------------- 1 | #ifndef _LZ4FILE_H 2 | #define _LZ4FILE_H 3 | 4 | typedef enum _LZ4_STATUS 5 | { 6 | LZ4_SUCCESS, 7 | LZ4_FAILED_OPEN_INPUT, 8 | LZ4_FAILED_OPEN_OUTPUT, 9 | LZ4_NOT_ENOUGH_MEMORY, 10 | LZ4_INVALID_ARCHIVE, 11 | LZ4_CORRUPTED_ARCHIVE 12 | } LZ4_STATUS; 13 | 14 | #if defined (__cplusplus) 15 | extern "C" 16 | { 17 | #endif 18 | 19 | __declspec(dllimport) LZ4_STATUS LZ4_compress_file(const char* input_filename, const char* output_filename); 20 | __declspec(dllimport) LZ4_STATUS LZ4_compress_fileW(const wchar_t* input_filename, const wchar_t* output_filename); 21 | __declspec(dllimport) LZ4_STATUS LZ4_decompress_file(const char* input_filename, const char* output_filename); 22 | __declspec(dllimport) LZ4_STATUS LZ4_decompress_fileW(const wchar_t* input_filename, const wchar_t* output_filename); 23 | 24 | #if defined (__cplusplus) 25 | } 26 | #endif 27 | 28 | #endif //_LZ4FILE_H -------------------------------------------------------------------------------- /qt5_resolver/pluginsdk/lz4/lz4hc.h: -------------------------------------------------------------------------------- 1 | /* 2 | LZ4 HC - High Compression Mode of LZ4 3 | Header File 4 | Copyright (C) 2011-2014, Yann Collet. 5 | BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 6 | 7 | Redistribution and use in source and binary forms, with or without 8 | modification, are permitted provided that the following conditions are 9 | met: 10 | 11 | * Redistributions of source code must retain the above copyright 12 | notice, this list of conditions and the following disclaimer. 13 | * Redistributions in binary form must reproduce the above 14 | copyright notice, this list of conditions and the following disclaimer 15 | in the documentation and/or other materials provided with the 16 | distribution. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | 30 | You can contact the author at : 31 | - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html 32 | - LZ4 source repository : http://code.google.com/p/lz4/ 33 | */ 34 | #ifndef _LZ4HC_H 35 | #define _LZ4HC_H 36 | 37 | #if defined (__cplusplus) 38 | extern "C" 39 | { 40 | #endif 41 | 42 | 43 | __declspec(dllimport) int LZ4_compressHC(const char* source, char* dest, int inputSize); 44 | /* 45 | LZ4_compressHC : 46 | return : the number of bytes in compressed buffer dest 47 | or 0 if compression fails. 48 | note : destination buffer must be already allocated. 49 | To avoid any problem, size it to handle worst cases situations (input data not compressible) 50 | Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h") 51 | */ 52 | 53 | __declspec(dllimport) int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize); 54 | /* 55 | LZ4_compress_limitedOutput() : 56 | Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'. 57 | If it cannot achieve it, compression will stop, and result of the function will be zero. 58 | This function never writes outside of provided output buffer. 59 | 60 | inputSize : Max supported value is 1 GB 61 | maxOutputSize : is maximum allowed size into the destination buffer (which must be already allocated) 62 | return : the number of output bytes written in buffer 'dest' 63 | or 0 if compression fails. 64 | */ 65 | 66 | 67 | __declspec(dllimport) int LZ4_compressHC2(const char* source, char* dest, int inputSize, int compressionLevel); 68 | __declspec(dllimport) int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); 69 | /* 70 | Same functions as above, but with programmable 'compressionLevel'. 71 | Recommended values are between 4 and 9, although any value between 0 and 16 will work. 72 | 'compressionLevel'==0 means use default 'compressionLevel' value. 73 | Values above 16 behave the same as 16. 74 | Equivalent variants exist for all other compression functions below. 75 | */ 76 | 77 | /* Note : 78 | Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license) 79 | */ 80 | 81 | 82 | /************************************** 83 | Using an external allocation 84 | **************************************/ 85 | __declspec(dllimport) int LZ4_sizeofStateHC(void); 86 | __declspec(dllimport) int LZ4_compressHC_withStateHC(void* state, const char* source, char* dest, int inputSize); 87 | __declspec(dllimport) int LZ4_compressHC_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize); 88 | 89 | __declspec(dllimport) int LZ4_compressHC2_withStateHC(void* state, const char* source, char* dest, int inputSize, int compressionLevel); 90 | __declspec(dllimport) int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); 91 | 92 | /* 93 | These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods. 94 | To know how much memory must be allocated for the compression tables, use : 95 | int LZ4_sizeofStateHC(); 96 | 97 | Note that tables must be aligned for pointer (32 or 64 bits), otherwise compression will fail (return code 0). 98 | 99 | The allocated memory can be provided to the compressions functions using 'void* state' parameter. 100 | LZ4_compress_withStateHC() and LZ4_compress_limitedOutput_withStateHC() are equivalent to previously described functions. 101 | They just use the externally allocated memory area instead of allocating their own (on stack, or on heap). 102 | */ 103 | 104 | 105 | /************************************** 106 | Streaming Functions 107 | **************************************/ 108 | __declspec(dllimport) void* LZ4_createHC(const char* inputBuffer); 109 | __declspec(dllimport) int LZ4_compressHC_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize); 110 | __declspec(dllimport) int LZ4_compressHC_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize); 111 | __declspec(dllimport) char* LZ4_slideInputBufferHC(void* LZ4HC_Data); 112 | __declspec(dllimport) int LZ4_freeHC(void* LZ4HC_Data); 113 | 114 | __declspec(dllimport) int LZ4_compressHC2_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel); 115 | __declspec(dllimport) int LZ4_compressHC2_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); 116 | 117 | /* 118 | These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks. 119 | In order to achieve this, it is necessary to start creating the LZ4HC Data Structure, thanks to the function : 120 | 121 | void* LZ4_createHC (const char* inputBuffer); 122 | The result of the function is the (void*) pointer on the LZ4HC Data Structure. 123 | This pointer will be needed in all other functions. 124 | If the pointer returned is NULL, then the allocation has failed, and compression must be aborted. 125 | The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. 126 | The input buffer must be already allocated, and size at least 192KB. 127 | 'inputBuffer' will also be the 'const char* source' of the first block. 128 | 129 | All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'. 130 | To compress each block, use either LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(). 131 | Their behavior are identical to LZ4_compressHC() or LZ4_compressHC_limitedOutput(), 132 | but require the LZ4HC Data Structure as their first argument, and check that each block starts right after the previous one. 133 | If next block does not begin immediately after the previous one, the compression will fail (return 0). 134 | 135 | When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : 136 | char* LZ4_slideInputBufferHC(void* LZ4HC_Data); 137 | must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer. 138 | Note that, for this function to work properly, minimum size of an input buffer must be 192KB. 139 | ==> The memory position where the next input data block must start is provided as the result of the function. 140 | 141 | Compression can then resume, using LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(), as usual. 142 | 143 | When compression is completed, a call to LZ4_freeHC() will release the memory used by the LZ4HC Data Structure. 144 | */ 145 | 146 | __declspec(dllimport) int LZ4_sizeofStreamStateHC(void); 147 | __declspec(dllimport) int LZ4_resetStreamStateHC(void* state, const char* inputBuffer); 148 | 149 | /* 150 | These functions achieve the same result as : 151 | void* LZ4_createHC (const char* inputBuffer); 152 | 153 | They are provided here to allow the user program to allocate memory using its own routines. 154 | 155 | To know how much space must be allocated, use LZ4_sizeofStreamStateHC(); 156 | Note also that space must be aligned for pointers (32 or 64 bits). 157 | 158 | Once space is allocated, you must initialize it using : LZ4_resetStreamStateHC(void* state, const char* inputBuffer); 159 | void* state is a pointer to the space allocated. 160 | It must be aligned for pointers (32 or 64 bits), and be large enough. 161 | The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. 162 | The input buffer must be already allocated, and size at least 192KB. 163 | 'inputBuffer' will also be the 'const char* source' of the first block. 164 | 165 | The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState(). 166 | return value of LZ4_resetStreamStateHC() must be 0 is OK. 167 | Any other value means there was an error (typically, state is not aligned for pointers (32 or 64 bits)). 168 | */ 169 | 170 | 171 | #if defined (__cplusplus) 172 | } 173 | #endif 174 | 175 | #endif //_LZ4HC_H 176 | -------------------------------------------------------------------------------- /qt5_resolver/qt5_resolver.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 16.0 84 | Win32Proj 85 | {cb5d5370-9c17-4530-a15b-54afbebdb36a} 86 | qt5_resolver 87 | 10.0 88 | x86-windows-static 89 | x64-windows-static 90 | 91 | 92 | 93 | DynamicLibrary 94 | true 95 | v143 96 | Unicode 97 | 98 | 99 | DynamicLibrary 100 | false 101 | v143 102 | true 103 | Unicode 104 | 105 | 106 | DynamicLibrary 107 | false 108 | v143 109 | Unicode 110 | false 111 | 112 | 113 | DynamicLibrary 114 | false 115 | v143 116 | true 117 | Unicode 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | .dp64 139 | $(ProjectDir);$(ProjectDir)pluginsdk\godzilla;$(VC_IncludePath);$(WindowsSDK_IncludePath); 140 | 141 | 142 | .dp64 143 | $(ProjectDir);$(ProjectDir)pluginsdk\godzilla;$(VC_IncludePath);$(WindowsSDK_IncludePath); 144 | 145 | 146 | .dp32 147 | $(ProjectDir);$(ProjectDir)pluginsdk\godzilla;$(ProjectDir)pluginsdk\godzilla;$(IncludePath) 148 | 149 | 150 | .dp32 151 | $(ProjectDir);$(ProjectDir)pluginsdk\godzilla;$(VC_IncludePath);$(WindowsSDK_IncludePath); 152 | 153 | 154 | 155 | Level3 156 | true 157 | WIN32;_DEBUG;X64DBGPLUGIN_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 158 | true 159 | Use 160 | pch.h 161 | MultiThreadedDebug 162 | 163 | 164 | Windows 165 | true 166 | false 167 | 168 | 169 | 170 | 171 | Level3 172 | true 173 | true 174 | true 175 | WIN32;NDEBUG;X64DBGPLUGIN_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 176 | true 177 | Use 178 | pch.h 179 | MultiThreaded 180 | 181 | 182 | Windows 183 | true 184 | true 185 | true 186 | false 187 | 188 | 189 | 190 | 191 | Level3 192 | true 193 | _DEBUG;X64DBGPLUGIN_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 194 | true 195 | NotUsing 196 | pch.h 197 | MultiThreadedDebug 198 | true 199 | 200 | 201 | Windows 202 | true 203 | false 204 | 205 | 206 | 207 | 208 | Level3 209 | true 210 | true 211 | true 212 | NDEBUG;X64DBGPLUGIN_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 213 | true 214 | Use 215 | pch.h 216 | MultiThreaded 217 | 218 | 219 | Windows 220 | true 221 | true 222 | true 223 | false 224 | 225 | 226 | 227 | 228 | 229 | -------------------------------------------------------------------------------- /qt5_resolver/qt5_resolver.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 6 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {68397ff3-3221-4eb7-816e-025016c22c77} 14 | 15 | 16 | {3ea3d8f9-3e5a-4146-9685-045eae8058e7} 17 | 18 | 19 | {c088ed8f-4933-4c5a-88a6-09a8f721a07e} 20 | 21 | 22 | {839d6958-a32e-4bdc-a6d8-816876ea99cf} 23 | 24 | 25 | {bf6ad558-ceb3-4993-b89a-ccfb663e1e61} 26 | 27 | 28 | {60dc5457-4f7e-4fec-b3d9-3873e2c751c5} 29 | 30 | 31 | {bbd62e88-5bc3-48ad-a67a-b983b07e84b1} 32 | 33 | 34 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 35 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 36 | 37 | 38 | {b478f9b1-e1f6-4ea5-9ec7-576bf5be8857} 39 | 40 | 41 | 42 | 43 | Header Files\pluginsdk\dbghelp 44 | 45 | 46 | Header Files\pluginsdk\DeviceNameResolver 47 | 48 | 49 | Header Files\pluginsdk\jansson 50 | 51 | 52 | Header Files\pluginsdk\jansson 53 | 54 | 55 | Header Files\pluginsdk\jansson 56 | 57 | 58 | Header Files\pluginsdk\lz4 59 | 60 | 61 | Header Files\pluginsdk\lz4 62 | 63 | 64 | Header Files\pluginsdk\lz4 65 | 66 | 67 | Header Files\pluginsdk\TitanEngine 68 | 69 | 70 | Header Files\pluginsdk\XEDParse 71 | 72 | 73 | Header Files\pluginsdk 74 | 75 | 76 | Header Files\pluginsdk 77 | 78 | 79 | Header Files\pluginsdk 80 | 81 | 82 | Header Files\pluginsdk 83 | 84 | 85 | Header Files\pluginsdk 86 | 87 | 88 | Header Files\pluginsdk 89 | 90 | 91 | Header Files\pluginsdk 92 | 93 | 94 | Header Files\pluginsdk 95 | 96 | 97 | Header Files\pluginsdk 98 | 99 | 100 | Header Files\pluginsdk 101 | 102 | 103 | Header Files\pluginsdk 104 | 105 | 106 | Header Files\pluginsdk 107 | 108 | 109 | Header Files\pluginsdk 110 | 111 | 112 | Header Files\pluginsdk 113 | 114 | 115 | Header Files\pluginsdk 116 | 117 | 118 | Header Files\pluginsdk 119 | 120 | 121 | Header Files\pluginsdk 122 | 123 | 124 | Header Files\pluginsdk 125 | 126 | 127 | Header Files\pluginsdk 128 | 129 | 130 | Header Files\pluginsdk 131 | 132 | 133 | Header Files\pluginsdk 134 | 135 | 136 | Header Files\pluginsdk 137 | 138 | 139 | Header Files\pluginsdk 140 | 141 | 142 | Header Files 143 | 144 | 145 | Header Files 146 | 147 | 148 | 149 | 150 | Library Files 151 | 152 | 153 | Library Files 154 | 155 | 156 | Library Files 157 | 158 | 159 | Library Files 160 | 161 | 162 | Library Files 163 | 164 | 165 | Library Files 166 | 167 | 168 | Library Files 169 | 170 | 171 | Library Files 172 | 173 | 174 | Library Files 175 | 176 | 177 | Library Files 178 | 179 | 180 | Library Files 181 | 182 | 183 | Library Files 184 | 185 | 186 | Library Files 187 | 188 | 189 | Library Files 190 | 191 | 192 | Library Files 193 | 194 | 195 | Library Files 196 | 197 | 198 | Library Files 199 | 200 | 201 | Library Files 202 | 203 | 204 | 205 | 206 | Source Files 207 | 208 | 209 | Source Files 210 | 211 | 212 | -------------------------------------------------------------------------------- /qt5_resolver/qt5_resolver.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | --------------------------------------------------------------------------------