基于VC++开发InlineHook网络数据发送接收函数

转自:http://blog.csdn.net/itcastcpp/article/details/8053802

大家都懂，很多时候开发项目需要修改网络数据，代码如下，请柬代码分析

[cpp]  view plain copy

1. #include "stdafx.h"     
2. #include <stdio.h>     
3. #include <Windows.h>     
4. #include <Winsock2.h>     
5.      
6.      
7. #ifdef _MANAGED     
8. #pragma managed(push, off)     
9. #endif     
10.      
11. #define HOOK_API extern "C" _declspec(dllexport)     
12. //本dll的handle     
13. HANDLE g_hInstance = NULL;     
14. //修改API入口为 mov eax, 00400000;jmp eax是程序能跳转到自己的函数     
15. BYTE g_btNewBytes[8] = { 0xB8, 0x0, 0x0, 0x40, 0x0, 0xFF, 0xE0, 0x0 };     
16. //保存原API入口的8个字节     
17. DWORD g_dwOldBytes[2][2] = { 0x0, 0x0, 0x0, 0x0 };     
18. //钩子句柄     
19. HHOOK    g_hOldHook = NULL;     
20. //API中send函数的地址     
21. DWORD g_pSend = 0;     
22. DWORD g_pRecv = 0;     
23. //事务，解决同步问题     
24. HANDLE g_hSendEvent = NULL;     
25. HANDLE g_hRecvEvent = NULL;     
26. //自己的send函数地址，参数必须与API的send函数地址相同     
27. int _stdcall hook_send( SOCKET s, const char *buf, int len, int flags );     
28. int _stdcall hook_recv(IN SOCKET s,OUT char FAR * buf,IN int len,IN int flags );     
29. //要Hook的进程和主线程ID号     
30. DWORD g_dwProcessID = 0;     
31. DWORD g_dwThreadID = 0;     
32.      
33. // 如果是win9x，不能使用fopen函数     
34. void WriteLog(char *fmt,...)     
35. {     
36.     va_list args;     
37.     char modname[200];     
38.      
39.     char temp[5000];     
40.     HANDLE hFile;     
41.     SYSTEMTIME loaclTime;     
42.     GetLocalTime(&loaclTime);     
43.     GetModuleFileName(NULL, modname, sizeof(modname));     
44.      
45.     if((hFile =CreateFile("c:\\hookapi.log", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) <0)     
46.     {     
47.         return;     
48.     }     
49.      
50.     SetFilePointer(hFile, 0, NULL, FILE_END);     
51.      
52.     wsprintf(temp, "%d:%d:%d mydll.dll:%s:", loaclTime.wHour,loaclTime.wMinute,loaclTime.wMilliseconds, modname);     
53.     DWORD dw;     
54.     WriteFile(hFile, temp, strlen(temp), &dw, NULL);     
55.      
56.     va_start(args,fmt);     
57.     vsprintf(temp, fmt, args);     
58.     va_end(args);     
59.      
60.     WriteFile(hFile, temp, strlen(temp), &dw, NULL);     
61.      
62.     wsprintf(temp, "\r\n");     
63.     WriteFile(hFile, temp, strlen(temp), &dw, NULL);     
64.      
65.     CloseHandle(hFile);     
66. }     
67.      
68. int _stdcall hook_recv(IN SOCKET s,OUT char FAR * buf,IN int len,IN int flags )     
69. {     
70.     int nRet;     
71.     WaitForSingleObject( g_hRecvEvent, INFINITE );     
72.      
73.     //恢复API头8个字节     
74.     WriteProcessMemory( INVALID_HANDLE_VALUE, ( void* )g_pRecv,( void* )g_dwOldBytes[0], sizeof( DWORD )*2, NULL );     
75.     /*   
76.     这里可以添加想要进行的处理过程   
77.     */     
78.     //真正执行API函数     
79.     nRet = recv( s, buf, len, flags );     
80.     //写入跳转语句，继续Hook     
81.     WriteProcessMemory( INVALID_HANDLE_VALUE, ( void* )g_pRecv,( void* )g_btNewBytes, sizeof( DWORD )*2, NULL);     
82.     WriteLog("%s",buf);     
83.     SetEvent( g_hRecvEvent );     
84.     return nRet;     
85. }     
86.      
87. int _stdcall hook_send( SOCKET s, const char *buf, int len, int flags )     
88. {     
89.     int nRet;     
90.     WaitForSingleObject( g_hSendEvent, INFINITE );     
91.      
92.     //恢复API头8个字节     
93.     WriteProcessMemory( INVALID_HANDLE_VALUE, ( void* )g_pSend,     
94.         ( void* )g_dwOldBytes[0], sizeof( DWORD )*2, NULL );     
95.     /*   
96.     这里可以添加想要进行的处理过程   
97.     */     
98.     WriteLog("Send:%s",buf);     
99.     //真正执行API函数     
100.     nRet = send( s, buf, len, flags );     
101.     //写入跳转语句，继续Hook     
102.     WriteProcessMemory( INVALID_HANDLE_VALUE, ( void* )g_pSend,     
103.         ( void* )g_btNewBytes, sizeof( DWORD )*2, NULL );     
104.     SetEvent( g_hSendEvent );     
105.     return nRet;     
106. }     
107.      
108. static LRESULT WINAPI HookProc( int nCode, WPARAM wParam, LPARAM lParam )     
109. {     
110.     return CallNextHookEx( g_hOldHook, nCode, wParam, lParam );     
111. }     
112. HOOK_API BOOL StartHook(HWND hWnd)     
113. {     
114.     //通过传入的窗口句柄获取线程句柄     
115.     g_dwThreadID = GetWindowThreadProcessId( hWnd, &g_dwProcessID );     
116.     //WH_CALLWNDPROC类型的Hook     
117.     g_hOldHook = SetWindowsHookEx( WH_CALLWNDPROC,   HookProc,( HINSTANCE ) g_hInstance, g_dwThreadID );     
118.     if( g_hOldHook == NULL )     
119.         return FALSE;     
120.      
121.     return TRUE;     
122. }     
123.      
124. HOOK_API void StopHook(void)     
125. {     
126.     if(g_hOldHook != NULL)     
127.     {     
128.         WaitForSingleObject( g_hSendEvent, INFINITE );     
129.      
130.         HANDLE hProcess = NULL;     
131.         hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, g_dwProcessID);     
132.      
133.         DWORD dwOldProc;     
134.         DWORD dwNewProc;     
135.         //改变页面属性为读写     
136.         VirtualProtectEx( hProcess, ( void* )g_pSend, 8, PAGE_READWRITE, &dwOldProc );     
137.         //恢复API的首8个字节     
138.         WriteProcessMemory( hProcess, ( void* )g_pSend,     
139.             ( void* )g_dwOldBytes[0], sizeof( DWORD )*2, NULL );     
140.         //恢复页面文件的属性     
141.         VirtualProtectEx( hProcess, ( void* )g_pSend, 8, dwOldProc, &dwNewProc );     
142.      
143.         CloseHandle(g_hSendEvent);     
144.      
145.         UnhookWindowsHookEx( g_hOldHook );     
146.     }     
147. }     
148.      
149. DWORD WINAPI ThreadFunc( LPVOID lpParam )      
150. {      
151.     char szMsg[80];     
152.      
153.     wsprintf( szMsg, "Parameter = %d.", *(DWORD*)lpParam );      
154.     MessageBox( NULL, szMsg, "ThreadFunc", MB_OK );     
155.     while(1) Sleep(1000);     
156.      
157.     return 0;      
158. }      
159.      
160. BOOL APIENTRY DllMain( HMODULE hModule,     
161.                        DWORD  ul_reason_for_call,     
162.                        LPVOID lpReserved     
163.                      )     
164. {     
165.     if(ul_reason_for_call == DLL_PROCESS_ATTACH)     
166.     {     
167.         WriteLog("Start HOOK");     
168.         //获取本dll句柄     
169.         g_hInstance = hModule;     
170.      
171.         //创建事务     
172.         g_hSendEvent = CreateEvent( NULL, FALSE, TRUE, NULL );     
173.      
174.         //重写API开头的8字节     
175.         HMODULE hWsock = LoadLibrary( "wsock32.dll" );     
176.         g_pSend = ( DWORD )GetProcAddress( hWsock, "send" );     
177.         g_pRecv = (DWORD)GetProcAddress( hWsock, "recv" );     
178.         //保存原始字节     
179.         ReadProcessMemory( INVALID_HANDLE_VALUE, ( void * )g_pSend,( void * )g_dwOldBytes[0], sizeof( DWORD )*2, NULL );     
180.         //将00400000改写为我们函数的地址     
181.         *( DWORD* )( g_btNewBytes + 1 ) = ( DWORD )hook_send;     
182.         WriteProcessMemory( INVALID_HANDLE_VALUE, ( void * )g_pSend,( void * )g_btNewBytes, sizeof( DWORD )*2, NULL );     
183.      
184. //      //保存原始字节     
185. //      ReadProcessMemory( INVALID_HANDLE_VALUE, ( void * )g_pRecv,( void * )g_dwOldBytes[0], sizeof( DWORD )*2, NULL );     
186. //      //将00400000改写为我们函数的地址     
187. //      *( DWORD* )( g_btNewBytes + 1 ) = ( DWORD )hook_recv;     
188. //      WriteProcessMemory( INVALID_HANDLE_VALUE, ( void * )g_pRecv,( void * )g_btNewBytes, sizeof( DWORD )*2, NULL );     
189.         DWORD dwThreadId, dwThrdParam = 1;      
190.         HANDLE hThread;      
191.         char szMsg[80];     
192.      
193.         hThread = CreateThread(      
194.             NULL,                        // default security attributes      
195.             0,                           // use default stack size       
196.             ThreadFunc,                  // thread function      
197.             &dwThrdParam,                // argument to thread function      
198.             0,                           // use default creation flags      
199.             &dwThreadId);                // returns the thread identifier      
200.      
201.         // Check the return value for success.      
202.         if (hThread == NULL)      
203.         {     
204.             wsprintf( szMsg, "CreateThread failed." );      
205.             MessageBox( NULL, szMsg, "main", MB_OK );     
206.         }     
207.         else      
208.         {     
209.             CloseHandle( hThread );     
210.         }     
211.     }     
212.     return TRUE;     
213. }     
214.      
215. #ifdef _MANAGED     
216. #pragma managed(pop)     
217. #endif    

