利用hook api屏幕取词

1. /**************************************************************************  
2.     HookApi.C  
3.   
4.     Hook and restore window api code in 32 BIT system code.  
5.       
6.     Hook   : Let application call api function after run my code.  
7.     Restore: Let application call api function no run my code.  
8.   
9.     (c) 1996.11 Inventec (TianJin) Co., Ltd.  
10.   
11.     Author: FengShuen Lu / ZhenYu Hou / Gang Yan  
12.   
13.     Comments:  1. 97.10.08 is version 1.0.  
14.   
15. ***************************************************************************/   
16. #include <windows.h>   
17. #include "string.h"   
18. #include "hookapi.h"   
19. #include "dbgfunc.h"   
20.    
21. #pragma comment(lib, "k32lib.lib")   
22.    
23. DWORD WINAPI VxDCall4(DWORD service_number, DWORD, DWORD, DWORD, DWORD);   
24.    
25. #define PC_WRITEABLE    0x00020000   
26. #define PC_USER         0x00040000   
27. #define PC_STATIC       0x20000000   
28.    
29. #define BUFFERLEN       7   // 用於定义一个长跳转的字节数·   
30. BOOL g_bCanWrite = FALSE;   
31.    
32. //   
33. WORD callgate1 = 0;   
34. /   
35.    
36. // 用於取得指定模块中指定输出函数的地址·   
37. FARPROC WINAPI getFunctionAddress(HINSTANCE hInst, LPCSTR lpMod, LPCSTR lpFun)   
38. {   
39.     HMODULE hMod;   
40.     FARPROC procFun;   
41.    
42.     if (lpMod != NULL)   
43.     {   
44.         hMod=GetModuleHandle(lpMod);   
45.         procFun = GetProcAddress(hMod,lpFun);   
46.     }   
47.     else   
48.     {   
49.         procFun = GetProcAddress(hInst,lpFun);   
50.     }   
51.        
52.     return  procFun;   
53. }    
54.    
55. // 用於形成一个３２ＢIT中的长跳转·   
56. void MakeJMPCode(LPBYTE lpJMPCode, LPVOID lpCodePoint)   
57. {   
58.     BYTE temp;   
59.     WORD wHiWord = HIWORD(lpCodePoint);   
60.     WORD wLoWord = LOWORD(lpCodePoint);   
61.     WORD wCS;   
62.    
63.     _asm                        // 取当前选择符·   
64.     {   
65.         push ax;   
66.         push cs;   
67.         pop  ax;   
68.         mov  wCS, ax;   
69.         pop  ax;   
70.     };   
71.        
72.     lpJMPCode[0] = 0xea;        // 填入 JMP 指令的机器码·   
73.    
74.     temp = LOBYTE(wLoWord);     // -------------------------   
75.     lpJMPCode[1] = temp;   
76.     temp = HIBYTE(wLoWord);   
77.     lpJMPCode[2] = temp;        // 填入地址·在内存中的顺序为；   
78.     temp = LOBYTE(wHiWord);     // Point: 0x1234   
79.     lpJMPCode[3] = temp;        // 内存： 4321   
80.     temp = HIBYTE(wHiWord);   
81.     lpJMPCode[4] = temp;        // -------------------------   
82.        
83.     temp = LOBYTE(wCS);         // 填入选择符·   
84.     lpJMPCode[5] = temp;   
85.     temp = HIBYTE(wCS);   
86.     lpJMPCode[6] = temp;   
87.    
88.     return;   
89. }   
90.    
91. // 使指定指针处的内存可写/不可写·   
92. void MakeMemCanWrite(LPVOID lpMemPoint, BOOL bCanWrite, int nSysMemStatus)   
93. {   
94.        
95.     switch (nSysMemStatus)   
96.     {   
97.         case HOOK_NEED_CHECK:   
98.              if (!g_bCanWrite)   
99.              {   
100.                 SetPageAttributes((DWORD)lpMemPoint, 0x0, 0x2);   
101.                 g_bCanWrite = TRUE;   
102.              }   
103.              break;   
104.         case HOOK_CAN_WRITE:   
105.              SetPageAttributes((DWORD)lpMemPoint, 0x0, 0x2);   
106.              g_bCanWrite = TRUE;   
107.              break;   
108.         case HOOK_ONLY_READ:   
109.              SetPageAttributes((DWORD)lpMemPoint, 0x42, 0x0);   
110.              g_bCanWrite = FALSE;   
111.              break;   
112.     }   
113.    
114. }   
115.    
116. void HookWin32Api(LPAPIHOOKSTRUCT lpApiHook, int nSysMemStatus)   
117. {                                           // nSysMemStatus = 0  说明需要检查可写标志·   
118.                                             // nSysMemStatus = 1  说明需要设置状态为可写·   
119.                                             // nSysMemStatus = 2  说明需要设置状态为只读·   
120.     BYTE   bWin32Api[5];   
121.    
122.     bWin32Api[0] = 0x00;    
123.    
124.     // 取得被拦截函数地址·   
125.     if(lpApiHook->lpWinApiProc == NULL)   
126.     {      
127.         lpApiHook->lpWinApiProc = (LPVOID)getFunctionAddress(lpApiHook->hInst, lpApiHook->lpszApiModuleName,lpApiHook->lpszApiName);   
128.         if (lpApiHook->dwApiOffset != 0)   
129.             lpApiHook->lpWinApiProc = (LPVOID)((DWORD)lpApiHook->lpWinApiProc + lpApiHook->dwApiOffset);   
130.     }   
131.     // 取得替代函数地址·   
132.     if(lpApiHook->lpHookApiProc == NULL)   
133.     {   
134.         lpApiHook->lpHookApiProc = (LPVOID)getFunctionAddress(lpApiHook->hInst, lpApiHook->lpszHookApiModuleName,lpApiHook->lpszHookApiName);   
135.     }   
136.     // 形成 JMP 指令·   
137.     if (lpApiHook->HookApiFiveByte[0] == 0x00)   
138.     {   
139.         MakeJMPCode(lpApiHook->HookApiFiveByte,lpApiHook->lpHookApiProc);   
140.     }   
141.    
142.     MakeMemCanWrite(lpApiHook->lpWinApiProc, TRUE, HOOK_CAN_WRITE);  // 令指定函数指针可写·   
143.        
144.     if (nSysMemStatus == HOOK_NEED_CHECK)   
145.     {   
146.         memcpy(lpApiHook->lpWinApiProc, (LPVOID)lpApiHook->HookApiFiveByte,BUFFERLEN);   
147.     }   
148.     else   
149.     {   
150.         if (lpApiHook->WinApiFiveByte[0] == 0x00)            // 判断是否已经拦截·   
151.         {   
152.             // 否·   
153.             // 备份 API 函数头五个字节·   
154.             memcpy(lpApiHook->WinApiFiveByte,(LPVOID)lpApiHook->lpWinApiProc,BUFFERLEN);   
155.             // 判断是否重复拦截·(即判断备份的头五个字节是否为形成的JMP指令)   
156.             if (strncmp(lpApiHook->WinApiFiveByte, lpApiHook->HookApiFiveByte, BUFFERLEN) == 0)   
157.             {   
158.                 // 恢复备份的字节·   
159.                 memcpy(lpApiHook->WinApiFiveByte,(LPVOID)lpApiHook->WinApiBakByte,BUFFERLEN);   
160.             }   
161.         }   
162.         else   
163.         {   
164.             // 是·   
165.             memcpy(bWin32Api,(LPVOID)lpApiHook->lpWinApiProc,BUFFERLEN);   
166.         }   
167.    
168.         if (strncmp(bWin32Api, lpApiHook->HookApiFiveByte, BUFFERLEN) != 0)   
169.         {   
170.             // 将 JMP 指定填入 API 函数的头·   
171.             memcpy(lpApiHook->lpWinApiProc, (LPVOID)lpApiHook->HookApiFiveByte,BUFFERLEN);   
172.         }   
173.     }   
174.     MakeMemCanWrite(lpApiHook->lpWinApiProc, FALSE, HOOK_ONLY_READ); //    
175. }   
176.    
177. void RestoreWin32Api(LPAPIHOOKSTRUCT lpApiHook, int nSysMemStatus)   
178. {                                           // nSysMemStatus = 0  说明需要检查可写标志·   
179.                                             // nSysMemStatus = 1  说明需要设置状态为可写·   
180.                                             // nSysMemStatus = 2  说明需要设置状态为只读·   
181.    
182.     if (lpApiHook->lpWinApiProc == NULL)   
183.         return;   
184.    
185.     MakeMemCanWrite(lpApiHook->lpWinApiProc, TRUE, HOOK_CAN_WRITE);  // 令指定函数指针可写·   
186.     memcpy(lpApiHook->lpWinApiProc,(LPVOID)lpApiHook->WinApiFiveByte,BUFFERLEN);   
187.     MakeMemCanWrite(lpApiHook->lpWinApiProc, FALSE, HOOK_ONLY_READ);   
188. }   
189.    
190.    
191. //==================================   
192. // PHYS - Matt Pietrek 1995   
193. // FILE: PHYS.C   
194. //==================================   
195.    
196. DWORD SetPageAttributes(DWORD linear, DWORD dwAndParam, DWORD dwOrParam )   
197. {   
198.        
199.     WORD myFwordPtr[3];   
200.     //if ( !callgate1 )   
201.         callgate1 = GetRing0Callgate( (DWORD)_SetPageAttributes, 3 );   
202.        
203.     if ( callgate1 )   
204.     {   
205.         WORD myFwordPtr[3];   
206.            
207.         myFwordPtr[2] = callgate1;   
208.         __asm   push    [linear]   
209.         __asm   push    [dwOrParam]   
210.         __asm   push    [dwAndParam]   
211.         __asm   cli   
212.         __asm   call    fword ptr [myFwordPtr]   
213.         __asm   sti   
214.    
215.         // The return value is in EAX.  The compiler will complain, but...   
216.     }   
217.     else   
218.         return 0xFFFFFFFF;   
219.     FreeRing0Callgate( callgate1 );   
220. }