dll注入
所谓DLL 注入就是将一个DLL放进某个进程的地址空间里，让它成为那个进程的一部分。要实现DLL注入，首先需要打开目标进程。
中文名 dll注入 外文名 hRemoteProcess 意 义 将一个DLL放进进程的地址空间里 方 法 打开目标进程
例：
hRemoteProcess = OpenProcess( PROCESS_CREATE_THREAD | //允许远程创建线程
PROCESS_VM_OPERATION | //允许远程VM操[2] 作
PROCESS_VM_WRITE, //允许远程VM写
FALSE, dwRemoteProcessId )
由于我们后面需要写入远程进程的内存地址空间并建立远程线程，所以需要申请足够的权限（PROCESS_CREATE_THREAD、VM_OPERATION、VM_WRITE）。
如果进程打不开，以后的操作就别想了。进程打开后，就可以建立远线程了，不过别急，先想想这个远线程的线程函数是什么？我们的目的是注入一个DLL。而且我们知道用LoadLibrary可以加载一个DLL到本进程的地址空间。于是，自然会想到如果可以在目标进程中调用LoadLibrary，不就可以把DLL加载到目标进程的地址空间了吗？对！就是这样。远线程就在这儿用了一次，建立的远线程的线程函数就是LoadLibrary，而参数就是要注入的DLL的文件名。(这里需要自己想一想，注意到了吗，线程函数ThreadProc和LoadLibrary函数非常相似，返回值，参数个数都一样) 还有一个问题，LoadLibrary这个函数的地址在哪儿？也许你会说，这个简单，GetProcAddress就可以得出。于是代码就出来了。
char *pszLibFileRemote="my.dll";
PTHREAD_START_ROUTINE pfnStartAddr = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("Kernel32"), "LoadLibraryA");
CreateRemoteThread( hRemoteProcess, NULL, 0, pfnStartAddr, pszLibFileRemote, 0, NULL);
但是不对！不要忘了，这是远线程，不是在你的进程里，而pszLibFileRemote指向的是你的进程里的数据，到了目标进程，这个指针都不知道指向哪儿去了，同样pfnStartAddr这个地址上的代码到了目标进程里也不知道是什么了，不知道是不是你想要的LoadLibraryA了。但是，问题总是可以解决的，Windows有些很强大的API函数，他们可以在目标进程里分配内存，可以将你的进程中的数据拷贝到目标进程中。因此pszLibFileRemote的问题可以解决了。
char *pszLibFileName="my.dll";//注意，这个一定要是全路径文件名，除非它在系统目录里；原因大家自己想想。
//计算DLL路径名需要的内存空间
int cb = (1 + lstrlenA(pszLibFileName)) * sizeof(char);
//使用VirtualAllocEx函数在远程进程的内存地址空间分配DLL文件名缓冲区
pszLibFileRemote = (char *) VirtualAllocEx( hRemoteProcess, NULL, cb, MEM_COMMIT, PAGE_READWRITE);
//使用WriteProcessMemory函数将DLL的路径名复制到远程进程的内存空间
iReturnCode = WriteProcessMemory(hRemoteProcess, pszLibFileRemote, (PVOID) pszLibFileName, cb, NULL);
OK，现在目标进程也认识pszLibFileRemote了，但是pfnStartAddr好像不好办，我怎么可能知道LoadLibraryA在目标进程中的地址呢？其实Windows为我们解决了这个问题，LoadLibraryA这个函数是在Kernel32.dll这个核心DLL里的，而这个DLL很特殊，不管对于哪个进程，Windows总是把它加载到相同的地址上去。因此你的进程中LoadLibraryA的地址和目标进程中LoadLibraryA的地址是相同的(其实，这个DLL里的所有函数都是如此)。至此，DLL注入结束了。
========
Dll注入经典方法完整版
http://pnig0s1992.blog.51cto.com/393390/804484/
Pnig0s1992:算是复习了，最经典的教科书式的Dll注入。
总结一下基本的注入过程，分注入和卸载
注入Dll：
1，OpenProcess获得要注入进程的句柄
2，VirtualAllocEx在远程进程中开辟出一段内存，长度为strlen(dllname)+1;
3，WriteProcessMemory将Dll的名字写入第二步开辟出的内存中。
4，CreateRemoteThread将LoadLibraryA作为线程函数，参数为Dll的名称，创建新线程
5，CloseHandle关闭线程句柄
卸载Dll：
1，CreateRemoteThread将GetModuleHandle注入到远程进程中，参数为被注入的Dll名
2，GetExitCodeThread将线程退出的退出码作为Dll模块的句柄值。
3，CloseHandle关闭线程句柄
3，CreateRemoteThread将FreeLibraryA注入到远程进程中，参数为第二步获得的句柄值。
4，WaitForSingleObject等待对象句柄返回
5，CloseHandle关闭线程及进程句柄。
#include <stdio.h>
#include <Windows.h>
#include <TlHelp32.h>
DWORD getProcessHandle(LPCTSTR lpProcessName)//根据进程名查找进程PID
{
DWORD dwRet = 0;
HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
if(hSnapShot == INVALID_HANDLE_VALUE)
{
printf("\n获得进程快照失败%d",GetLastError());
return dwRet;
}
PROCESSENTRY32 pe32;//声明进程入口对象
pe32.dwSize = sizeof(PROCESSENTRY32);//填充进程入口对象大小
Process32First(hSnapShot,&pe32);//遍历进程列表
do
{
if(!lstrcmp(pe32.szExeFile,lpProcessName))//查找指定进程名的PID
{
dwRet = pe32.th32ProcessID;
break;
}
} while (Process32Next(hSnapShot,&pe32));
CloseHandle(hSnapShot);
return dwRet;//返回
}
INT main(INT argc,CHAR * argv[])
{
DWORD dwPid = getProcessHandle((LPCTSTR)argv[1]);
LPCSTR lpDllName = "EvilDll.dll";
HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_WRITE,FALSE,dwPid);
if(hProcess == NULL)
{
printf("\n获取进程句柄错误%d",GetLastError());
return -1;
}
DWORD dwSize = strlen(lpDllName)+1;
DWORD dwHasWrite;
LPVOID lpRemoteBuf = VirtualAllocEx(hProcess,NULL,dwSize,MEM_COMMIT,PAGE_READWRITE);
if(WriteProcessMemory(hProcess,lpRemoteBuf,lpDllName,dwSize,&dwHasWrite))
{
if(dwHasWrite != dwSize)
{
VirtualFreeEx(hProcess,lpRemoteBuf,dwSize,MEM_COMMIT);
CloseHandle(hProcess);
return -1;
}
}else
{
printf("\n写入远程进程内存空间出错%d。",GetLastError());
CloseHandle(hProcess);
return -1;
}
DWORD dwNewThreadId;
LPVOID lpLoadDll = LoadLibraryA;
HANDLE hNewRemoteThread = CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_ROUTINE)lpLoadDll,lpRemoteBuf,0,&dwNewThreadId);
if(hNewRemoteThread == NULL)
{
printf("\n建立远程线程失败%d",GetLastError());
CloseHandle(hProcess);
return -1;
}
WaitForSingleObject(hNewRemoteThread,INFINITE);
CloseHandle(hNewRemoteThread);
//准备卸载之前注入的Dll
DWORD dwHandle,dwID;
LPVOID pFunc = GetModuleHandleA;//获得在远程线程中被注入的Dll的句柄
HANDLE hThread = CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_ROUTINE)pFunc,lpRemoteBuf,0,&dwID);
WaitForSingleObject(hThread,INFINITE);
GetExitCodeThread(hThread,&dwHandle);//线程的结束码即为Dll模块儿的句柄
CloseHandle(hThread);
pFunc = FreeLibrary;
hThread = CreateRemoteThread(hThread,NULL,0,(LPTHREAD_START_ROUTINE)pFunc,(LPVOID)dwHandle,0,&dwID); //将FreeLibraryA注入到远程线程中去卸载Dll
WaitForSingleObject(hThread,INFINITE);
CloseHandle(hThread);
CloseHandle(hProcess);
return 0;
}DLL注入技术
http://blog.csdn.net/chenyujing1234/article/details/7860629
转载自： http://hi.baidu.com/xwind85/blog/item/ae5332ad04bb7f034a36d662.html
一、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步实现将原目标代码写回目标进程的入口。
// 监视程序和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)
上面结构体的代码为汇编代码，对应的汇编为：
[cpp] view plain copy
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）启动目标进程。
[cpp] view plain copy
CreateProcessA(0, szRunFile, 0, 0, FALSE, CREATE_SUSPENDED
0, NULL, &stInfo,
&m_proInfo) ;
用CreateProcess启动一个暂停的目标进程；
找到目标进程的入口点，函数如下
第二步：找到目标进程的入口，用ImageHlp中的函数可以实现。
[cpp] view plain copy
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
[cpp] view plain copy
hMap = CreateFileMapping((HANDLE)0xFFFFFFFF, NULL,
PAGE_READWRITE, 0, sizeof(SPY_MEM_SHARE), “MyDllMapView”);
// 保存目标进程的代码
第三步：将目标进程入口的代码保存起来。
[cpp] view plain copy
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的代码
[cpp] view plain copy
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运行目标进程。
[cpp] view plain copy
ResumeThread(m_proInfo.hThread);
在监视进程中就结束了自己的任务，剩下的第6，7，8步就需要在Dll的DllMain中进行配合。
DLL中用来保存数据的结构体
[cpp] view plain copy
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的注入。
[cpp] view plain copy
int WINAPI DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved)
{
switch(dwReason)
{
case DLL_PROCESS_ATTACH:
return InitApiSpy();
……
// InitApiSpy函数的实现
[cpp] view plain copy
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)后，将原来的代码写回目标进程的入口。
[cpp] view plain copy
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)
{
// 恢复目标进程的入口代码
// 得到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;
}
[cpp] view plain copy
// 转入处理程序
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
}
第八步：目标进程Jmp至原来的入口，继续运行程序。
[cpp] view plain copy
// 跳至目标代码的入口
_asm popad
_asm jmp _lpCode.lpEntryPoint
}
这样就实现了原来的目标，将DLL的注入放在目标进程的入口运行，实现了目标进程运行之前运行我们的注入Dll的功能。
========