DLL注入

Windows消息钩取

钩子

英文 Hook 一词,翻成中文是 “钩子”、“鱼钩” 的意思,泛指钓取所需东西而使用的一切工具。“钩子” 这一基本含义延伸发展为 “偷看或截取信息时所用的手段或工具”。下面举例向各位进一步说明 “钩子” 这一概念。

“钩子” 的概念

假设有一个非常重要的军事设施,其外围设置了 3 层岗哨以进行保护。外部人员若想进入,需要经过 3 层岗哨复杂的检查程序(身份确认、随身物品查验、访问事由说明等)。若间谍在通往该军事设施的道路上私设一个岗哨,经过该岗哨的人员未起疑心,通过时履行同样的检查程序,那么间谍就可以坐享其成,轻松获取(甚至可以操纵)来往该岗哨的所有信息。

像这样,为了偷看或截取来往信息而在中间设置岗哨的行为称为 “挂钩”(或 “安装钩子”)。实际上,偷看或操作信息的行为就是人们常说的 “钩取”(Hooking)。

“钩取” 技术广泛应用于计算机领域。其实,我们不仅可以查看来往于 “OS‑应用程序‑用户” 之间的全部信息,也可以操作它们,并且神不知鬼不觉。具体方法有很多,其中最基本的是 “消息钩子”(Message Hook),下面会详细介绍。

消息钩子

Windows 操作系统向用户提供 GUI(Graphic User Interface,图形用户界面),它以事件驱动(Event Driven)方式工作。在操作系统中借助键盘、鼠标,选择菜单、按钮,以及移动鼠标、改变窗口大小与位置等都是事件(Event)。发生这样的事件时,OS 会把事先定义好的消息发送给相应的应用程序,应用程序分析收到的信息后执行相应动作(上述过程在《Windows 程序设计》一书中有详尽说明)。

也就是说,敲击键盘时,消息会从 OS 移动到应用程序。所谓的 “消息钩子” 就在此间偷看这些信息。为了帮助各位进一步理解它,下面以键盘消息为例说明。请看下图

image-20260826201247670

先讲解常规 Windows 消息流。

  • 发生键盘输入事件时,WM_KEYDOWN 消息被添加到 [OS message queue]。
  • OS 判断哪个应用程序中发生了事件,然后从 [OS message queue] 取出消息,添加到相应应用程序的 [application message queue] 中。
  • 应用程序 (如记事本) 监视自身的 [application message queue],发现新添加的 WM_KEYDOWN 消息后,调用相应的事件处理程序处理。

正如在上图中看到的一样,OS 消息队列与应用程序消息队列之间存在一条 “钩链”(Hook Chain),设置好键盘消息钩子之后,处于 “钩链” 中的键盘消息钩子会比应用程序先看到相应信息。在键盘消息钩子函数的内部,除了可以查看消息之外,还可以修改消息本身,而且还能对消息实施拦截,阻止消息传递。

提示

可以同时设置多个相同的键盘消息钩子。按照设置顺序依次调用这些钩子,它们组成的链条称为 “钩链”。

像这样的消息钩子功能是 Windows 操作系统提供的基本功能,其中最具代表性的是 MS Visual Studio 中提供的 SPY++,它是一个功能十分强大的消息钩取程序,能够查看操作系统中来往的所有消息。

SetWindowsHookEx()

使用 SetWindowsHookEx () API 可轻松实现消息钩子,SetWindowsHookEx () API 的定义如下所示。

1
2
3
4
5
6
HHOOK SetWindowsHookEx(
int idHook, // hook type
HOOKPROC lpfn, // hook procedure
HINSTANCE hMod, // hook procedure所属的DLL句柄(Handle)
DWORD dwThreadId // 想要挂钩的线程ID
);

钩子过程(hook procedure)是由操作系统调用的回调函数。安装消息 “钩子” 时,“钩子” 过程需要存在于某个 DLL 内部,且该 DLL 的示例句柄(instance handle)即是 hMod。

提示

若 dwThreadID 参数被设置为 0,则安装的钩子为 “全局钩子”(Global Hook),它会影响到运行中的(以及以后要运行的)所有进程。

像这样,使用 SetWindowsHookEx () 设置好钩子之后,在某个进程中生成指定消息时,操作系统会将相关的 DLL 文件强制注入(injection)相应进程,然后调用注册的 “钩子” 过程。注入进程时用户几乎不需要做什么,非常方便。

键盘消息钩取练习

做一个简单的键盘消息钩取练习,以进一步加深各位对前面内容的理解

image-20260828104448432

KeyHook.dll文件是一个含有钩子过程(KeyboardProc)的DLL文件。

HookMain.exe是最先加载KeyHook.dll并安装键盘钩子的程序。HookMain.exe加载KeyHook.dll文件后使用SetWindowsHookEx()安装键盘钩子(KeyboardProc)。若其他进程(explorer.exe、iexplore.exe、notepad.exe等)中发生键盘输入事件,OS就会强制将KeyHook.dll加载到相应进程的内存,然后调用KeyboardProc()函数。

这里需要注意的一点是,OS会将KeyHook.dll强制加载到发生键盘输入事件的所有进程。换言之,消息钩取技术常常被用作一种DLL注入技术。

练习示例 HookMain.exe

通过示例来练习一下键盘钩取技术,拦截notepad.exe进程的键盘消息,使之无法显示在记事本中。

运行HookMain.exe

首先运行HookMain.exe程序,如图所示。

image-20260902103849620

运行HookMain.exe程序后,输出“press ‘q’ to quit!”信息,提示在HookMain.exe程序中输入“q”即可停止键盘钩取。

运行Noterpad.exe程序

当前系统中已安装好键盘钩子。运行Notepad.exe,用键盘输入。

如图所示,Notepad.exe进程忽视了用户的键盘输入。使用Process Explorer查看notepad.exe进程,可以看到KeyHook.dll已经加载其中。

image-20260902104547841

HookMain.exe终止 - 拆除键盘钩子

直接在Process Explorer终止任务即可

分析源代码

HookMain.cpp

首先看一下 HookMain.exe 文件的源代码(HookMain.cpp)。

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
// HookMain.cpp

#include "stdio.h"
#include "conio.h"
#include "windows.h"

#define DEF_DLL_NAME "KeyHook.dll"
#define DEF_HOOKSTART "HookStart"
#define DEF_HOOKSTOP "HookStop"

typedef void(*PFN_HOOKSTART)();
typedef void(*PFN_HOOKSTOP)();

