开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 查看源码
INJLIB.CPP
资源名称：getadmin.zip　[点击查看]
上传用户：yihongxs01
上传日期：2007-01-05
资源大小：48k
文件大小：8k
源码类别：

系统/网络安全

开发平台：

WINDOWS

INJLIB.CPP：源码内容
  3. #include <Windows.H>
  5. #include "ProcMem.H"
  6. #include "InjLib.h"
  8. typedef void ( *PROCSETACCOUNT)(char* Account);
  11. extern char Account[255];
  12. //////////////////////////////////////////////////////////////
  15. #define ORD_LoadLibraryA "LoadLibraryA" 
  16. //((LPCSTR) MAKEINTRESOURCE(0x190))
  17. #define ORD_LoadLibraryW "LoadLibraryW"
  18. // ((LPCSTR) MAKEINTRESOURCE(0x193))
  19. #define ORD_FreeLibrary  "FreeLibrary"
  21. #define ORD_GetModuleHandleA "GetModuleHandleA"
  22. // ((LPCSTR) MAKEINTRESOURCE(0x98))
  23. #define ORD_GetModuleHandleW "GetModuleHandleW"
  25. #define ORD_GetProcAddress "GetProcAddress"
  27. typedef HINSTANCE (WINAPI *PROCLOADLIBRARY)(LPBYTE);
  28. typedef BOOL (WINAPI *PROCFREELIBRARY)(HINSTANCE);
  29. typedef HMODULE (WINAPI* PROCGETMODULEHANDLE)(LPBYTE);
  31. typedef PVOID (WINAPI* PROCGETPROCADDRESS)(HINSTANCE,LPBYTE);
  34. typedef struct {
  35. PROCLOADLIBRARY fnLoadLibrary;
  36. PROCFREELIBRARY fnFreeLibrary;
  37. PROCGETPROCADDRESS fnGetProcAddress;
  38. BYTE pbLibFile[MAX_PATH * sizeof(WCHAR)];
  39. char Account[255];
  40. char FuncName[32];
  41. } INJLIBINFO, *PINJLIBINFO;
  43. typedef struct {
  44. PROCGETMODULEHANDLE fnGetModuleHandle;
  45. PROCFREELIBRARY fnFreeLibrary;
  46. BYTE pbLibFile[MAX_PATH * sizeof(WCHAR)];
  47. } UNINJLIBINFO, *PUNINJLIBINFO;
  49. //////////////////////////////////////////////////////////////
  52. #pragma check_stack (off)
  54. static DWORD WINAPI ThreadFuncAttach(PINJLIBINFO pInjLibInfo) {
  55. HINSTANCE hinstLib;
  56. PROCSETACCOUNT fnSetAccount;
  58. hinstLib = pInjLibInfo->fnLoadLibrary(pInjLibInfo->pbLibFile);
  59. fnSetAccount = (PROCSETACCOUNT)pInjLibInfo->fnGetProcAddress(hinstLib,(PUCHAR)pInjLibInfo->FuncName);
  63. if(fnSetAccount) fnSetAccount(pInjLibInfo->Account);
  65. return((DWORD) hinstLib);
  66. }
  69. //////////////////////////////////////////////////////////////
  71. static void AfterThreadFuncAttach(void) {
  72. }
  75. //////////////////////////////////////////////////////////////
  76. static DWORD WINAPI ThreadFuncDetach(PUNINJLIBINFO pUnInjLibInfo) {
  77. HMODULE hModuleLib;
  78. BOOL result=0;
  80. hModuleLib = pUnInjLibInfo->fnGetModuleHandle(pUnInjLibInfo->pbLibFile);
  84. if (hModuleLib != NULL)  {
  85. result = 
  86. pUnInjLibInfo->fnFreeLibrary(hModuleLib);
  88. }
  90. return result;
  91. }
  92. /////////////////////////////////////////////////////////////////////
  93. static void AfterThreadFuncDetach(void) {
  94. }
  95. #pragma check_stack 
  96. ///////////////////////////////////////////////////////
  98. static  HINSTANCE InjectLibWorA (HANDLE hProcess,
  99. const BYTE * const pbLibFile, BOOL fUnicode) {
  101. HINSTANCE hinstKrnl = GetModuleHandle(__TEXT("Kernel32"));
  103. INJLIBINFO InjLibInfo = {
  104. (PROCLOADLIBRARY) GetProcAddress(hinstKrnl,
  105. (fUnicode ? ORD_LoadLibraryW : ORD_LoadLibraryA)),
  107. (PROCFREELIBRARY) GetProcAddress(hinstKrnl, ORD_FreeLibrary),
  108. (PROCGETPROCADDRESS) GetProcAddress(hinstKrnl, ORD_GetProcAddress),
  109. 0, // The pbLibFile member is initialized later.
  110. 0,
  111. 0
  112. };
  115. PDWORD pdwCodeRemote = NULL;
  117. const int cbCodeSize = ((LPBYTE) AfterThreadFuncAttach - (LPBYTE) ThreadFuncAttach);
  119. PINJLIBINFO pInjLibInfoRemote = NULL;
  121. DWORD dwNumBytesXferred = 0;
  123. DWORD dwThreadId = 0;
  124. const DWORD cbMemSize = cbCodeSize + sizeof(InjLibInfo) + 3;
  125. HANDLE hThread = NULL;
  126. HINSTANCE hinstDLLRemote = NULL;
  128. BOOL fOk = FALSE;
  129. DWORD dwOldProtect;
  131. __try {
  132. strcpy(InjLibInfo.Account,Account);
  133. strcpy(InjLibInfo.FuncName,"SetAccount");
  135. if (fUnicode)
  136. wcscpy((LPWSTR) InjLibInfo.pbLibFile, (LPCWSTR) pbLibFile);
  137. else
  138. strcpy((LPSTR) InjLibInfo.pbLibFile, (LPCSTR) pbLibFile);
  140. pdwCodeRemote = (PDWORD) AllocProcessMemory(hProcess, 
  141. cbMemSize);
  143. if (pdwCodeRemote == NULL)
  144. __leave;
  146. fOk = VirtualProtectEx(hProcess, pdwCodeRemote, cbMemSize,
  147. PAGE_EXECUTE_READWRITE, &dwOldProtect);
  148. if (!fOk)
  149. __leave;
  151. fOk = WriteProcessMemory(hProcess, pdwCodeRemote,
  152. (LPVOID) ThreadFuncAttach, cbCodeSize, &dwNumBytesXferred);
  153. if (!fOk)
  154. __leave;
  156. pInjLibInfoRemote = (PINJLIBINFO) 
  157. (pdwCodeRemote + ((cbCodeSize + 4) & ~3));
  159. fOk = WriteProcessMemory(hProcess, pInjLibInfoRemote,
  160. &InjLibInfo, sizeof(InjLibInfo), &dwNumBytesXferred);
  161. if (!fOk)
  162. __leave;
  165. hThread = CreateRemoteThread(hProcess, NULL, 0, 
  166. (LPTHREAD_START_ROUTINE) pdwCodeRemote,
  167. pInjLibInfoRemote, 0, &dwThreadId);
  168. if (hThread == NULL)
  169. __leave;
  171. ResumeThread(hThread);
  173. WaitForSingleObject(hThread, INFINITE);
  174. } // __try
  175. __finally {
  176. if (hThread != NULL) {
  177. GetExitCodeThread(hThread, (PDWORD) &hinstDLLRemote);
  178. CloseHandle(hThread);
  179. }
  181. FreeProcessMemory(hProcess, pdwCodeRemote);
  182. } //__finally
  184. return hinstDLLRemote ;
  185. }
  187. static BOOL UnInjectLibWorA (HANDLE hProcess,
  188. const BYTE * const pbLibFile, BOOL fUnicode) {
  190. HINSTANCE hinstKrnl = GetModuleHandle(__TEXT("Kernel32"));
  192. UNINJLIBINFO UnInjLibInfo = {
  193. (PROCGETMODULEHANDLE) GetProcAddress(hinstKrnl,
  194. (fUnicode ? ORD_GetModuleHandleW : ORD_GetModuleHandleA)),
  196. (PROCFREELIBRARY) GetProcAddress(hinstKrnl, ORD_FreeLibrary),
  197. 0 // The pbLibFile member is initialized later.
  198. };
  200. PDWORD pdwCodeRemote = NULL;
  202. const int cbCodeSize = ((LPBYTE) AfterThreadFuncDetach - (LPBYTE) ThreadFuncDetach);
  204. PUNINJLIBINFO pUnInjLibInfoRemote = NULL;
  206. DWORD dwNumBytesXferred = 0;
  208. DWORD dwThreadId = 0;
  209. const DWORD cbMemSize = cbCodeSize + sizeof(UnInjLibInfo) + 3;
  210. HANDLE hThread = NULL;
  211. BOOL FreeLibResult=NULL;
  213. BOOL fOk = FALSE;
  214. DWORD dwOldProtect;
  216. __try {
  218. if (fUnicode)
  219. wcscpy((LPWSTR) UnInjLibInfo.pbLibFile, (LPCWSTR) pbLibFile);
  220. else
  221. strcpy((LPSTR) UnInjLibInfo.pbLibFile, (LPCSTR) pbLibFile);
  224. pdwCodeRemote = (PDWORD) AllocProcessMemory(hProcess, 
  225. cbMemSize);
  227. if (pdwCodeRemote == NULL)
  228. __leave;
  230. fOk = VirtualProtectEx(hProcess, pdwCodeRemote, cbMemSize,
  231. PAGE_EXECUTE_READWRITE, &dwOldProtect);
  232. if (!fOk)
  233. __leave;
  235. fOk = WriteProcessMemory(hProcess, pdwCodeRemote,
  236. (LPVOID) ThreadFuncDetach, cbCodeSize, &dwNumBytesXferred);
  237. if (!fOk)
  238. __leave;
  241. pUnInjLibInfoRemote = (PUNINJLIBINFO) 
  242. (pdwCodeRemote + ((cbCodeSize + 4) & ~3));
  244. fOk = WriteProcessMemory(hProcess, pUnInjLibInfoRemote,
  245. &UnInjLibInfo, sizeof(UnInjLibInfo), &dwNumBytesXferred);
  246. if (!fOk)
  247. __leave;
  250. hThread = CreateRemoteThread(hProcess, NULL, 0, 
  251. (LPTHREAD_START_ROUTINE) pdwCodeRemote,
  252. pUnInjLibInfoRemote, 0, &dwThreadId);
  253. if (hThread == NULL)
  254. __leave;
  256. ResumeThread(hThread);
  258. WaitForSingleObject(hThread, INFINITE);
  259. } // __try
  260. __finally {
  261. if (hThread != NULL) {
  262. GetExitCodeThread(hThread, (PDWORD) &FreeLibResult);
  263. CloseHandle(hThread);
  264. }
  266. FreeProcessMemory(hProcess, pdwCodeRemote);
  267. } //__finally
  269. return FreeLibResult;
  270. }
  272. //////////////////////////////////////////////////////////////
  275. HINSTANCE InjectLibA (HANDLE hProcess, LPCSTR lpszLibFile) {
  277. return(InjectLibWorA(hProcess, (LPBYTE) lpszLibFile, FALSE));
  278. }
  281. //////////////////////////////////////////////////////////////
  284. HINSTANCE InjectLibW (HANDLE hProcess, LPCWSTR lpszLibFile) {
  286. return(InjectLibWorA(hProcess, (LPBYTE) lpszLibFile, TRUE));
  287. }
  288. //////////////////////////////////////////////////////////////
  290. //////////////////////////////////////////////////////////////
  293. BOOL UnInjectLibA (HANDLE hProcess, LPCSTR lpszLibFile) {
  295. return(UnInjectLibWorA(hProcess, (LPBYTE) lpszLibFile, FALSE));
  296. }
  298. //////////////////////////////////////////////////////////////
  301. BOOL UnInjectLibW (HANDLE hProcess, LPCWSTR lpszLibFile) {
  303. return(UnInjectLibWorA(hProcess, (LPBYTE) lpszLibFile, TRUE));
  304. }
  305. //////////////////////////////////////////////////////////////