拦截Windows关机消息

chenqiang

原文链接：拦截Windows关机消息

写了一个小工具，可以通过Hook Winlogon进程主模块的导入表、延迟导入表来拦截对于User32!ExitWindowsEx函数的调用。
整个步骤如下：
1、启动一个进程，注入DLL到Winlogon进程。
(1) 因为winlogon进程是system级别进程，所以要让注入进程已管理员方式启动，并使能SeDebugPrivilege权限，这样才可以注入system进程。
(2) 通过进程枚举获取到winlogon进程的PID，这个过程还可以判断session会话，因为同一时刻，系统中可能存在多个winlogon进程。
(3) 打开此进程，可以使用PROCESS_ALL_ACCESS标志。
(4) 在目标进程winlogon进程中申请内存，并写入需要注入的DLL对应的路径名称，写入绝对路径名称。
(5) 通过远线程注入，启动函数为LoadLibraryA(W)，传入参数为目标进程中需要注入DLL的路径地址。
2、在DLL的入口函数DllMain中HOOk 导入表，延迟导入表。
(1) 通过尝试，在windows 7 x86中，winlogon进程是在导入表中引用了User32模块的ExitWindowsEx函数。
(2) 而在 Windows 10 1809 x64中，winlogon进程是在延迟导入表中引用了User32模块的ExitWindowsEx函数。所以直接对这两个表都进行修复即可。
3、Hook函数指向自己写的函数，在自己写的函数中编写功能代码。
(1) 通过尝试，Winlogon进程会调用两次ExitWindowsEx函数，调用时使用的标志数据uFlags是不一样的，第一次调用ExitWindowsEx时会向桌面进程发送一些用户注销或者关机消息，用户进程可以在此时处理以便需要保存的内容。所有进程都处理完成后，第一次调用的ExitWindowsEx函数就返回TRUE了，否则返回FALSE。
(2) 如果第一次调用ExitWindowsEx成功，那么就说明桌面进程都同意关机或者注销了，会第二次调用ExitWindowsEx函数，需要意识到第二次调用前，桌面进程都被销毁了，此时如果要显示一个程序窗口，我们需要在桌面"WinSta0\winlogon"上进行显示，指定STARTUPINFOA(W)的lpDesktop指向此字符串。
备注：在windows 7上存在会话隔离，服务进程默认处于会话0(Session 0)下，所以窗口正常情况下都看不见，Windows启动后的第一个Winlogon进程为会话1，Winlogon下创建了工作站WinSta0，在此工作站下创建了桌面"WinSta0\winlogon"，登录对话框就是显示在这个桌面上的，当用户成功登录后，显示的桌面为"WinSta0\Default"，也就是说一般情况下我们看到的的程序都运行在WinSta0\Default桌面上，Winlogon进程还创建了桌面"WinSta0\Disconnect"。可以通过Process Explorer工具来查看某个进程中的句柄，可以看到类似的桌面都打开了WindowsStation对象，对应的名称为\Sessions\1\Windows\WindowStations\WinSta0 不同的会话对应的会话ID不同，所以WindowsStation对象对应的Name为\Sessions\XXX\Windows\WindowStations\WinSta0。SysinternalsSuite套件中提供了一个工具叫做Desktops.exe，这个工具除了当前默认的桌面外，还可以模拟出3个桌面，查看此进程可以看到共对应四个Desktop对象，分别为：【\Default】、【\Sysinternals Desktop 1】、【\Sysinternals Desktop 2】、【\Sysinternals Desktop 3】，通过Alt 1、2、3、4即可在四个桌面之间快速进行切换。
通过上面的知识，我们可以选择在Winlogon进程第二次调用ExitWindowsEx前，进行拦截，可以弹窗提示告知用户即将关机，或者显示其它消息。因为第一次ExitWindowsEx返回TRUE才会进行第二次调用，表明用户进程都已知晓，如果有未保存文件，此时用户都已知晓并处理过了。
当第一次调用ExitWindowsEx成功后，此时Windows桌面已经进入到了上面所说的WinSta0\winlogon下，所以调用CreateProcessAsUserA(W)时需要指定对应的桌面。
4、需要考虑到我们的DLL是运行在system进程中的，而提示时需要启动一个新的进程，最好不要让这个进程拥有过高权限，所以我们使用CreateProcessAsUserA(W)来创建进程。
通过尝试，在第二次调用ExitWindowsEx前，我们先打开当前进程，因为之后需要复制token，再修改token进程等级。但是在打开当前进程时程序执行失败，所以我们选择在DllMain函数中创建好一个Token进行保存，在调用CreateProcessAsUserA(W)使用这个token就可以了。注入进程代码如下：

