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

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

钩子与API截获

开发平台：

Visual C++

Injector.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. //
  3. // Injector.cpp
  4. //
  5. // SUBSYSTEM: 
  6. // API hooking system
  7. // MODULE:    
  8. //              Implements injection mechanism
  9. //
  10. // DESCRIPTION:
  11. //              
  12. //
  13. // AUTHOR: Ivo Ivanov (ivopi@hotmail.com)
  14. // DATE: 2001 November 13,  version 1.0 
  15. //                                                                         
  16. // FIXES:
  17. //              - 2002 November 20
  18. //                Added a mechanism for handling reference count of the HookTool.dll 
  19. //                instances. This allows us to fix a problem caused by the asynchronous 
  20. //                behavior of ::UnhookWindowsHookEx() API                
  21. //
  22. //---------------------------------------------------------------------------
  24. #include "Injector.h"
  25. #include "..CommonModuleInstance.h"
  26. #include "..CommonSysUtils.h"
  27. #include "..CommonIniFile.h"
  28. #include "NtInjectorThread.h"
  30. //---------------------------------------------------------------------------
  31. //
  32. // Thread function prototype
  33. //
  34. //---------------------------------------------------------------------------
  35. typedef unsigned (__stdcall *PTHREAD_START)(void *);
  37. //---------------------------------------------------------------------------
  38. //
  39. // External declarations
  40. //
  41. //---------------------------------------------------------------------------
  43. extern LRESULT CALLBACK GetMsgProc(
  44. int code,       // hook code
  45. WPARAM wParam,  // removal option
  46. LPARAM lParam   // message
  47. );
  50. //---------------------------------------------------------------------------
  51. //
  52. // class CInjector  
  53. //
  54. //---------------------------------------------------------------------------
  56. CInjector::CInjector(BOOL bServerInstance):
  57. m_bServerInstance(bServerInstance),
  58. m_bHookAllEnabledInitialized(FALSE),
  59. m_bHookAllEnabled(FALSE)
  60. {
  62. }
  64. CInjector::~CInjector()
  65. {
  67. }
  69. //
  70. // examines whether a process should be hooked up by the DLL
  71. //
  72. BOOL CInjector::IsProcessForHooking(PSTR pszExaminedProcessName)
  73. {
  74. BOOL  bHoolAll = GetHookAllEnabled();
  75. BOOL  bProcessProtected = FALSE;
  76. char  szProcessName[MAX_PATH];
  77. DWORD dwStartPos = 0;
  78. long  nCommaPos;
  79. if (bHoolAll)
  80. {
  81. while ( (dwStartPos < strlen(m_szProcessesForHooking)) &&
  82.         GetNextCommaSeparatedString(
  83. &m_szProcessesForHooking[dwStartPos],
  84. szProcessName,
  85. sizeof(szProcessName),
  86. &nCommaPos
  87. ) 
  88.       )
  89. {
  90. strcat(szProcessName, ".exe");
  91. if (0 == stricmp(szProcessName, pszExaminedProcessName))
  92. {
  93. bProcessProtected = TRUE;
  94. return FALSE;
  95. } // if
  96. dwStartPos += nCommaPos + 1;
  97. } // while
  98. } // if
  99. if (!bHoolAll)
  100. {
  101. dwStartPos = 0;
  102. while ( (dwStartPos < strlen(m_szProcessesForHooking)) &&
  103.         GetNextCommaSeparatedString(
  104. &m_szProcessesForHooking[dwStartPos],
  105. szProcessName,
  106. sizeof(szProcessName),
  107. &nCommaPos
  108. ) 
  109.       )
  110. {
  111. strcat(szProcessName, ".exe");
  112. if (0 == stricmp(szProcessName, pszExaminedProcessName))
  113. return TRUE;
  114. dwStartPos += nCommaPos + 1;
  115. } // while
  116. return FALSE;
  117. } // if
  119. return TRUE;
  120. }
  122. //
  123. // Return the name of the INI file
  124. //
  125. void CInjector::GetIniFile(char* pszIniFile)
  126. {
  127. char  *pdest;
  128. ::GetModuleFileName(
  129. ModuleFromAddress(GetMsgProc), 
  130. pszIniFile, 
  131. MAX_PATH
  132. );
  133. pdest = &pszIniFile[strlen(pszIniFile) - 4];
  134. strcpy(pdest, ".ini");
  135. }
  138. //
  139. // Get the value of [Scope] / HookAll from the INI file
  140. //
  141. BOOL CInjector::GetHookAllEnabled()
  142. {
  143. if (!m_bHookAllEnabledInitialized)
  144. {
  145. char szIniFile[MAX_PATH];
  146. GetIniFile(szIniFile);
  147. CIniFile iniFile(szIniFile);
  148. m_bHookAllEnabled = iniFile.ReadBool(
  149. "Scope",
  150. "HookAll",
  151. TRUE
  152. );
  153. m_bHookAllEnabledInitialized = TRUE;
  154. strcpy(m_szProcessesForHooking, "");
  155. strcpy(m_szProtectedProcesses, "");
  156. //
  157. // Should we process the two lists with processes for hooking
  158. // and ones that shouldn't be hooked up at all
  159. //
  160. if (!m_bHookAllEnabled)
  161. iniFile.ReadString(
  162. "Scope",
  163. "Hook",
  164. "",
  165. m_szProcessesForHooking
  166. );
  167. else
  168. iniFile.ReadString(
  169. "Scope",
  170. "Protect",
  171. "",
  172. m_szProtectedProcesses
  173. );
  174. } // if
  176. return m_bHookAllEnabled;
  177. }
  180. //---------------------------------------------------------------------------
  181. //
  182. // class CWinHookInjector  
  183. //
  184. //---------------------------------------------------------------------------
  186. HHOOK* CWinHookInjector::sm_pHook = NULL;
  188. CWinHookInjector::CWinHookInjector(BOOL bServerInstance, HHOOK* pHook):
  189. CInjector(bServerInstance)
  190. {
  191. sm_pHook = pHook;
  192. }
  195. //
  196. // Inject the DLL into all running processes
  197. //
  198. BOOL CWinHookInjector::InjectModuleIntoAllProcesses()
  199. {
  200. *sm_pHook = ::SetWindowsHookEx(
  201. WH_GETMESSAGE,
  202. (HOOKPROC)(GetMsgProc),
  203. ModuleFromAddress(GetMsgProc), 
  204. 0
  205. );
  207. return (NULL != *sm_pHook);
  208. }
  210. //
  211. // Eject the DLL from all processes if it has been injected before 
  212. //
  213. BOOL CWinHookInjector::EjectModuleFromAllProcesses(HANDLE hWaitOn)
  214. {
  215. BOOL bResult;
  216. if (NULL != *sm_pHook)
  217. {
  218. bResult = ::UnhookWindowsHookEx(*sm_pHook);
  219. // Wait on the reference counter event handle 
  220. // until all the instances of the DLL get unloaded
  221. ::WaitForSingleObject(hWaitOn, INFINITE);
  222. }
  223. else 
  224. bResult = TRUE;
  225. return bResult;
  226. }
  229. //---------------------------------------------------------------------------
  230. //
  231. // class CRemThreadInjector  
  232. //
  233. //---------------------------------------------------------------------------
  235. CCSWrapper  CRemThreadInjector::sm_CritSecInjector;
  238. //
  239. //
  240. //
  241. CRemThreadInjector::CRemThreadInjector(BOOL bServerInstance):
  242. CInjector(bServerInstance),
  243. m_pNtInjectorThread(NULL)
  244. {
  245. if (bServerInstance)
  246. m_pNtInjectorThread = new CNtInjectorThread(this);
  247. }
  249. //
  250. //
  251. //
  252. CRemThreadInjector::~CRemThreadInjector()
  253. {
  254. if (m_bServerInstance)
  255. {
  256. m_pNtInjectorThread->SetActive(FALSE);
  257. delete m_pNtInjectorThread;
  258. } // if
  259. }
  261. //
  262. // Attempts to enable SeDebugPrivilege. This is required by use of
  263. // CreateRemoteThread() under NT/2K
  264. //
  265. BOOL CRemThreadInjector::EnableDebugPrivilege()
  266. {
  267. HANDLE           hToken;
  268. LUID             sedebugnameValue;
  269. TOKEN_PRIVILEGES tp;
  271. if ( !::OpenProcessToken( 
  272. GetCurrentProcess(),
  273. TOKEN_ADJUST_PRIVILEGES | // to adjust privileges
  274. TOKEN_QUERY,              // to get old privileges setting
  275. &hToken 
  276. ) )
  277. //
  278. // OpenProcessToken() failed
  279. //
  280. return FALSE;
  281. //
  282. // Given a privilege's name SeDebugPrivilege, we should locate its local LUID mapping.
  283. //
  284. if ( !::LookupPrivilegeValue( NULL, SE_DEBUG_NAME, &sedebugnameValue ) )
  285. {
  286. //
  287. // LookupPrivilegeValue() failed
  288. //
  289. ::CloseHandle( hToken );
  290. return FALSE;
  291. }
  293. tp.PrivilegeCount = 1;
  294. tp.Privileges[0].Luid = sedebugnameValue;
  295. tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  297. if ( !::AdjustTokenPrivileges( hToken, FALSE, &tp, sizeof(tp), NULL, NULL ) )
  298. {
  299. //
  300. // AdjustTokenPrivileges() failed
  301. //
  302. ::CloseHandle( hToken );
  303. return FALSE;
  304. }
  306. ::CloseHandle( hToken );
  307. return TRUE;
  308. }
  312. //
  313. // Inject the DLL into all running processes
  314. //
  315. BOOL CRemThreadInjector::InjectModuleIntoAllProcesses()
  316. {
  317. BOOL                bResult = FALSE;
  319. if (m_bServerInstance)
  320. {
  321. CTaskManager        taskManager;
  322. CExeModuleInstance* pProcess; 
  324. taskManager.Populate(FALSE);
  325. EnableDebugPrivilege();
  326. for (long i = 0; i < taskManager.GetProcessCount(); i++)
  327. {
  328. pProcess = taskManager.GetProcessByIndex(i);
  329. bResult = InjectModuleInto( pProcess->Get_ProcessId() ) || bResult; 
  330. } // for
  332. m_pNtInjectorThread->SetActive(TRUE);
  333. } // if
  335. return bResult;
  336. }
  338. //
  339. // Eject the DLL from all processes if it has been injected before 
  340. //
  341. BOOL CRemThreadInjector::EjectModuleFromAllProcesses(HANDLE hWaitOn)
  342. {
  343. BOOL                bResult = FALSE;
  345. if (m_bServerInstance)
  346. {
  347. CTaskManager        taskManager;
  348. CExeModuleInstance* pProcess; 
  350. m_pNtInjectorThread->SetActive(FALSE);
  351. taskManager.Populate(FALSE);
  353. for (long i = 0; i < taskManager.GetProcessCount(); i++)
  354. {
  355. pProcess = taskManager.GetProcessByIndex(i);
  356. bResult = EjectModuleFrom( pProcess->Get_ProcessId() ) || bResult; 
  357. } // for
  358. } // if
  360. return bResult;
  361. }
  363. //
  364. // Inject the DLL into address space of a specific external process
  365. //
  366. BOOL CRemThreadInjector::InjectModuleInto(DWORD dwProcessId)
  367. {
  368. CLockMgr<CCSWrapper> lockMgr(sm_CritSecInjector, TRUE);
  369. BOOL                 bResult  = FALSE; 
  370. //
  371. // We shouldn't inject the dll into the address space of the
  372. // server
  373. //
  374. if (dwProcessId != ::GetCurrentProcessId())
  375. {
  376. CTaskManager         taskManager;
  377. taskManager.PopulateProcess(dwProcessId, TRUE);
  378. CExeModuleInstance  *pProcess = taskManager.GetProcessById(dwProcessId);
  379. if (TRUE == IsProcessForHooking(pProcess->GetBaseName()))
  380. bResult = DoInjectModuleInto(pProcess);
  381. } // if
  383. return bResult;
  384. }
  386. //
  387. // Eject the DLL from the address space of an external process
  388. //
  389. BOOL CRemThreadInjector::EjectModuleFrom(DWORD dwProcessId)
  390. {
  391. CLockMgr<CCSWrapper> lockMgr(sm_CritSecInjector, TRUE);
  392. BOOL   bResult  = FALSE;
  393. //
  394. // We shouldn't eject the dll into the address space of the
  395. // server
  396. //
  397. if (dwProcessId != ::GetCurrentProcessId())
  398. {
  399. CTaskManager         taskManager;
  400. taskManager.PopulateProcess(dwProcessId, TRUE);
  401. CExeModuleInstance  *pProcess = taskManager.GetProcessById(dwProcessId);
  402. if (pProcess)
  403. bResult  = DoEjectModuleFrom(*pProcess);
  404. } // if
  405. return bResult;
  406. }
  408. //
  409. // Execute injection mechanism for NT/2K systems
  410. //
  411. BOOL CRemThreadInjector::DoInjectModuleInto(CExeModuleInstance *pProcess)
  412. {
  413. BOOL   bResult          = FALSE; 
  414. HANDLE hProcess         = NULL;
  415. HANDLE hThread          = NULL;
  416. PSTR   pszLibFileRemote = NULL;
  417. __try 
  418. {
  419. if (TRUE == IsWindows9x())
  420. __leave;
  421. if (NULL == pProcess)
  422. __leave;
  424. char szLibFile[MAX_PATH];
  425. ::GetModuleFileNameA(
  426. ModuleFromAddress(GetMsgProc), 
  427. szLibFile, 
  428. MAX_PATH
  429. );
  431. BOOL bFound = FALSE;
  432. CModuleInstance* pModuleInstance;
  433. for (long i = 0; i < pProcess->GetModuleCount(); i++)
  434. {
  435. pModuleInstance = pProcess->GetModuleByIndex(i);
  436. if ( 0 == stricmp(pModuleInstance->Get_Name(), szLibFile) )
  437. {
  438. bFound = TRUE;
  439. break;
  440. } // if
  441. } // for
  442. if (bFound) 
  443. __leave;
  445. // Get a handle for the process we want to inject into
  446. hProcess = ::OpenProcess(
  447. PROCESS_ALL_ACCESS, // Specifies all possible access flags
  448. FALSE, 
  449. pProcess->Get_ProcessId()
  450. );
  451. if (hProcess == NULL) 
  452. __leave;
  454. // Calculate the number of bytes needed for the DLL's pathname
  455. int cch = 1 + strlen(szLibFile);
  457. // Allocate space in the remote process for the pathname
  458. pszLibFileRemote = (PSTR)::VirtualAllocEx(
  459. hProcess, 
  460. NULL, 
  461. cch, 
  462. MEM_COMMIT, 
  463. PAGE_READWRITE
  464. );
  465. if (pszLibFileRemote == NULL) 
  466. __leave;
  467. // Copy the DLL's pathname to the remote process's address space
  468. if (!::WriteProcessMemory(
  469. hProcess, 
  470. (PVOID)pszLibFileRemote, 
  471. (PVOID)szLibFile, 
  472. cch, 
  473. NULL)) 
  474. __leave;
  475. // Get the real address of LoadLibraryW in Kernel32.dll
  476. PTHREAD_START_ROUTINE pfnThreadRtn = (PTHREAD_START_ROUTINE)
  477. ::GetProcAddress(::GetModuleHandle("Kernel32"), "LoadLibraryA");
  478. if (pfnThreadRtn == NULL) 
  479. __leave;
  480. // Create a remote thread that calls LoadLibraryW(DLLPathname)
  481. hThread = ::CreateRemoteThread(
  482. hProcess, 
  483. NULL, 
  484. 0, 
  485. pfnThreadRtn, 
  486. (PVOID)pszLibFileRemote, 
  487. 0, 
  488. NULL
  489. );
  490. if (hThread == NULL) 
  491. __leave;
  492. // Wait for the remote thread to terminate
  493. ::WaitForSingleObject(hThread, INFINITE);
  495. bResult = TRUE; 
  496. }
  497. __finally 
  498. { 
  499. // Free the remote memory that contained the DLL's pathname
  500. if (pszLibFileRemote != NULL) 
  501. ::VirtualFreeEx(hProcess, (PVOID)pszLibFileRemote, 0, MEM_RELEASE);
  503. if (hThread  != NULL) 
  504. ::CloseHandle(hThread);
  506. if (hProcess != NULL) 
  507. ::CloseHandle(hProcess);
  508. }
  509. return bResult;
  510. }
  512. //
  513. // Perform actual ejection of the DLL from the address space of an external process
  514. //
  515. BOOL CRemThreadInjector::DoEjectModuleFrom(CExeModuleInstance& process)
  516. {
  517. BOOL   bResult  = FALSE; 
  518. HANDLE hProcess = NULL; 
  519. HANDLE hThread  = NULL;
  520. __try 
  521. {
  522. if (TRUE == IsWindows9x())
  523. __leave;
  524. //
  525. // Do not force the server to eject the DLL
  526. //
  527. if (process.Get_ProcessId() == ::GetCurrentProcessId())
  528. __leave;
  530. char szLibFile[MAX_PATH];
  531. ::GetModuleFileNameA(
  532. ModuleFromAddress(GetMsgProc), 
  533. szLibFile, 
  534. MAX_PATH
  535. );
  537. BOOL bFound = FALSE;
  538. CModuleInstance* pModuleInstance;
  539. for (long i = 0; i < process.GetModuleCount(); i++)
  540. {
  541. pModuleInstance = process.GetModuleByIndex(i);
  542. if ( 0 == stricmp(pModuleInstance->Get_Name(), szLibFile) )
  543. {
  544. bFound = TRUE;
  545. break;
  546. } // if
  547. } // for
  549. if (!bFound) 
  550. __leave;
  552. // Get a handle for the target process.
  553. hProcess = ::OpenProcess(
  554. PROCESS_ALL_ACCESS, // Specifies all possible access flags
  555. FALSE, 
  556. process.Get_ProcessId()
  557. );
  558. if (hProcess == NULL) 
  559. __leave;
  560. // Get the real address of LoadLibraryW in Kernel32.dll
  561. PTHREAD_START_ROUTINE pfnThreadRtn = (PTHREAD_START_ROUTINE)
  562. ::GetProcAddress(::GetModuleHandle("Kernel32"), "FreeLibrary");
  563. if (pfnThreadRtn == NULL) 
  564. __leave;
  565. // Create a remote thread that calls LoadLibraryW(DLLPathname)
  566. hThread = ::CreateRemoteThread(
  567. hProcess, 
  568. NULL, 
  569. 0, 
  570. pfnThreadRtn, 
  571. pModuleInstance->Get_Module(), 
  572. 0, 
  573. NULL
  574. );
  575. if (hThread == NULL) 
  576. __leave;
  577. // Wait for the remote thread to terminate
  578. ::WaitForSingleObject(hThread, INFINITE);
  580. bResult = TRUE; 
  581. }
  582. __finally 
  583. { 
  584. if (hThread != NULL) 
  585. ::CloseHandle(hThread);
  586. if (hProcess != NULL) 
  587. ::CloseHandle(hProcess);
  588. }
  589. return bResult;
  590. }
  592. //----------------------------End of the file -------------------------------