void main()
{
HMODULE hDll = NULL;
PFN_HOOKSTART HookStart = NULL;
PFN_HOOKSTOP HookStop = NULL;
char ch = 0;

// 加载KeyHook.dll
hDll = LoadLibraryA(DEF_DLL_NAME);

// 获取导出函数地址
HookStart = (PFN_HOOKSTART)GetProcAddress(hDll, DEF_HOOKSTART);
HookStop = (PFN_HOOKSTOP)GetProcAddress(hDll, DEF_HOOKSTOP);

// 开始钩取
HookStart();

// 等待直到用户输入"q"
printf("press 'q' to quit!\n");
while( _getch() != 'q' );

// 终止钩取
HookStop();

// 卸载KeyHook.dll
FreeLibrary(hDll);
}

源代码非常简单。先加载 KeyHook.dll 文件,然后调用 HookStart() 函数开始钩取,用户输入 “q” 时,调用 HookStop() 函数终止钩取。

KeyHook.cpp

接下来继续看 KeyHook.dll 文件的源代码(KeyHook.cpp)。

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
// KeyHook.cpp

#include "stdio.h"
#include "windows.h"

#define DEF_PROCESS_NAME "notepad.exe"

HINSTANCE g_hInstance = NULL;
HHOOK g_hHook = NULL;
HWND g_hWnd = NULL;

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID
lpvReserved)
{
switch( dwReason )
{
case DLL_PROCESS_ATTACH:
g_hInstance = hinstDLL;
break;

case DLL_PROCESS_DETACH:
break;
}

return TRUE;
}

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
char szPath[MAX_PATH] = {0,};
char *p = NULL;

if( nCode == 0 )
{
// bit 31 : 0 = key press, 1 = key release
if( !(lParam & 0x80000000) ) // 释放键盘按键时
{
GetModuleFileNameA(NULL, szPath, MAX_PATH);
p = strrchr(szPath, '\\');

// 比较当前进程名称,若为notepad.exe,则消息不会传递给应用程序(或下一个“钩子”)
if( !_stricmp(p + 1, DEF_PROCESS_NAME) )
return 1;
}
}

// 若非notepad.exe,则调用CallNextHookEx()函数,将消息传递给应用程序(或下一个“钩子”)
return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}

#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) void HookStart()
{
g_hHook = SetWindowsHookEx(
WH_KEYBOARD, #钩子类型:WH_KEYBOARD
KeyboardProc, #回调函数:KeyboardProc
g_hInstance, #回调函数所在 DLL:KeyHook.dll
0 #目标线程:0,也就是全局键盘 Hook
);
}

__declspec(dllexport) void HookStop()
{
if( g_hHook )
{
UnhookWindowsHookEx(g_hHook);
g_hHook = NULL;
}
}

#ifdef __cplusplus
}
#endif

DLL 代码也非常简单。调用导出函数 HookStart() 时,SetWindowsHookEx() 函数就会将 KeyboardProc() 添加到键盘钩链。

提示

MSDN 中对 KeyboardProc 函数的定义如下:

1
2
3
4
5
LRESULT CALLBACK KeyboardProc(
int code, // HC_ACTION(0), HC_NOREMOVE(3)
WPARAM wParam, // virtual-key code
LPARAM lParam // extra information
);

上面 3 个参数中,wParam 指用户按下的键盘按键的虚拟键值(virtual key code)。对键盘这一硬件而言,英文字符 “A” 与 “a” 具有完全相同的虚拟键值。参数 lParam 根据不同的位具有多种不同的含义(repeat count、scan code、extended-key flag、context code、previous key-state flag、transition-state flag)。使用 ToAscii() API 函数可以获得实际按下的键盘的 ASCII 值。

安装好键盘“钩子”后,无论哪个进程,只要发生键盘输入事件,OS 就会强制将 KeyHook.dll 注入相应进程。加载了 KeyHook.dll 的进程中,发生键盘事件时会首先调用执行 KeyHook.KeyboardProc()。

KeyboardProc() 函数中发生键盘输入事件时,就会比较当前进程的名称与 “notepad.exe” 字符串,若相同,则返回 1,终止 KeyboardProc() 函数,这意味着截获且删除消息。这样,键盘消息就不会传递到 notepad.exe 程序的消息队列。

因 notepad.exe 未能接收到任何键盘消息,故无法输出。

除此之外(即当前进程名称并非 “notepad.exe” 时),执行 return CallNextHookEx(g_hHook,nCode,wParam,lParam); 语句,消息会被传递到另一个应用程序或钩链的另一个“钩子”函数。

初次学习会遇到很多疑惑

整个过程发生了什么

image-20260902113923575

KeyboardProc 回调函数
1
2
3
4
5
LRESULT CALLBACK KeyboardProc(
_In_ int code,
_In_ WPARAM wParam,
_In_ LPARAM lParam
);

简单来说就是你定义一个函数,把函数指针交给系统或库,之后由系统/库在特定事件发生时调用它。

一个应用程序定义或库定义的回调函数,配合 [SetWindowsHookExA]/[SetWindowsHookExW] 函数使用。

