《逆向工程核心原理》-- DLL注入和卸载

零五零八

DLL注入和卸载



一、DLL注入

  DLL注入：向运行中的其他进程强制插入特定的DLL文件，主要是命令其他进程自行调用LoadLibrary() API，加载用户指定的DLL文件。DLL注入与一般DLL加载的主要区别是加载的目标进程是其自身或其他进程。

1. DLL

  DLL（Dynamic Linked Library，动态链接库），DLL被加载到进程后会自动运行DllMain函数，用户可以把想要执行的额代码放到DllMain函数，每当加载DLL时，添加的代码就会自动得到执行。利用该特性可以修复程序BUG，或向程序添加新功能。

1. // DllMain()函数
   
2. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpvRserved)
   
3. {
   
4.   switch(dwReason)
   
5.   {
   
6.     case DLL_PROCESS_ATTACH:
   
7.       // 添加想要执行的代码
   
8.       break;
   
9. 
   
10.     case DLL_THREAD_ATTACH:
    
11.       break;
    
12. 
    
13.     case DLL_THREAD_DETACH:
    
14.       break;
    
15. 
    
16.     case DLL_PROCESS_DETACH:
    
17.       break;
    
18.   }
    
19. 
    
20.   return TRUE;
    
21. }

复制代码

2. DLL注入实例

使用LoadLibrary()加载某个DLL时，该DLL中的DllMain()函数会被调用执行。DLL注入的原理就是从外部促使目标进程调用LoadLibrary() API。

• 改善功能与修复BUG
• 消息钩取--Windows 默认提供的消息钩取功能本质上应用的就是一种DLL注入技术
• API钩取--先创建DLL形态的钩取函数，然后注入要钩取的目标进程，主要是应用了被注入的DLL拥有目标进程内存访问权限这一特性
• 其他应用程序--监视、管理PC用户的应用程序
• 恶意代码--非法注入，进行代码隐藏
  

3. DLL注入的实现方法


1. 创建远程线程（CreateRemoteThread() API）

此处主要记录一下书上的源码分析，操作部分请自行实践。

1. // myhack.cpp
   
2. #include "windows.h"
   
3. #include "tchar.h"
   
4. 
   
5. #pragma comment(lib, "urlmon.lib")
   
6. 
   
7. #define DEF_URL         (L"http://www.naver.com/index.html")
   
8. #define DEF_FILE_NAME   (L"index.html")
   
9. 
   
10. HMODULE g_hMod = NULL;
    
11. 
    
12. DWORD WINAPI ThreadProc(LPVOID lParam)
    
13. {
    
14.     TCHAR szPath[_MAX_PATH] = {0,};
    
15. 
    
16.     if( !GetModuleFileName( g_hMod, szPath, MAX_PATH ) )
    
17.         return FALSE;
    
18. 
    
19.     TCHAR *p = _tcsrchr( szPath, '\\' );
    
20.     if( !p )
    
21.         return FALSE;
    
22. 
    
23.     _tcscpy_s(p+1, _MAX_PATH, DEF_FILE_NAME); //参数准备
    
24. 
    
25.     URLDownloadToFile(NULL, DEF_URL, szPath, 0, NULL); //调用函数进行URL下载
    
26. 
    
27.     return 0;
    
28. }
    
29. 
    
30. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
    
31. {
    
32.     HANDLE hThread = NULL;
    
33. 
    
34.     g_hMod = (HMODULE)hinstDLL;
    
35. 
    
36.     switch( fdwReason )
    
37.     {
    
38.     case DLL_PROCESS_ATTACH :
    
39.         OutputDebugString(L"<myhack.dll> Injection!!!");
    
40. 
    
41.         //创建远程线程进行download
    
42.         hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
    
43. 
    
44.         // 需要注意，切记随手关闭句柄，保持好习惯
    
45.         CloseHandle(hThread);
    
46.         break;
    
47.     }
    
48. 
    
49.     return TRUE;
    
50. }

复制代码

