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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
HookAPI.cpp
资源名称：HookAPI　[点击查看]
上传用户：nbcables
上传日期：2007-01-11
资源大小：1243k
文件大小：14k
源码类别：

钩子与API截获

开发平台：

Visual C++

HookAPI.cpp：源码内容
  1. // ------------------------------------- //
  2. // 您如果要使用本文件，请不要删除本说明  //
  3. // ------------------------------------- //
  4. //             HOOKAPI v1.6              //
  5. //   Copyright 2002 编程沙龙 Paladin     //
  6. //       www.ProgramSalon.com            //
  7. // ------------------------------------- //
  8. // 
  9. //  HookAPI.cpp
  10. //  通过取得函数地址，并在函数代码前插入call myfunc来实现调用myfunc的程序
  11. //  Last Modified: 2003.05.07, by Paladin
  12. //
  14. #include <windows.h>
  15. #include <time.h>
  16. #include <stdio.h>
  17. #include "ApiInfo.h"
  18. #include "HookApi.h"
  19. #include "util.h"
  21. #ifdef WINNT
  22. #include "injlib.h"
  23. #endif
  25. #ifdef WIN95
  26. #include "ring0.h"
  27. #endif
  29. #pragma check_stack(off)
  31. #ifdef WIN95
  33. #pragma code_seg("_INIT")
  34. #pragma comment(linker,"/SECTION:.bss,RWS /SECTION:.data,RWS /SECTION:.rdata,RWS /SECTION:.text,RWS /SECTION:_INIT,RWS ")
  35. #pragma comment(linker,"/BASE:0xBFF70000")
  37. #endif
  40. #define CALL_BYTES_SIZE 5 // CALL 0xnnnnnnnn size=5
  42. CAPIInfo g_api_info;
  44. char g_szDllPath[128];
  46. static int g_demo_count =0;
  47. #ifdef WINNT
  48. extern BOOL ObtainSeDebugPrivilege();
  49. #endif
  52. ////////////////////////
  53. CHookAPI::CHookAPI()
  54. {
  55. g_szDllPath[0] =0;
  57. //WriteLog("debug: hooked");
  58. m_hMyDll =NULL;
  59. HMODULE hMod =GetModuleHandle(HOOKAPI_DLL_NAME);
  60. if(hMod)
  61. {
  62. char fname[128];
  63. GetModuleFileName(hMod, fname, sizeof(fname));
  64. GetFilePath(fname, g_szDllPath);
  65. WriteProfileString("HookAPI", "DLL_PATH", g_szDllPath);
  66. }
  67. else GetProfileString("HookAPI", "DLL_PATH", "", g_szDllPath, sizeof(g_szDllPath));
  69. LoadMyDll();
  71. char mod_name[256], mod_name2[100];
  72. GetModuleFileName(NULL, mod_name, sizeof(mod_name));
  73. GetProfileString("HookAPI", "exe_name", "", mod_name2, sizeof(mod_name2));
  74. strupr(mod_name);
  75. strupr(mod_name2);
  77. #ifdef WINNT
  78. if(mod_name2[0] ==0 || strstr(mod_name, mod_name2) ==NULL)
  79. #endif
  80. {
  81. Init();
  82. HookAllAPI();
  83. }
  84. }
  86. CHookAPI::~CHookAPI()
  87. {
  88. UnhookAllAPI();
  89. FreeMyDll();
  90. }
  92. int CHookAPI::LoadMyDll()
  93. {
  94. if(GetModuleHandle(MY_DLL_NAME)) return 0;
  96. char fdll[128];
  97. wsprintf(fdll, "%s\%s", g_szDllPath, MY_DLL_NAME);
  98. if((m_hMyDll =LoadLibrary(fdll)) ==NULL)
  99. {
  100. WriteLog("LoadMyDll %s failed!", fdll);
  101. return -1;
  102. }
  104. return 0;
  105. }
  107. void CHookAPI::FreeMyDll()
  108. {
  109. if(m_hMyDll) FreeLibrary(m_hMyDll);
  111. m_hMyDll =NULL;
  112. }
  114. // Init hooked api info
  115. int CHookAPI::Init()
  116. {
  117. char cur_mod[200];
  118. MYAPIINFO *pMyAPIInfo;
  119. tagGetMyAPIInfo GetMyAPIInfo;
  120. APIFUNC old_api, my_api;
  121. HMODULE hmod;
  122. HINSTANCE hMyDll;
  124. // 得到要截获的api信息
  125. if(m_hMyDll ==NULL)
  126. {
  127. hMyDll =GetModuleHandle(MY_DLL_NAME);
  128. if(hMyDll ==NULL)
  129. {
  130. WriteLog("Init()::m_hMyDll ==NULL");
  131. return false;
  132. }
  133. }
  134. else
  135. hMyDll =m_hMyDll;
  137. if((GetMyAPIInfo=(tagGetMyAPIInfo)GetProcAddress(hMyDll, "GetMyAPIInfo")) ==NULL)
  138. {
  139. WriteLog("GetProcAddress GetMyAPIInfo of %s failed!", MY_DLL_NAME);
  140. return false;
  141. }
  142. pMyAPIInfo =GetMyAPIInfo();
  143. if(pMyAPIInfo ==NULL)
  144. {
  145. WriteLog("Init()::GetMyAPIInfo failed!");
  146. return false;
  147. }
  149. int count =0;
  150. //int f_hook_process =false;
  152. // 分析并保存函数和参数
  153. GetModuleFileName(NULL, cur_mod, sizeof(cur_mod));
  154. APIINFO *pinfo;
  156. //WriteLog("debug: get api info...");
  157. while (pMyAPIInfo[count].module_name !=NULL)
  158. {
  159. if((hmod =GetModuleHandle(pMyAPIInfo[count].module_name)) ==NULL)
  160. {
  161. WriteLog("Error Get module %s, so not hook this module's api", pMyAPIInfo[count].module_name);
  162. count++;
  163. continue;
  164. }
  165. if((old_api =(APIFUNC)GetProcAddress(hmod, pMyAPIInfo[count].api_name)) ==NULL)
  166. {
  167. WriteLog("Error Get ProcAddress %s of module %s, so not hook this module's api", pMyAPIInfo[count].api_name, pMyAPIInfo[count].module_name);
  168. count++;
  169. continue;
  170. }
  171. //WriteLog("debug: GetProcAddress %s %s =%x", pMyAPIInfo[count].module_name, pMyAPIInfo[count].api_name, old_api);
  173. if((my_api =(APIFUNC)GetProcAddress(hMyDll, pMyAPIInfo[count].my_api_name)) ==NULL)
  174. {
  175. WriteLog("failed to GetrProcAddress:%s", pMyAPIInfo[count].my_api_name);
  176. return false;
  177. }
  179. //WriteLog("debug: add api info:%s", pMyAPIInfo[count].api_name);
  180. if((pinfo =g_api_info.Add(pMyAPIInfo[count].module_name, pMyAPIInfo[count].api_name,
  181. pMyAPIInfo[count].my_api_name, pMyAPIInfo[count].param_count,
  182. old_api, my_api, pMyAPIInfo[count].friend_my_api_name,
  183. pMyAPIInfo[count].start_pos)) ==NULL)
  184. break;
  186. count++;
  187. }
  189. #ifdef WINNT
  190. if((hmod =GetModuleHandle("Kernel32.dll")) ==NULL)
  191. {
  192. WriteLog("Error Get module Kernel32.dll, can not hook CreateprocessA");
  193. return -1;
  194. }
  195. if((old_api =(APIFUNC)GetProcAddress(hmod, "CreateProcessA")) ==NULL)
  196. {
  197. WriteLog("Error Get ProcAddress CreateProcessA of module Kernel32.dll");
  198. return -1;
  199. }
  200. if((pinfo =g_api_info.Add("Kernel32.dll", "CreateProcessA", "myCreateprocessA2003", 10, old_api,
  201. (APIFUNC)myCreateProcessA2003)) ==NULL)
  202. {
  203. WriteLog("Error add APIINFO of CreateProcessA");
  204. return -1;
  205. }
  207. if((old_api =(APIFUNC)GetProcAddress(hmod, "CreateProcessW")) ==NULL)
  208. {
  209. WriteLog("Error Get ProcAddress CreateProcessW of module Kernel32.dll");
  210. return -1;
  211. }
  212. if((pinfo =g_api_info.Add("Kernel32.dll", "CreateProcessW", "myCreateprocessW2003", 10, old_api,
  213. (APIFUNC)myCreateProcessW2003)) ==NULL)
  214. {
  215. WriteLog("Error add APIINFO of CreateProcessW");
  216. return -1;
  217. }
  218. #endif
  220. //WriteLog("debug: Init ok!");
  222. return 0;
  223. }
  225. // hook one api
  226. int CHookAPI::HookOneAPI(APIINFO *pinfo)
  227. {
  228. //WriteLog("debug: Hook one api:%s, start_pos:%d", pinfo->api_name, pinfo->start_pos);
  230. if(pinfo->f_hooked)
  231. return 0;
  233. BYTE *papi =(BYTE *)pinfo->old_api + pinfo->start_pos;  // insert call xxxxxxxx from start_pos. lgd 2003.03.01
  235. //将函数所指内容改为可写
  236. if(!RemoveProtection(pinfo))
  237. {
  238. WriteLog("RemoveProtection failed! %s", pinfo->api_name);
  239. return -1;
  240. }
  242. // 保存源函数前5个字节，因为后面将覆盖此处
  243. memcpy(pinfo->save_bytes, papi, 5/*sizeof(pinfo->save_bytes)*/);
  245. //在源函数前插入call ProcessCall命令
  246. papi[0] =0xE8;
  247. *(DWORD *)&papi[1] =(DWORD)ProcessCall -(DWORD)papi -CALL_BYTES_SIZE;
  249. pinfo->f_hooked =true;
  251. WriteLog("debug: Hook one api ok:hmod=%x, %s-%x(%x,%x,%x,%x), start_pos:%d", 
  252. GetModuleHandle(pinfo->module_name), pinfo->api_name,
  253. papi, papi[0], papi[1], pinfo->save_bytes[0], pinfo->save_bytes[1], pinfo->start_pos);
  255. return 0;
  256. }
  258. int CHookAPI::UnhookOneAPI(APIINFO *pinfo)
  259. {
  260. if(!pinfo->f_hooked) return 0;
  262. // ligang, 2003.04.19
  263. // check if already unhooked in the first hook for same old api like that CreateProcessW are hooked in HookAPINT.dll and mydll.dll
  264. // or: unhook only once for api that hooked more than once.
  265. APIINFO *pinfo2 =g_api_info.m_pInfo;
  266. int f_already_unhooked =0;
  267. while(pinfo2)
  268. {
  269. if(pinfo2 ==pinfo)
  270. break;
  271. if(pinfo2->old_api ==pinfo->old_api)  // already unhooked
  272. {
  273. f_already_unhooked =true;
  274. break;
  275. }
  276. pinfo2 =pinfo2->pnext;
  277. }
  279. if(f_already_unhooked)  // only unhook first hook, because the next hook's save_bytes is not origion bytes of old api
  280. {
  281. pinfo->f_hooked =false;
  282. return 0;
  283. }
  285. BYTE *papi =(BYTE *)pinfo->old_api +pinfo->start_pos;
  287. //char *p =(char *)papi;
  288. //WriteLog("debug: unHook one api:%s(%x, %x,%x), start_pos:%d", pinfo->api_name, papi, papi[0], papi[1], pinfo->start_pos);
  290. if(RemoveProtection(pinfo))
  291. memcpy((PBYTE)papi, pinfo->save_bytes, CALL_BYTES_SIZE);  // 恢复原5个字节
  292. else WriteLog("UnhookAPIFunction %s RemoveProtection failed!", pinfo->save_bytes);
  294. #ifdef WIN95
  295. SetPageProtection(papi);
  296. #else
  297. DWORD dwScratch;
  298. VirtualProtect(papi, 20, pinfo->old_protection_flags, &dwScratch);
  299. #endif
  300. pinfo->f_hooked =false;
  302. return 0;
  303. }
  305. int CHookAPI::HookAllAPI()
  306. {
  307. APIINFO *pinfo =g_api_info.m_pInfo;
  309. while (pinfo !=NULL)
  310. {
  311. HookOneAPI(pinfo);
  312. pinfo =pinfo->pnext;
  313. }
  315. return 0;
  316. }
  318. void CHookAPI::UnhookAllAPI()
  319. {
  320. APIINFO *pinfo =g_api_info.m_pInfo;
  321. //ObtainSeDebugPrivilege();
  323. while (pinfo !=NULL)
  324. {
  325. UnhookOneAPI(pinfo);
  326. pinfo =pinfo->pnext;
  327. }
  328. }
  330. // 主要函数ProcessCall，所有api函数的替换函数
  331. void CHookAPI::ProcessCall()
  332. {
  333. PBYTE pbAfterCall;
  334. PDWORD pdwParam;
  335. PDWORD pdwESP;
  336. DWORD dwParamSize;
  337. void *pvReturnAddr;
  338. DWORD dwReturnValue;
  339. BYTE cl_val;
  340. BYTE *papi;
  341. DWORD errcode =0;
  343. #ifdef WINNT
  344. PROCESS_INFORMATION *pi;
  345. char fname[128];
  346. #endif
  348. _asm
  349. {
  350. Mov [cl_val], CL   // 备份CL for xxTextOutx in WIN9X
  351. Mov EAX, [EBP + 4] //前面是被替换的call xxxxxxxx命令
  352. Mov [pbAfterCall], EAX
  354. Mov EAX, [EBP + 8]
  355. Mov [pvReturnAddr], EAX // 保存上次调用位置
  357. Lea EAX, [EBP + 12]
  358. Mov [pdwParam], EAX    //取参数
  359. }
  360. APIINFO *pinfo;
  362. #ifdef DEMO_VERSION
  363. if(++g_demo_count > 200)
  364. MsgBox("This is demo version, max hook count: 20 exceed...");
  365. #endif
  367. if((pinfo =g_api_info.FindByOldAPI((APIFUNC)(pbAfterCall-CALL_BYTES_SIZE))) ==NULL)
  368. {
  369. WriteLog("ProcessCall: can not found api");
  370. goto call_ret;
  371. }
  372. g_api_info.lock(pinfo);
  374. papi =(BYTE *)pinfo->old_api+pinfo->start_pos;
  376. dwParamSize =pinfo->param_count * 4;  // 32位地址使用4个字节
  378. errcode =0;
  380. if(!RemoveProtection(pinfo))   // add 2004.03.30 for some time other program changed api's write permission
  381. {
  382. WriteLog("RemoveProtection failed! %s", pinfo->api_name);
  383. goto call_ret;
  384. }
  386. memcpy(papi, pinfo->save_bytes, CALL_BYTES_SIZE);   //还原原api函数前5字节(恢复api原函数调用)
  388. if(pinfo->my_friend_api_name[0]) // 如果此api和其他api函数共用部分代码如98中的TextOutA和TextOutW，则先恢复用到的函数的被修改的内容
  389. {
  390. WriteLog("Restore my_friend_api_name:%s", pinfo->my_friend_api_name);
  391. RestoreAPICodes(pinfo->my_friend_api_name);
  392. }
  394. // 压参数入堆栈
  395. _asm
  396. {
  397. Sub ESP, [dwParamSize]
  398. Mov [pdwESP], ESP
  399. }
  401. memcpy(pdwESP, pdwParam, dwParamSize);
  403. _asm
  404. {
  405. Mov CL, [cl_val]
  406. }
  408. // 调用mydll里的替换函数
  409. pinfo->my_api();
  411. _asm
  412. {
  413. Push EAX
  414. Mov [dwReturnValue], EAX  //构造返回值
  415. }
  417. errcode =GetLastError();
  418. //#endif
  419. //MsgBox(pAPIInfo->szAPIName);
  420. #ifdef WINNT
  421. if(!strcmp(pinfo->api_name, "CreateProcessW") || !strcmp(pinfo->api_name, "CreateProcessA") )
  422. {
  423. pi =(PROCESS_INFORMATION *)pdwParam[9];
  424. if(pi->hProcess)
  425. {
  426. //if(g_process_to_hook.Find(process_name))
  427. wsprintf(fname, "%s\HookAPINT.dll", g_szDllPath);
  428. //WaitForSingleObject(pi->hProcess, 0);
  429. //SuspendThread(pi->hThread);
  430. #ifdef WINNT
  431. ObtainSeDebugPrivilege();
  432. #endif
  433. InjectLib(pi->hProcess, fname);  // hook 新进程
  434. //ResumeThread(pi->hThread);
  435. }
  436. else WriteLog("hProcess ==NULL");
  437. }
  438. #endif
  440. if(pinfo->my_friend_api_name[0]) // 再恢复上面修改的内容
  441. {
  442. WriteLog("Restore my_friend_api_name...");
  443. RestoreAPICodes(pinfo->my_friend_api_name);
  444. }
  446. // 恢复 Call xxxx
  447. papi[0] =0xE8;
  448. *(DWORD *)&papi[1] =(DWORD)ProcessCall - (DWORD)papi - CALL_BYTES_SIZE;
  450. g_api_info.unlock(pinfo);
  453. call_ret:
  454. // 恢复错误码
  455. SetLastError(errcode);
  457. // 构造虚函数返回
  459. _asm
  460. {
  461. Pop EAX
  463. Mov ECX, [dwParamSize]
  464. Mov EDX, [pvReturnAddr]
  465. Pop EDI
  466. Pop ESI
  467. Pop EBX
  468. Mov ESP, EBP
  469. Pop EBP
  470. Add ESP, 8
  471. Add ESP, ECX  //堆栈指针加参数大小，因为ProcessCall没有参数，所以要如此
  472. Push EDX
  473. Ret
  474. }
  475. }
  477. int CHookAPI::RestoreAPICodes(char *my_api_name)
  478. {
  479. APIINFO *pinfo =g_api_info.FindByMyAPIName(my_api_name);
  480. if(pinfo ==NULL || pinfo->f_hooked ==false) return 0;
  482. g_api_info.lock(pinfo);
  483. memcpy((PBYTE)pinfo->old_api+pinfo->start_pos, pinfo->save_bytes, CALL_BYTES_SIZE/*(5>bytes)?bytes:5*/);
  484. g_api_info.unlock(pinfo);
  486. return 0;
  487. }
  489. int CHookAPI::ChangeAPICodes(char *my_api_name)
  490. {
  491. APIINFO *pinfo =g_api_info.FindByMyAPIName(my_api_name);
  492. if(pinfo==NULL) return 0;
  494. BYTE *papi =(BYTE *)pinfo->old_api+pinfo->start_pos;
  496. papi[0] =0xE8;
  497. *(DWORD *)&papi[1] =(DWORD)ProcessCall -(DWORD)papi -CALL_BYTES_SIZE;
  499. return 0;
  500. }
  502. // 使某块有写保护的内存地址（代码段内地址）为可写
  503. BOOL CHookAPI::RemoveProtection(APIINFO *pinfo)
  504. {
  505. BYTE *papi =(BYTE *)pinfo->old_api+pinfo->start_pos;
  506. BOOL ret;
  508. #ifdef WIN95
  510. ret =RemovePageProtection(papi);
  512. #endif
  514. #ifdef WINNT
  516. MEMORY_BASIC_INFORMATION mbi;
  517. DWORD dwProtectionFlags;
  518. DWORD dwScratch;
  520. VirtualQuery(papi, &mbi, sizeof(mbi));
  522. dwProtectionFlags =mbi.Protect;
  523. pinfo->old_protection_flags =dwProtectionFlags;
  525. dwProtectionFlags =PAGE_READWRITE;
  527. ret =VirtualProtect(papi, 20, dwProtectionFlags, &dwScratch);
  529. #endif
  531. if(ret ==FALSE)
  532. {
  533. char err[256];
  534. GetErrString(err, sizeof(err), GetLastError());
  535. WriteLog("Error VirtualProtect:%s", err);
  536. //WriteLog("VirtualProtect:%x,%x,%x", pvAddress, dwProtectionFlags, dwScratch);
  537. return false;
  538. }
  540. return ret;
  541. }
  543. #ifdef WINNT
  545. // to hook new process
  546. DWORD WINAPI CHookAPI::myCreateProcessW2003(
  547. LPCWSTR lpApplicationName,
  548. LPWSTR lpCommandLine, 
  549. LPSECURITY_ATTRIBUTES lpProcessAttributes,
  550. LPSECURITY_ATTRIBUTES lpThreadAttributes,
  551. BOOL bInheritHandles,
  552. DWORD dwCreationFlags,
  553. LPVOID lpEnvironment,
  554. LPCWSTR lpCurrentDirectory,
  555. LPSTARTUPINFOW lpStartupInfo,
  556. LPPROCESS_INFORMATION lpProcessInformation
  557. )
  558. {
  559. //WriteLog("HookAPI:CreateProcessW");
  560. DWORD aaa= CreateProcessW(lpApplicationName,
  561. lpCommandLine, lpProcessAttributes,
  562. lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
  563. lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
  564. char fname[400];
  565. int len =WideCharToMultiByte( CP_ACP, 0, lpCommandLine, -1, fname, sizeof(fname),NULL,NULL);
  566. fname[len] =0;
  567. WriteLog("HookAPI:CreateProcessW:%s", fname);
  568. return aaa;
  570. }
  572. DWORD WINAPI CHookAPI::myCreateProcessA2003(
  573. LPCSTR lpApplicationName,
  574. LPSTR lpCommandLine, 
  575. LPSECURITY_ATTRIBUTES lpProcessAttributes,
  576. LPSECURITY_ATTRIBUTES lpThreadAttributes,
  577. BOOL bInheritHandles,
  578. DWORD dwCreationFlags,
  579. LPVOID lpEnvironment,
  580. LPCSTR lpCurrentDirectory,
  581. LPSTARTUPINFO lpStartupInfo,
  582. LPPROCESS_INFORMATION lpProcessInformation
  583. )
  584. {
  585. DWORD aaa= CreateProcessA(lpApplicationName,
  586. lpCommandLine, lpProcessAttributes,
  587. lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
  588. lpCurrentDirectory, lpStartupInfo, lpProcessInformation);
  589. WriteLog("HookAPI:CreateProcessA:%s", lpCommandLine);
  590. return aaa;
  591. }
  592. #endif