DLL注入技术

DLL注入技术的用途是很广泛的，这主要体现在，1假如你要操纵的对象涉及的数据不在进程内.2你想对目标进程中的函数进行拦截(甚至API函数，嘿嘿，由此编写个拦截timeGettime的过程，变速齿轮不就出来了么？改天我试试)，比如对它所属窗口进行子类化。3你想编写一些函数用于增强或增加目标进程功能，比如可以给目标进程的某个窗口插入个消息循环增加其响应能力。（Mfc Windows程序设计称之为消息泵）。4隐藏自己的程序，很多恶意程序都是这样做的，即使你将恶意程序的进程结束掉也毫无意义了，因为它自己已经插入到很多进程中去了，唯一有效的办法只有注销windows.。4如果你是个爱搞破坏的人就更应该掌握该技术了，不但可以利用该技术实现隐藏自己的进程，还可以破坏某个目标进程。因为将破坏代码插入到目标进程进行破坏的话简直易如反掌。不信试试？:(
*******************
实现DLL注入的另一种方法[@more@]

将DLL注入进程技术在实现Api函数的监视程序中不可缺少的一项工作。其中最常见的就是用SetWindowsHookEx函数实现了。不过，该方法的缺点是被监视的目标进程必须有窗口，这样，SetWindowsHookEx才能将DLL注入目标进程中。而且，目标程序已经运行了，那么，在窗口创建之前的Api函数就不能被Hook了。

另外一种方法用Debug方案，就可以实现在程序创建时监视所有的Api了，缺点是必须是目标进程的Debug源，在监视程序终了时，目标进程会无条件终了。最大的缺点就是无法调试注入的DLL。

还有其他多种方案也可以实现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步实现将原目标代码写回目标进程的入口。

／／ 监视程序和DLL共用的结构体

#pragma pack (push ,1) ／／ 保证下面的结构体采用BYTE对齐（必须）

typedef struct

{

BYTE int_PUSHAD; // pushad 0x60

BYTE int_PUSH; // push &szDLL 0x68

DWORD push_Value; // &szDLL = "ApiSpy.dll"的path

BYTE int_MOVEAX; // move eax &LoadLibrary 0xB8

DWORD eax_Value; // &LoadLibrary

WORD call_eax; // call eax 0xD0FF(FF D0) (LoadLibrary("ApiSpy.dll");

BYTE jmp_MOVEAX; // move eax &ReplaceOldCode 0xB8

DWORD jmp_Value; // JMP的参数

WORD jmp_eax; // jmp eax 0xE0FF(FF E0) jmp ReplaceOldCode;

char szDLL[MAX_PATH]; // "ApiSpy.dll"的FullPath

}INJECT_LOADLIBRARY_CODE, *LPINJECT_CODE;

#pragma pack (pop , 1)

上面结构体的代码为汇编代码，对应的汇编为：

pushad

push szDll

mov eax, &LoadLibraryA

call eax // 实现调用LoadLibrary(szDll)的代码

mov eax, oldentry

jmp eax // 实现在LoadLibrary运行完后, 跳至目标进程的入口继续运行

// FileMaping的结构体

typedef struct

{

LPBYTE lpEntryPoint; // 目标进程的入口地址

BYTE oldcode[sizeof(INJECT_CODE)]; // 目标进程的代码保存

}SPY_MEM_SHARE, * LPSPY_MEM_SHARE;

准备工作：

第一步：用CreateProcess（CREATE_SUSPENDED）启动目标进程。

CreateProcessA(0, szRunFile, 0, 0, FALSE, CREATE_SUSPENDED

0, NULL, &stInfo,

&m_proInfo) ;

// 用CreateProcess启动一个暂停的目标进程

// 找到目标进程的入口点，函数如下

第二步：找到目标进程的入口，用ImageHlp中的函数可以实现。

pEntryPoint = GetExeEntryPoint(szRunFile);

LPBYTE GetExeEntryPoint(char *filename)

{

PIMAGE_NT_HEADERS pNTHeader;

DWORD pEntryPoint;

PLOADED_IMAGE pImage;

pImage = ImageLoad(filename, NULL);

if(pImage == NULL)

return NULL;

pNTHeader = pImage->FileHeader;

pEntryPoint = pNTHeader->OptionalHeader.AddressOfEntryPoint + pNTHeader->OptionalHeader.ImageBase;

ImageUnload(pImage);

return (LPBYTE)pEntryPoint;

}

// 创建FileMapping

hMap = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL,

PAGE_READWRITE, 0, sizeof(SPY_MEM_SHARE), “MyDllMapView”);

// 保存目标进程的代码

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

LPSPY_MEM_SHARE lpMap = pMapViewOfFile(hMap,

FILE_MAP_ALL_ACCESS,

0, 0, 0);

ReadProcessMemory(m_proInfo.hProcess, pEntryPoint,

&lpMap->oldcode, sizeof(INJECT_CODE),

&cBytesMoved);

lpMap->lpEntryPoint = pEntryPoint;

// 第四步：在目标进程的入口写入LoadLibrary（MyDll）实现Dll的注入。

// 准备注入DLL的代码

INJECT_CODE newCode;

// 写入MyDll―――用全路径

lstrcpy(newCode.szDLL, szMyDll);

// 准备硬代码（汇编代码）

newCode.int_PUSHAD = 0x60;

newCode.int_PUSH = 0x68;

newCode.int_MOVEAX = 0xB8;

newCode.call_eax = 0xD0FF;

newCode.jmp_MOVEAX = 0xB8;

newCode.jmp_eax = 0xE0FF;

newCode.eax_Value = (DWORD)＆LoadLibrary;

newCode.push_Value=(pEntryPoint + offsetof(INJECT_CODE,szDLL));

// 将硬代码写入目标进程的入口