1. // InjectDll.cpp
   
2. #include "windows.h"
   
3. #include "tchar.h"
   
4. 
   
5. BOOL InjectDll(DWORD dwPID, LPCTSTR szDllPath)
   
6. {
   
7.     HANDLE hProcess = NULL, hThread = NULL;
   
8.     HMODULE hMod = NULL;
   
9.     LPVOID pRemoteBuf = NULL;
   
10. 
    
11.       //确定路径需要占用的缓冲区大小
    
12.     DWORD dwBufSize = (DWORD)(_tcslen(szDllPath) + 1) * sizeof(TCHAR);
    
13.     LPTHREAD_START_ROUTINE pThreadProc;
    
14. 
    
15.     // #1. 使用OpenProcess函数获取目标进程句柄（PROCESS_ALL_ACCESS权限）
    
16.     if ( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)) )
    
17.     {
    
18.         _tprintf(L"OpenProcess(%d) failed!!! [%d]\n", dwPID, GetLastError());
    
19.         return FALSE;
    
20.     }
    
21. 
    
22.     // #2. 使用VirtualAllocEx函数在目标进程中分配内存，大小为szDllName
    
23.       // VirtualAllocEx函数返回的是hProcess指向的目标进程的分配所得缓冲区的内存地址
    
24.     pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize, MEM_COMMIT, PAGE_READWRITE);
    
25. 
    
26.     // #3.  将myhack.dll路径 ("c:\\myhack.dll")写入目标进程中分配到的内存
    
27.     WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllPath, dwBufSize, NULL);
    
28. 
    
29.     // #4. 获取LoadLibraryA() API的地址
    
30.       // 这里主要利用来了kernel32.dll文件在每个进程中的加载地址都相同这一特点，所以不管是获取加载到   
    
31.       // InjectDll.exe还是notepad.exe进程的kernel32.dll中的LoadLibraryW函数的地址都是一样的。这里的加载地
    
32.       // 址相同指的是在同一次系统运行中，如果再次启动系统kernel32.dll的加载地址会变，但是每个进程的
    
33.       // kernerl32.dll的加载地址还是一样的。
    
34.       hMod = GetModuleHandle(L"kernel32.dll");
    
35.     pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hMod, "LoadLibraryW");
    
36. 
    
37.     // #5. 在目标进程notepad.exe中运行远程线程
    
38.       // pThreadProc = notepad.exe进程内存中的LoadLibraryW()地址
    
39.       // pRemoteBuf = notepad.exe进程内存中待加载注入dll的路径字符串的地址
    
40.     hThread = CreateRemoteThread(hProcess, NULL, 0, pThreadProc, pRemoteBuf, 0, NULL);
    
41.     WaitForSingleObject(hThread, INFINITE);   
    
42. 
    
43.       //同样，记得关闭句柄
    
44.     CloseHandle(hThread);
    
45.     CloseHandle(hProcess);
    
46. 
    
47.     return TRUE;
    
48. }
    
49. 
    
50. int _tmain(int argc, TCHAR *argv[])
    
51. {
    
52.     if( argc != 3)
    
53.     {
    
54.         _tprintf(L"USAGE : %s <pid> <dll_path>\n", argv[0]);
    
55.         return 1;
    
56.     }
    
57. 
    
58.     // change privilege
    
59.     if( !SetPrivilege(SE_DEBUG_NAME, TRUE) )
    
60.         return 1;
    
61. 
    
62.     // inject dll
    
63.     if( InjectDll((DWORD)_tstol(argv[1]), argv[2]) )
    
64.         _tprintf(L"InjectDll("%s") success!!!\n", argv[2]);
    
65.     else
    
66.         _tprintf(L"InjectDll("%s") failed!!!\n", argv[2]);
    
67. 
    
68.     return 0;
    
69. }

复制代码

