驱动开发：Win10内核枚举SSDT表基址

三年前面朝黄土背朝天的我，写了一篇如何在Windows 7系统下枚举内核SSDT表的文章《驱动开发：内核读取SSDT表基址》三年过去了我还是个单身狗，开个玩笑，微软的Windows 10系统已经覆盖了大多数个人PC终端，以前的方法也该进行迭代更新了，或许在网上你能够找到类似的文章，但我可以百分百肯定都不能用，今天LyShark将带大家一起分析Win10 x64最新系统SSDT表的枚举实现。
看一款闭源ARK工具的枚举效果:

直接步入正题，首先SSDT表中文为系统服务描述符表，SSDT表的作用是把应用层与内核层联系起来起到桥梁的作用，枚举SSDT表也是反内核工具最基本的功能，通常在64位系统中要想找到SSDT表，需要先找到KeServiceDescriptorTable这个函数，由于该函数没有被导出，所以只能动态的查找它的地址，庆幸的是我们可以通过查找msr(c0000082)这个特殊的寄存器来替代查找KeServiceDescriptorTable这一步，在新版系统中查找SSDT可以归纳为如下这几个步骤。

• rdmsr c0000082 -> KiSystemCall64Shadow -> KiSystemServiceUser -> SSDT
  

首先第一步通过rdmsr C0000082 MSR寄存器得到KiSystemCall64Shadow的函数地址，计算KiSystemCall64Shadow与KiSystemServiceUser偏移量，如下图所示。

• 得到相对偏移6ed53180(KiSystemCall64Shadow) - 6ebd2a82(KiSystemServiceUser) = 1806FE
  
• 也就是说 6ed53180(rdmsr) - 1806FE = KiSystemServiceUser
  

如上当我们找到了KiSystemServiceUser的地址以后，在KiSystemServiceUser向下搜索可找到KiSystemServiceRepeat里面就是我们要找的SSDT表基址。
其中fffff8036ef8c880则是SSDT表的基地址，紧随其后的fffff8036ef74a80则是SSSDT表的基地址。

那么如果将这个过程通过代码的方式来实现，我们还需要使用《驱动开发：内核枚举IoTimer定时器》中所使用的特征码定位技术，如下我们查找这段特征。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include <ntifs.h>
7. #pragma intrinsic(__readmsr)
9. ULONGLONG ssdt_address = 0;
11. // 获取 KeServiceDescriptorTable 首地址
12. ULONGLONG GetLySharkCOMKeServiceDescriptorTable()
13. {
14.         // 设置起始位置
15.         PUCHAR StartSearchAddress = (PUCHAR)__readmsr(0xC0000082) - 0x1806FE;
17.         // 设置结束位置
18.         PUCHAR EndSearchAddress = StartSearchAddress + 0x100000;
19.         DbgPrint("[LyShark Search] 扫描起始地址: %p --> 扫描结束地址: %p \n", StartSearchAddress, EndSearchAddress);
21.         PUCHAR ByteCode = NULL;
23.         UCHAR OpCodeA = 0, OpCodeB = 0, OpCodeC = 0;
24.         ULONGLONG addr = 0;
25.         ULONG templong = 0;
27.         for (ByteCode = StartSearchAddress; ByteCode < EndSearchAddress; ByteCode++)
28.         {
29.                 // 使用MmIsAddressValid()函数检查地址是否有页面错误
30.                 if (MmIsAddressValid(ByteCode) && MmIsAddressValid(ByteCode + 1) && MmIsAddressValid(ByteCode + 2))
31.                 {
32.                         OpCodeA = *ByteCode;
33.                         OpCodeB = *(ByteCode + 1);
34.                         OpCodeC = *(ByteCode + 2);
36.                         // 对比特征值 寻找 nt!KeServiceDescriptorTable 函数地址
37.                         /*
38.                         nt!KiSystemServiceRepeat:
39.                         fffff803`6ebd2b94 4c8d15e59c3b00  lea     r10,[nt!KeServiceDescriptorTable (fffff803`6ef8c880)]
40.                         fffff803`6ebd2b9b 4c8d1dde1e3a00  lea     r11,[nt!KeServiceDescriptorTableShadow (fffff803`6ef74a80)]
41.                         fffff803`6ebd2ba2 f7437880000000  test    dword ptr [rbx+78h],80h
42.                         fffff803`6ebd2ba9 7413            je      nt!KiSystemServiceRepeat+0x2a (fffff803`6ebd2bbe)  Branch
43.                         */
44.                         if (OpCodeA == 0x4c && OpCodeB == 0x8d && OpCodeC == 0x15)
45.                         {
46.                                 // 获取高位地址fffff802
47.                                 memcpy(&templong, ByteCode + 3, 4);
49.                                 // 与低位64da4880地址相加得到完整地址
50.                                 addr = (ULONGLONG)templong + (ULONGLONG)ByteCode + 7;
51.                                 return addr;
52.                         }
53.                 }
54.         }
55.         return  0;
56. }
58. VOID UnDriver(PDRIVER_OBJECT driver)
59. {
60.         DbgPrint(("驱动程序卸载成功! \n"));
61. }
63. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
64. {
65.         DbgPrint("hello lyshark.com");
67.         ssdt_address = GetLySharkCOMKeServiceDescriptorTable();
68.         DbgPrint("[LyShark] SSDT = %p \n", ssdt_address);
70.         DriverObject->DriverUnload = UnDriver;
71.         return STATUS_SUCCESS;
72. }