[cpp]  view plain copy

1. #include <Winsock2.h>     
2. //#include <windows.h>     
3. #include <stdio.h>     
4. #include <Tlhelp32.h>     
5. //#pragma argsused     
6.      
7. //自定义APIHOOK结构     
8. typedef struct     
9. {     
10.     FARPROC funcaddr;     
11.     BYTE    olddata[5];     
12.     BYTE    newdata[5];     
13. }HOOKSTRUCT;     
14.      
15. HHOOK       g_hHook;     
16. HINSTANCE   g_hinstDll;     
17. HMODULE     hModule ;     
18. HWND      g_hForm;    //接收信息窗口句柄     
19. DWORD       dwIdOld, dwIdNew;     
20.      
21. //------------------------------------------------------------------------     
22. // 由于要截获两个库里面的函数,所以每个函数定义了两个HOOK结构     
23. // 一个是wsock32.dll, 一个是ws2_32.dll     
24. //------------------------------------------------------------------------     
25. HOOKSTRUCT  recvapi;     
26. HOOKSTRUCT  recvapi1;     
27. HOOKSTRUCT  sendapi;     
28. HOOKSTRUCT  sendapi1;     
29. HOOKSTRUCT  sendtoapi;     
30. HOOKSTRUCT  sendtoapi1;     
31. HOOKSTRUCT  WSASendapi;     
32. HOOKSTRUCT  connectapi;     
33. void HookOn();     
34. void HookOff();     
35. BOOL Init();     
36. extern "C" __declspec(dllexport)  BOOL __stdcall InstallHook();     
37. extern "C" __declspec(dllexport)  BOOL __stdcall UninstallHook();     
38.      
39. BOOL hookapi(char *dllname, char *procname, DWORD myfuncaddr, HOOKSTRUCT *hookfunc);     
40. int WINAPI Myrecv(SOCKET s, char FAR *buf, int len, int flags);     
41. int WINAPI Myrecv1(SOCKET s, char FAR *buf, int len, int flags);     
42. int WINAPI Mysend(SOCKET s, char FAR *buf, int len, int flags);     
43. int WINAPI Mysend1(SOCKET s, char FAR *buf, int len, int flags);     
44. int WINAPI Mysendto(SOCKET s, const char FAR * buf, int len,     
45.                     int flags, const struct sockaddr FAR * to, int tolen);     
46. int WINAPI Mysendto1(SOCKET s, const char FAR * buf, int len,     
47.                      int flags, const struct sockaddr FAR * to, int tolen);     
48. int WINAPI MyWSASend(     
49.                      SOCKET s,     
50.                      LPWSABUF lpBuffers,     
51.                      DWORD dwBufferCount,     
52.                      LPDWORD lpNumberOfBytesSent,     
53.                      DWORD dwFlags,     
54.                      LPWSAOVERLAPPED lpOverlapped,     
55.                      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine     
56.                      );     
57. int WINAPI Myconnect(SOCKET s,const struct sockaddr* name,int namelen);     
58. void sndmsg(char *buf);     
59. void WriteLog(char *fmt,...);     
60. //---------------------------------------------------------------------------     
61. // 入口函数     
62. // 在一载入库时就进行API截获     
63. // 释放时还原     
64. //---------------------------------------------------------------------------     
65. int WINAPI DllMain(HINSTANCE hinst, unsigned long reason, void* lpReserved)     
66. {        
67.     //__asm int 3        
68.     switch (reason)     
69.     {     
70.     case DLL_PROCESS_ATTACH:             
71.              
72.         g_hinstDll = hinst;     
73.         g_hForm = FindWindow(NULL, "ZwelL");     
74.         InstallHook();     
75.         if(!Init())     
76.         {     
77.             MessageBoxA(NULL,"Init","ERROR",MB_OK);     
78.             return(false);     
79.         }     
80.         break;     
81.     case DLL_THREAD_ATTACH:     
82.         break;     
83.     case DLL_THREAD_DETACH:     
84.         break;     
85.     case DLL_PROCESS_DETACH:     
86.         UninstallHook();     
87.         break;     
88.     }     
89.     return TRUE;     
90. }     
91.      
92. //-----------------------------------------------------------------------     
93. BOOL Init()     
94. {     
95.     hookapi("wsock32.dll", "recv", (DWORD)Myrecv, &recvapi);     
96.     hookapi("ws2_32.dll", "recv", (DWORD)Myrecv1, &recvapi1);     
97.     hookapi("wsock32.dll", "send", (DWORD)Mysend, &sendapi);     
98.     hookapi("ws2_32.dll", "send", (DWORD)Mysend1, &sendapi1);     
99.     hookapi("wsock32.dll", "sendto", (DWORD)Mysendto, &sendtoapi);     
100.     hookapi("ws2_32.dll", "sendto", (DWORD)Mysendto1, &sendtoapi1);     
101.     hookapi("wsock32.dll", "WSASend", (DWORD)MyWSASend, &WSASendapi);     
102.     hookapi("ws2_32.dll", "connect", (DWORD)Myconnect, &connectapi);     
103.     //hookapi("wsock32.dll", "connect", (DWORD)Myconnect, &connectapi);     
104.     dwIdNew = GetCurrentProcessId(); // 得到所属进程的ID     
105.     dwIdOld = dwIdNew;     
106.     HookOn(); // 开始拦截     
107.     return(true);     
108. }     
109. //---------------------------------------------------------------------------     
110. LRESULT WINAPI Hook(int nCode, WPARAM wParam, LPARAM lParam)     
111. {     
112.     return(CallNextHookEx(g_hHook, nCode, wParam, lParam));     
113. }     
114. //---------------------------------------------------------------------------     
115. extern "C" __declspec(dllexport)      
116. BOOL __stdcall InstallHook()     
117. {     
118.     g_hHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)Hook, g_hinstDll, 0);     
119.     if (!g_hHook)     
120.     {     
121.         MessageBoxA(NULL, "SET ERROR", "ERROR", MB_OK);     
122.         return(false);     
123.     }     
124.     return(true);     
125. }     
126. //---------------------------------------------------------------------------     
127. extern "C" __declspec(dllexport)      
128. BOOL __stdcall UninstallHook()     
129. {     
130.     HookOff();     
131.     if(g_hHook == NULL)     
132.         return true;     
133.     return(UnhookWindowsHookEx(g_hHook));     
134. }     
135.      
136. //---------------------------------------------------------------------------     
137. // 根据输入结构截获API     
138. //---------------------------------------------------------------------------     
139. BOOL hookapi(char *dllname, char *procname, DWORD myfuncaddr, HOOKSTRUCT *hookfunc)     
140. {     
141.     hModule = LoadLibrary(dllname);     
142.     hookfunc->funcaddr = GetProcAddress(hModule, procname);     
143.     if(hookfunc->funcaddr == NULL)     
144.         return false;     
145.      
146.     memcpy(hookfunc->olddata, hookfunc->funcaddr, 6);     
147.     hookfunc->newdata[0] = 0xe9;     
148.     DWORD jmpaddr = myfuncaddr - (DWORD)hookfunc->funcaddr - 5;     
149.     memcpy(&hookfunc->newdata[1], &jmpaddr, 5);     
150.     return true;     
151. }     
152. //---------------------------------------------------------------------------     
153. void HookOnOne(HOOKSTRUCT *hookfunc)     
154. {     
155.     HANDLE hProc;     
156.     dwIdOld = dwIdNew;     
157.     hProc = OpenProcess(PROCESS_ALL_ACCESS, 0, dwIdOld);     
158.     VirtualProtectEx(hProc, hookfunc->funcaddr, 5, PAGE_READWRITE,&dwIdOld);     
159.     WriteProcessMemory(hProc, hookfunc->funcaddr, hookfunc->newdata, 5, 0);     
160.     VirtualProtectEx(hProc, hookfunc->funcaddr, 5, dwIdOld, &dwIdOld);     
161. }     
162. //---------------------------------------------------------------------------     
163. void HookOn()     
164. {     
165. //  HookOnOne(&recvapi);     
166. //  HookOnOne(&sendapi);     
167. //  HookOnOne(&sendtoapi);     
168. //  HookOnOne(&recvapi1);     
169. //  HookOnOne(&sendapi1);     
170. //  HookOnOne(&sendtoapi1);     
171. //  HookOnOne(&WSASendapi);     
172.     HookOnOne(&connectapi);     
173.          
174. }     
175. //---------------------------------------------------------------------------     
176. void HookOffOne(HOOKSTRUCT *hookfunc)     
177. {     
178.     HANDLE hProc;     
179.     dwIdOld = dwIdNew;     
180.     hProc = OpenProcess(PROCESS_ALL_ACCESS, 0, dwIdOld);     
181.     VirtualProtectEx(hProc, hookfunc->funcaddr,5, PAGE_READWRITE, &dwIdOld);     
182.     WriteProcessMemory(hProc, hookfunc->funcaddr, hookfunc->olddata, 5, 0);     
183.     VirtualProtectEx(hProc, hookfunc->funcaddr, 5, dwIdOld, &dwIdOld);     
184. }     
185.      
186. //---------------------------------------------------------------------------     
187. void HookOff()     
188. {     
189. //  HookOffOne(&recvapi);     
190. //  HookOffOne(&sendapi);     
191. //  HookOffOne(&sendtoapi);     
192. //  HookOffOne(&recvapi1);     
193. //  HookOffOne(&sendapi1);     
194. //  HookOffOne(&sendtoapi1);     
195. //  HookOffOne(&WSASendapi);     
196.     HookOffOne(&connectapi);     
197. }     
198. //---------------------------------------------------------------------------     
199. int WINAPI Myrecv(SOCKET s, char FAR *buf, int len, int flags)     
200. {     
201.     int nReturn;     
202.     HookOffOne(&recvapi);     
203.     nReturn = recv(s, buf, len, flags);     
204.     HookOnOne(&recvapi);     
205.      
206.     char *tmpbuf=new char[len+100];     
207.     memset(tmpbuf, 0, sizeof(tmpbuf));     
208.     sprintf(tmpbuf, "recv|%d|%d|%s",     
209.         GetCurrentProcessId(),     
210.         len,     
211.         buf);     
212.     sndmsg(tmpbuf);     
213.     delete tmpbuf;     
214.     return(nReturn);     
215. }     
216. //---------------------------------------------------------------------------     
217. int WINAPI Myrecv1(SOCKET s, char FAR *buf, int len, int flags)     
218. {     
219.     int nReturn;     
220.     HookOffOne(&recvapi1);     
221.     nReturn = recv(s, buf, len, flags);     
222.     HookOnOne(&recvapi1);     
223.      
224.     char *tmpbuf=new char[len+100];     
225.     memset(tmpbuf, 0, sizeof(tmpbuf));     
226.     sprintf(tmpbuf, "recv1|%d|%d|%s",     
227.         GetCurrentProcessId(),     
228.         len,     
229.         buf);     
230.     sndmsg(tmpbuf);     
231.     delete tmpbuf;     
232.     return(nReturn);     
233. }     
234. //---------------------------------------------------------------------------     
235. int WINAPI Mysend(SOCKET s, char FAR *buf, int len, int flags)     
236. {     
237.     int nReturn;     
238.     HookOffOne(&sendapi);     
239.     nReturn = send(s, buf, len, flags);     
240.     HookOnOne(&sendapi);     
241.      
242.     char *tmpbuf=new char[len+100];     
243.     memset(tmpbuf, 0, sizeof(tmpbuf));     
244.     sprintf(tmpbuf, "send|%d|%d|%s",     
245.         GetCurrentProcessId(),     
246.         len,     
247.         buf);     
248.     sndmsg(tmpbuf);     
249.     delete tmpbuf;     
250.     return(nReturn);     
251. }     
252. //---------------------------------------------------------------------------     
253. int WINAPI Mysend1(SOCKET s, char FAR *buf, int len, int flags)     
254. {     
255.     int nReturn;     
256.     HookOffOne(&sendapi1);     
257.     nReturn = send(s, buf, len, flags);     
258.     HookOnOne(&sendapi1);     
259.      
260.     char *tmpbuf=new char[len+100];     
261.     memset(tmpbuf, 0, sizeof(tmpbuf));     
262.     sprintf(tmpbuf, "send1|%d|%d|%s",     
263.         GetCurrentProcessId(),     
264.         len,     
265.         buf);     
266.     sndmsg(tmpbuf);     
267.     delete tmpbuf;     
268.     return(nReturn);     
269. }     
270. //--------------------------------------------------------------------------     
271. int WINAPI Mysendto(SOCKET s, const char FAR * buf, int len,     
272.                     int flags, const struct sockaddr FAR * to, int tolen)     
273. {     
274.     int nReturn;     
275.     HookOffOne(&sendtoapi);     
276.     nReturn = sendto(s, buf, len, flags, to, tolen);     
277.     HookOnOne(&sendtoapi);     
278.      
279.     char *tmpbuf=new char[len+100];     
280.     memset(tmpbuf, 0, sizeof(tmpbuf));     
281.     sprintf(tmpbuf, "sendto|%d|%d|%s",     
282.         GetCurrentProcessId(),     
283.         len,     
284.         buf);     
285.     sndmsg(tmpbuf);     
286.     delete tmpbuf;     
287.     return(nReturn);         
288. }     
289. //--------------------------------------------------------------------------     
290. int WINAPI Mysendto1(SOCKET s, const char FAR * buf, int len,     
291.                      int flags, const struct sockaddr FAR * to, int tolen)     
292. {     
293.     int nReturn;     
294.     HookOffOne(&sendtoapi1);     
295.     nReturn = sendto(s, buf, len, flags, to, tolen);     
296.     HookOnOne(&sendtoapi1);     
297.      
298.     char *tmpbuf=new char[len+100];     
299.     memset(tmpbuf, 0, sizeof(tmpbuf));     
300.     sprintf(tmpbuf, "sendto1|%d|%d|%s",     
301.         GetCurrentProcessId(),     
302.         len,     
303.         buf);     
304.     sndmsg(tmpbuf);     
305.     delete tmpbuf;     
306.     return(nReturn);         
307. }     
308. //----------------------------------------------------------------------------     
309. int WINAPI MyWSASend(     
310.                      SOCKET s,     
311.                      LPWSABUF lpBuffers,     
312.                      DWORD dwBufferCount,     
313.                      LPDWORD lpNumberOfBytesSent,     
314.                      DWORD dwFlags,     
315.                      LPWSAOVERLAPPED lpOverlapped,     
316.                      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine     
317.                      )     
318. {     
319.     int nReturn;     
320.     HookOffOne(&WSASendapi);     
321.     nReturn = WSASend(s, lpBuffers, dwBufferCount,     
322.         lpNumberOfBytesSent, dwFlags, lpOverlapped, lpCompletionRoutine);     
323.     HookOnOne(&WSASendapi);     
324.      
325.     char *tmpbuf=new char[*lpNumberOfBytesSent+100];     
326.     memset(tmpbuf, 0, sizeof(tmpbuf));     
327.     sprintf(tmpbuf, "WSASend|%d|%d|%s",     
328.         GetCurrentProcessId(),     
329.         lpNumberOfBytesSent,     
330.         lpBuffers->buf);     
331.     sndmsg(tmpbuf);     
332.     delete tmpbuf;     
333.     return(nReturn);        
334. }     
335.      
336. //---------显示进程的模块     
337. bool GetListModules(DWORD dwPID,char* ModuleName,ULONG uAddress)     
338. {     
339.     HANDLE hModuleSnap = INVALID_HANDLE_VALUE;     
340.     MODULEENTRY32 me32;     
341.     BOOL bRet = FALSE;     
342.     // Take a snapshot of all modules in the specified process.     
343.     hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwPID );     
344.     if( hModuleSnap == INVALID_HANDLE_VALUE )     
345.     {     
346.         //MessageBox(NULL,"CreateToolhelp32Snapshot error"),"提示",MB_OK);     
347.         return FALSE;     
348.     }     
349.      
350.     // Set the size of the structure before using it.     
351.     me32.dwSize = sizeof( MODULEENTRY32);     
352.      
353.     // Retrieve information about the first module,     
354.     // and exit if unsuccessful     
355.     if( !Module32First( hModuleSnap, &me32 ) )     
356.     {     
357.         //MessageBox(NULL,_T("Module32First error"),"提示",MB_OK);     
358.         CloseHandle( hModuleSnap );     // Must clean up the snapshot object!     
359.         return( FALSE );     
360.     }     
361.      
362.     // Now walk the module list of the process,     
363.     // and display information about each module     
364.     //因为我只需要得到exe文件的路径,所以这个循环不要     
365.     do       
366.     {     
367.         //----下面这两个地方的显示结果是一样的，有中文字符就显示为 ?      
368.         //MessageBox(NULL,me32.szExePath,"提示",MB_OK); //弹出窗口显示exe文件的路径     
369.         //m_edit.SetWindowText(me32.szExePath); //edit控件中显示exe文件的路径     
370.      
371. //      BYTE* pMem = new BYTE[me32.modBaseSize];     
372. //      if(GetProcessMem(dwPID,(DWORD)me32.modBaseAddr,me32.modBaseSize,pMem))     
373. //      {     
374. //          if(GetProcessFunction(pMem) == 0)     
375. //              printf("%s\n",me32.szExePath);     
376. //      }     
377. //      delete[] pMem;     
378.         if( uAddress >= (ULONG)me32.modBaseAddr && (uAddress = (ULONG)me32.modBaseAddr + me32.modBaseSize))     
379.         {     
380.             strcpy(ModuleName,me32.szExePath);     
381.             bRet = TRUE;     
382.             break;     
383.         }     
384.     }      
385.     while( Module32Next( hModuleSnap, &me32 ) );      
386.      
387.     CloseHandle( hModuleSnap );     
388.     return bRet;     
389. }     
390.      
391. int WINAPI Myconnect(     
392.                         SOCKET s,     
393.                         const struct sockaddr* name,     
394.                         int namelen     
395.                         )     
396. {     
397.     ULONG rEbp;     
398.     __asm      
399.     {     
400.         mov rEbp,ebp     
401.     }     
402.     ULONG uAddress = *(ULONG*)(rEbp + 4);   //获取调用堆榨地址     
403.     char szMsg[MAX_PATH]={0};     
404.     if(GetListModules(GetCurrentProcessId(),szMsg,uAddress))     
405.         WriteLog(szMsg);     
406.     SOCKADDR_IN* destSockAddr;     
407.     destSockAddr = (SOCKADDR_IN *)name;     
408.     sprintf(szMsg,"0x%x,%s:%d",destSockAddr->sin_family, inet_ntoa(destSockAddr->sin_addr),destSockAddr->sin_port);     
409.     WriteLog(szMsg);     
410.      
411.      
412.     int nReturn;     
413.     HookOffOne(&connectapi);     
414.     nReturn = connect(s,name,namelen);     
415.     HookOnOne(&connectapi);     
416.     return nReturn;     
417. }     
418. __declspec(naked) int  WINAPI Myconnect1(     
419.                                         SOCKET s,     
420.                                         const struct sockaddr* name,     
421.                                         int namelen     
422.                                         )     
423. {     
424.     //int nReturn;     
425.     //HookOffOne(&connectapi);     
426.     __asm     
427.     {     
428.             mov     edi,edi     
429.             push    ebp     
430.             mov     ebp,esp     
431.             push    0x71a24a0c     
432.             ret     
433.     }     
434. //  connect(s,name,namelen);     
435. //  HookOnOne(&connectapi);     
436. //      
437. //  char szMsg[MAX_PATH];     
438. //  sprintf(szMsg,"%x",name->sa_data);     
439. //  WriteLog(szMsg);     
440. //  return ;     
441. }     
442. //-----------------------------------------------------------------     
443. // 向窗口发送消息     
444. // 考虑到简单性,用了COPYDATASTRUCT结构     
445. // 用内存映射应该会快一点     
446. //-----------------------------------------------------------------     
447. void sndmsg(char *buf)     
448. {     
449.     COPYDATASTRUCT cds;     
450.     cds.dwData=sizeof(COPYDATASTRUCT);     
451.     cds.cbData=strlen(buf);     
452.     cds.lpData=buf;     
453.     SendMessage(g_hForm,WM_COPYDATA,(WPARAM)NULL,(LPARAM)&cds);     
454. }     
455. static char s_szMessageBuf[5000];     
456. void WriteLog(char *fmt,...)     
457. {     
458.     va_list args;     
459.     char modname[200];     
460.          
461.     HANDLE hFile;     
462.     SYSTEMTIME loaclTime;     
463.     GetLocalTime(&loaclTime);     
464.     GetModuleFileName(NULL, modname, sizeof(modname));     
465.      
466.     if((hFile =CreateFile("c:\\hookConnect.log", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) <0)     
467.     {     
468.         return;     
469.     }     
470.      
471.     SetFilePointer(hFile, 0, NULL, FILE_END);     
472.      
473.     wsprintf(s_szMessageBuf, "%d:%d:%d :%s:", loaclTime.wHour,loaclTime.wMinute,loaclTime.wMilliseconds, modname);     
474.     DWORD dw;     
475.     WriteFile(hFile, s_szMessageBuf, strlen(s_szMessageBuf), &dw, NULL);     
476.      
477.     va_start(args,fmt);     
478.     vsprintf(s_szMessageBuf, fmt, args);     
479.     va_end(args);     
480.       
481.     WriteFile(hFile, s_szMessageBuf, strlen(s_szMessageBuf), &dw, NULL);     
482.      
483.     wsprintf(s_szMessageBuf, "\r\n");     
484.     WriteFile(hFile, s_szMessageBuf, strlen(s_szMessageBuf), &dw, NULL);     
485.      
486.     CloseHandle(hFile);     
487. }