main()函数主要检查输入程序的参数，然后调用InjectDll函数。InjectDll函数是实施DLL注入的核心函数，功能是命令目标进程自行调用LoadLibrary API。重点介绍一下CreateRemoteThread()函数，该函数在进行DLL注入时会经常用到，其函数原型如下：

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

复制代码

2. AppInit_DLLs

  第二种方法是操作注册表，Windows的注册表中默认提供了AppInit_DLLs与LoadAppInit_DLLs两个注册表项，只要将要注入DLL的路径字符串写入AppInit_DLLs项目，并在LoadAppInit_DLLs中设置值为1，重启时，系统就会将指定的DLL注入到所有运行进程中。主要原理是User32.dll被加载到进程时，会读取AppInit_DLLs注册表项，若值为1，就调用LoadLibrary()函数加载用户DLL。所以严格来说，是将注入DLL加载到使用user32.dll的进程中。

1. // myhack2.cpp
   
2. // 主要作用是以隐藏模式运行IE，连接到指定网站
   
3. 
   
4. #include "windows.h"
   
5. #include "tchar.h"
   
6. 
   
7. #define DEF_CMD  L"c:\\Program Files\\Internet Explorer\\iexplore.exe"
   
8. #define DEF_ADDR L"http://www.naver.com"
   
9. #define DEF_DST_PROC L"notepad.exe"
   
10. 
    
11. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
    
12. {
    
13.     TCHAR szCmd[MAX_PATH]  = {0,};
    
14.     TCHAR szPath[MAX_PATH] = {0,};
    
15.     TCHAR *p = NULL;
    
16.     STARTUPINFO si = {0,};
    
17.     PROCESS_INFORMATION pi = {0,};
    
18. 
    
19.     si.cb = sizeof(STARTUPINFO);
    
20.     si.dwFlags = STARTF_USESHOWWINDOW;
    
21.     si.wShowWindow = SW_HIDE;
    
22. 
    
23.     switch( fdwReason )
    
24.     {
    
25.     case DLL_PROCESS_ATTACH :
    
26.         if( !GetModuleFileName( NULL, szPath, MAX_PATH ) )
    
27.             break;
    
28. 
    
29.         if( !(p = _tcsrchr(szPath, '\\')) )
    
30.             break;
    
31. 
    
32.         if( _tcsicmp(p+1, DEF_DST_PROC) )
    
33.             break;
    
34. 
    
35.         wsprintf(szCmd, L"%s %s", DEF_CMD, DEF_ADDR);
    
36.         if( !CreateProcess(NULL, (LPTSTR)(LPCTSTR)szCmd,
    
37.                             NULL, NULL, FALSE,
    
38.                             NORMAL_PRIORITY_CLASS,
    
39.                             NULL, NULL, &si, &pi) )
    
40.             break;
    
41. 
    
42.         if( pi.hProcess != NULL )
    
43.             CloseHandle(pi.hProcess);
    
44. 
    
45.         break;
    
46.     }
    
47. 
    
48.     return TRUE;
    
49. }

复制代码

  将上述dll文件复制到某个位置，修改注册表项HKEY_LOCAL_MACHINE\SOFTWARE\Microdoft\Windows NT\CurrentVersion\Windows,将AppInit_DLLs项的值修改为待注入DLL的绝对路径，然后修改LoadAppInit_DLLs注册表项的值为1，重启，运行notepad.exe，就会看到DLL已经被注入。

3. 使用SetWindowsHookEx()函数

第三个方法就是消息钩取，使用SetWindowsHookEx安装钩子，将指定DLL强制注入进程。

二、DLL卸载

  DLL卸载原理：驱使目标进程调用FreeLibrary()函数，即将FreeLibrary()函数的地址传递给CreateRemoteThread()函数的lpStartAddress参数，并把待卸载的DLL句柄传递给lpParameter参数。需要注意的一点是：引用计数问题。调用一次FreeLibrary()函数，引用计数就会-1。引用计数表示的是内核对象被使用的次数。

1. // EjectDll.exe
   
2. 
   
3. #include "windows.h"
   
4. #include "tlhelp32.h"
   
