利用CreateProcess实现程序未启动前的监视,并注入DLL!

一、DLL注入技术的用途

DLL注入技术的用途是很广泛的,这主要体现在:

1、假如你要操纵的对象涉及的数据不在进程内

2、你想对目标进程中的函数进行拦截(甚至API函数,嘿嘿,由此编写个拦截timeGettime的过程,变速齿轮不就出来了么?改天我试试),比如对它所属窗口进行子类化。

3、你想编写一些函数用于增强或增加目标进程功能,比如可以给目标进程的某个窗口插入个消息循环增加其响应能力。(Mfc Windows程序设计称之为消息泵)。

4、隐藏自己的程序,很多恶意程序都是这样做的,即使你将恶意程序的进程结束掉也毫无意义了,因为它自己已经插入到很多进程中去了,唯一有效的办法只有注销windows.。如果你是个爱搞破坏的人就更应该掌握该技术了,不但可以利用该技术实现隐藏自己的进程,还可以破坏某个目标进程。因为将破坏代码插入到目标进程进行破坏的话简直易如反掌。不信试试?:(

二、实现DLL注入的另一种方法

1、将DLL注入进程技术在实现Api函数的监视程序中不可缺少的一项工作。其中最常见的就是用SetWindowsHookEx函数实现了。不过,该方法的缺点是被监视的目标进程必须有窗口,这样,SetWindowsHookEx才能将DLL注入目标进程中。而且,目标程序已经运行了,那么,在窗口创建之前的Api函数就不能被Hook了
2、另外一种方法用Debug方案,就可以实现在程序创建时监视所有的Api了,缺点是必须是目标进程的Debug源,在监视程序终了时,目标进程会无条件终了。最大的缺点就是无法调试注入的DLL
3、还有其他多种方案也可以实现DLL的注入,在《Windows核心编程》一书中就介绍了8-9种,其中有一种采用CreateProcess的方法,实现起来比较复杂,但没有上面几种方法的局限性。且可以用其他工具(VC等)调试注入的DLL。下面进行介绍。
原理如下:
1). 用CreateProcess(CREATE_SUSPENDED)启动目标进程。
2). 找到目标进程的入口,用ImageHlp中的函数可以实现。
3). 将目标进程入口的代码保存起来。
4). 在目标进程的入口写入LoadLibrary(MyDll)实现Dll的注入。
5). 用ResumeThread运行目标进程。
6). 目标进程就运行了LoadLibrary(MyDll),实现DLL的注入。
7). 目标进程运行完LoadLibrary(MyDll)后,将原来的代码写回目标进程的入口
8). 目标进程Jmp至原来的入口,继续运行程序。
从原理上可以看出,DLL的注入在目标进程的开始就运行了,而且不是用Debug的方案,这样,就没有上面方案的局限性了。该方案的关键在6,7,8三步,实现方法需要监视进程和DLL合作。下面,结合代码进行分析。
在监视进程中,创建FileMapping,用来保存目标进程的入口代码,同时保证DLL中可以访问。在第7步实现将原目标代码写回目标进程的入口。

[cpp]  view plain  copy
  1. // 监视程序和DLL共用的结构体  
  2. #pragma pack (push ,1)  // 保证下面的结构体采用BYTE对齐(必须)  
  3. typedef struct   
  4. {  
  5.     BYTE int_PUSHAD;    // pushad 0x60   
  6.     BYTE int_PUSH;      // push &szDLL 0x68  
  7.     DWORD push_Value;   // &szDLL = "ApiSpy.dll"的path  
  8.     BYTE int_MOVEAX;    // move eax &LoadLibrary 0xB8  
  9.     DWORD eax_Value;    // &LoadLibrary  
  10.     WORD call_eax;      // call eax 0xD0FF(FF D0) (LoadLibrary("ApiSpy.dll");  
  11.     BYTE jmp_MOVEAX;    // move eax &ReplaceOldCode 0xB8   
  12.     DWORD jmp_Value;    // JMP的参数  
  13.     WORD jmp_eax;       // jmp eax 0xE0FF(FF E0) jmp ReplaceOldCode;  
  14.     char szDLL[MAX_PATH]; // "ApiSpy.dll"的FullPath  
  15. }INJECT_LOADLIBRARY_CODE, *LPINJECT_CODE;  
  16. #pragma pack (pop , 1)  


上面结构体的代码为汇编代码,对应的汇编为:

[cpp]  view plain  copy
  1. pushad  
  2. push szDll  
  3. mov eax, &LoadLibraryA  
  4. call eax                                // 实现调用LoadLibrary(szDll)的代码  
  5. mov eax, oldentry  
  6. jmp eax                                 // 实现在LoadLibrary运行完后, 跳至目标进程的入口继续运行  
  7. // FileMaping的结构体  
  8. typedef struct   
  9. {  
  10.     LPBYTE lpEntryPoint;                // 目标进程的入口地址  
  11.     BYTE oldcode[sizeof(INJECT_CODE)];  // 目标进程的代码保存  
  12. }SPY_MEM_SHARE, * LPSPY_MEM_SHARE;  


