#pragma once #define FIND_EXPORT(MOD, EXP, TYPE) win_api::find_export(_XS(MOD), _XS(EXP)) #define DECLARE_FUNC(MOD, EXP, TYPE, ID) if(!table[ID]) table[ID] = FIND_EXPORT(MOD, EXP, TYPE); \ auto* const fn = (TYPE*)table[ID] namespace win_api { #pragma data_seg("data") __declspec(allocate("data")) inline void* table[8192]; #pragma data_seg() template < typename T > T* find_export(const char* mod_name, const char* exp_name) { auto mod_handle = LI_FN(GetModuleHandleA)(mod_name); if (mod_handle == nullptr) return nullptr; return pe::find_export(mod_handle, exp_name); } inline_block auto get_last_error() -> DWORD { return *(DWORD*)(__readgsqword(0x30u) + 104); } inline_block auto get_current_process() -> HANDLE { return (HANDLE)-1; } inline_block auto get_current_thread() -> HANDLE { return (HANDLE)-2; } inline_block auto get_current_process_id() -> u_long { return *(DWORD*)(__readgsqword(0x30u) + 64); } inline_block auto get_process_heap() -> HANDLE { return *(HANDLE*)(__readgsqword(0x60u) + 48); } inline_block auto get_module_handle(const char* name) -> HMODULE { DECLARE_FUNC("kernel32.dll", "GetModuleHandleA", decltype(get_module_handle), __COUNTER__); return fn(name); } inline_block auto get_module_handle_wide(const wchar_t* name) -> HMODULE { DECLARE_FUNC("kernel32.dll", "GetModuleHandleA", decltype(get_module_handle_wide), __COUNTER__); return fn(name); } inline_block auto virtual_alloc( void* address, size_t size, u_long alloc_type, u_long protect ) -> void* { DECLARE_FUNC("kernel32.dll", "VirtualAlloc", decltype(virtual_alloc), __COUNTER__); return fn( address, size, alloc_type, protect ); } inline_block auto virtual_query(const void* address, PMEMORY_BASIC_INFORMATION buffer, size_t size) -> size_t { DECLARE_FUNC("kernel32.dll", "VirtualQuery", decltype(virtual_query), __COUNTER__); return fn(address, buffer, size); } inline_block auto virtual_free(void* address, size_t size, u_long free_type) -> int { DECLARE_FUNC("kernel32.dll", "VirtualFree", decltype(virtual_free), __COUNTER__); return fn(address, size, free_type); } inline_block auto read_process_memory(_handle process, const void* base_address, void* buffer, size_t size, size_t* cnt) -> BOOL { DECLARE_FUNC("kernel32.dll", "ReadProcessMemory", decltype(read_process_memory), __COUNTER__); return fn(process, base_address, buffer, size, cnt); } inline_block auto output_debug_string(const char* text) -> void { DECLARE_FUNC("kernel32.dll", "OutputDebugStringA", decltype(output_debug_string), __COUNTER__); return fn(text); } inline_block auto suspend_thread(HANDLE handle) -> DWORD { DECLARE_FUNC("kernel32.dll", "SuspendThread", decltype(suspend_thread), __COUNTER__); return fn(handle); } inline_block auto heap_create(DWORD options, SIZE_T initial_size, SIZE_T maximum_size) -> HANDLE { DECLARE_FUNC("kernel32.dll", "HeapCreate", decltype(heap_create), __COUNTER__); return fn(options, initial_size, maximum_size); } inline_block auto heap_destroy(HANDLE handle) -> BOOL { DECLARE_FUNC("kernel32.dll", "HeapDestroy", decltype(heap_destroy), __COUNTER__); return fn(handle); } inline_block auto pc_to_file_header(PVOID value, PVOID* base_of_image) -> PVOID { DECLARE_FUNC("kernel32.dll", "RtlPcToFileHeader", decltype(pc_to_file_header), __COUNTER__); return fn(value, base_of_image); } inline_block auto heap_alloc(HANDLE handle, DWORD flags, SIZE_T size) -> PVOID { DECLARE_FUNC("ntdll.dll", "RtlAllocateHeap", decltype(heap_alloc), __COUNTER__); return fn(handle, flags, size); } inline_block auto heap_re_alloc(HANDLE handle, DWORD flags, PVOID ptr, SIZE_T size) -> PVOID { DECLARE_FUNC("ntdll.dll", "RtlReAllocateHeap", decltype(heap_re_alloc), __COUNTER__); return fn(handle, flags, ptr, size); } extern bool virtual_protect(void* address, size_t size, u_long new_protect, u_long* old_protect); namespace rebuilt { inline_block auto virtual_alloc(void* address, size_t size, u_long alloc_type, u_long protect) -> void* { if (!NT_SUCCESS(sc_asm_alloc_virtual_memory(get_current_process(), &address, 0, &size, alloc_type, protect))) return nullptr; return address; } inline_block auto virtual_query(const void* address, PMEMORY_BASIC_INFORMATION info_buffer, size_t length) -> size_t { if (!NT_SUCCESS(sc_asm_query_virtual_memory(get_current_process(), (void*)address, k::MemoryBasicInformation, info_buffer, length, &length))) return 0; return length; } inline_block auto get_thread_context(_handle thread, PCONTEXT context) -> bool { return NT_SUCCESS(sc_asm_get_context_thread(thread, context)); } inline_block auto sleep(int miliseconds) { LARGE_INTEGER delay; delay.QuadPart = -(miliseconds * 10000); sc_asm_delay_execution(FALSE, &delay); } } }