保护电脑系统时间不被修改

本文通过WH_SHELL钩子配合HookAPI、远程线程，以windows service形式来保证系统时间不被修改。

其中

关于service程序编写参考了http://www.vckbase.com/。

HookApi、远程线程技术来源于网络。

本文HOOK如下函数：

OpenProcess（保护进程不被结束）

SetLocalTime（禁止修改时间）

 CreateProcessW（CreateProcessA底层调用CreateProcessW，拦截SHELL创建的所有进程）

CreateProcessInternalW（拦截cmd创建的所有进程）

对于GUI进程，WH_SHELL钩子会自动将HookAPI模块注入该进程。

对于SHELL和cmd创建的CUI进程，我们需要自己注入HookAPII模块（本文通过创建远程线程）。

为了保证Hook有效，程序主体为service程序（system创建，在explorer.exe运行之前）。

程序分为两个部分，主体service程序、Hook模块。

好了，见代码了。

以下为service程序主要代码

[cpp]  view plain copy

1. // timeprotects.cpp : Defines the entry point for the console application.  
2. //  
3.   
4. #include "stdafx.h"  
5. #include <stdio.h>  
6. #include "service.h"  
7.   
8. #pragma warning(disable:4101)  
9.   
10. #pragma comment(lib,"timeprotect")  
11.   
12.   
13. int main(int argc,char* argv[])  
14. {  
15.     static const char *szServiceName="TimeProtect";  
16.       
17.     if(argc==2)  
18.     {  
19.         if(!lstrcmpiA("install",argv[1]))  
20.         {  
21.             char szPath[MAX_PATH]="";  
22.             GetModuleFileNameA(NULL,szPath,MAX_PATH);  
23.               
24.             if(!ServiceManger::InstallService(szServiceName,szPath))//安装并以自动启动方式启动服务  
25.                 MessageBox(NULL,"服务启动失败","提示",MB_OK);  
26.         }  
27.         else if(!lstrcmpiA("uninstall",argv[1]))  
28.         {  
29.             ServiceManger::UninstallService(szServiceName);//停止并删除服务  
30.         }  
31.     }  
32.     else  
33.     {  
34.         if(!ServiceManger::CheckServiceIsRunning(szServiceName))  
35.         {  
36.             ServiceManger::Services service;  
37.             service.RunService(szServiceName);  
38.         }  
39.     }  
40.       
41.     return 0;  
42. }  
43. //---------------------------------------------------------------------------  

以下HookAPI模块主要代码，HookAPI方法：替换目标函数前5个字节、修改第一个字节为0xe9（jmp）跳转自定义处理函数处理。

[cpp]  view plain copy