准备工作:
第一步:用CreateProcess(CREATE_SUSPENDED)启动目标进程。

[cpp]  view plain  copy
  1. CreateProcessA(0, szRunFile, 0, 0, FALSE, CREATE_SUSPENDED  
  2. 0, NULL, &stInfo,  
  3. &m_proInfo) ;  

用CreateProcess启动一个暂停的目标进程;
找到目标进程的入口点,函数如下
第二步:找到目标进程的入口,用ImageHlp中的函数可以实现。

[cpp]  view plain  copy
  1. pEntryPoint = GetExeEntryPoint(szRunFile);  
  2. LPBYTE GetExeEntryPoint(char *filename)  
  3. {  
  4.     PIMAGE_NT_HEADERS pNTHeader;  
  5.     DWORD pEntryPoint;  
  6.     PLOADED_IMAGE pImage;  
  7.     pImage = ImageLoad(filename, NULL);  
  8.     if(pImage == NULL)  
  9.         return NULL;  
  10.     pNTHeader = pImage->FileHeader;  
  11.     pEntryPoint = pNTHeader->OptionalHeader.AddressOfEntryPoint + pNTHeader->OptionalHeader.ImageBase;  
  12.     ImageUnload(pImage);  
  13.     return (LPBYTE)pEntryPoint;  
  14. }  


// 创建FileMapping

[cpp]  view plain  copy
  1. hMap = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL,  
  2. PAGE_READWRITE, 0, sizeof(SPY_MEM_SHARE), “MyDllMapView”);  


// 保存目标进程的代码
第三步:将目标进程入口的代码保存起来。

[cpp]  view plain  copy
  1. LPSPY_MEM_SHARE lpMap = pMapViewOfFile(hMap, FILE_MAP_ALL_ACCESS,0, 0, 0);  
  2. ReadProcessMemory(m_proInfo.hProcess, pEntryPoint,&lpMap->oldcode, sizeof(INJECT_CODE),&cBytesMoved);  
  3. lpMap->lpEntryPoint = pEntryPoint;  

// 第四步:在目标进程的入口写入LoadLibrary(MyDll)实现Dll的注入。
// 准备注入DLL的代码

[cpp]  view plain  copy
  1. INJECT_CODE newCode;  
  2. // 写入MyDll―――用全路径  
  3. lstrcpy(newCode.szDLL, szMyDll);  
  4. // 准备硬代码(汇编代码)  
  5. newCode.int_PUSHAD = 0x60;   
  6. newCode.int_PUSH = 0x68;  
  7. newCode.int_MOVEAX = 0xB8;  
  8. newCode.call_eax = 0xD0FF;  
  9. newCode.jmp_MOVEAX = 0xB8;  
  10. newCode.jmp_eax = 0xE0FF;  
  11. newCode.eax_Value = (DWORD)&LoadLibrary;  
  12. newCode.push_Value=(pEntryPoint + offsetof(INJECT_CODE,szDLL));  
  13. // 将硬代码写入目标进程的入口  
  14. // 修改内存属性  
  15. DWORD dwNewFlg, dwOldFlg;  
  16. dwNewFlg = PAGE_READWRITE;  
  17. VirtualProtectEx(m_proInfo.hProcess, (LPVOID)pEntryPoint, sizeof(DWORD), dwNewFlg, &dwOldFlg);  
  18. WriteProcessMemory(m_proInfo.hProcess, pEntryPoint,&newCode, sizeof(newCode), NULL);//&dwWrited);  
  19. VirtualProtectEx(proInfo.hProcess, (LPVOID)pEntryPoint, sizeof(DWORD), dwOldFlg, &dwNewFlg);  
  20. // 释放FileMaping 注意,不是Closehandle(hMap)  
  21. UnmapViewOfFile(lpMap);  


// 继续目标进程的运行
第五步:用ResumeThread运行目标进程。

[cpp]  view plain  copy
  1. ResumeThread(m_proInfo.hThread);  

在监视进程中就结束了自己的任务,剩下的第6,7,8步就需要在Dll的DllMain中进行配合
DLL中用来保存数据的结构体

[cpp]  view plain  copy
  1. typedef struct  
  2. {  
  3.     DWORD lpEntryPoint;  
  4.     DWORD OldAddr;  
  5.     DWORD OldCode[4];     
  6. }JMP_CODE,* LPJMP_CODE;  
  7. static JMP_CODE _lpCode;  


// 在DllMain的DLL_PROCESS_ATTACH中调用InitApiSpy函数
// 在该函数中实现第6,7,8步
第六步:目标进程就运行了LoadLibrary(MyDll),实现DLL的注入。