复制代码

如上代码中所提及的步骤我想不需要再做解释了，这段代码运行后即可输出SSDT表的基址。

如上通过调用GetLySharkCOMKeServiceDescriptorTable()得到SSDT地址以后我们就需要对该地址进行解密操作。
得到ServiceTableBase的地址后，就能得到每个服务函数的地址。但这个表存放的并不是SSDT函数的完整地址，而是其相对于ServiceTableBase[Index]>>4的数据，每个数据占四个字节，所以计算指定Index函数完整地址的公式是；

• 在x86平台上: FuncAddress = KeServiceDescriptorTable + 4 * Index
  
• 在x64平台上：FuncAddress = [KeServiceDescriptorTable+4*Index]>>4 + KeServiceDescriptorTable
  

如下汇编代码就是一段解密代码，代码中rcx寄存器传入SSDT的下标，而rdx寄存器则是传入SSDT表基址。

1.   48:8BC1                  | mov rax,rcx                             |  rcx=index
2.   4C:8D12                  | lea r10,qword ptr ds:[rdx]              |  rdx=ssdt
3.   8BF8                     | mov edi,eax                             |
4.   C1EF 07                  | shr edi,7                               |
5.   83E7 20                  | and edi,20                              |
6.   4E:8B1417                | mov r10,qword ptr ds:[rdi+r10]          |
7.   4D:631C82                | movsxd r11,dword ptr ds:[r10+rax*4]     |
8.   49:8BC3                  | mov rax,r11                             |
9.   49:C1FB 04               | sar r11,4                               |
10.   4D:03D3                  | add r10,r11                             |
11.   49:8BC2                  | mov rax,r10                             |
12.   C3                       | ret                                     |

复制代码