每当应用程序调用 [GetMessage]或 [PeekMessageA]/[PeekMessageW] 函数且有键盘消息([WM_KEYUP] 或 [WM_KEYDOWN] 需要处理时,系统就会调用该函数。

调试

本节将学习有关 Windows 消息钩取调试的技术。

调试 HookMain.exe

先调试用来安装键盘钩子的 HookMain.exe。

EP代码

image-20260902114419943

上图显示的是 HookMain.exe 的 EP 代码,它是典型的 VC++ 启动函数,其中最受关注的是开始进行键盘钩取的部分。

查找核心代码

有几种方法可以帮助我们找到关注的核心代码:

  • 逐行跟踪。
  • 检索相关 API。
  • 检索相关字符串。

第一种方法是程序无法正常运行或难以预测时使用的下策,此处略去不谈。这样就剩下后面 2 种方法(检索 API 或字符串)了。

由于已经运行过 HookMain.exe 程序,我们知道了该程序的功能(键盘钩取)与输出的字符串,所以下面要使用检索字符串的方法。

image-20260902114629339

40104D 地址处的指令引用了要查找的字符串。双击字符串,转到相应地址处(40104D)

image-20260902114848432

上图中显示的代码其实就是 HookMain.exe 程序的 main() 函数

调试main函数

在 401000 地址处设置断点,然后运行程序,到断点处停下来,开始调试。

从断点开始依次跟踪调试代码,可以了解 main() 中的主要代码流。先在 401006 地址处调用 LoadLibrary(KeyHook.dll),然后由 40104B 地址处的 CALL EBX 命令调用 KeyHook.HookStart() 函数。

跟踪 40104B 地址处的 CALL EBX 命令(StepInto(F7)),出现下图所示的代码。

image-20260902120518442

上图中的代码是被加载到 HookMain.exe 进程中的 KeyHook.dll 的 HookStart() 函数。

在 100010EE 地址处可以看到 CALL SetWindowsHookExW() 指令,其上方 100010E8 与 100010ED 地址处的 2 条 PUSH 指令用于把 SetWindowsHookExW() API 的第 1、2 两个参数压入栈。

1
2
3
4
5
6
HHOOK SetWindowsHookEx(
int idHook, // hook type
HOOKPROC lpfn, // hook procedure
HINSTANCE hMod, // hook procedure所属的DLL句柄(Handle)
DWORD dwThreadId // 想要挂钩的线程ID
);

SetWindowsHookExW() API 的第一个参数(idHook)值为 WH_KEYBOARD(2),第二个参数(lpfn)值为 10001020,该值即是钩子过程的地址。后面调试 KeyHook.dll 时再仔细看该地址。HookMain.exe 的 main() 函数(401000)的其余代码接收到用户输入的 “q” 命令后终止钩取。

调试Notepad.exe 进程内的 KeyHook.dll

本小节将调试 KeyHook.dll 中的钩子过程,此时 KeyHook.dll 已被注入 notepad.exe 进程。

首先使用Dbg 打开 Notepad.exe 程序(也可以使用 Attach 命令打开运行中的 notepad.exe 进程)。

image-20260902122849032

其次,在Options里的Preferences的Events开启DLL Load

image-20260902121724361

开启该选项后,每当新的DLL装入被调试(Debuggee)进程时就会自动暂停调试(这在“从DLL注入时开始调试”的情况下非常有用)。

此时运行HookMain.exe。然后在notepad.exe中使用键盘输入,此时Dbg暂停调试,下方显示

QQ_1788323494231

KeyHook.dll被加载到10000000地址处。

双击KeyHook.dll转到KeyHook.dll的EP地址处。由于我们已经知道钩子过程的地址为10001020,下面直接转到该地址处

QQ_1788324323436

“钩子”过程(10001020)设置断点,每当notepad.exe中发生键盘输入事件时,调试就停在该处。

在栈中可以看到KeyboardProc()函数的参数

整理过程如下 :

  • 用ODbg运行notepad.exe(或者Attach运行中的notepad.exe);
  • 开启Break on new module(DLL)选项;
  • 运行KeyLogger.exe → 安装global keyboard message hook;
  • 在notepad中使用键盘输入 → 发生键盘消息事件;
  • KeyLogger.dll被注入notepad.exe进程;
  • 在Dbg中向KeyboardProc(钩子过程)设置断点。

DLL注入

DLL注入(DLL Injection)是渗透其他进程的最简单有效的方法,本章将详细讲解DLL注入的有关内容。借助DLL注入技术,可以钩取API、改进程序、修复Bug等。

什么是DLL注入

DLL注入指的是向运行中的其他进程强制插入特定的DLL文件。

从技术细节来说,DLL注入命令其他进程自行调用LoadLibrary() API,加载(Loading)用户指定的DLL文件。

DLL注入与一般DLL加载的区别在于,加载的目标进程是其自身或其他进程。下图描述了DLL注入的概念。

image-20260902130255032

从上图中可以看到,myhack.dll已被强制插入notepad进程(本来notepad并不会加载myhack.dll)。

加载到notepad.exe进程中的myhack.dll与已经加载到notepad.exe进程中的DLL(kernel32.dll、user32.dll)一样,拥有访问notepad.exe进程内存的(正常的)权限,这样用户就可以做任何想做的事了(比如:向notepad添加通信功能以实现Messenger、文本网络浏览器等)。

DLL(Dynamic Linked Library,动态链接库)

DLL被加载到进程后会自动运行DllMain()函数,用户可以把想执行的代码放到**DllMain()**函数,参与加载DLL时,添加的代码就会自然而然得到执行。利用该特性可修复程序Bug,或向程序添加新功能。

DllMain 是 DLL 的入口函数,类似于 exe 程序里的 main(),但它不是由你手动调用的,而是由 Windows 加载器自动调用。

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
BOOL WINAPI DllMain(
HINSTANCE hinstDLL,
DWORD dwReason,
LPVOID lpvReserved
)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
// DLL 被加载到某个进程时执行
// 添加想执行的代码
break;

case DLL_THREAD_ATTACH:
// 当前进程创建新线程时执行
break;

case DLL_THREAD_DETACH:
// 当前进程中的某个线程结束时执行
break;

case DLL_PROCESS_DETACH:
// DLL 从进程中卸载时执行
break;
}

return TRUE;
}

DLL注入示例

使用LoadLibrary() API加载某个DLL时,该DLL中的DllMain()函数就会被调用执行。

DLL注入的工作原理就是从外部促使目标进程调用LoadLibrary() API(与一般DLL加载相同),所以会强制调用执行DLL的DllMain()函数。并且,被注入的DLL拥有目标进程内存的访问权限,用户可以随意操作(修复Bug、添加功能等)。下面看一些使用DLL注入技术的示例。

改善功能与修复BUG

DLL注入技术可用于改善功能与修复Bug。没有程序对应的源码,或直接修改程序比较困难时,就可以使用DLL注入技术为程序添加新功能(类似于插件),或者修改有问题的代码、数据。

消息钩取

Windows OS默认提供的消息钩取功能应用的就是一种DLL注入技术。与常规的DLL注入唯一的区别是,OS会直接将已注册的钩取DLL注入目标进程。

API钩取

API钩取广泛应用于实际的项目开发,而进行API钩取时经常使用DLL注入技术。先创建好DLL形态的钩取函数,再将其轻松注入要钩取的目标进程,这样就完成了API钩取。这灵活运用了“被注入的DLL拥有目标进程内存访问权限”这一特性。

其他应用程序

DLL注入技术也应用于监视、管理PC用户的应用程序。