5. #include "tchar.h"
   
6. 
   
7. #define DEF_PROC_NAME    (L"notepad.exe")
   
8. #define DEF_DLL_NAME    (L"myhack.dll")
   
9. 
   
10. DWORD FindProcessID(LPCTSTR szProcessName)
    
11. {
    
12.     DWORD dwPID = 0xFFFFFFFF;
    
13.     HANDLE hSnapShot = INVALID_HANDLE_VALUE;
    
14.     PROCESSENTRY32 pe;
    
15. 
    
16.     // 获取系统快照
    
17.     pe.dwSize = sizeof( PROCESSENTRY32 );
    
18.     hSnapShot = CreateToolhelp32Snapshot( TH32CS_SNAPALL, NULL );
    
19. 
    
20.     // 查找进程
    
21.     Process32First(hSnapShot, &pe);
    
22.     do
    
23.     {
    
24.         if(!_tcsicmp(szProcessName, (LPCTSTR)pe.szExeFile))
    
25.         {
    
26.             dwPID = pe.th32ProcessID;
    
27.             break;
    
28.         }
    
29.     }
    
30.     while(Process32Next(hSnapShot, &pe));
    
31. 
    
32.     CloseHandle(hSnapShot);
    
33. 
    
34.     return dwPID;
    
35. }
    
36. 
    
37. BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)
    
38. {
    
39.     TOKEN_PRIVILEGES tp;
    
40.     HANDLE hToken;
    
41.     LUID luid;
    
42. 
    
43.     if( !OpenProcessToken(GetCurrentProcess(),
    
44.                           TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
    
45.                           &hToken) )
    
46.     {
    
47.         _tprintf(L"OpenProcessToken error: %u\n", GetLastError());
    
48.         return FALSE;
    
49.     }
    
50. 
    
51.     if( !LookupPrivilegeValue(NULL,           // lookup privilege on local system
    
52.                               lpszPrivilege,  // privilege to lookup
    
53.                               &luid) )        // receives LUID of privilege
    
54.     {
    
55.         _tprintf(L"LookupPrivilegeValue error: %u\n", GetLastError() );
    
56.         return FALSE;
    
57.     }
    
58. 
    
59.     tp.PrivilegeCount = 1;
    
60.     tp.Privileges[0].Luid = luid;
    
61.     if( bEnablePrivilege )
    
62.         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    
63.     else
    
64.         tp.Privileges[0].Attributes = 0;
    
65. 
    
66.     // Enable the privilege or disable all privileges.
    
67.     if( !AdjustTokenPrivileges(hToken,
    
68.                                FALSE,
    
69.                                &tp,
    
70.                                sizeof(TOKEN_PRIVILEGES),
    
71.                                (PTOKEN_PRIVILEGES) NULL,
    
72.                                (PDWORD) NULL) )
    
73.     {
    
74.         _tprintf(L"AdjustTokenPrivileges error: %u\n", GetLastError() );
    
75.         return FALSE;
    
76.     }
    
77. 
    
78.     if( GetLastError() == ERROR_NOT_ALL_ASSIGNED )
    
79.     {
    
80.         _tprintf(L"The token does not have the specified privilege. \n");
    
81.         return FALSE;
    
82.     }
    
83. 
    
84.     return TRUE;
    
85. }
    
86. 
    
87. BOOL EjectDll(DWORD dwPID, LPCTSTR szDllName)
    