有了解密公式以后代码的编写就变得很容易，如下是读取SSDT的完整代码。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include <ntifs.h>
7. #pragma intrinsic(__readmsr)
9. typedef struct _SYSTEM_SERVICE_TABLE
10. {
11.         PVOID     ServiceTableBase;
12.         PVOID     ServiceCounterTableBase;
13.         ULONGLONG   NumberOfServices;
14.         PVOID     ParamTableBase;
15. } SYSTEM_SERVICE_TABLE, *PSYSTEM_SERVICE_TABLE;
17. ULONGLONG ssdt_base_aadress;
18. PSYSTEM_SERVICE_TABLE KeServiceDescriptorTable;
20. typedef UINT64(__fastcall *SCFN)(UINT64, UINT64);
21. SCFN scfn;
23. // 解密算法
24. VOID DecodeSSDT()
25. {
26.         UCHAR strShellCode[36] = "\x48\x8B\xC1\x4C\x8D\x12\x8B\xF8\xC1\xEF\x07\x83\xE7\x20\x4E\x8B\x14\x17\x4D\x63\x1C\x82\x49\x8B\xC3\x49\xC1\xFB\x04\x4D\x03\xD3\x49\x8B\xC2\xC3";
27.         /*
28.         48:8BC1                  | mov rax,rcx                             |  rcx=index
29.         4C:8D12                  | lea r10,qword ptr ds:[rdx]              |  rdx=ssdt
30.         8BF8                     | mov edi,eax                             |
31.         C1EF 07                  | shr edi,7                               |
32.         83E7 20                  | and edi,20                              |
33.         4E:8B1417                | mov r10,qword ptr ds:[rdi+r10]          |
34.         4D:631C82                | movsxd r11,dword ptr ds:[r10+rax*4]     |
35.         49:8BC3                  | mov rax,r11                             |
36.         49:C1FB 04               | sar r11,4                               |
37.         4D:03D3                  | add r10,r11                             |
38.         49:8BC2                  | mov rax,r10                             |
39.         C3                       | ret                                     |
40.         */
41.         scfn = ExAllocatePool(NonPagedPool, 36);
42.         memcpy(scfn, strShellCode, 36);
43. }
45. // 获取 KeServiceDescriptorTable 首地址
46. ULONGLONG GetKeServiceDescriptorTable()
47. {
48.         // 设置起始位置
49.         PUCHAR StartSearchAddress = (PUCHAR)__readmsr(0xC0000082) - 0x1806FE;
51.         // 设置结束位置
52.         PUCHAR EndSearchAddress = StartSearchAddress + 0x8192;
53.         DbgPrint("扫描起始地址: %p --> 扫描结束地址: %p \n", StartSearchAddress, EndSearchAddress);
55.         PUCHAR ByteCode = NULL;
57.         UCHAR OpCodeA = 0, OpCodeB = 0, OpCodeC = 0;
58.         ULONGLONG addr = 0;
59.         ULONG templong = 0;
61.         for (ByteCode = StartSearchAddress; ByteCode < EndSearchAddress; ByteCode++)
62.         {
63.                 // 使用MmIsAddressValid()函数检查地址是否有页面错误
64.                 if (MmIsAddressValid(ByteCode) && MmIsAddressValid(ByteCode + 1) && MmIsAddressValid(ByteCode + 2))
65.                 {
66.                         OpCodeA = *ByteCode;
67.                         OpCodeB = *(ByteCode + 1);
68.                         OpCodeC = *(ByteCode + 2);
70.                         // 对比特征值 寻找 nt!KeServiceDescriptorTable 函数地址
71.                         // LyShark.com
72.                         // 4c 8d 15 e5 9e 3b 00  lea r10,[nt!KeServiceDescriptorTable (fffff802`64da4880)]
73.                         // 4c 8d 1d de 20 3a 00  lea r11,[nt!KeServiceDescriptorTableShadow (fffff802`64d8ca80)]
74.                         if (OpCodeA == 0x4c && OpCodeB == 0x8d && OpCodeC == 0x15)
75.                         {
76.                                 // 获取高位地址fffff802
77.                                 memcpy(&templong, ByteCode + 3, 4);
79.                                 // 与低位64da4880地址相加得到完整地址
80.                                 addr = (ULONGLONG)templong + (ULONGLONG)ByteCode + 7;
81.                                 return addr;
82.                         }
83.                 }
84.         }
85.         return  0;
86. }
88. // 得到函数相对偏移地址
89. ULONG GetOffsetAddress(ULONGLONG FuncAddr)
90. {
91.         ULONG dwtmp = 0;
92.         PULONG ServiceTableBase = NULL;
93.         if (KeServiceDescriptorTable == NULL)
94.         {
95.                 KeServiceDescriptorTable = (PSYSTEM_SERVICE_TABLE)GetKeServiceDescriptorTable();
96.         }
97.         ServiceTableBase = (PULONG)KeServiceDescriptorTable->ServiceTableBase;
98.         dwtmp = (ULONG)(FuncAddr - (ULONGLONG)ServiceTableBase);
99.         return dwtmp << 4;
100. }
102. // 根据序号得到函数地址
103. ULONGLONG GetSSDTFunctionAddress(ULONGLONG NtApiIndex)
104. {
105.         ULONGLONG ret = 0;
106.         if (ssdt_base_aadress == 0)
107.         {
108.                 // 得到ssdt基地址
109.                 ssdt_base_aadress = GetKeServiceDescriptorTable();
110.         }
111.         if (scfn == NULL)
112.         {
113.                 DecodeSSDT();
114.         }
115.         ret = scfn(NtApiIndex, ssdt_base_aadress);
116.         return ret;
117. }
119. VOID UnDriver(PDRIVER_OBJECT driver)
120. {
121.         DbgPrint(("驱动程序卸载成功! \n"));
122. }
124. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
125. {
126.         DbgPrint("hello lyshark.com \n");
128.         ULONGLONG ssdt_address = GetKeServiceDescriptorTable();
129.         DbgPrint("SSDT基地址 = %p \n", ssdt_address);
131.         // 根据序号得到函数地址
132.         ULONGLONG address = GetSSDTFunctionAddress(51);
133.         DbgPrint("[LyShark] NtOpenFile地址 = %p \n", address);
134.          
135.         // 得到相对SSDT的偏移量
136.         DbgPrint("函数相对偏移地址 = %p \n", GetOffsetAddress(address));
138.         DriverObject->DriverUnload = UnDriver;
139.         return STATUS_SUCCESS;
140. }

复制代码

运行后即可得到SSDT下标为51的函数也就是得到NtOpenFile的绝对地址和相对地址。

你也可以打开ARK工具，对比一下是否一致，如下图所示，LyShark的代码是没有任何问题的。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！