1. // timeprotect.cpp : Defines the entry point for the DLL application.  
2. //  
3.   
4. #include "stdafx.h"  
5. #include "timeprotect.h"  
6.   
7. #pragma comment(linker,"/EXPORT:_RemoveApplicationMonitor,@1,NONAME")  
8. #pragma comment(linker,"/EXPORT:_AddApplicatinMonitor,@2,NONAME")  
9.   
10. #pragma data_seg (".shared")    
11. HHOOK g_hShellHook=NULL;  
12. DWORD g_dwProcessId=0;  
13. char  g_szModule[MAX_PATH]="";  
14. #pragma data_seg ()    
15.   
16. #pragma comment(linker, "/SECTION:.shared,RWS")   
17.   
18.   
19. HINSTANCE g_hIns=NULL;  
20.   
21. const int HOOKAPICOUNT=4;  
22.   
23. CHOOKAPI HookItem[HOOKAPICOUNT];  
24.   
25.   
26. HANDLE WINAPI MyOpenProcess(DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwProcessId)  
27. {  
28.     CHookapiManager manager(&HookItem[0]);  
29.     lpfn_OpenProcess fOpenProcess=(lpfn_OpenProcess)manager.get()->GetOldFunEntry();  
30.     HANDLE hRet=NULL;  
31.     if(dwProcessId!=g_dwProcessId)  
32.     hRet=fOpenProcess(dwDesiredAccess,bInheritHandle,dwProcessId);  
33.     return hRet;  
34. }  
35. BOOL WINAPI MySetLocalTime(IN CONST SYSTEMTIME *lpSystemTime)  
36. {  
37.     return FALSE;  
38. }  
39.   
40. BOOL WINAPI MyCreateProcessW(IN LPCWSTR lpApplicationName,  
41.                              IN LPWSTR lpCommandLine,  
42.                              IN LPSECURITY_ATTRIBUTES lpProcessAttributes,  
43.                              IN LPSECURITY_ATTRIBUTES lpThreadAttributes,  
44.                              IN BOOL bInheritHandles,  
45.                              IN DWORD dwCreationFlags,  
46.                              IN LPVOID lpEnvironment,  
47.                              IN LPCWSTR lpCurrentDirectory,  
48.                              IN LPSTARTUPINFOW lpStartupInfo,  
49.                              OUT LPPROCESS_INFORMATION lpProcessInformation  
50.                              )  
51. {  
52.     CHookapiManager manager(&HookItem[2]);  
53.       
54.     lpfn_CreateProcessW fCreateProcessW=(lpfn_CreateProcessW)manager.get()->GetOldFunEntry();  
55.     BOOL bRet=fCreateProcessW(lpApplicationName,  
56.         lpCommandLine,  
57.         lpProcessAttributes,  
58.         lpThreadAttributes,  
59.         bInheritHandles,  
60.         dwCreationFlags,  
61.         lpEnvironment,  
62.         lpCurrentDirectory,  
63.         lpStartupInfo,  
64.         lpProcessInformation);  
65.     if(bRet)  
66.     {  
67.         InjectModuleToProcessById(lpProcessInformation->dwProcessId,g_szModule);  
68.     }  
69.     return bRet;  
70. }  
71. BOOL WINAPI MyCreateProcessInternalW(HANDLE hToken,  
72.                                      LPCWSTR lpApplicationName,  
73.                                      LPWSTR lpCommandLine,  
74.                                      LPSECURITY_ATTRIBUTES lpProcessAttributes,  
75.                                      LPSECURITY_ATTRIBUTES lpThreadAttributes,  
76.                                      BOOL bInheritHandles,  
77.                                      DWORD dwCreationFlags,  
78.                                      LPVOID lpEnvironment,  
79.                                      LPCWSTR lpCurrentDirectory,  
80.                                      LPSTARTUPINFOW lpStartupInfo,  
81.                                      LPPROCESS_INFORMATION lpProcessInformation,  
82.                                      PHANDLE hNewToken)  
83. {  
84.     CHookapiManager manager(&HookItem[3]);  
85.       
86.     lpfn_CreateProcessInternalW fCreateProcessInternalW=(lpfn_CreateProcessInternalW)manager.get()->GetOldFunEntry();  
87.     BOOL bRet=fCreateProcessInternalW(  hToken,  
88.         lpApplicationName,  
89.         lpCommandLine,  
90.         lpProcessAttributes,  
91.         lpThreadAttributes,  
92.         bInheritHandles,  
93.         dwCreationFlags,  
94.         lpEnvironment,  
95.         lpCurrentDirectory,  
96.         lpStartupInfo,  
97.         lpProcessInformation,  
98.         hNewToken  
99.         );  
100.       
101.     if(bRet)  
102.     {  
103.         InjectModuleToProcessById(lpProcessInformation->dwProcessId,g_szModule);  
104.     }   
105.     return bRet;  
106. }   
107.   
108.   
109. void Start()  
110. {  
111.     HookItem[0].Hook("kernel32.dll","OpenProcess",(FARPROC)MyOpenProcess);  
112.     HookItem[1].Hook("kernel32.dll","SetLocalTime",(FARPROC)MySetLocalTime);  
113.     HookItem[2].Hook("kernel32.dll","CreateProcessW",(FARPROC)MyCreateProcessW);  
114.     HookItem[3].Hook("kernel32.dll","CreateProcessInternalW",(FARPROC)MyCreateProcessInternalW);  
115. }  
116. void End()  
117. {  
118.     HookItem[0].UnHook();  
119.     HookItem[1].UnHook();  
120.     HookItem[2].UnHook();  
121.     HookItem[3].UnHook();  
122. }  
123. LRESULT CALLBACK ShellProc(  
124.                            int nCode,      // hook code  
125.                            WPARAM wParam,  // event-specific information  
126.                            LPARAM lParam   // event-specific information  
127.                            )  
128. {  
129.     return CallNextHookEx(g_hShellHook,nCode,wParam,lParam);  
130. }  
131. extern "C"  
132. {  
133.     void RemoveApplicationMonitor()  
134.     {  
135.         if(UnhookWindowsHookEx(g_hShellHook))  
136.             g_hShellHook=NULL;  
137.     }  
138.     bool AddApplicatinMonitor()  
139.     {  
140.         g_dwProcessId=GetCurrentProcessId();  
141.           
142.         GetModuleFileName(g_hIns,g_szModule,MAX_PATH);  
143.           
144.         if(g_hShellHook)  
145.         {  
146.             RemoveApplicationMonitor();  
147.         }  
148.         g_hShellHook = SetWindowsHookEx(WH_SHELL,ShellProc,g_hIns,0);  
149.         return g_hShellHook!=NULL;  
150.     }  
151. }  
152. BOOL APIENTRY DllMain( HANDLE hModule,   
153.                       DWORD  ul_reason_for_call,   
154.                       LPVOID lpReserved  
155.                       )  
156. {  
157.     g_hIns=(HINSTANCE)hModule;  
158.     switch(ul_reason_for_call)  
159.     {  
160.     case DLL_PROCESS_ATTACH:  
161.         Start();  
162.         break;  
163.     case DLL_PROCESS_DETACH:  
164.         End();  
165.         break;  
166.     }  
167.     return TRUE;  
168. }