比如,用来阻止特定程序(像游戏、股票交易等)运行、禁止访问有害网站,以及监视PC的使用等。管理员(或者父母)主要安装这类拦截/阻断应用程序来管理/监视。受管理/监视的一方当然千方百计地想关闭这些监视程序,但由于这些监视程序采用DLL注入技术,它们可以隐藏在正常进程中运行,所以管理员一般不用担心被发现或被终止(若用户强制终止Windows系统进程,也会一并关闭系统,最后也算达成了拦截/阻断这一目标)。

恶意代码

恶意代码制作者们是不会置这么好的技术于不顾的,他们积极地把DLL注入技术运用到自己制作的恶意代码中。这些人把自己编写的恶意代码隐藏到正常进程(winlogon.exe、services.exe、svchost.exe、explorer.exe等),打开后门端口(Backdoor port)、尝试从外部连接,或通过键盘偷录(Keylogging)功能将用户的个人信息盗走。只有了解恶意代码制作者们使用的手法,才能拿出相应对策。

DLL注入的实现方法

向某个进程注入DLL时主要使用以下三种方法:

DLL注入方法

  • 创建远程线程(CreateRemoteThread() API)
  • 使用注册表(AppInit_DLLs 值)
  • 消息钩取(SetWindowsHookEx() API)

CreateRemoteThread()

本方法是《Windows核心编程》中介绍过的。本节通过一个简单的示例来演示如何通过创建远程线程完成DLL注入。

练习示例myhack.dll

本示例将把myhack.dll注入notepad.exe进程,被注入的myhack.dll是用来联网并下载 http://www.naver.com/index.html 文件的。

首先将练习文件(InjectDll.exe、myhack.dll)放到同一文件夹。

image-20260902133743925

运行notepad.exe程序

先运行notepad.exe(日记本)程序,再运行Process Explorer(或者Windows任务管理器)获取notepad.exe进程的PID。

image-20260902133039515

可以看到图中notepad.exe进程的PID值为33044。

运行DebugView

DebugView是一个非常有用的实用程序,它可以用来捕获并显示系统中运行的进程输出的所有调试字符串,请访问下面URL下载。

1
http://technet.microsoft.com/en-us/sysinternals/bb896647

当示例中的DLL文件被成功注入notepad.exe进程时,就会输出调试字符串,此时使用DebugView即可查看。

myhack.dll注入

InjectDll.exe是用来向目标进程注入DLL文件的实用小程序(后面会详细讲解工作原理及源代码)。如图所示,打开命令窗口并输入相应参数即可运行InjectDll.exe。

image-20260902134126118

确认DLL注入成功

下面要检查myhack.dll文件是否成功注入notepad.exe进程。首先查看DebugView日志,如图所示。

image-20260902134257963

DebugView中显示出调试字符串中,该字符串是由PID:33044进程输出的。PID:33044进程就是注入myhack.dll的notepad.exe进程。成功注入myhack.dll时,就会调用执行DllMain()函数的OutputDebugString() API。

在Process Explorer中也可以看到myhack.dll已经成功注入notepad.exe进程。在Process Explorer的View菜单中,选择Show Lower Pane与Lower Pane Views - DLLs项,然后选择notepad.exe进程,就会列出所有加载到notepad.exe进程中的dll,如图所示。在图中可以看到已经成功注入notepad.exe的myhack.dll文件。

image-20260902134745374

结果确认

下面确认一下指定网站的index.html文件下载是否正常。

image-20260902134940903

双击图中的Index.html文件,在浏览器中查看页面。

image-20260902135122389

就像在上述示例中看到的一样,借助创建远程线程的方法可以成功“渗透”指定进程,进而可以随意操作。下面继续分析示例源代码,进一步学习使用CreateRemoteThread() API实施DLL注入的原理与实现方法。

分析示例源代码

Myhack.cpp

先分析一下myhack.dll源代码(myhack.cpp)。

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
// myhack.cpp

#include "windows.h"
#include "tchar.h"

#pragma comment(lib, "urlmon.lib") // 使用 URLDownloadToFile 需要链接 urlmon.lib

#define DEF_URL (L"http://www.naver.com/index.html")
#define DEF_FILE_NAME (L"index.html")

HMODULE g_hMod = NULL; // 保存当前 DLL 的模块句柄

DWORD WINAPI ThreadProc(LPVOID lParam)
{
TCHAR szPath[MAX_PATH] = {0,};

// 获取当前 DLL 的完整路径
if( !GetModuleFileName(g_hMod, szPath, MAX_PATH) )
return FALSE;

// 找到路径中最后一个 '\'
TCHAR *p = _tcsrchr(szPath, '\\');
if( !p )
return FALSE;

// 把 myhack.dll 改成 index.html
_tcscpy_s(p + 1, MAX_PATH, DEF_FILE_NAME);

// 下载网页到 index.html
URLDownloadToFile(NULL, DEF_URL, szPath, 0, NULL);

return 0;
}

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
HANDLE hThread = NULL;

// 保存 DLL 句柄,后面用于获取 DLL 路径
g_hMod = (HMODULE)hinstDLL;

switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
// DLL 被加载到进程时执行

OutputDebugString(L"<myhack.dll Injection!!!>");

// 创建线程执行下载逻辑
hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);

// 关闭线程句柄,不是结束线程
CloseHandle(hThread);

break;
}

return TRUE;
}

在DllMain()函数中可以看到,该DLL被加载(DLL_PROCESS_ATTACH)时,先输出一个调试字符串(“myhack.dll Injection!!!”),然后创建线程调用函数(ThreadProc)。在ThreadProc()函数中通过调用urlmon!URLDownloadToFile() API来下载指定网站的index.html文件。

前面提到过,向进程注入DLL后就会调用执行该DLL的DllMain()函数。所以当myhack.dll注入notepad.exe进程后,最终会调用执行URLDownloadToFile() API。

InjectDll.cpp

InjectDll.exe程序用来将myhack.dll注入notepad.exe进程,下面看一下其源代码。

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
// InjectDll.cpp

#include "windows.h"
#include "tchar.h"

BOOL InjectDll(DWORD dwPID, LPCTSTR szDllPath)
{
HANDLE hProcess = NULL, hThread = NULL;
HMODULE hMod = NULL;
LPVOID pRemoteBuf = NULL;
DWORD dwBufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
LPTHREAD_START_ROUTINE pThreadProc;

// #1. 使用dwPID获取目标进程(notepad.exe)的句柄。
if( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)) )
{
_tprintf(L"OpenProcess(%d) failed!!! [%d]\n", dwPID,
GetLastError());
return FALSE;
}

// #2. 在目标进程(notepad.exe)内存中分配szDllName大小的内存。
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT,
PAGE_READWRITE);

