From 5dde105856d92833755c0fe0c06248a2376c5cb0 Mon Sep 17 00:00:00 2001 From: momo5502 Date: Mon, 10 Jun 2024 18:23:45 +0200 Subject: [PATCH] Add all samples and scripts --- README.md | 14 +- qiling/analyze.py | 20 ++ sample/hook/dllmain.cpp | 101 +++++++ sample/hook/hook.vcxproj | 159 +++++++++++ sample/hook/hook.vcxproj.filters | 33 +++ sample/hook/hook.vcxproj.user | 4 + sample/hook/hyperhook.h | 20 ++ sample/hook/hyperhook.lib | Bin 0 -> 1988 bytes sample/hook/pch.cpp | 5 + sample/hook/pch.h | 13 + sample/lul.sln | 41 +++ sample/lul/asm.asm | 10 + sample/lul/lul.cpp | 241 +++++++++++++++++ sample/lul/lul.vcxproj | 150 +++++++++++ sample/lul/lul.vcxproj.filters | 27 ++ sample/lul/lul.vcxproj.user | 4 + sample/lul/peb.h | 449 +++++++++++++++++++++++++++++++ sample/lul/xorstr.hpp | 242 +++++++++++++++++ sample/x64/Release/hook.dll | Bin 0 -> 13824 bytes sample/x64/Release/lul.exe | Bin 0 -> 336896 bytes 20 files changed, 1532 insertions(+), 1 deletion(-) create mode 100644 qiling/analyze.py create mode 100644 sample/hook/dllmain.cpp create mode 100644 sample/hook/hook.vcxproj create mode 100644 sample/hook/hook.vcxproj.filters create mode 100644 sample/hook/hook.vcxproj.user create mode 100644 sample/hook/hyperhook.h create mode 100644 sample/hook/hyperhook.lib create mode 100644 sample/hook/pch.cpp create mode 100644 sample/hook/pch.h create mode 100644 sample/lul.sln create mode 100644 sample/lul/asm.asm create mode 100644 sample/lul/lul.cpp create mode 100644 sample/lul/lul.vcxproj create mode 100644 sample/lul/lul.vcxproj.filters create mode 100644 sample/lul/lul.vcxproj.user create mode 100644 sample/lul/peb.h create mode 100644 sample/lul/xorstr.hpp create mode 100644 sample/x64/Release/hook.dll create mode 100644 sample/x64/Release/lul.exe diff --git a/README.md b/README.md index 5660453..c7442ed 100644 --- a/README.md +++ b/README.md @@ -1 +1,13 @@ -# drm-analysis \ No newline at end of file +# Analyzing modern DRMs +Material acompanying the guest lecture at Ruhr-Universität Bochum. + +## Slides +* https://docs.google.com/presentation/d/17TXl_pds6BC0Zm2gLUnIZK7BtlGc_TRt/edit + +## Recording +* https://www.youtube.com/watch?v=AEvpYgzDATA + +## Links: +* https://qiling.io +* https://github.com/momo5502/hypervisor +* https://hyperdbg.org/ diff --git a/qiling/analyze.py b/qiling/analyze.py new file mode 100644 index 0000000..9655b36 --- /dev/null +++ b/qiling/analyze.py @@ -0,0 +1,20 @@ +from qiling import Qiling +from qiling.const import QL_VERBOSE + +from unicorn.x86_const import * + +def hook_syscall(ql: Qiling): + ql.log.debug(f'!!! SYSCALL {ql.arch.regs.arch_pc:#x}: {ql.arch.regs.eax:#x}') + return (0, 0) + +def mem_read(ql: Qiling, access: int, address: int, size: int, value: int): + ql.log.debug(f'intercepted a memory read from {address:#x} at {ql.arch.regs.arch_pc:#x}') + +if __name__ == "__main__": + ql = Qiling(["C:\\Users\\mauri\\Desktop\\qiling-sample\\lul.exe"], + "C:\\Users\\mauri\\Desktop\\qiling-sample", verbose=QL_VERBOSE.DEBUG, libcache=True) + + ql.hook_mem_read(mem_read) + ql.hook_insn(hook_syscall, UC_X86_INS_SYSCALL) + + ql.run() diff --git a/sample/hook/dllmain.cpp b/sample/hook/dllmain.cpp new file mode 100644 index 0000000..80e9439 --- /dev/null +++ b/sample/hook/dllmain.cpp @@ -0,0 +1,101 @@ +#include "pch.h" +#include +#include +#include + +#include "hyperhook.h" +#include "../lul/peb.h" + +NTSTATUS custom_query_process_information_hook(HANDLE, + PROCESSINFOCLASS, + uint8_t* ProcessInformation, ULONG, + PULONG) +{ + puts("!!! Hook triggered"); + + auto* desired_string = L"C:\\Users\\mauri\\source\\repos\\lul\\x64\\Release\\lul.exe"; + + auto* res = reinterpret_cast(ProcessInformation); + res->Buffer = reinterpret_cast(res + 1); + res->Length = wcslen(desired_string) * 2; + res->MaximumLength = res->Length; + + memcpy(res->Buffer, desired_string, res->Length); + + return 0; +} + +std::vector get_jump_bytes(void* address) +{ + std::vector bytes{ + 0x48, 0xb8, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, // mov rax, 0x1122334455667788 + 0xff, 0xe0, // jmp rax + }; + + memcpy(bytes.data() + 2, &address, sizeof(address)); + + return bytes; +} + +void write_bytes_regularly(void* place, const std::vector& bytes) +{ + DWORD old_protect{}; + VirtualProtect(place, bytes.size(), PAGE_EXECUTE_READWRITE, &old_protect); + + memcpy(place, bytes.data(), bytes.size()); + + VirtualProtect(place, bytes.size(), old_protect, &old_protect); +} + +void write_bytes_with_hypervisor(void* place, const std::vector& bytes) +{ + hyperhook_write(GetCurrentProcessId(), reinterpret_cast(place), bytes.data(), bytes.size()); +} + +void insert_hook(uint64_t address, void* target, const bool using_hypervisor) +{ + auto* place = reinterpret_cast(address); + const auto bytes = get_jump_bytes(target); + + if (using_hypervisor) + { + write_bytes_with_hypervisor(place, bytes); + } + else + { + write_bytes_regularly(place, bytes); + } +} + +void run() +{ + puts(""); + puts("Hook DLL loaded"); + puts("Use hypervisor for hooks? (y/n)"); + const auto use_hypervisor = _getch() == 'y'; + + if(use_hypervisor) + { + puts("Using hypervisor..."); + }else + { + puts("Using regular hooks..."); + } + + insert_hook(0x14004FAE8, &custom_query_process_information_hook, use_hypervisor); + + puts(""); +} + +BOOL APIENTRY DllMain(HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved +) +{ + if (ul_reason_for_call == DLL_PROCESS_ATTACH) + { + run(); + } + + return TRUE; +} diff --git a/sample/hook/hook.vcxproj b/sample/hook/hook.vcxproj new file mode 100644 index 0000000..7098016 --- /dev/null +++ b/sample/hook/hook.vcxproj @@ -0,0 +1,159 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 17.0 + Win32Proj + {1c5f4fcf-8744-450f-863d-923716431557} + hook + 10.0 + + + + DynamicLibrary + true + v143 + Unicode + + + DynamicLibrary + false + v143 + true + Unicode + + + DynamicLibrary + true + v143 + Unicode + + + DynamicLibrary + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + Level3 + true + WIN32;_DEBUG;HOOK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + false + + + + + Level3 + true + true + true + WIN32;NDEBUG;HOOK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + true + true + false + + + + + Level3 + true + _DEBUG;HOOK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + stdcpp20 + + + Windows + true + false + + + + + Level3 + true + true + true + NDEBUG;HOOK_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + stdcpp20 + + + Windows + true + true + true + false + + + + + + + + + + Create + Create + Create + Create + + + + + + \ No newline at end of file diff --git a/sample/hook/hook.vcxproj.filters b/sample/hook/hook.vcxproj.filters new file mode 100644 index 0000000..8446d5c --- /dev/null +++ b/sample/hook/hook.vcxproj.filters @@ -0,0 +1,33 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Headerdateien + + + Headerdateien + + + + + Quelldateien + + + Quelldateien + + + \ No newline at end of file diff --git a/sample/hook/hook.vcxproj.user b/sample/hook/hook.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/sample/hook/hook.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/sample/hook/hyperhook.h b/sample/hook/hyperhook.h new file mode 100644 index 0000000..5d0611e --- /dev/null +++ b/sample/hook/hyperhook.h @@ -0,0 +1,20 @@ +#ifndef EXTERN_C +#ifdef __cplusplus +#define EXTERN_C extern "C" +#else +#define EXTERN_C +#endif +#endif + +#ifndef DLL_IMPORT +#define DLL_IMPORT __declspec(dllimport) +#endif + +EXTERN_C DLL_IMPORT +int hyperhook_initialize(); + +EXTERN_C DLL_IMPORT +int hyperhook_write(unsigned int process_id, unsigned long long address, const void* data, + unsigned long long size); + +#pragma comment(lib, "hyperhook.lib") diff --git a/sample/hook/hyperhook.lib b/sample/hook/hyperhook.lib new file mode 100644 index 0000000000000000000000000000000000000000..3fc6e60f7f314c80530511fa2fc279a03d2bb2a7 GIT binary patch literal 1988 zcmcIl&1(}u6#s2LS`B`LS}z54)k5`POw+C)ifnBKL$_&3(_A+(8_i=NXia{Hb<_(Oj4-&Cwcry%qe!w4c}=yV|s$*AXlVDZA~Tw(U;X z)RTwCU^>7cNgzzb03!ixldv}elnE93pdf|>l5UNY?}tL8JA@&k3z-J!cp>+}*f-5s z%_c$fKSpR-NtsH@+KFSP^6JZJ1vo|saLHKp2b+&3S3L=sr@>1ph+aqfZpOB%o$6#x zPL0#xBh?>55vN{9c30Tl5Ne#FfkOL9JJ#z^cj-_tj^ixiWF)95oJsTfd~)YNf0)Al z*4UC=Ydagx!;X5TcvUs>g+(zR=}wTuu5cydyQ4I9w{CD7%khqJ1vhuJr>_eDT1l$1_ zlhbnIHetrZ@EYmg?_3Aj&EAZ$yeYp8F=j?8nK5srAbMuZ5iwzq(>+IS{PUt48n>Il zy~COIW@Gc`ciO-^>fX5Z$uvzu#hJ>P7A`t;nQ609&vxIWAbPet0(=L-_5!)khnB;l zt7-DBTciy + +#include "peb.h" +#include "xorstr.hpp" + + +#define LOAD_STR(x) (xorstr_(x)) + +EXTERN_C IMAGE_DOS_HEADER __ImageBase; + +// Adapt the hash in the compiled binary +volatile uint32_t theHash = 0x12345678; + +// Adapt the value to the desired path +#define EXPECTED_FILENAME LOAD_STR("C:\\Users\\mauri\\source\\repos\\lul\\x64\\Release\\lul.exe") + +extern "C" NTSTATUS __stdcall InlineNtQueryInformationProcess(HANDLE ProcessHandle, + PROCESSINFOCLASS ProcessInformationClass, + PVOID ProcessInformation, ULONG ProcessInformationLength, + PULONG ReturnLength); + +namespace +{ + FORCEINLINE bool str_equal(const char* s1, const char* s2) + { + for (size_t i = 0;; ++i) + { + if (s1[i] != s2[i]) + { + return false; + } + + if (s1[i] == 0) + { + break; + } + } + + return true; + } + + FORCEINLINE uint32_t jenkins_one_at_a_time_hash(const uint8_t* key, const size_t length) + { + size_t i = 0; + uint32_t hash = 0; + while (i != length) + { + hash += key[i++]; + hash += hash << 10; + hash ^= hash >> 6; + } + hash += hash << 3; + hash ^= hash >> 11; + hash += hash << 15; + return hash; + } + + FORCEINLINE std::pair get_text_section() + { + auto* base = reinterpret_cast(&__ImageBase); + auto* nt_headers = reinterpret_cast(base + __ImageBase.e_lfanew); + + auto section = IMAGE_FIRST_SECTION(nt_headers); + + for (uint16_t i = 0; i < nt_headers->FileHeader.NumberOfSections; ++i, ++section) + { + if (str_equal(reinterpret_cast(section->Name), ".text")) + { + return {base + section->VirtualAddress, section->Misc.VirtualSize}; + } + } + + return {nullptr, 0}; + } + + FORCEINLINE uint32_t compute_text_hash() + { + const auto [addr, size] = get_text_section(); + return jenkins_one_at_a_time_hash(addr, size); + } + + FORCEINLINE bool is_integrity_violated() + { + const auto computed = compute_text_hash(); + + printf(LOAD_STR("Checksum: %08X\n"), computed); + printf(LOAD_STR("Expected: %08X\n"), theHash); + return computed != theHash; + } + + FORCEINLINE void fill_module_filename(char* buffer, const size_t size) + { + if (size == 0) return; + + char totalBuffer[0x1024]; + auto* str = reinterpret_cast(totalBuffer); + + ULONG retLength{0}; + const auto res = InlineNtQueryInformationProcess(reinterpret_cast(0xFFFFFFFFFFFFFFFF), + ProcessImageFileNameWin32, &totalBuffer, sizeof(totalBuffer), + &retLength); + if (res != 0) + { + buffer[0] = 0; + return; + } + + size_t i = 0; + for (; i < (str->Length / 2) && i < (size - 1); ++i) + { + buffer[i] = static_cast(str->Buffer[i]); + } + + buffer[i] = 0; + } + + template + FORCEINLINE void fill_module_filename(char (&buffer)[Size]) + { + fill_module_filename(buffer, Size); + } + + FORCEINLINE bool was_copied() + { + char filename[MAX_PATH]; + fill_module_filename(filename); + + printf(LOAD_STR("Filename: %s\n"), filename); + printf(LOAD_STR("Expected: %s\n"), EXPECTED_FILENAME); + + return !str_equal(filename, EXPECTED_FILENAME); + } + + FORCEINLINE void stuff() + { + puts(LOAD_STR("Loading hook.dll...")); + LoadLibraryA(LOAD_STR("hook.dll")); + + bool valid = true; + + puts(""); + + if (is_integrity_violated()) + { + puts(LOAD_STR(" -> Integrity violation!")); + valid = false; + } + + puts(""); + + if (was_copied()) + { + puts(LOAD_STR(" -> You copied the program")); + valid = false; + } + + puts(""); + + if (!valid) + { + puts(LOAD_STR("Something's wrong.")); + return; + + } + + puts(LOAD_STR("Yay program is running!")); + } + + // This essentially does nothing. + // Its only purpose is to look confusing in IDA to simulate obfuscation. + + template + FORCEINLINE bool decisionMaker(volatile unsigned int* num) + { + if constexpr (Count == 0) + { + return *num == 3; + } + + if constexpr (Count == 1) + { + return *num & 100; + } + + if constexpr (Count > 2) + { + if (*num == 3) + { + *num ^= Count; + return decisionMaker(num); + } + + if constexpr (Count < 5) + { + if (*num > 40) + { + *num = ~Count; + return decisionMaker(num); + } + } + + + if (Count % 4 && *num > 4) + { + constexpr auto newCount = Count >> 1; + return decisionMaker(num); + } + + if (*num % Count == 0) + { + *num = (*num & ~3) ^ ~Count; + return decisionMaker(num); + } + + ++*num; + + return decisionMaker(num) ^ decisionMaker(num); + } + + return true; + } +} + +int main(int argc) +{ + if (argc > 3 && decisionMaker<11>((volatile unsigned int*)&argc)) + { + return 1; + } + + stuff(); + + if (argc > 4 && decisionMaker<7>((volatile unsigned int*)&argc)) + { + return 1; + } + + return 0; +} diff --git a/sample/lul/lul.vcxproj b/sample/lul/lul.vcxproj new file mode 100644 index 0000000..91ecbd8 --- /dev/null +++ b/sample/lul/lul.vcxproj @@ -0,0 +1,150 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 17.0 + Win32Proj + {6061641d-671e-4a1b-bcb9-070d57d87cd0} + lul + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + true + false + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + Speed + stdcpp20 + MultiThreadedDebugDLL + + + Console + true + true + true + true + false + + + + + + + + Document + + + + + + + \ No newline at end of file diff --git a/sample/lul/lul.vcxproj.filters b/sample/lul/lul.vcxproj.filters new file mode 100644 index 0000000..41015ba --- /dev/null +++ b/sample/lul/lul.vcxproj.filters @@ -0,0 +1,27 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Quelldateien + + + + + Quelldateien + + + \ No newline at end of file diff --git a/sample/lul/lul.vcxproj.user b/sample/lul/lul.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/sample/lul/lul.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/sample/lul/peb.h b/sample/lul/peb.h new file mode 100644 index 0000000..ced99ac --- /dev/null +++ b/sample/lul/peb.h @@ -0,0 +1,449 @@ +#pragma once + +#include + +typedef _Return_type_success_(return >= 0) LONG NTSTATUS; + +typedef enum _PROCESSINFOCLASS +{ + ProcessBasicInformation = 0, + ProcessDebugPort = 7, + ProcessWow64Information = 26, + ProcessImageFileName = 27, + ProcessBreakOnTermination = 29, + ProcessImageFileNameWin32 = 43, +} PROCESSINFOCLASS; + +struct RTL_USER_PROCESS_PARAMETERS; + +typedef struct _LSA_UNICODE_STRING { + USHORT Length; + USHORT MaximumLength; + PWSTR Buffer; +} UNICODE_STRING; + +typedef struct _LDR_MODULE +{ + LIST_ENTRY InLoadOrderModuleList; + LIST_ENTRY InMemoryOrderModuleList; + LIST_ENTRY InInitializationOrderModuleList; + PVOID BaseAddress; + PVOID EntryPoint; + ULONG SizeOfImage; + UNICODE_STRING FullDllName; + UNICODE_STRING BaseDllName; + ULONG Flags; + SHORT LoadCount; + SHORT TlsIndex; + LIST_ENTRY HashTableEntry; + ULONG TimeDateStamp; +} LDR_MODULE, *PLDR_MODULE; + +typedef struct _PEB_LDR_DATA +{ + ULONG Length; + BOOLEAN Initialized; + HANDLE SsHandle; + LIST_ENTRY InLoadOrderModuleList; + LIST_ENTRY InMemoryOrderModuleList; + LIST_ENTRY InInitializationOrderModuleList; + PVOID EntryInProgress; + BOOLEAN ShutdownInProgress; + HANDLE ShutdownThreadId; +} PEB_LDR_DATA, *PPEB_LDR_DATA; + +#define GDI_HANDLE_BUFFER_SIZE32 34 +#define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE32 +typedef ULONG GDI_HANDLE_BUFFER[GDI_HANDLE_BUFFER_SIZE]; + +typedef struct _PEB +{ + BOOLEAN InheritedAddressSpace; + BOOLEAN ReadImageFileExecOptions; + BOOLEAN BeingDebugged; + + union + { + BOOLEAN BitField; + + struct + { + BOOLEAN ImageUsesLargePages : 1; + BOOLEAN IsProtectedProcess : 1; + BOOLEAN IsImageDynamicallyRelocated : 1; + BOOLEAN SkipPatchingUser32Forwarders : 1; + BOOLEAN IsPackagedProcess : 1; + BOOLEAN IsAppContainer : 1; + BOOLEAN IsProtectedProcessLight : 1; + BOOLEAN IsLongPathAwareProcess : 1; + }; + }; + + HANDLE Mutant; + + PVOID ImageBaseAddress; + PPEB_LDR_DATA Ldr; + RTL_USER_PROCESS_PARAMETERS* ProcessParameters; + PVOID SubSystemData; + PVOID ProcessHeap; + PRTL_CRITICAL_SECTION FastPebLock; + PSLIST_HEADER AtlThunkSListPtr; + PVOID IFEOKey; + + union + { + ULONG CrossProcessFlags; + + struct + { + ULONG ProcessInJob : 1; + ULONG ProcessInitializing : 1; + ULONG ProcessUsingVEH : 1; + ULONG ProcessUsingVCH : 1; + ULONG ProcessUsingFTH : 1; + ULONG ProcessPreviouslyThrottled : 1; + ULONG ProcessCurrentlyThrottled : 1; + ULONG ProcessImagesHotPatched : 1; // REDSTONE5 + ULONG ReservedBits0 : 24; + }; + }; + + union + { + PVOID KernelCallbackTable; + PVOID UserSharedInfoPtr; + }; + + ULONG SystemReserved; + ULONG AtlThunkSListPtr32; + void* ApiSetMap; + ULONG TlsExpansionCounter; + PVOID TlsBitmap; + ULONG TlsBitmapBits[2]; // TLS_MINIMUM_AVAILABLE + + PVOID ReadOnlySharedMemoryBase; + void* SharedData; // HotpatchInformation + PVOID* ReadOnlyStaticServerData; + + PVOID AnsiCodePageData; // PCPTABLEINFO + PVOID OemCodePageData; // PCPTABLEINFO + PVOID UnicodeCaseTableData; // PNLSTABLEINFO + + ULONG NumberOfProcessors; + ULONG NtGlobalFlag; + + ULARGE_INTEGER CriticalSectionTimeout; + SIZE_T HeapSegmentReserve; + SIZE_T HeapSegmentCommit; + SIZE_T HeapDeCommitTotalFreeThreshold; + SIZE_T HeapDeCommitFreeBlockThreshold; + + ULONG NumberOfHeaps; + ULONG MaximumNumberOfHeaps; + PVOID* ProcessHeaps; // PHEAP + + PVOID GdiSharedHandleTable; // PGDI_SHARED_MEMORY + PVOID ProcessStarterHelper; + ULONG GdiDCAttributeList; + + PRTL_CRITICAL_SECTION LoaderLock; + + ULONG OSMajorVersion; + ULONG OSMinorVersion; + USHORT OSBuildNumber; + USHORT OSCSDVersion; + ULONG OSPlatformId; + ULONG ImageSubsystem; + ULONG ImageSubsystemMajorVersion; + ULONG ImageSubsystemMinorVersion; + KAFFINITY ActiveProcessAffinityMask; + GDI_HANDLE_BUFFER GdiHandleBuffer; + PVOID PostProcessInitRoutine; + + PVOID TlsExpansionBitmap; + ULONG TlsExpansionBitmapBits[32]; // TLS_EXPANSION_SLOTS + + ULONG SessionId; + + ULARGE_INTEGER AppCompatFlags; // KACF_* + ULARGE_INTEGER AppCompatFlagsUser; + PVOID pShimData; + PVOID AppCompatInfo; // APPCOMPAT_EXE_DATA + + UNICODE_STRING CSDVersion; + + void* ActivationContextData; + void* ProcessAssemblyStorageMap; + void* SystemDefaultActivationContextData; + void* SystemAssemblyStorageMap; + + SIZE_T MinimumStackCommit; + + PVOID SparePointers[2]; // 19H1 (previously FlsCallback to FlsHighIndex) + PVOID PatchLoaderData; + PVOID ChpeV2ProcessInfo; // _CHPEV2_PROCESS_INFO + + ULONG AppModelFeatureState; + ULONG SpareUlongs[2]; + + USHORT ActiveCodePage; + USHORT OemCodePage; + USHORT UseCaseMapping; + USHORT UnusedNlsField; + + PVOID WerRegistrationData; + PVOID WerShipAssertPtr; + + union + { + PVOID pContextData; // WIN7 + PVOID pUnused; // WIN10 + PVOID EcCodeBitMap; // WIN11 + }; + + PVOID pImageHeaderHash; + + union + { + ULONG TracingFlags; + + struct + { + ULONG HeapTracingEnabled : 1; + ULONG CritSecTracingEnabled : 1; + ULONG LibLoaderTracingEnabled : 1; + ULONG SpareTracingBits : 29; + }; + }; + + ULONGLONG CsrServerReadOnlySharedMemoryBase; + PRTL_CRITICAL_SECTION TppWorkerpListLock; + LIST_ENTRY TppWorkerpList; + PVOID WaitOnAddressHashTable[128]; + void* TelemetryCoverageHeader; // REDSTONE3 + ULONG CloudFileFlags; + ULONG CloudFileDiagFlags; // REDSTONE4 + CHAR PlaceholderCompatibilityMode; + CHAR PlaceholderCompatibilityModeReserved[7]; + void* LeapSecondData; // REDSTONE5 + union + { + ULONG LeapSecondFlags; + + struct + { + ULONG SixtySecondEnabled : 1; + ULONG Reserved : 31; + }; + }; + + ULONG NtGlobalFlag2; + ULONGLONG ExtendedFeatureDisableMask; // since WIN11 +} PEB, *PPEB; + + +typedef struct _CLIENT_ID +{ + HANDLE UniqueProcess; + HANDLE UniqueThread; +} CLIENT_ID, * PCLIENT_ID; + +typedef struct _ACTIVATION_CONTEXT_STACK +{ + void* ActiveFrame; + LIST_ENTRY FrameListCache; + ULONG Flags; // ACTIVATION_CONTEXT_STACK_FLAG_* + ULONG NextCookieSequenceNumber; + ULONG StackId; +} ACTIVATION_CONTEXT_STACK, * PACTIVATION_CONTEXT_STACK; + +#define GDI_BATCH_BUFFER_SIZE 310 +#define WIN32_CLIENT_INFO_LENGTH 62 +#define STATIC_UNICODE_BUFFER_LENGTH 261 + +typedef struct _GDI_TEB_BATCH +{ + ULONG Offset; + ULONG_PTR HDC; + ULONG Buffer[GDI_BATCH_BUFFER_SIZE]; +} GDI_TEB_BATCH, * PGDI_TEB_BATCH; + +typedef struct _TEB +{ + NT_TIB NtTib; + + PVOID EnvironmentPointer; + CLIENT_ID ClientId; + PVOID ActiveRpcHandle; + PVOID ThreadLocalStoragePointer; + PPEB ProcessEnvironmentBlock; + + ULONG LastErrorValue; + ULONG CountOfOwnedCriticalSections; + PVOID CsrClientThread; + PVOID Win32ThreadInfo; + ULONG User32Reserved[26]; + ULONG UserReserved[5]; + PVOID WOW32Reserved; + LCID CurrentLocale; + ULONG FpSoftwareStatusRegister; + PVOID ReservedForDebuggerInstrumentation[16]; +#ifdef _WIN64 + PVOID SystemReserved1[30]; +#else + PVOID SystemReserved1[26]; +#endif + + CHAR PlaceholderCompatibilityMode; + BOOLEAN PlaceholderHydrationAlwaysExplicit; + CHAR PlaceholderReserved[10]; + + ULONG ProxiedProcessId; + ACTIVATION_CONTEXT_STACK ActivationStack; + + UCHAR WorkingOnBehalfTicket[8]; + NTSTATUS ExceptionCode; + + PACTIVATION_CONTEXT_STACK ActivationContextStackPointer; + ULONG_PTR InstrumentationCallbackSp; + ULONG_PTR InstrumentationCallbackPreviousPc; + ULONG_PTR InstrumentationCallbackPreviousSp; +#ifdef _WIN64 + ULONG TxFsContext; +#endif + + BOOLEAN InstrumentationCallbackDisabled; +#ifdef _WIN64 + BOOLEAN UnalignedLoadStoreExceptions; +#endif +#ifndef _WIN64 + UCHAR SpareBytes[23]; + ULONG TxFsContext; +#endif + GDI_TEB_BATCH GdiTebBatch; + CLIENT_ID RealClientId; + HANDLE GdiCachedProcessHandle; + ULONG GdiClientPID; + ULONG GdiClientTID; + PVOID GdiThreadLocalInfo; + ULONG_PTR Win32ClientInfo[WIN32_CLIENT_INFO_LENGTH]; + + PVOID glDispatchTable[233]; + ULONG_PTR glReserved1[29]; + PVOID glReserved2; + PVOID glSectionInfo; + PVOID glSection; + PVOID glTable; + PVOID glCurrentRC; + PVOID glContext; + + NTSTATUS LastStatusValue; + UNICODE_STRING StaticUnicodeString; + WCHAR StaticUnicodeBuffer[STATIC_UNICODE_BUFFER_LENGTH]; + + PVOID DeallocationStack; + PVOID TlsSlots[TLS_MINIMUM_AVAILABLE]; + LIST_ENTRY TlsLinks; + + PVOID Vdm; + PVOID ReservedForNtRpc; + PVOID DbgSsReserved[2]; + + ULONG HardErrorMode; +#ifdef _WIN64 + PVOID Instrumentation[11]; +#else + PVOID Instrumentation[9]; +#endif + GUID ActivityId; + + PVOID SubProcessTag; + PVOID PerflibData; + PVOID EtwTraceData; + PVOID WinSockData; + ULONG GdiBatchCount; + + union + { + PROCESSOR_NUMBER CurrentIdealProcessor; + ULONG IdealProcessorValue; + + struct + { + UCHAR ReservedPad0; + UCHAR ReservedPad1; + UCHAR ReservedPad2; + UCHAR IdealProcessor; + }; + }; + + ULONG GuaranteedStackBytes; + PVOID ReservedForPerf; + PVOID ReservedForOle; // tagSOleTlsData + ULONG WaitingOnLoaderLock; + PVOID SavedPriorityState; + ULONG_PTR ReservedForCodeCoverage; + PVOID ThreadPoolData; + PVOID* TlsExpansionSlots; +#ifdef _WIN64 + PVOID DeallocationBStore; + PVOID BStoreLimit; +#endif + ULONG MuiGeneration; + ULONG IsImpersonating; + PVOID NlsCache; + PVOID pShimData; + ULONG HeapData; + HANDLE CurrentTransactionHandle; + void* ActiveFrame; + PVOID FlsData; + + PVOID PreferredLanguages; + PVOID UserPrefLanguages; + PVOID MergedPrefLanguages; + ULONG MuiImpersonation; + + union + { + USHORT CrossTebFlags; + USHORT SpareCrossTebBits : 16; + }; + + union + { + USHORT SameTebFlags; + + struct + { + USHORT SafeThunkCall : 1; + USHORT InDebugPrint : 1; + USHORT HasFiberData : 1; + USHORT SkipThreadAttach : 1; + USHORT WerInShipAssertCode : 1; + USHORT RanProcessInit : 1; + USHORT ClonedThread : 1; + USHORT SuppressDebugMsg : 1; + USHORT DisableUserStackWalk : 1; + USHORT RtlExceptionAttached : 1; + USHORT InitialThread : 1; + USHORT SessionAware : 1; + USHORT LoadOwner : 1; + USHORT LoaderWorker : 1; + USHORT SkipLoaderInit : 1; + USHORT SkipFileAPIBrokering : 1; + }; + }; + + PVOID TxnScopeEnterCallback; + PVOID TxnScopeExitCallback; + PVOID TxnScopeContext; + ULONG LockCount; + LONG WowTebOffset; + PVOID ResourceRetValue; + PVOID ReservedForWdf; + ULONGLONG ReservedForCrt; + GUID EffectiveContainerId; + ULONGLONG LastSleepCounter; // Win11 + ULONG SpinCallCount; + ULONGLONG ExtendedFeatureDisableMask; +} TEB, * PTEB; \ No newline at end of file diff --git a/sample/lul/xorstr.hpp b/sample/lul/xorstr.hpp new file mode 100644 index 0000000..38a71f9 --- /dev/null +++ b/sample/lul/xorstr.hpp @@ -0,0 +1,242 @@ +/* + * Copyright 2017 - 2021 Justas Masiulis + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef JM_XORSTR_HPP +#define JM_XORSTR_HPP + +#if defined(_M_ARM64) || defined(__aarch64__) || defined(_M_ARM) || defined(__arm__) +#include +#elif defined(_M_X64) || defined(__amd64__) || defined(_M_IX86) || defined(__i386__) +#include +#else +#error Unsupported platform +#endif + +#include +#include +#include +#include + +#define xorstr(str) ::jm::xor_string([]() { return str; }, std::integral_constant{}, std::make_index_sequence<::jm::detail::_buffer_size()>{}) +#define xorstr_(str) xorstr(str).crypt_get() + +#ifdef _MSC_VER +#define XORSTR_FORCEINLINE __forceinline +#else +#define XORSTR_FORCEINLINE __attribute__((always_inline)) inline +#endif + +namespace jm { + + namespace detail { + + template + XORSTR_FORCEINLINE constexpr std::size_t _buffer_size() + { + return ((Size / 16) + (Size % 16 != 0)) * 2; + } + + template + XORSTR_FORCEINLINE constexpr std::uint32_t key4() noexcept + { + std::uint32_t value = Seed; + for(char c : __TIME__) + value = static_cast((value ^ c) * 16777619ull); + return value; + } + + template + XORSTR_FORCEINLINE constexpr std::uint64_t key8() + { + constexpr auto first_part = key4<2166136261 + S>(); + constexpr auto second_part = key4(); + return (static_cast(first_part) << 32) | second_part; + } + + // loads up to 8 characters of string into uint64 and xors it with the key + template + XORSTR_FORCEINLINE constexpr std::uint64_t + load_xored_str8(std::uint64_t key, std::size_t idx, const CharT* str) noexcept + { + using cast_type = typename std::make_unsigned::type; + constexpr auto value_size = sizeof(CharT); + constexpr auto idx_offset = 8 / value_size; + + std::uint64_t value = key; + for(std::size_t i = 0; i < idx_offset && i + idx * idx_offset < N; ++i) + value ^= + (std::uint64_t{ static_cast(str[i + idx * idx_offset]) } + << ((i % idx_offset) * 8 * value_size)); + + return value; + } + + // forces compiler to use registers instead of stuffing constants in rdata + XORSTR_FORCEINLINE std::uint64_t load_from_reg(std::uint64_t value) noexcept + { +#if defined(__clang__) || defined(__GNUC__) + asm("" : "=r"(value) : "0"(value) :); + return value; +#else + volatile std::uint64_t reg = value; + return reg; +#endif + } + + } // namespace detail + + template + class xor_string; + + template + class xor_string, std::index_sequence> { +#ifndef JM_XORSTR_DISABLE_AVX_INTRINSICS + constexpr static inline std::uint64_t alignment = ((Size > 16) ? 32 : 16); +#else + constexpr static inline std::uint64_t alignment = 16; +#endif + + alignas(alignment) std::uint64_t _storage[sizeof...(Keys)]; + + public: + using value_type = CharT; + using size_type = std::size_t; + using pointer = CharT*; + using const_pointer = const CharT*; + + template + XORSTR_FORCEINLINE xor_string(L l, std::integral_constant, std::index_sequence) noexcept + : _storage{ ::jm::detail::load_from_reg((std::integral_constant(Keys, Indices, l())>::value))... } + {} + + XORSTR_FORCEINLINE constexpr size_type size() const noexcept + { + return Size - 1; + } + + XORSTR_FORCEINLINE void crypt() noexcept + { + // everything is inlined by hand because a certain compiler with a certain linker is _very_ slow +#if defined(__clang__) + alignas(alignment) + std::uint64_t arr[]{ ::jm::detail::load_from_reg(Keys)... }; + std::uint64_t* keys = + (std::uint64_t*)::jm::detail::load_from_reg((std::uint64_t)arr); +#else + alignas(alignment) std::uint64_t keys[]{ ::jm::detail::load_from_reg(Keys)... }; +#endif + +#if defined(_M_ARM64) || defined(__aarch64__) || defined(_M_ARM) || defined(__arm__) +#if defined(__clang__) + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : __builtin_neon_vst1q_v( + reinterpret_cast(_storage) + Indices * 2, + veorq_u64(__builtin_neon_vld1q_v(reinterpret_cast(_storage) + Indices * 2, 51), + __builtin_neon_vld1q_v(reinterpret_cast(keys) + Indices * 2, 51)), + 51)), ...); +#else // GCC, MSVC + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : vst1q_u64( + reinterpret_cast(_storage) + Indices * 2, + veorq_u64(vld1q_u64(reinterpret_cast(_storage) + Indices * 2), + vld1q_u64(reinterpret_cast(keys) + Indices * 2)))), ...); +#endif +#elif !defined(JM_XORSTR_DISABLE_AVX_INTRINSICS) + ((Indices >= sizeof(_storage) / 32 ? static_cast(0) : _mm256_store_si256( + reinterpret_cast<__m256i*>(_storage) + Indices, + _mm256_xor_si256( + _mm256_load_si256(reinterpret_cast(_storage) + Indices), + _mm256_load_si256(reinterpret_cast(keys) + Indices)))), ...); + + if constexpr(sizeof(_storage) % 32 != 0) + _mm_store_si128( + reinterpret_cast<__m128i*>(_storage + sizeof...(Keys) - 2), + _mm_xor_si128(_mm_load_si128(reinterpret_cast(_storage + sizeof...(Keys) - 2)), + _mm_load_si128(reinterpret_cast(keys + sizeof...(Keys) - 2)))); +#else + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : _mm_store_si128( + reinterpret_cast<__m128i*>(_storage) + Indices, + _mm_xor_si128(_mm_load_si128(reinterpret_cast(_storage) + Indices), + _mm_load_si128(reinterpret_cast(keys) + Indices)))), ...); +#endif + } + + XORSTR_FORCEINLINE const_pointer get() const noexcept + { + return reinterpret_cast(_storage); + } + + XORSTR_FORCEINLINE pointer get() noexcept + { + return reinterpret_cast(_storage); + } + + XORSTR_FORCEINLINE pointer crypt_get() noexcept + { + // crypt() is inlined by hand because a certain compiler with a certain linker is _very_ slow +#if defined(__clang__) + alignas(alignment) + std::uint64_t arr[]{ ::jm::detail::load_from_reg(Keys)... }; + std::uint64_t* keys = + (std::uint64_t*)::jm::detail::load_from_reg((std::uint64_t)arr); +#else + alignas(alignment) std::uint64_t keys[]{ ::jm::detail::load_from_reg(Keys)... }; +#endif + +#if defined(_M_ARM64) || defined(__aarch64__) || defined(_M_ARM) || defined(__arm__) +#if defined(__clang__) + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : __builtin_neon_vst1q_v( + reinterpret_cast(_storage) + Indices * 2, + veorq_u64(__builtin_neon_vld1q_v(reinterpret_cast(_storage) + Indices * 2, 51), + __builtin_neon_vld1q_v(reinterpret_cast(keys) + Indices * 2, 51)), + 51)), ...); +#else // GCC, MSVC + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : vst1q_u64( + reinterpret_cast(_storage) + Indices * 2, + veorq_u64(vld1q_u64(reinterpret_cast(_storage) + Indices * 2), + vld1q_u64(reinterpret_cast(keys) + Indices * 2)))), ...); +#endif +#elif !defined(JM_XORSTR_DISABLE_AVX_INTRINSICS) + ((Indices >= sizeof(_storage) / 32 ? static_cast(0) : _mm256_store_si256( + reinterpret_cast<__m256i*>(_storage) + Indices, + _mm256_xor_si256( + _mm256_load_si256(reinterpret_cast(_storage) + Indices), + _mm256_load_si256(reinterpret_cast(keys) + Indices)))), ...); + + if constexpr(sizeof(_storage) % 32 != 0) + _mm_store_si128( + reinterpret_cast<__m128i*>(_storage + sizeof...(Keys) - 2), + _mm_xor_si128(_mm_load_si128(reinterpret_cast(_storage + sizeof...(Keys) - 2)), + _mm_load_si128(reinterpret_cast(keys + sizeof...(Keys) - 2)))); +#else + ((Indices >= sizeof(_storage) / 16 ? static_cast(0) : _mm_store_si128( + reinterpret_cast<__m128i*>(_storage) + Indices, + _mm_xor_si128(_mm_load_si128(reinterpret_cast(_storage) + Indices), + _mm_load_si128(reinterpret_cast(keys) + Indices)))), ...); +#endif + + return (pointer)(_storage); + } + }; + + template + xor_string(L l, std::integral_constant, std::index_sequence) -> xor_string< + std::remove_const_t>, + Size, + std::integer_sequence()...>, + std::index_sequence>; + +} // namespace jm + +#endif // include guard diff --git a/sample/x64/Release/hook.dll b/sample/x64/Release/hook.dll new file mode 100644 index 0000000000000000000000000000000000000000..ba54de6ee78be38343728be09d441eb1c0000559 GIT binary patch literal 13824 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 literal 0 HcmV?d00001 diff --git a/sample/x64/Release/lul.exe b/sample/x64/Release/lul.exe new file mode 100644 index 0000000000000000000000000000000000000000..bd738ef0169f93eba37cb173c2b60d4dea0f5b3b GIT binary patch literal 336896 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­g23lh_*S+5YWtHDIujHy)CKL;spn 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 literal 0 HcmV?d00001