88. {
    
89.     BOOL bMore = FALSE, bFound = FALSE;
    
90.     HANDLE hSnapshot, hProcess, hThread;
    
91.     HMODULE hModule = NULL;
    
92.     MODULEENTRY32 me = { sizeof(me) };
    
93.     LPTHREAD_START_ROUTINE pThreadProc;
    
94. 
    
95.     // dwPID = notepad 进程ID
    
96.     // 使用TH32CS_SNAPMODULE参数，获取加载到notepad进程的DLL名称
    
97.     hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
    
98. 
    
99.     bMore = Module32First(hSnapshot, &me);
    
100.     for( ; bMore ; bMore = Module32Next(hSnapshot, &me) )
     
101.     {
     
102.         if( !_tcsicmp((LPCTSTR)me.szModule, szDllName) ||
     
103.             !_tcsicmp((LPCTSTR)me.szExePath, szDllName) )
     
104.         {
     
105.             bFound = TRUE;
     
106.             break;
     
107.         }
     
108.     }
     
109. 
     
110.     if( !bFound )
     
111.     {
     
112.         CloseHandle(hSnapshot);
     
113.         return FALSE;
     
114.     }
     
115. 
     
116.     if ( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)) )
     
117.     {
     
118.         _tprintf(L"OpenProcess(%d) failed!!! [%d]\n", dwPID, GetLastError());
     
119.         return FALSE;
     
120.     }
     
121. 
     
122.     hModule = GetModuleHandle(L"kernel32.dll");
     
123.       // 获取FreeLibrary函数加载地址，并使用CreateRemoteThread进行调用
     
124.     pThreadProc = (LPTHREAD_START_ROUTINE)GetProcAddress(hModule, "FreeLibrary");
     
125.     hThread = CreateRemoteThread(hProcess, NULL, 0,
     
126.                                  pThreadProc, me.modBaseAddr,
     
127.                                  0, NULL);
     
128.     WaitForSingleObject(hThread, INFINITE);   
     
129. 
     
130.     CloseHandle(hThread);
     
131.     CloseHandle(hProcess);
     
132.     CloseHandle(hSnapshot);
     
133. 
     
134.     return TRUE;
     
135. }
     
136. 
     
137. int _tmain(int argc, TCHAR* argv[])
     
138. {
     
139.     DWORD dwPID = 0xFFFFFFFF;
     
140. 
     
141.     // 查找process
     
142.     dwPID = FindProcessID(DEF_PROC_NAME);
     
143.     if( dwPID == 0xFFFFFFFF )
     
144.     {
     
145.         _tprintf(L"There is no <%s> process!\n", DEF_PROC_NAME);
     
146.         return 1;
     
147.     }
     
148. 
     
149.     _tprintf(L"PID of "%s" is %d\n", DEF_PROC_NAME, dwPID);
     
150. 
     
151.     // 更改 privilege
     
152.     if( !SetPrivilege(SE_DEBUG_NAME, TRUE) )
     
153.         return 1;
     
154. 
     
155.     // 注入 dll
     
156.     if( EjectDll(dwPID, DEF_DLL_NAME) )
     
157.         _tprintf(L"EjectDll(%d, "%s") success!!!\n", dwPID, DEF_DLL_NAME);
     
158.     else
     
159.         _tprintf(L"EjectDll(%d, "%s") failed!!!\n", dwPID, DEF_DLL_NAME);
     
160. 
     
161.     return 0;
     
162. }

复制代码

CreateToolhelp32Snapshot()函数主要用来获取加载到进程的模块信息，将获取的hSnapshot句柄传递给Module32First()/Module32Next()函数后，即可设置与MODULEENTRY32结构相关的模块信息，以下为该结构的详细定义：

.

1. typedef sturc tagMODULEENTRY32
   
2. {
   
3.     DWORD dwSize;
   
4.   DWORD th32ModuleID;        // 该模块
   
5.   DWORD th32ProcessID;    // 模块拥有的进程
   
6.   DWORD GlbcntUsage;        //模块中的global usage计数
   
7.   DWORD ProcessUsage;      
   
8.   BYTE * modBaseAddr;        //在进程的上下文中的模块的基地址
   
9.   DWORD modBaseSize;        // 在modBaseAddr开始位置的模块的大小（字节为单位）
   
10.   HMODULE hModule;
    
11.   char szModule[MAX_MODULE_NAME32+1];    //DLL名称
    
12.   char szExePath[MAX_PATH];
    
13. }MODULEENTRY32;

复制代码