// #3. 将myhack.dll路径写入分配的内存。
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize,
NULL);

// #4. 获取LoadLibraryW() API的地址。
hMod = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod,
"LoadLibraryW");

// #5. 在notepad.exe中运行线程。
hThread = CreateRemoteThread(hProcess, // hProcess
NULL, // lpThreadAttributes
0, // dwStackSize
pThreadProc, // lpStartAddress
pRemoteBuf, // lpParameter
0, // dwCreationFlags
NULL); // lpThreadId

WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);

return TRUE;
}

int _tmain(int argc, TCHAR *argv[])
{
if( argc != 3 )
{
_tprintf(L"USAGE : %s pid dll_path\n", argv[0]);
return 1;
}

// inject dll
if( InjectDll((DWORD)_tstol(argv[1]), argv[2]) )
_tprintf(L"InjectDll(\"%s\") success!!!\n", argv[2]);
else
_tprintf(L"InjectDll(\"%s\") failed!!!\n", argv[2]);

return 0;
}

main()函数的主要功能是检查输入程序的参数,然后调用InjectDll()函数。InjectDll()函数是用来实施DLL注入的核心函数,其功能是命令目标进程(notepad.exe)自行调用LoadLibrary(“myhack.dll”) API。下面逐行详细查看InjectDll()函数。

获取目标进程句柄
1
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)

调用 OpenProcess() API,借助程序运行时以参数形式传递过来的 dwPID 值,获取 notepad.exe 进程的句柄(PROCESS_ALL_ACCESS 权限)。获得 PROCESS_ALL_ACCESS 权限后,就可以使用获取的句柄(hProcess)控制对应进程(notepad.exe)。

OpenProcess 函数用于打开现有的本地进程对象。

1
2
3
4
5
HANDLE OpenProcess(
DWORD dwDesiredAccess, // 访问权限
BOOL bInheritHandle, // 是否继承句柄
DWORD dwProcessId // 目标进程的 PID
);

参数说明

  • dwDesiredAccess: 指定对目标进程的访问权限。常见权限包括: PROCESS_ALL_ACCESS: 获取所有权限。 PROCESS_TERMINATE: 终止进程的权限。 PROCESS_VM_READ: 读取进程内存的权限。 PROCESS_VM_WRITE: 写入进程内存的权限。 PROCESS_QUERY_INFORMATION: 查询进程信息的权限。 PROCESS_CREATE_THREAD: 创建线程的权限。
  • bInheritHandle: 指定句柄是否可以被子进程继承。TRUE 表示可以继承,FALSE 表示不能继承。
  • dwProcessId: 要打开的目标进程的进程 ID (PID)。可以通过 EnumProcesses 或 GetCurrentProcessId 获取。

返回值

  • 成功时,返回目标进程的句柄。
  • 失败时,返回 NULL,可通过 GetLastError 获取错误代码。
将要注入的 DLL 路径写入目标进程内存
1
2
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT,
PAGE_READWRITE);

需要把即将加载的 DLL 文件的路径(字符串)告知目标进程(notepad.exe)。

因为任何内存空间都无法进行写入操作,故先使用 VirtualAllocEx() API 在目标进程(notepad.exe)的内存空间中分配一块缓冲区,且指定该缓冲区的大小为 DLL 文件路径字符串的长度(含 Terminating NULL)即可。

VirtualAllocEx 函数 用于保留、提交或更改指定进程的虚拟地址空间中内存区域的状态。 它特别适用于需要给其他进程分配内存的场景。

1
2
3
4
5
6
7
LPVOID VirtualAllocEx(
[in] HANDLE hProcess,
[in, optional] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD flAllocationType,
[in] DWORD flProtect
);

参数说明

  • hProcess :目标进程的句柄。调用该函数时,这个句柄需要具有:PROCESS_VM_OPERATION权限,也就是说,你必须先通过类似下面的方式打开目标进程**OpenProcess(PROCESS_VM_OPERATION, …);**当然我们已经有了所有权限

  • lpAddress : 期望分配内存的起始地址。若传入NULL,则由系统自动选择合适的地址。

  • dwSize : 要分配的内存大小,单位是字节。例如要写入 DLL 路径:C:\work\myhack.dll,那么 dwSize 就应该是这个字符串长度加上结尾的 \0。

  • flAllocationType : 指定内存分配类型。常见取值有:MEM_COMMIT,提交内存,为这块虚拟内存分配实际可用的存储空间。MEM_RESERVE,保留一段虚拟地址空间,但暂时不分配实际物理存储。

  • flProtect : 指定内存保护属性。就是可读可写可执行。

返回值

  • 成功时,返回分配到的内存区域的基地址。注意是目标进程中的内存地址,而不是当前进程自己的地址。
  • 失败时,返回NULL。

提示

VirtualAllocEx() 函数的返回值(pRemoteBuf)为分配所得缓冲区的地址。该地址并不是程序(Inject.exe)的虚拟内存地址,而是 hProcess 句柄所指目标进程(notepad.exe)的内存地址,请务必牢记这一点。

再来看

1
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllName, dwBufSize, NULL);

使用 WriteProcessMemory() API 将 DLL 路径字符串(C:\work\dummy.dll)写入分配所得缓冲区(pRemoteBuf)地址。WriteProcessMemory() API 所写的内存空间也是 hProcess 句柄所指的目标进程(notepad.exe)的内存空间。这样,要注入的 DLL 文件的路径就被写入目标进程(notepad.exe)的内存空间。

调试 API

Windows 操作系统提供了调试 API,借助它们可以访问其他进程的内存空间。其中具有代表性的有 VirtualAllocEx()、VirtualFreeEx()、WriteProcessMemory()、ReadProcessMemory() 等。

获取 LoadLibraryW() API 地址
1
2
hMod = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");

最重要的是理解好以上代码的含义。

我们的目标明明是获取加载到 notepad.exe 进程的 kernel32.dll 的 LoadLibraryW() API 起始地址,但上面的代码却用来获取加载到 InjectDll.exe 进程的 kernel32.dll 的 LoadLibraryW() API 的起始地址。

如果加载到 notepad.exe 进程中的 kernel32.dll 地址与加载到 InjectDll.exe 进程中的 kernel32.dll 地址相同,那么上面的代码就不会有什么问题。

但是如果 kernel32.dll 在每个进程中加载的地址都不同,那么上面的代码就错了,执行时会发生内存引用错误。