[cpp]  view plain  copy
  1. int WINAPI DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved)  
  2. {  
  3. switch(dwReason)  
  4. {  
  5. case DLL_PROCESS_ATTACH:  
  6.     return InitApiSpy();  
  7.     ……  


// InitApiSpy函数的实现

[cpp]  view plain  copy
  1. BOOL WINAPI InitApiSpy()  
  2. {  
  3.     HANDLE hMap;  
  4.     LPSPY_MEM_SHARE lpMem;  
  5.     DWORD dwSize;  
  6.     BOOL rc;  
  7.     BYTE* lpByte;  
  8.     // 取得FileMapping的句柄  
  9.     hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, 0, “MyDllMapView”);  
  10.     if(hMap)  
  11.     {  
  12.         lpMem = (LPSPY_MEM_SHARE)MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS,0, 0, 0);  
  13.         if(lpMem)  
  14.         {  


第七步:目标进程运行完LoadLibrary(MyDll)后,将原来的代码写回目标进程的入口。

[cpp]  view plain  copy
  1. BOOL WINAPI InitApiSpy()  
  2. {  
  3.     HANDLE hMap;  
  4.     LPSPY_MEM_SHARE lpMem;  
  5.     DWORD dwSize;  
  6.     BOOL rc;  
  7.     BYTE* lpByte;  
  8.     // 取得FileMapping的句柄  
  9.     hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, 0, “MyDllMapView”);  
  10.     if(hMap)  
  11.     {  
  12.         lpMem = (LPSPY_MEM_SHARE)MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS,0, 0, 0);  
  13.         if(lpMem)  
  14.         {  
  15.   
  16.             // 恢复目标进程的入口代码  
  17.             // 得到mov eax, value代码的地址  
  18.             _lpCode.OldAddr = (DWORD)((BYTE*)lpMem->lpEntryPoint + offsetof(INJECT_CODE, jmp_MOVEAX));  
  19.             _lpCode.lpEntryPoint = (DWORD)lpMem->lpEntryPoint;  
  20.             // 保存LoadLibrary()后面的代码  
  21.             memcpy(&_lpCode.OldCode, (BYTE*)lpMem->oldcode + offsetof(INJECT_CODE, jmp_MOVEAX), 2*sizeof(DWORD));  
  22.             // 恢复目标进程的入口代码  
  23.             rc = WriteProcessMemory(GetCurrentProcess(), lpMem->lpEntryPoint, lpMem->oldcode, sizeof(INJECT_CODE), &dwSize);  
  24.             lpByte = (BYTE*)lpMem->lpEntryPoint + offsetof(INJECT_CODE, jmp_MOVEAX);  
  25.             UnmapViewOfFile(lpMem);  
  26.         }  
  27.         CloseHandle(hMap);  
  28.     }  
  29.     // 实现自己Dll的其他功能,如导入表的替换  
  30.     // ……  
  31.     // 将LoadLibrary后面的代码写为转入处理程序中  
  32.     // 指令为:mov eax, objAddress  
  33.     // jmp eax  
  34.     {  
  35.         BYTE* lpMovEax;  
  36.         DWORD* lpMovEaxValu;  
  37.         WORD* lpJmp;  
  38.         DWORD fNew, fOld;  
  39.         fNew = PAGE_READWRITE;  
  40.         lpMovEax = lpByte;  
  41.         VirtualProtect(lpMovEax, 2*sizeof(DWORD), fNew, &fOld);  
  42.         *lpMovEax = 0xB8;  
  43.         lpMovEaxValu = (DWORD*)(lpMovEax + 1);  
  44.         *lpMovEaxValu = (DWORD)&DoJmpEntryPoint;  
  45.         lpJmp = (WORD*)(lpMovEax + 5);  
  46.         *lpJmp = 0xE0FF; // (FF E0)  
  47.         VirtualProtect(lpMovEax, 2*sizeof(DWORD), fOld, &fNew);  
  48.     }  
  49.     return TRUE;  
  50. }  


 

[cpp]  view plain  copy
  1. // 转入处理程序  
  2. DWORD* lpMovEax;  
  3. DWORD fNew, fOld;  
  4. void __declspec(naked) DoJmpEntryPoint ()  
  5. {  
  6.     // 恢复LoadLibrary后面的代码  
  7.     _gfNew = PAGE_READWRITE;  
  8.     _glpMovEax = (DWORD*)_lpCode.OldAddr;  
  9.     VirtualProtect(_glpMovEax, 2*sizeof(DWORD), _gfNew, &_gfOld);  
  10.     *_glpMovEax = _lpCode.OldCode[0];  
  11.     *(_glpMovEax + 1) = _lpCode.OldCode[1];  
  12.     VirtualProtect(_glpMovEax, 2*sizeof(DWORD), _gfOld, &_gfNew);  
  13. //第八步:目标进程Jmp至原来的入口,继续运行程序。  
  14. // 跳至目标代码的入口  
  15. _asm popad  
  16. _asm jmp _lpCode.lpEntryPoint  
  17. }  


 

第八步:目标进程Jmp至原来的入口,继续运行程序。

[cpp]  view plain  copy
  1. // 跳至目标代码的入口  
  2. _asm popad  
  3. _asm jmp _lpCode.lpEntryPoint  
  4. }  


这样就实现了原来的目标,将DLL的注入放在目标进程的入口运行,实现了目标进程运行之前运行我们的注入Dll的功能。

你可能感兴趣的:(VC++)