1. 
   
2. #include <Windows.h>
   
3. #include <iostream>
   
4. #include <Psapi.h>
   
5. #include <Tlhelp32.h>
   
6. #include <sddl.h>
   
7. #include <Shlwapi.h>
   
8. 
   
9. using namespace std;
   
10. #pragma comment (lib,"advapi32.lib")
    
11. #pragma comment (lib,"Shlwapi.lib")
    
12. 
    
13. VOID InjectToWinLogon()
    
14. {   
    
15.     PROCESSENTRY32 entry;
    
16.     HANDLE snapshot = NULL, proc = NULL;
    
17.     entry.dwSize = sizeof(PROCESSENTRY32);
    
18.     snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    
19. 
    
20.     INT pid = -1;
    
21.     if (Process32First(snapshot, &entry))
    
22.     {
    
23.         while (Process32Next(snapshot, &entry))
    
24.         {
    
25.             if (wcscmp(entry.szExeFile, L"winlogon.exe") == 0)
    
26.             {               
    
27.                 pid = entry.th32ProcessID;
    
28.                 break;
    
29.             }
    
30.         }
    
31.     }
    
32.     CloseHandle(snapshot);
    
33.     if (pid < 0)
    
34.     {
    
35.         //puts("[-] Could not find winlogon.exe");
    
36.         return;
    
37.     }  
    
38.     proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    
39.     if (proc == NULL)
    
40.     {
    
41.         DWORD error = GetLastError();
    
42.         puts("[-] Failed to open process.");
    
43.         printf("error %d\n", error);
    
44.         return;
    
45.     }
    
46.     TCHAR buffDll[MAX_PATH] = { 0 };
    
47.     GetModuleFileName(NULL, buffDll, _countof(buffDll));
    
48.     PathRemoveFileSpec(buffDll);
    
49.     _tcscat_s(buffDll, _countof(buffDll), L"\\DllHookExitWindowsEx.dll");   
    
50.     LPVOID buffer = VirtualAllocEx(proc, NULL, sizeof(buffDll), MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
51.     if (buffer == NULL)
    
52.     {
    
53.         printf("[-] Failed to allocate remote memory");
    
54.     }
    
55.     if (!WriteProcessMemory(proc, buffer, buffDll, sizeof(buffDll), 0))
    
56.     {
    
57.         puts("[-] Failed to write to remote memory");
    
58.         return;
    
59.     }      
    
60.     LPTHREAD_START_ROUTINE start = (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(L"Kernel32.dll"), "LoadLibraryW");
    
61.     HANDLE hthread = CreateRemoteThread(proc, 0, 0, (LPTHREAD_START_ROUTINE)start, buffer, 0, 0);   
    
62. 
    
63.     DWORD error = GetLastError();
    
64.     if (hthread == INVALID_HANDLE_VALUE)
    
65.     {
    
66.         puts("[-] Failed to create remote thread");
    
67.         return;
    
68.     }
    
69. }
    
70. 
    
71. void EnableSeDebugPrivilegePrivilege()
    
72. {
    
73.     LUID luid;
    
74.     HANDLE currentProc = OpenProcess(PROCESS_ALL_ACCESS, false, GetCurrentProcessId());
    
75.     if (currentProc)
    
76.     {
    
77.         HANDLE TokenHandle = NULL;
    
78.         BOOL hProcessToken = OpenProcessToken(currentProc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &TokenHandle);
    
79.         if (hProcessToken)
    
80.         {
    
81.             BOOL checkToken = LookupPrivilegeValue(NULL, L"SeDebugPrivilege", &luid);
    
82. 
    
83.             if (!checkToken)
    
84.             {
    
85.                 //std::cout << "[+] Current process token already includes SeDebugPrivilege\n" << std::endl;
    
86.             }
    
87.             else
    
88.             {
    
89.                 TOKEN_PRIVILEGES tokenPrivs;
    
90. 
    
91.                 tokenPrivs.PrivilegeCount = 1;
    
92.                 tokenPrivs.Privileges[0].Luid = luid;
    
93.                 tokenPrivs.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    
94. 
    
95.                 BOOL adjustToken = AdjustTokenPrivileges(TokenHandle, FALSE, &tokenPrivs, sizeof(TOKEN_PRIVILEGES), (PTOKEN_PRIVILEGES)NULL, (PDWORD)NULL);
    
96. 
    
97.                 if (adjustToken != 0)
    
98.                 {
    
99.                     //std::cout << "[+] Added SeDebugPrivilege to the current process token" << std::endl;
    
100.                 }
     
101.             }
     
102.             CloseHandle(TokenHandle);
     
103.         }
     
104.     }
     
105.     CloseHandle(currentProc);
     
106. }
     
107. 
     
108. int _tmain(int argc, _TCHAR* argv[])
     
109. {               
     
110.     //开启权限 使之可以注入到syetem进程
     
111.     EnableSeDebugPrivilegePrivilege();
     
112.     //注入dll
     
113.     InjectToWinLogon();
     
114. 
     
115.     getchar();
     
116.     return 0;
     
117. }

复制代码

被注入的DLL代码如下：

1. #include <Windows.h>
   
2. #include <Psapi.h>
   
3. #include <Tlhelp32.h>
   
4. 
   
5. #include "warningUser.h"
   
6. 
   
7. #include <Shlwapi.h>
   
8. #include <stdlib.h>
   
9. #include <tchar.h>
   
10. 
    
11. #pragma comment (lib,"Shlwapi.lib")
    
12. 
    
13. LPVOID _copyNtShutdownSystem = NULL;
    
14. LPVOID _ExitWindowsExAddTwoByte = NULL;
    
15. HMODULE _gloDllModule = NULL;
    
16. 
    
17. 
    
18. #pragma warning(disable:4996)
    
19. 
    
20. /*__declspec(naked)*/ void MyExitWindowsEx()
    
21. {
    
22.     /*__asm
    
23.     {
    
24.         call testMsgBox;
    
25.         jmp _ExitWindowsExAddTwoByte
    
26.     }*/
    
27. }
    
28. 
    
29. typedef BOOL(WINAPI* FuncExitWindowsEx)(_In_ UINT uFlags, _In_ DWORD dwReason);
    
30. FuncExitWindowsEx _OldExitWindowsEx = NULL;
    
31. 
    
32. 
    
33. HANDLE gloCreateProcessHandle = NULL;
    
34. 
    
35. BOOL WINAPI IATHookExitWindowsEx(_In_ UINT uFlags, _In_ DWORD dwReason)
    
36. {   
    
37.     BOOL bRet = FALSE;
    
38.     static BOOL bNeedWarning = FALSE;
    
39.     //__asm int 3
    
40.     //DebugBreak();
    
41. 
    
42.     /*if (uFlags & 0x200000)//win7 x86可以通过这句来判断是否是第二次调用 通过调试获得的   需要测试
    
43.     {      
    
44.     }*/
    
45.     if (bNeedWarning)
    
46.     {
    
47.         TCHAR wszProcessName[MAX_PATH] = { 0 };
    
48.         GetModuleFileName(_gloDllModule, wszProcessName, _countof(wszProcessName));
    
49.         PathRemoveFileSpec(wszProcessName);
    
50.         _tcscat_s(wszProcessName, _countof(wszProcessName), L"\\LogOffWillRun.exe");
    
51.         useTokenCreateProcess(gloCreateProcessHandle, wszProcessName);
    
52.     }
    
53. 
    
54.     bRet = _OldExitWindowsEx(uFlags, dwReason);
    
55.     if (bRet)
    
56.     {      
    
57.         bNeedWarning = TRUE;      
    
58.     }   
    
59.     return bRet;   
    
60. }
    
61. 
    
62. //这是 win7 x86上的 Iniline Hook
    
63. void hook_ExitWindowsEx()
    
64. {   
    
65.     HMODULE hUser32 = GetModuleHandle(L"user32.dll");
    
66.     char* pOldExitWindowsEx = (char*)GetProcAddress(hUser32, "ExitWindowsEx");
    
67.     char* pOldAddr = pOldExitWindowsEx;   
    
68. 
    
69.     //00540000 8bff            mov     edi, edi   
    
70.     int iLengthCopy = 7;
    
71.     if (NULL != pOldAddr)
    
72.     {
    
73.         _copyNtShutdownSystem = VirtualAlloc(0, 1024, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
74.         char* pNewAddr = (char*)_copyNtShutdownSystem;
    
75. 
    
76.         char* pnop = pOldAddr - 5; //有5个字节的NOP
    
77.         char aa = *pOldAddr;
    
78.         char bb = *(pOldAddr+1);
    
79.         if ((char)0x8b == *pOldAddr && (char)0xff == *(pOldAddr+1))
    
80.         {
    
81.             DWORD oldshutdownProtect = 0;
    
82.             if (VirtualProtect(pOldAddr-5, iLengthCopy, PAGE_EXECUTE_READWRITE, &oldshutdownProtect))
    
83.             {
    
84.                 //*pOldNtShutdownSyetem = (char)0xe9;//jmp
    
85.                 *pOldExitWindowsEx = (char)0xeB;//jmp 短跳转
    
86.                 *(UCHAR*)(pOldExitWindowsEx + 1) = (USHORT)(-0x7); //addr
    
87. 
    
88.                 *pnop = (char)0xe9;//jmp
    
89.                 *(int*)(pnop + 1) = (int)MyExitWindowsEx-(int)(pnop + 5); //addr
    
90.                 _ExitWindowsExAddTwoByte = pOldExitWindowsEx + 2;
    
91.                 VirtualProtect(pOldAddr-5, iLengthCopy, oldshutdownProtect, NULL);
    
92.             }
    
93.         }      
    
94.     }
    
95.     return;
    
96. }
    
97. 
    
98. BYTE* getNtHdrs(BYTE* pe_buffer)
    
99. {
    
100.     if (pe_buffer == NULL) return NULL;
     
101. 
     
102.     IMAGE_DOS_HEADER* idh = (IMAGE_DOS_HEADER*)pe_buffer;
     
103.     if (idh->e_magic != IMAGE_DOS_SIGNATURE) {
     
104.         return NULL;
     
105.     }
     
106.     const LONG kMaxOffset = 1024;
     
107.     LONG pe_offset = idh->e_lfanew;
     
108.     if (pe_offset > kMaxOffset) return NULL;
     
109.     IMAGE_NT_HEADERS32* inh = (IMAGE_NT_HEADERS32*)((BYTE*)pe_buffer + pe_offset);
     
110.     if (inh->Signature != IMAGE_NT_SIGNATURE) return NULL;
     
111.     return (BYTE*)inh;
     
112. }
     
113. 
     
114. IMAGE_DATA_DIRECTORY* getPeDir(PVOID pe_buffer, size_t dir_id)
     
115. {
     
116.     if (dir_id >= IMAGE_NUMBEROF_DIRECTORY_ENTRIES) return NULL;
     
117. 
     
118.     BYTE* nt_headers = getNtHdrs((BYTE*)pe_buffer);
     
119.     if (nt_headers == NULL) return NULL;
     
120. 
     
121.     IMAGE_DATA_DIRECTORY* peDir = NULL;
     
122. 
     
123.     IMAGE_NT_HEADERS* nt_header = (IMAGE_NT_HEADERS*)nt_headers;
     
124.     peDir = &(nt_header->OptionalHeader.DataDirectory[dir_id]);
     
125. 
     
126.     if (peDir->VirtualAddress == NULL) {
     
127.         return NULL;
     
128.     }
     
129.     return peDir;
     
130. 
     
131. }
     
132. 
     
133. bool FixDelayIATHook(PVOID modulePtr)
     
134. {   
     
135.     IMAGE_DATA_DIRECTORY* importsDir = getPeDir(modulePtr, IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT);
     
136.     if (importsDir == NULL) return false;
     
137. 
     
138.     size_t maxSize = importsDir->Size;
     
139.     size_t impAddr = importsDir->VirtualAddress;
     
140. 
     
141.     IMAGE_DELAYLOAD_DESCRIPTOR* lib_desc = NULL;
     
142.     size_t parsedSize = 0;
     
143.     bool bFound = TRUE;
     
144. 
     
145.     size_t addrExitWindowsEx = (size_t)GetProcAddress(GetModuleHandle(L"User32"), "ExitWindowsEx");   
     
146. 
     
147.     for (; parsedSize < maxSize; parsedSize += sizeof(IMAGE_DELAYLOAD_DESCRIPTOR)) {
     
148. 
     
149.         lib_desc = (IMAGE_DELAYLOAD_DESCRIPTOR*)(impAddr + parsedSize + (ULONG_PTR)modulePtr);
     
150. 
     
151.         if (lib_desc->ImportAddressTableRVA == NULL && lib_desc->ImportNameTableRVA == NULL) break;
     
152. 
     
153.         LPSTR lib_name = (LPSTR)((ULONGLONG)modulePtr + lib_desc->DllNameRVA);      
     
154. 
     
155.         size_t call_via = lib_desc->ImportAddressTableRVA;
     
156.         size_t thunk_addr = lib_desc->ImportNameTableRVA;
     
157.         if (thunk_addr == NULL) thunk_addr = lib_desc->ImportAddressTableRVA;
     
158. 
     
159.         size_t offsetField = 0;
     
160.         size_t offsetThunk = 0;      
     
161.         for (;; offsetField += sizeof(IMAGE_THUNK_DATA), offsetThunk += sizeof(IMAGE_THUNK_DATA))
     
162.         {
     
163.             IMAGE_THUNK_DATA* fieldThunk = (IMAGE_THUNK_DATA*)(size_t(modulePtr) + offsetField + call_via);
     
164.             IMAGE_THUNK_DATA* orginThunk = (IMAGE_THUNK_DATA*)(size_t(modulePtr) + offsetThunk + thunk_addr);
     
165. 
     
166.             if (0 == fieldThunk->u1.Function && 0 == orginThunk->u1.Function)
     
167.             {
     
168.                 break;
     
169.             }           
     
170.             PIMAGE_IMPORT_BY_NAME by_name = NULL;
     
171.             LPSTR func_name = NULL;
     
172.             size_t addrOld = NULL;
     
173.             if (orginThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG32 || orginThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG64) // check if using ordinal (both x86 && x64)
     
174.             {
     
175.                 addrOld = (size_t)GetProcAddress(LoadLibraryA(lib_name), (char*)(orginThunk->u1.Ordinal & 0xFFFF));//通过序号也可以获取到  获取低两个字节 也可以获取到函数地址
     
176.                 //printf("        [V] API %x at %x\n", orginThunk->u1.Ordinal, addr);
     
177.                 //fieldThunk->u1.Function = addr;               
     
178.                 continue;
     
179.             }
     
180.             else
     
181.             {
     
182.                 by_name = (PIMAGE_IMPORT_BY_NAME)(size_t(modulePtr) + orginThunk->u1.AddressOfData);
     
183.                 func_name = (LPSTR)by_name->Name;
     
184.                 addrOld = (size_t)GetProcAddress(LoadLibraryA(lib_name), func_name);
     
185.             }                       
     
186.             //printf("        [V] API %s at %x\n", func_name, addr);
     
187.             OutputDebugStringA("\r\n");
     
188.             OutputDebugStringA(func_name);
     
189.             //HOOK           
     
190.             if (strcmpi(func_name, "ExitWindowsEx") == 0)
     
191.             {               
     
192.                 //DebugBreak();
     
193.                 DWORD dOldProtect = 0;
     
194.                 size_t* pFuncAddr = (size_t*)&fieldThunk->u1.Function;
     
195.                 if (VirtualProtect(pFuncAddr, sizeof(size_t), PAGE_EXECUTE_READWRITE, &dOldProtect))
     
196.                 {
     
197.                     fieldThunk->u1.Function = (size_t)IATHookExitWindowsEx;
     
198.                     VirtualProtect(pFuncAddr, sizeof(size_t), dOldProtect, &dOldProtect);
     
199.                     _OldExitWindowsEx = (FuncExitWindowsEx)addrExitWindowsEx;
     
200.                     bFound = true;
     
201.                     return bFound;
     
202.                 }               
     
203.                 break;
     
204.             }
     
205. 
     
206.         }
     
207. 
     
208.     }   
     
209.     return true;
     
210. }
     
211. 
     
212. bool FixIATHook(PVOID modulePtr)
     
213. {
     
214.     IMAGE_DATA_DIRECTORY* importsDir = getPeDir(modulePtr, IMAGE_DIRECTORY_ENTRY_IMPORT);
     
215.     if (importsDir == NULL) return false;
     
216. 
     
217.     size_t maxSize = importsDir->Size;
     
218.     size_t impAddr = importsDir->VirtualAddress;
     
219. 
     
220.     IMAGE_IMPORT_DESCRIPTOR* lib_desc = NULL;
     
221.     size_t parsedSize = 0;
     
222.     bool bFound = TRUE;   
     
223.     size_t addrExitWindowsEx = (size_t)GetProcAddress(GetModuleHandle(L"User32"), "ExitWindowsEx");
     
224. 
     
225.     for (; parsedSize < maxSize; parsedSize += sizeof(IMAGE_IMPORT_DESCRIPTOR)) {
     
226.         lib_desc = (IMAGE_IMPORT_DESCRIPTOR*)(impAddr + parsedSize + (ULONG_PTR)modulePtr);
     
227.         if (lib_desc->OriginalFirstThunk == NULL && lib_desc->FirstThunk == NULL)
     
228.             break;
     
229. 
     
230.         LPSTR lib_name = (LPSTR)((size_t)modulePtr + lib_desc->Name);
     
231. 
     
232.         size_t call_via = lib_desc->FirstThunk;
     
233.         size_t thunk_addr = lib_desc->OriginalFirstThunk;
     
234.         if (thunk_addr == NULL)
     
235.             thunk_addr = lib_desc->FirstThunk;
     
236. 
     
237.         size_t offsetField = 0;
     
238.         size_t offsetThunk = 0;
     
239. 
     
240.         for (;; offsetField += sizeof(IMAGE_THUNK_DATA), offsetThunk += sizeof(IMAGE_THUNK_DATA))
     
241.         {
     
242.             IMAGE_THUNK_DATA* fieldThunk = (IMAGE_THUNK_DATA*)(size_t(modulePtr) + offsetField + call_via);
     
243.             IMAGE_THUNK_DATA* orginThunk = (IMAGE_THUNK_DATA*)(size_t(modulePtr) + offsetThunk + thunk_addr);
     
244. 
     
245.             if (0 == fieldThunk->u1.Function && 0 == orginThunk->u1.Function)
     
246.             {
     
247.                 break;
     
248.             }
     
249. 
     
250.             PIMAGE_IMPORT_BY_NAME by_name = NULL;
     
251.             LPSTR func_name = NULL;
     
252.             size_t addrOld = NULL;
     
253.             if (orginThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG32 || orginThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG64) // check if using ordinal (both x86 && x64)
     
254.             {
     
255.                 addrOld = (size_t)GetProcAddress(LoadLibraryA(lib_name), (char*)(orginThunk->u1.Ordinal & 0xFFFF));//通过序号?
     
256.                 //printf("        [V] API %x at %x\n", orginThunk->u1.Ordinal, addr);
     
257.                 //fieldThunk->u1.Function = addr;   
     
258.                 //DebugBreak();
     
259.                 continue;
     
260.             }
     
261.             else
     
262.             {
     
263.                 by_name = (PIMAGE_IMPORT_BY_NAME)(size_t(modulePtr) + orginThunk->u1.AddressOfData);
     
264.                 func_name = (LPSTR)by_name->Name;
     
265.                 addrOld = (size_t)GetProcAddress(LoadLibraryA(lib_name), func_name);
     
266.             }
     
267.             //printf("        [V] API %s at %x\n", func_name, addr);
     
268.             OutputDebugStringA("\r\n");
     
269.             OutputDebugStringA(func_name);
     
270.             //HOOK           
     
271.             if (strcmpi(func_name, "ExitWindowsEx") == 0)
     
272.             {               
     
273.                 //DebugBreak();                                               
     
274.                 DWORD dOldProtect = 0;
     
275.                 size_t* pFuncAddr = (size_t*)&fieldThunk->u1.Function;
     
276.                 if (VirtualProtect(pFuncAddr, sizeof(size_t), PAGE_EXECUTE_READWRITE, &dOldProtect))
     
277.                 {
     
278.                     fieldThunk->u1.Function = (size_t)IATHookExitWindowsEx;
     
279.                     VirtualProtect(pFuncAddr, sizeof(size_t), dOldProtect, &dOldProtect);
     
280.                     _OldExitWindowsEx = (FuncExitWindowsEx)addrExitWindowsEx;
     
281.                     bFound = true;
     
282.                     return bFound;
     
283.                 }               
     
284.             }
     
285.         }               
     
286.     }
     
287.     return true;   
     
288. }
     
289. 
     
290. BOOL APIENTRY DllMain( HMODULE hModule,
     
291.                        DWORD  ul_reason_for_call,
     
292.                        LPVOID lpReserved
     
293.                      )
     
294. {
     
295. 
     
296.     switch (ul_reason_for_call)
     
297.     {
     
298.     case DLL_PROCESS_ATTACH:
     
299.     {      
     
300.         //DebugBreak();
     
301.         _gloDllModule = hModule;
     
302.         gloCreateProcessHandle = getMediumProcessToken();      
     
303.         HMODULE exeModule = GetModuleHandle(NULL);      
     
304.         FixIATHook(exeModule);
     
305.         FixDelayIATHook(exeModule);               
     
306.         break;
     
307.     }      
     
308.     case DLL_THREAD_ATTACH:
     
309.     case DLL_THREAD_DETACH:
     
310.     case DLL_PROCESS_DETACH:
     
311.     {
     
312.         if (gloCreateProcessHandle != NULL)
     
313.         {
     
314.             CloseHandle(gloCreateProcessHandle);
     
315.             gloCreateProcessHandle = NULL;
     
316.         }
     
317.     }
     
318.         break;
     
319.     }
     
320.     return TRUE;
     
321. }

复制代码

其中引用了warningUser.h文件内容如下：

1. 
   
2. HANDLE getMediumProcessToken();
   
3. void useTokenCreateProcess(HANDLE hToken, TCHAR* szProcessName);
   

复制代码

源文件warningUser.cpp文件内容为：

1. 
   
2. #include "warningUser.h"
   
3. #include <Windows.h>
   
4. #include <sddl.h>
   
5. #include <tchar.h>
   
6. #include <Shlwapi.h>
   
7. #include <stdlib.h>
   
8. 
   
9. #pragma comment(lib, "Advapi32.lib")
   
10. #pragma comment (lib,"Shlwapi.lib")
    
11. 
    
12. HANDLE getMediumProcessToken()
    
13. {
    
14.     WCHAR* wszIntegritySid = L"S-1-16-8192";
    
15.     //CreateIntegritySidProcess(L"S-1-16-4096");//low权限进程
    
16.     //CreateIntegritySidProcess(L"S-1-16-8192");//medium权限进程
    
17.     //CreateIntegritySidProcess(L"S-1-16-12288");//high权限进程
    
18.     //CreateIntegritySidProcess(L"S-1-16-16384");//system权限进程
    
19.     HANDLE mediumToken = NULL;   
    
20.     HANDLE hToken = NULL;
    
21.     HANDLE hNewToken = NULL;
    
22. 
    
23.     PSID pIntegritySid = NULL;
    
24.     TOKEN_MANDATORY_LABEL TIL = { 0 };   
    
25.     __try
    
26.     {
    
27.         if (FALSE == OpenProcessToken(GetCurrentProcess(), MAXIMUM_ALLOWED, &hToken))
    
28.         {
    
29.             __leave;
    
30.         }
    
31.         if (FALSE == DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL,
    
32.             SecurityImpersonation, TokenPrimary, &hNewToken))
    
33.         {
    
34.             __leave;
    
35.         }
    
36.         if (FALSE == ConvertStringSidToSid(wszIntegritySid, &pIntegritySid))
    
37.         {
    
38.             __leave;
    
39.         }
    
40.         TIL.Label.Attributes = SE_GROUP_INTEGRITY;
    
41.         TIL.Label.Sid = pIntegritySid;
    
42. 
    
43.         // Set the process integrity level
    
44.         if (FALSE == SetTokenInformation(hNewToken, TokenIntegrityLevel, &TIL,
    
45.             sizeof(TOKEN_MANDATORY_LABEL)+GetLengthSid(pIntegritySid)))
    
46.         {
    
47.             __leave;
    
48.         }
    
49.         mediumToken = hNewToken;
    
50.     }
    
51.     __finally
    
52.     {
    
53.         if (NULL != pIntegritySid)
    
54.         {
    
55.             LocalFree(pIntegritySid);
    
56.             pIntegritySid = NULL;
    
57.         }
    
58.         if (NULL != hToken)
    
59.         {
    
60.             CloseHandle(hToken);
    
61.             hToken = NULL;
    
62.         }
    
63. 
    
64.     }
    
65.     return mediumToken;
    
66. }
    
67. 
    
68. void useTokenCreateProcess(HANDLE hToken, TCHAR* szProcessName)
    
69. {
    
70.     //LogOffWillRun
    
71. 
    
72.     //WCHAR wszProcessName[MAX_PATH] = L"C:\\Windows\\System32\\CMD.exe";
    
73.     PROCESS_INFORMATION ProcInfo = { 0 };
    
74.     STARTUPINFO StartupInfo = { 0 };
    
75.     StartupInfo.cb = sizeof(STARTUPINFO);
    
76.     //si.dwXSize = 120;
    
77.     //StartupInfo.lpDesktop = L"WinSta0\\Default";
    
78.     StartupInfo.lpDesktop = L"WinSta0\\winlogon";
    
79.     StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
    
80.     StartupInfo.wShowWindow = SW_SHOWNORMAL;
    
81.     BOOL bRet = CreateProcessAsUser(hToken, NULL,
    
82.         szProcessName, NULL, NULL, FALSE,
    
83.         0, NULL, NULL, &StartupInfo, &ProcInfo);
    
84.     if (bRet)
    
85.     {
    
86.         WaitForSingleObject(ProcInfo.hProcess, INFINITE);
    
87.     }
    
88.     if (ProcInfo.hProcess)
    
89.     {
    
90.         CloseHandle(ProcInfo.hProcess);
    
91.         ProcInfo.hProcess = NULL;
    
92.     }
    
93.     if (ProcInfo.hThread)
    
94.     {
    
95.         CloseHandle(ProcInfo.hThread);
    
96.         ProcInfo.hThread = NULL;
    
97.     }
    
98. }

复制代码

在提示进程LogOffWillRun中，代码很简单，进行提示，如下：

1. 
   
2. #include <Windows.h>
   
3. 
   
4. #pragma comment(lib, "User32.lib")
   
5. int _tmain(int argc, _TCHAR* argv[])
   
6. {
   
7.     MessageBox(GetConsoleWindow(), _TEXT("调用了ExitWindowsEx进行关机或者注销"), _TEXT("提示"), MB_OK);
   
8.     return 0;
   
9. }

复制代码

代码基本到此结束，运行注入DLL的进程时需要以管理员权限运行。
winlogon调用两次ExitWindowsEx后，wininit进程会去调用ntdll!NtShutDownSystem进程进行关机。在win 10 1809 x64上，发现wininit会进行第三次调用ExitWindowsEx函数。本来想远线程注入wininit进程，但是失败，错误代码为8，含义为内存资源不足，无法处理此命令。
还有一个想法是Hook wininit进程，具体如下：
1、打开wininit进程。
2、远程修改导入表，Hook NtShutDownSystem。
(1) 可以通过在本进程中调用LoadLibraryExA(W)展开wininit的PE文件，定位到NtShutDownSystem函数对应的地址，通过此地址与内存中的wininit映像计算一个偏移。
(2)枚举wininit进程模块，获取主进程基地址，然后通过上一步的偏移量来修改导入表或者延迟导入表。
(3)修改地址为一段shellcode的起始地址，并保留原来wininit中导入表的内容。
a、远程申请一段空间，可读可写可执行，这段空间包括两部分内容，第一部分是数据，第二部分是代码。
b、数据是原来导入表的内容，也可以写入其它数据。
c、代码可以使用PIC_Bindshell项目，然后自己编写C语言函数，编写一段shellcode，引用之前的数据（可以通过call pop重定位或者生成shellcode后，通过每次修改shellcode硬编码来引用数据）。
3、修改导入表后，Hook函数指针指向我们自己的shellcode(如果数据与代码在连续内存，记得加上偏移，使指针指向shellcode起始地址)，当wininit调用NtShutDownSystem时会先调用我们自己的函数，使用PIC_Bindshell编写代码可以加载我们自己的动态库，调用动态库导出函数来启动一个进程提示用户关机了。
备注：winlogon进程调用两次ExitWindowsEx后程序就退出了，如果我们选择注销当前用户，当前winlogon结束，会启动新的winlogon，此时没有我们注入的动态库，即可以将注入器写成服务进程，后台枚举winlogon进程，注入DLL。或者HOOk Wininit进程。也可以在桌面进程中监听窗口消息WM_QUERYENDSESSION。或者在服务进程中通过RegisterServiceCtrlHandlerA(W)注册一个回调函数，在回调函数中处理SERVICE_CONTROL_SHUTDOWN请求。
2022-12-28添加：在Hook的ExitWindowsEx函数中也可以通过MessageBox来提示用户，如下：

1. 
   
2. if (bNeedWarning)
   
3. {
   
4.     MessageBox(NULL, _TEXT("弹框提示"), _TEXT("提示"), MB_OK);
   
5. }

复制代码

效果如下：

如果是通过启动一个新进程的方式，优点是更加灵活，自己编写新进程，不需要修改DLL。