其实在 Windows 系统中,kernel32.dll 在每个进程中的加载地址都是相同的。

《Windows核心编程》一书中对此进行了介绍,此后这一特性被广泛应用于 DLL 注入技术。

提示

根据 OS 类型、语言、版本不同,kernel32.dll 加载的地址也不同。并且 Vista/7 中启用了新的 ASLR 功能,每次启动时,系统 DLL 加载的地址都会改变。但是在系统运行期间它都不会被映射(Mapping)到每个进程的相同地址。Windows 操作系统中,DLL 首次注入内存称为“加载”(Loading),以后其他进程需要使用相同 DLL 时不必再次加载,只要将加载过的 DLL 代码与资源映射一下即可,这种映射技术有利于提高内存的使用效率。

像上面这样,OS 核心 DLL 会被加载到自身固有的地址,DLL 注入利用的就是 Windows OS 的这一特性(该特性也可能会被恶意使用,成为 Windows 安全漏洞)。所以,导入 InjectDll.exe 进程中的 LoadLibraryW() 地址与导入 notepad.exe 进程中的 LoadLibraryW() 地址是相同的。

提示

一般而言,DLL 文件的 ImageBase 默认为 0x10000000。依次加载 a.dll 与 b.dll 时,先加载的 a.dll 被正常加载到 0x10000000 地址处,后加载的 b.dll 无法再被加载到此,而是加载到其他空白地址空间,也就是说,该过程中发生了 DLL 重定位(因为 a.dll 已经先加载到它默认的地址处)。

若 kernel32.dll 加载到各个进程的地址不同,那么上述代码肯定是错误的。但实际上 Windows 操作系统中,kernel32.dll 不管在哪个进程都会被加载至相同地址。为什么会这样呢?我借助 PEView 软件查看了 Windows 操作系统的核心 DLL 文件的 ImageBase 值,罗列如下表(Windows XP SP3 版本,根据 Windows 更新不同,各值会有所变化)。

DLL 文件 ImageBase SizeOfImage
msvcrt.dll 77BC0000 00058000
user32.dll 77CF0000 00090000
gdi32.dll 77E20000 00049000
advapi32.dll 77F50000 000A8000
kernel32.dll 7C7D0000 0013D000
shell32.dll 7D5A0000 007FD000
…… …… ……

微软整理了一份 OS 核心 DLL 文件的 ImageBase 值,防止各 DLL 文件加载时出现区域重合,这样加载 DLL 就不会发生 DLL 重定位了。

在目标进程中运行远程线程(Remote Thread)
1
2
3
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL);
pThreadProc = notepad.exe进程内存中的LoadLibraryW()地址
pRemoteBuf = notepad.exe进程内存中的 "C:\work\myhack.dll" 字符串地址

一切准备就绪后,最后向 notepad.exe 发送一个命令,让其调用 LoadLibraryW() API 函数加载指定的 DLL 文件即可,遗憾的是 Windows 并未直接提供执行这一个命令的 API。但是我们可以另辟蹊径,使用 CreateRemoteThread() 这个 API(在 DLL 注入时几乎总会用到)。

CreateRemoteThread() API 用来在目标进程中执行其创建出的线程,其函数原型如下:

1
2
3
4
5
6
7
8
9
HANDLE WINAPI CreateRemoteThread(
__in HANDLE hProcess, // 目标进程的句柄
__in LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in SIZE_T dwStackSize,
__in LPTHREAD_START_ROUTINE lpStartAddress, // 线程函数地址
__in LPVOID lpParameter, // 线程参数地址
__in DWORD dwCreationFlags,
__out LPDWORD lpThreadId
);

除第一个参数 hProcess 外,其他参数与 CreateThread() 函数完全一样。hProcess 参数是要执行线程的目标进程(或称“远程进程”、“宿主进程”)的句柄。lpStartAddress 与 lpParameter 参数分别给出线程函数地址与线程参数地址。需要注意的是,这 2 个地址都应该在目标进程虚拟内存空间中(这样目标进程才能认识它们)。

初次接触 DLL 注入技术的读者朋友可能会头昏脑胀、不知所云。本来想向其他进程注入 DLL 文件,这里为何突然出现线程运行函数呢?仔细观察线程函数 ThreadProc() 与 LoadLibrary() API,可以从中得到一些启示。

1
2
3
4
5
6
7
DWORD WINAPI ThreadProc(
__in LPVOID lpParameter
);

HMODULE WINAPI LoadLibrary(
__in LPCTSTR lpFileName
);

两函数都有一个 4 字节的参数,并返回一个 4 字节的值。也就是说,二者形态结构完全一样,灵感即源于此。调用 CreateRemoteThread() 时,只要将 LoadLibrary() 函数的地址传递给第四个参数 lpStartAddress,把要注入的 DLL 的路径字符串地址传递给第五个参数 lpParameter 即可(必须是目标进程的虚拟内存空间中的地址)。由于前面已经做好了一切准备,现在调用该函数使目标进程加载指定的 DLL 文件就行了。

其实,CreateRemoteThread() 函数最主要的功能就是驱使目标进程调用 LoadLibrary() 函数,进而加载指定的 DLL 文件了。

调试方法

本节将介绍如何从 DLL 文件注入目标进程就开始调试。首先重新运行 notepad.exe,然后使用 Dbg 的 Attach 命令附加新生成的 notepad.exe 进程。

在 Option 对话框的 Events 中复选 “用户DLL入口” 一项。

image-20260902150525009

这样一来,每当有新的 DLL 被加载到 notepad.exe 进程,都会在该 DLL 的 EP 处暂停。同样,进行 DLL 注入时也会在该 DLL 的 EP 处暂停。使用 InjectDll.exe 将 myhack.dll 文件注入 notepad.exe 进程

image-20260902162401218

此时调试器暂停,如图所示。

image-20260902162456026

但10000000还只是myhack.dll 的 PE 文件头,看4D 5A就知道了,F9运行一次

image-20260902164543973

EIP即为myhack.dll的EP

至此,对于使用 CreateRemoteThread() 函数进行 DLL 注入技术的讲解就完成了。初学时可能不怎么理解,反复认真阅读前面的讲解,实际动手操作,就较容易掌握。

AppInit_DLLs

这里我就贴原著的图了,虽然步骤不多,但怕改错了xD

进行 DLL 注入的第二种方法是使用注册表。Windows 操作系统的注册表中默认提供了 AppInit_DLLs 与 LoadAppInit_DLLs 两个注册表项,如图所示。