// 修改内存属性

DWORD dwNewFlg, dwOldFlg;

dwNewFlg = PAGE_READWRITE;

VirtualProtectEx(m_proInfo.hProcess, (LPVOID)pEntryPoint, sizeof(DWORD), dwNewFlg, &dwOldFlg);

WriteProcessMemory(m_proInfo.hProcess, pEntryPoint,

&newCode, sizeof(newCode), NULL);//&dwWrited);

VirtualProtectEx(proInfo.hProcess, (LPVOID)pEntryPoint, sizeof(DWORD), dwOldFlg, &dwNewFlg);

// 释放FileMaping 注意，不是Closehandle(hMap)

UnmapViewOfFile(lpMap);

// 继续目标进程的运行

第五步：用ResumeThread运行目标进程。

ResumeThread(m_proInfo.hThread);

在监视进程中就结束了自己的任务，剩下的第6，7，8步就需要在Dll的DllMain中进行配合。

DLL中用来保存数据的结构体

typedef struct
{
DWORD lpEntryPoint;
DWORD OldAddr;
DWORD OldCode[4];
}JMP_CODE,* LPJMP_CODE;

static JMP_CODE _lpCode;

// 在DllMain的DLL_PROCESS_ATTACH中调用InitApiSpy函数

// 在该函数中实现第6，7，8步

第六步：目标进程就运行了LoadLibrary（MyDll），实现DLL的注入。

int WINAPI DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved)

{

switch(dwReason)

{

case DLL_PROCESS_ATTACH:

return InitApiSpy();

……

// InitApiSpy函数的实现

BOOL WINAPI InitApiSpy()

{

HANDLE hMap;

LPSPY_MEM_SHARE lpMem;

DWORD dwSize;

BOOL rc;

BYTE* lpByte;

// 取得FileMapping的句柄

hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, 0, “MyDllMapView”);

if(hMap)

{

lpMem = (LPSPY_MEM_SHARE)MapViewOfFile(hMap,

FILE_MAP_ALL_ACCESS,

0, 0, 0);

if(lpMem)

{

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

// 恢复目标进程的入口代码

// 得到mov eax, value代码的地址

_lpCode.OldAddr = (DWORD)((BYTE*)lpMem->lpEntryPoint + offsetof(INJECT_CODE, jmp_MOVEAX));

_lpCode.lpEntryPoint = (DWORD)lpMem->lpEntryPoint;

// 保存LoadLibrary()后面的代码

memcpy(&_lpCode.OldCode, (BYTE*)lpMem->oldcode + offsetof(INJECT_CODE, jmp_MOVEAX), 2*sizeof(DWORD));

// 恢复目标进程的入口代码

rc = WriteProcessMemory(GetCurrentProcess(), lpMem->lpEntryPoint, lpMem->oldcode, sizeof(INJECT_CODE), &dwSize);

lpByte = (BYTE*)lpMem->lpEntryPoint + offsetof(INJECT_CODE, jmp_MOVEAX);

UnmapViewOfFile(lpMem);

}

CloseHandle(hMap);

}

// 实现自己Dll的其他功能，如导入表的替换

// ……

// 将LoadLibrary后面的代码写为转入处理程序中

// 指令为：mov eax, objAddress

// jmp eax

{

BYTE* lpMovEax;

DWORD* lpMovEaxValu;

WORD* lpJmp;

DWORD fNew, fOld;

fNew = PAGE_READWRITE;

lpMovEax = lpByte;

VirtualProtect(lpMovEax, 2*sizeof(DWORD), fNew, &fOld);

*lpMovEax = 0xB8;

lpMovEaxValu = (DWORD*)(lpMovEax + 1);

*lpMovEaxValu = (DWORD)&DoJmpEntryPoint;

lpJmp = (WORD*)(lpMovEax + 5);

*lpJmp = 0xE0FF; // (FF E0)

VirtualProtect(lpMovEax, 2*sizeof(DWORD), fOld, &fNew);

}

return TRUE;

}

// 转入处理程序

DWORD* lpMovEax;

DWORD fNew, fOld;

void __declspec(naked) DoJmpEntryPoint ()

{

// 恢复LoadLibrary后面的代码

_gfNew = PAGE_READWRITE;

_glpMovEax = (DWORD*)_lpCode.OldAddr;

VirtualProtect(_glpMovEax, 2*sizeof(DWORD), _gfNew, &_gfOld);

*_glpMovEax = _lpCode.OldCode[0];

*(_glpMovEax + 1) = _lpCode.OldCode[1];

VirtualProtect(_glpMovEax, 2*sizeof(DWORD), _gfOld, &_gfNew);

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

// 跳至目标代码的入口

_asm popad

_asm jmp _lpCode.lpEntryPoint

}

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

下面用图形表示在目标进程中代码发生变化的情况。(示意图)

监视程序 FileMapping 目标进程

第一步 启动目标进程 无 无

第二步 找到入口 无 启动(暂停中)

第三步 保存代码 目标进程的代码 无变化

第四步 写入注入代码 同上 入口代码为：LoadLibrary(MyDll); jmp xxxxxxxx 其他原来的代码

第五步 运行目标进程 同上 运行LoadLibrary

第六步 无变化 无变化 LoadLibrary中处理

第七步 无变化 无变化 入口代码被写为原来的代码

第7.5步 无变化 无变化 上面jmp xxxxxxxx的代码写为jmp DoJmpEntryPoint

第7.9步 无变化 无变化 运行完LoadLibrary后，转入DoJmpEntryPoint函数中处理,在该函数中，将jmp DoJmpEntryPoint的指令恢复为原指令。

第八步 无变化 无变化 转入目标进程的入口执行，完成注入目标。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/777154/viewspace-963863/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/777154/viewspace-963863/