image-20260902165454361

在注册表编辑器中,将要注入的 DLL 的路径字符串写入 AppInit_DLLs 项中,然后把 LoadAppInit_DLLs 的项目值设置为 1。重启后,指定 DLL 会注入所有运行进程。该方法操作非常简单,但功能相当强大。

提示

上述方法的工作原理是,User32.dll 被加载到进程时,会读取 AppInit_DLLs 注册表项,若有值,则调用 LoadLibrary() API 加载用户 DLL。所以,严格地说,相应 DLL 并不会被加载到所有进程,而只是加载至加载 user32.dll 的进程。请注意,Windows XP 会忽略 LoadAppInit_DLLs 注册表项。

分析示例源码

myhack2.cpp

下面分析一下 myhack2.dll 的源代码(myhack2.cpp)。

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
// myhack2.cpp

#include "windows.h"
#include "tchar.h"

#define DEF_CMD L"c:\\Program Files\\Internet Explorer\\iexplore.exe"
#define DEF_ADDR L"http://www.naver.com"
#define DEF_DST_PROC L"notepad.exe"

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID
lpvReserved)
{
TCHAR szCmd[MAX_PATH] = {0,};
TCHAR szPath[MAX_PATH] = {0,};
TCHAR *p = NULL;
STARTUPINFO si = {0,};
PROCESS_INFORMATION pi = {0,};

si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;

switch( fdwReason )
{
case DLL_PROCESS_ATTACH :
if( !GetModuleFileName( NULL, szPath, MAX_PATH ) )
break;

if( !(p = _tcsrchr(szPath, '\\')) )
break;

if( _tcsicmp(p+1, DEF_DST_PROC) )
break;

wsprintf(szCmd, L"%s %s", DEF_CMD, DEF_ADDR);
if( !CreateProcess(NULL, (LPTSTR)(LPCTSTR)szCmd,
NULL, NULL, FALSE,
NORMAL_PRIORITY_CLASS,
NULL, NULL, &si, &pi) )
break;

if( pi.hProcess != NULL )
CloseHandle(pi.hProcess);

break;
}

return TRUE;
}

myhack2.dll 的源代码非常简单,若当前加载自己的进程为 “notepad.exe”,则以隐藏模式运行 IE,连接指定网站。这样就可以根据不同目的执行多种任务了。

练习示例 myhack2.dll

下面使用修改注册表项的方法做个 DLL 注入练习,注意操作顺序。

复制文件

首先将要注入的 DLL 文件(myhack2.dll)复制到合适位置(在我电脑中的位置为 C:\work\myhack2.dll)

修改注册表项

运行注册表编辑器 regedit.exe,进入如下路径。

1
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows

编辑修改 AppInit_DLLs 表项的值

image-20260902170204867

然后修改 LoadAppInit_DLLs 注册表项的值为 1

image-20260902170244988

重启系统

注册表项修改完毕后,重启系统,使修改生效。系统重启完成后,使用 Process Explorer 查看 myhack2.dll 是否被注入所有(加载 user32.dll 的)进程。

image-20260902185312204

从下图可以看到,myhack2.dll 成功注入所有加载 user32.dll 的进程。但由于它的目标进程仅是 notepad.exe 进程,所以在其他进程中不会执行任何动作。运行 notepad.exe,可以看到 IE 被(以隐藏模式)执行,如下图所示。

image-20260902185256169

提示

AppInit_DLLs 注册表键非常强大,通过它几乎可以向所有进程注入 DLL 文件。若被注入的 DLL 出现问题(Bug),则有可能导致 Windows 无法正常启动,所以修改该 AppInit_DLLs 前务必慎重。

SetWindowsHookEx()

注入 DLL 的第三个方法就是消息钩取,即用 SetWindowsHookEx() API 安装消息“钩子”,然后由 OS 将指定 DLL(含有“钩子”过程)强制注入相应(带窗口的)进程。其工作原理与使用方法在上述已有详细讲解。

DLL卸载

DLL卸载(DLL Ejection)是将强制插入进程的DLL弹出的一种技术,其基本工作原理与使用CreateRemoteThread API 进行 DLL 注入的原理类似。

DLL 卸载的工作原理

前面我们学习过使用 CreateRemoteThread() API 进行 DLL 注入的工作原理,概括如下:

驱使目标进程调用 LoadLibrary() API

同样,DLL 卸载工作原理也非常简单:

驱使目标进程调用 FreeLibrary() API

也就是说,将 FreeLibrary() API 的地址传递给 CreateRemoteThread() 的 lpStartAddress 参数,并把要卸载的 DLL 的句柄传递给 lpParameter 参数。

提示

每个 Windows 内核对象(Kernel Object)都拥有一个引用计数(Reference Count),代表对象被使用的次数。调用 10 次 LoadLibrary("a.dll"),a.dll 的引用计数就变为 10,卸载 a.dll 时同样需要调用 10 次 FreeLibrary()。每调用一次 LoadLibrary(),引用计数会加 1;每调用一次 FreeLibrary(),引用计数会减 1。因此,卸载 DLL 时要充分考虑好“引用计数”这个因素。

实现 DLL 卸载

首先分析一下 EjectDll.exe 程序,它用来从目标进程(notepad.exe)卸载指定的 DLL 文件(myhack.dll,已注入目标进程),程序源代码(EjectDll.cpp)如下所示。

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
// EjectDll.cpp

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

#define DEF_PROC_NAME (L"notepad.exe")
#define DEF_DLL_NAME (L"myhack.dll")

// 根据进程名查找 PID
DWORD FindProcessID(LPCTSTR szProcessName)
{
DWORD dwPID = 0xFFFFFFFF;
HANDLE hSnapShot = INVALID_HANDLE_VALUE;
PROCESSENTRY32 pe = { 0 };

pe.dwSize = sizeof(PROCESSENTRY32);

// 获取系统进程快照
hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapShot == INVALID_HANDLE_VALUE)
return dwPID;

// 遍历进程
if (Process32First(hSnapShot, &pe))
{
do
{
if (!_tcsicmp(szProcessName, pe.szExeFile))
{
dwPID = pe.th32ProcessID;
break;
}
} while (Process32Next(hSnapShot, &pe));
}

CloseHandle(hSnapShot);
return dwPID;
}

// 开启指定权限,例如 SeDebugPrivilege
BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)
{
TOKEN_PRIVILEGES tp;
HANDLE hToken = NULL;
LUID luid;

// 打开当前进程的访问令牌
if (!OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken))
{
_tprintf(L"OpenProcessToken error: %u\n", GetLastError());
return FALSE;
}

// 获取权限对应的 LUID
if (!LookupPrivilegeValue(NULL, lpszPrivilege, &luid))
{
_tprintf(L"LookupPrivilegeValue error: %u\n", GetLastError());
CloseHandle(hToken);
return FALSE;
}

tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;

if (bEnablePrivilege)
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
else
tp.Privileges[0].Attributes = 0;

// 调整当前进程权限
if (!AdjustTokenPrivileges(hToken,
FALSE,
&tp,
sizeof(TOKEN_PRIVILEGES),
NULL,
NULL))
{
_tprintf(L"AdjustTokenPrivileges error: %u\n", GetLastError());
CloseHandle(hToken);
return FALSE;
}

if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
{
_tprintf(L"The token does not have the specified privilege.\n");
CloseHandle(hToken);
return FALSE;
}

CloseHandle(hToken);
return TRUE;
}

// 从指定 PID 的进程中卸载指定 DLL
BOOL EjectDll(DWORD dwPID, LPCTSTR szDllName)
{
BOOL bMore = FALSE;
BOOL bFound = FALSE;

HANDLE hSnapshot = INVALID_HANDLE_VALUE;
HANDLE hProcess = NULL;
HANDLE hThread = NULL;

HMODULE hKernel32 = NULL;
MODULEENTRY32 me = { 0 };
LPTHREAD_START_ROUTINE pThreadProc = NULL;

me.dwSize = sizeof(MODULEENTRY32);

// 获取目标进程中加载的模块快照
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
if (hSnapshot == INVALID_HANDLE_VALUE)
{
_tprintf(L"CreateToolhelp32Snapshot failed! [%u]\n", GetLastError());
return FALSE;
}

// 遍历目标进程中的 DLL 模块
bMore = Module32First(hSnapshot, &me);
for (; bMore; bMore = Module32Next(hSnapshot, &me))
{
// 比较模块名或者完整路径
if (!_tcsicmp(me.szModule, szDllName) ||
!_tcsicmp(me.szExePath, szDllName))
{
bFound = TRUE;
break;
}
}

if (!bFound)
{
_tprintf(L"Cannot find %s in target process.\n", szDllName);
CloseHandle(hSnapshot);
return FALSE;
}

_tprintf(L"Found DLL: %s\n", me.szModule);
_tprintf(L"Base Address: 0x%p\n", me.modBaseAddr);

// 打开目标进程
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
if (!hProcess)
{
_tprintf(L"OpenProcess(%d) failed! [%u]\n", dwPID, GetLastError());
CloseHandle(hSnapshot);
return FALSE;
}

// 获取 FreeLibrary 地址
hKernel32 = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hKernel32, "FreeLibrary");

if (!pThreadProc)
{
_tprintf(L"GetProcAddress(FreeLibrary) failed! [%u]\n", GetLastError());
CloseHandle(hProcess);
CloseHandle(hSnapshot);
return FALSE;
}

// 在目标进程中创建远程线程,执行 FreeLibrary(me.modBaseAddr)
hThread = CreateRemoteThread(
hProcess,
NULL,
0,
pThreadProc,
me.modBaseAddr,
0,
NULL
);

if (!hThread)
{
_tprintf(L"CreateRemoteThread failed! [%u]\n", GetLastError());
CloseHandle(hProcess);
CloseHandle(hSnapshot);
return FALSE;
}

WaitForSingleObject(hThread, INFINITE);

CloseHandle(hThread);
CloseHandle(hProcess);
CloseHandle(hSnapshot);

return TRUE;
}

int _tmain(int argc, TCHAR* argv[])
{
DWORD dwPID = 0xFFFFFFFF;

// 查找 notepad.exe 的 PID
dwPID = FindProcessID(DEF_PROC_NAME);
if (dwPID == 0xFFFFFFFF)
{
_tprintf(L"There is no %s process!\n", DEF_PROC_NAME);
return 1;
}

_tprintf(L"PID of \"%s\" is %d\n", DEF_PROC_NAME, dwPID);

// 开启调试权限
if (!SetPrivilege(SE_DEBUG_NAME, TRUE))
{
_tprintf(L"SetPrivilege failed!\n");
return 1;
}

// 卸载 DLL
if (EjectDll(dwPID, DEF_DLL_NAME))
{
_tprintf(L"EjectDll(%d, \"%s\") success!\n", dwPID, DEF_DLL_NAME);
}
else
{
_tprintf(L"EjectDll(%d, \"%s\") failed!\n", dwPID, DEF_DLL_NAME);
}

return 0;
}

szModule 成员表示 DLL 的名称,modBaseAddr 成员表示相应 DLL 被加载的地址(进程虚拟内存)。在 EjectDll() 函数的 for 循环中比较 szModule 与希望卸载的 DLL 文件名称,能够准确查找到相应模块的信息。

获取目标进程的句柄

1
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);

该语句使用进程 ID 来获取目标进程(notepad)的进程句柄,下面用获得的进程句柄调用 CreateRemoteThread() API。

获取 FreeLibrary() API 地址

1
2
hModule = GetModuleHandle(L"kernel32.dll");
pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hModule, "FreeLibrary");

若要驱使 notepad 进程自己调用 FreeLibrary() API,需要先得到 FreeLibrary() 的地址。然而上述代码获取的不是加载到 notepad.exe 进程中的 Kernel32!FreeLibrary 地址,而是加载到 EjectDll.exe 进程中的 Kernel32!FreeLibrary 地址。

如果理解了前面学过的有关 DLL 注入的内容,那么各位应该能猜出其中缘由——FreeLibrary 地址在所有进程中都是相同的。

在目标进程中运行线程

1
2
hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc,
me.modBaseAddr, 0, NULL);

pThreadProc 参数是 FreeLibrary() API 的地址,me.modBaseAddr 参数是要卸载的 DLL 的加载地址。将线程函数指定为 FreeLibrary 函数,并把 DLL 加载地址传递给线程参数,这样就在目标进程中成功调用了 FreeLibrary() API。

CreateRemoteThread() API 原意是在外部进程调用执行线程函数,只不过这里的线程函数换成了 FreeLibrary() 函数。

1
2
3
BOOL WINAPI FreeLibrary(
HMODULE hLibModule
);

ThreadProc 函数与 FreeLibrary 函数都只有 1 个参数,以上方法的灵感即源于此。

封面来自げみ