驱动开发：内核远程线程实现DLL注入

在笔者上一篇文章《内核RIP劫持实现DLL注入》介绍了通过劫持RIP指针控制程序执行流实现插入DLL的目的，本章将继续探索全新的注入方式，通过NtCreateThreadEx这个内核函数实现注入DLL的目的，需要注意的是该函数在微软系统中未被导出使用时需要首先得到该函数的入口地址，NtCreateThreadEx函数最终会调用ZwCreateThread，本章在寻找函数的方式上有所不同，前一章通过内存定位的方法得到所需地址，本章则是通过解析导出表实现。
内核导出表远程线程是一种实现DLL注入的常见技术之一。通过使用该技术，注入代码可以利用目标进程的导出表中已有的函数来加载DLL，并在远程线程中执行DLL代码，从而实现DLL注入。
具体而言，内核导出表远程线程实现DLL注入的过程包括以下步骤：

• 打开目标进程，获取其进程句柄。
  
• 在目标进程的内存空间中分配一段可执行代码的内存空间，将注入代码写入其中。
  
• 通过GetProcAddress函数获取目标进程中已有的一个导出函数的地址，如LoadLibraryA等函数。
  
• 在目标进程中创建一个远程线程，将获取到的导出函数地址作为线程的入口点，并将DLL路径等参数传递给导出函数。
  
• 远程线程在目标进程中运行，并调用导出函数。导出函数会将DLL加载到目标进程的内存中，并返回DLL的句柄。
  
• 远程线程继续执行注入代码，利用DLL的句柄和GetProcAddress函数获取目标函数的地址，从而实现DLL注入。
  

需要注意的是，内核导出表远程线程作为一种内核级别的注入技术，可能会被安全软件或操作系统检测到，并对其进行防御。因此，在使用这种技术进行DLL注入时，需要谨慎使用，并采取必要的安全措施，以防止被检测和防御。
在内核模式中实现这一过程的具体方法可分为如下步骤；

• 1.通过GetKeServiceDescriptorTable64获取到SSDT表基址
  
• 2.通过KeStackAttachProcess附加到远程进程内
  
• 3.通过GetUserModuleAddress获取到Ntdll.dll模块内存基址
  
• 4.通过GetModuleExportAddress获取到LdrLoadDll函数的内存地址
  
• 5.调用GetNative32Code生成拉起特定DLL的ShellCode片段
  
• 6.通过NtCreateThreadEx将ShellCode执行起来，并自动加载DLL
  
• 7.通过KeUnstackDetachProcess取消附加远程进程，并做好最后的清理工作
  

首先需要定义一个标准头文件，并将其命名为lyshark.h其定义部分如下所示，此部分内容包含了微软官方结构定义，以及一些通用函数的规整，已做较为详细的分析和备注，由于前面课程中都有介绍，此处不再介绍具体原理，如果需要了解结构体内的含义，请去自行查阅微软官方文档。

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. #include <ntimage.h>
8. #include <ntstrsafe.h>
10. #define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x00000004
12. // -----------------------------------------------------------------------------------
13. // 声明未导出函数
14. // -----------------------------------------------------------------------------------
16. NTKERNELAPI PPEB NTAPI PsGetProcessPeb(IN PEPROCESS Process);
17. NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
18. NTKERNELAPI PVOID NTAPI PsGetProcessWow64Process(IN PEPROCESS Process);
19. NTKERNELAPI HANDLE PsGetProcessInheritedFromUniqueProcessId(IN PEPROCESS Process);
21. NTSYSAPI NTSTATUS NTAPI ZwQueryInformationThread(
22.         IN HANDLE ThreadHandle,
23.         IN THREADINFOCLASS ThreadInformationClass,
24.         OUT PVOID ThreadInformation,
25.         IN ULONG ThreadInformationLength,
26.         OUT PULONG ReturnLength OPTIONAL
27.         );
29. typedef NTSTATUS(NTAPI* LPFN_NTCREATETHREADEX)(
30.         OUT PHANDLE ThreadHandle,
31.         IN ACCESS_MASK DesiredAccess,
32.         IN PVOID ObjectAttributes,
33.         IN HANDLE ProcessHandle,
34.         IN PVOID StartAddress,
35.         IN PVOID Parameter,
36.         IN ULONG Flags,
37.         IN SIZE_T StackZeroBits,
38.         IN SIZE_T SizeOfStackCommit,
39.         IN SIZE_T SizeOfStackReserve,
40.         OUT PVOID ByteBuffer
41.         );
43. // -----------------------------------------------------------------------------------
44. // 结构体声明
45. // -----------------------------------------------------------------------------------
47. // SSDT表结构
48. typedef struct _SYSTEM_SERVICE_TABLE
49. {
50.         PVOID       ServiceTableBase;
51.         PVOID       ServiceCounterTableBase;
52.         ULONGLONG   NumberOfServices;
53.         PVOID       ParamTableBase;
54. } SYSTEM_SERVICE_TABLE, *PSYSTEM_SERVICE_TABLE;
56. PSYSTEM_SERVICE_TABLE KeServiceDescriptorTable;
58. typedef struct _PEB_LDR_DATA32
59. {
60.         ULONG Length;
61.         UCHAR Initialized;
62.         ULONG SsHandle;
63.         LIST_ENTRY32 InLoadOrderModuleList;
64.         LIST_ENTRY32 InMemoryOrderModuleList;
65.         LIST_ENTRY32 InInitializationOrderModuleList;
66. } PEB_LDR_DATA32, *PPEB_LDR_DATA32;
68. typedef struct _PEB_LDR_DATA
69. {
70.         ULONG Length;
71.         UCHAR Initialized;
72.         PVOID SsHandle;
73.         LIST_ENTRY InLoadOrderModuleList;
74.         LIST_ENTRY InMemoryOrderModuleList;
75.         LIST_ENTRY InInitializationOrderModuleList;
76. } PEB_LDR_DATA, *PPEB_LDR_DATA;
78. // PEB32/PEB64
79. typedef struct _PEB32
80. {
81.         UCHAR InheritedAddressSpace;
82.         UCHAR ReadImageFileExecOptions;
83.         UCHAR BeingDebugged;
84.         UCHAR BitField;
85.         ULONG Mutant;
86.         ULONG ImageBaseAddress;
87.         ULONG Ldr;
88.         ULONG ProcessParameters;
89.         ULONG SubSystemData;
90.         ULONG ProcessHeap;
91.         ULONG FastPebLock;
92.         ULONG AtlThunkSListPtr;
93.         ULONG IFEOKey;
94.         ULONG CrossProcessFlags;
95.         ULONG UserSharedInfoPtr;
96.         ULONG SystemReserved;
97.         ULONG AtlThunkSListPtr32;
98.         ULONG ApiSetMap;
99. } PEB32, *PPEB32;
101. typedef struct _PEB
102. {
103.         UCHAR InheritedAddressSpace;
104.         UCHAR ReadImageFileExecOptions;
105.         UCHAR BeingDebugged;
106.         UCHAR BitField;
107.         PVOID Mutant;
108.         PVOID ImageBaseAddress;
109.         PPEB_LDR_DATA Ldr;
110.         PVOID ProcessParameters;
111.         PVOID SubSystemData;
112.         PVOID ProcessHeap;
113.         PVOID FastPebLock;
114.         PVOID AtlThunkSListPtr;
115.         PVOID IFEOKey;
116.         PVOID CrossProcessFlags;
117.         PVOID KernelCallbackTable;
118.         ULONG SystemReserved;
119.         ULONG AtlThunkSListPtr32;
120.         PVOID ApiSetMap;
121. } PEB, *PPEB;
123. typedef struct _LDR_DATA_TABLE_ENTRY32
124. {
125.         LIST_ENTRY32 InLoadOrderLinks;
126.         LIST_ENTRY32 InMemoryOrderLinks;
127.         LIST_ENTRY32 InInitializationOrderLinks;
128.         ULONG DllBase;
129.         ULONG EntryPoint;
130.         ULONG SizeOfImage;
131.         UNICODE_STRING32 FullDllName;
132.         UNICODE_STRING32 BaseDllName;
133.         ULONG Flags;
134.         USHORT LoadCount;
135.         USHORT TlsIndex;
136.         LIST_ENTRY32 HashLinks;
137.         ULONG TimeDateStamp;
138. } LDR_DATA_TABLE_ENTRY32, *PLDR_DATA_TABLE_ENTRY32;
140. typedef struct _LDR_DATA_TABLE_ENTRY
141. {
142.         LIST_ENTRY InLoadOrderLinks;
143.         LIST_ENTRY InMemoryOrderLinks;
144.         LIST_ENTRY InInitializationOrderLinks;
145.         PVOID DllBase;
146.         PVOID EntryPoint;
147.         ULONG SizeOfImage;
148.         UNICODE_STRING FullDllName;
149.         UNICODE_STRING BaseDllName;
150.         ULONG Flags;
151.         USHORT LoadCount;
152.         USHORT TlsIndex;
153.         LIST_ENTRY HashLinks;
154.         ULONG TimeDateStamp;
155. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
157. typedef struct _THREAD_BASIC_INFORMATION
158. {
159.         NTSTATUS ExitStatus;
160.         PVOID TebBaseAddress;
161.         CLIENT_ID ClientId;
162.         ULONG_PTR AffinityMask;
163.         LONG Priority;
164.         LONG BasePriority;
165. } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
167. typedef struct _NT_PROC_THREAD_ATTRIBUTE_ENTRY
168. {
169.         ULONG Attribute;    // PROC_THREAD_ATTRIBUTE_XXX
170.         SIZE_T Size;
171.         ULONG_PTR Value;
172.         ULONG Unknown;
173. } NT_PROC_THREAD_ATTRIBUTE_ENTRY, *NT_PPROC_THREAD_ATTRIBUTE_ENTRY;
175. typedef struct _NT_PROC_THREAD_ATTRIBUTE_LIST
176. {
177.         ULONG Length;
178.         NT_PROC_THREAD_ATTRIBUTE_ENTRY Entry[1];
179. } NT_PROC_THREAD_ATTRIBUTE_LIST, *PNT_PROC_THREAD_ATTRIBUTE_LIST;
182. // 注入ShellCode结构
183. typedef struct _INJECT_BUFFER
184. {
185.         UCHAR Code[0x200];
186.         union
187.         {
188.                 UNICODE_STRING Path64;
189.                 UNICODE_STRING32 Path32;
190.         };
191.         wchar_t Buffer[488];
192.         PVOID ModuleHandle;
193.         ULONG Complete;
194.         NTSTATUS Status;
195. } INJECT_BUFFER, *PINJECT_BUFFER;
197. // -----------------------------------------------------------------------------------
198. // 一些开发中的通用函数封装，可任意拷贝使用
199. // -----------------------------------------------------------------------------------
201. // 传入函数名获取SSDT导出表RVA
202. // 参数1：传入函数名称
203. ULONG GetSSDTRVA(UCHAR *function_name)
204. {
205.         NTSTATUS Status;
206.         HANDLE FileHandle;
207.         IO_STATUS_BLOCK ioStatus;
208.         FILE_STANDARD_INFORMATION FileInformation;
210.         // 设置NTDLL路径
211.         UNICODE_STRING uniFileName;
212.         RtlInitUnicodeString(&uniFileName, L"\\SystemRoot\\system32\\ntoskrnl.exe");
214.         // 初始化打开文件的属性
215.         OBJECT_ATTRIBUTES objectAttributes;
216.         InitializeObjectAttributes(&objectAttributes, &uniFileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
218.         // 打开文件
219.         Status = IoCreateFile(&FileHandle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &objectAttributes, &ioStatus, 0, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0, CreateFileTypeNone, NULL, IO_NO_PARAMETER_CHECKING);
220.         if (!NT_SUCCESS(Status))
221.         {
222.                 return 0;
223.         }
225.         // 获取文件信息
226.         Status = ZwQueryInformationFile(FileHandle, &ioStatus, &FileInformation, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
227.         if (!NT_SUCCESS(Status))
228.         {
229.                 ZwClose(FileHandle);
230.                 return 0;
231.         }
233.         // 判断文件大小是否过大
234.         if (FileInformation.EndOfFile.HighPart != 0)
235.         {
236.                 ZwClose(FileHandle);
237.                 return 0;
238.         }
239.         // 取文件大小
240.         ULONG uFileSize = FileInformation.EndOfFile.LowPart;
242.         // 分配内存
243.         PVOID pBuffer = ExAllocatePoolWithTag(PagedPool, uFileSize + 0x100, (ULONG)"PGu");
244.         if (pBuffer == NULL)
245.         {
246.                 ZwClose(FileHandle);
247.                 return 0;
248.         }
250.         // 从头开始读取文件
251.         LARGE_INTEGER byteOffset;
252.         byteOffset.LowPart = 0;
253.         byteOffset.HighPart = 0;
254.         Status = ZwReadFile(FileHandle, NULL, NULL, NULL, &ioStatus, pBuffer, uFileSize, &byteOffset, NULL);
255.         if (!NT_SUCCESS(Status))
256.         {
257.                 ZwClose(FileHandle);
258.                 return 0;
259.         }
261.         // 取出导出表
262.         PIMAGE_DOS_HEADER pDosHeader;
263.         PIMAGE_NT_HEADERS pNtHeaders;
264.         PIMAGE_SECTION_HEADER pSectionHeader;
265.         ULONGLONG FileOffset;
266.         PIMAGE_EXPORT_DIRECTORY pExportDirectory;
268.         // DLL内存数据转成DOS头结构
269.         pDosHeader = (PIMAGE_DOS_HEADER)pBuffer;
271.         // 取出PE头结构
272.         pNtHeaders = (PIMAGE_NT_HEADERS)((ULONGLONG)pBuffer + pDosHeader->e_lfanew);
274.         // 判断PE头导出表表是否为空
275.         if (pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress == 0)
276.         {
277.                 return 0;
278.         }
280.         // 取出导出表偏移
281.         FileOffset = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
283.         // 取出节头结构
284.         pSectionHeader = (PIMAGE_SECTION_HEADER)((ULONGLONG)pNtHeaders + sizeof(IMAGE_NT_HEADERS));
285.         PIMAGE_SECTION_HEADER pOldSectionHeader = pSectionHeader;
287.         // 遍历节结构进行地址运算
288.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
289.         {
290.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
291.                 {
292.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
293.                 }
294.         }
296.         // 导出表地址
297.         pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)((ULONGLONG)pBuffer + FileOffset);
299.         // 取出导出表函数地址
300.         PULONG AddressOfFunctions;
301.         FileOffset = pExportDirectory->AddressOfFunctions;
303.         // 遍历节结构进行地址运算
304.         pSectionHeader = pOldSectionHeader;
305.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
306.         {
307.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
308.                 {
309.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
310.                 }
311.         }
312.         AddressOfFunctions = (PULONG)((ULONGLONG)pBuffer + FileOffset);
314.         // 取出导出表函数名字
315.         PUSHORT AddressOfNameOrdinals;
316.         FileOffset = pExportDirectory->AddressOfNameOrdinals;
318.         // 遍历节结构进行地址运算
319.         pSectionHeader = pOldSectionHeader;
320.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
321.         {
322.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
323.                 {
324.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
325.                 }
326.         }
327.         AddressOfNameOrdinals = (PUSHORT)((ULONGLONG)pBuffer + FileOffset);
329.         //取出导出表函数序号
330.         PULONG AddressOfNames;
331.         FileOffset = pExportDirectory->AddressOfNames;
333.         //遍历节结构进行地址运算
334.         pSectionHeader = pOldSectionHeader;
336.         // 循环所有节
337.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
338.         {
339.                 // 寻找符合条件的节
340.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
341.                 {
342.                         // 得到文件偏移
343.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
344.                 }
345.         }
346.         AddressOfNames = (PULONG)((ULONGLONG)pBuffer + FileOffset);
348.         //DbgPrint("\n AddressOfFunctions %llX AddressOfNameOrdinals %llX AddressOfNames %llX  \n", (ULONGLONG)AddressOfFunctions- (ULONGLONG)pBuffer, (ULONGLONG)AddressOfNameOrdinals- (ULONGLONG)pBuffer, (ULONGLONG)AddressOfNames- (ULONGLONG)pBuffer);
349.         //DbgPrint("\n AddressOfFunctions %llX AddressOfNameOrdinals %llX AddressOfNames %llX  \n", pExportDirectory->AddressOfFunctions, pExportDirectory->AddressOfNameOrdinals, pExportDirectory->AddressOfNames);
351.         // 开始分析导出表
352.         ULONG uOffset;
353.         LPSTR FunName;
354.         ULONG uAddressOfNames;
355.         ULONG TargetOff = 0;
357.         // 循环导出表
358.         for (ULONG uIndex = 0; uIndex < pExportDirectory->NumberOfNames; uIndex++, AddressOfNames++, AddressOfNameOrdinals++)
359.         {
360.                 uAddressOfNames = *AddressOfNames;
361.                 pSectionHeader = pOldSectionHeader;
362.                 for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
363.                 {
364.                         // 函数地址在某个范围内
365.                         if (pSectionHeader->VirtualAddress <= uAddressOfNames && uAddressOfNames <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
366.                         {
367.                                 uOffset = uAddressOfNames - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
368.                         }
369.                 }
371.                 // 得到函数名
372.                 FunName = (LPSTR)((ULONGLONG)pBuffer + uOffset);
374.                 // 判断是否符合要求
375.                 if (!_stricmp((const char *)function_name, FunName))
376.                 {
377.                         // 返回函数地址
378.                         TargetOff = (ULONG)AddressOfFunctions[*AddressOfNameOrdinals];
379.                         DbgPrint("索引 [ %p ] 函数名 [ %s ] 相对RVA [ %p ] \n", *AddressOfNameOrdinals, FunName, TargetOff);
380.                 }
382.         }
384.         ExFreePoolWithTag(pBuffer, (ULONG)"PGu");
385.         ZwClose(FileHandle);
386.         return TargetOff;
387. }
389. // 传入函数名 获取该函数所在模块下标
390. ULONG GetIndexByName(UCHAR *function_name)
391. {
392.         NTSTATUS Status;
393.         HANDLE FileHandle;
394.         IO_STATUS_BLOCK ioStatus;
395.         FILE_STANDARD_INFORMATION FileInformation;
397.         // 设置NTDLL路径
398.         UNICODE_STRING uniFileName;
399.         RtlInitUnicodeString(&uniFileName, L"\\SystemRoot\\system32\\ntdll.dll");
401.         // 初始化打开文件的属性
402.         OBJECT_ATTRIBUTES objectAttributes;
403.         InitializeObjectAttributes(&objectAttributes, &uniFileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
405.         // 打开文件
406.         Status = IoCreateFile(&FileHandle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &objectAttributes, &ioStatus, 0, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0, CreateFileTypeNone, NULL, IO_NO_PARAMETER_CHECKING);
407.         if (!NT_SUCCESS(Status))
408.         {
409.                 return 0;
410.         }
412.         // 获取文件信息
413.         Status = ZwQueryInformationFile(FileHandle, &ioStatus, &FileInformation, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
414.         if (!NT_SUCCESS(Status))
415.         {
416.                 ZwClose(FileHandle);
417.                 return 0;
418.         }
420.         // 判断文件大小是否过大
421.         if (FileInformation.EndOfFile.HighPart != 0)
422.         {
423.                 ZwClose(FileHandle);
424.                 return 0;
425.         }
427.         // 取文件大小
428.         ULONG uFileSize = FileInformation.EndOfFile.LowPart;
430.         // 分配内存
431.         PVOID pBuffer = ExAllocatePoolWithTag(PagedPool, uFileSize + 0x100, (ULONG)"Ntdl");
432.         if (pBuffer == NULL)
433.         {
434.                 ZwClose(FileHandle);
435.                 return 0;
436.         }
438.         // 从头开始读取文件
439.         LARGE_INTEGER byteOffset;
440.         byteOffset.LowPart = 0;
441.         byteOffset.HighPart = 0;
442.         Status = ZwReadFile(FileHandle, NULL, NULL, NULL, &ioStatus, pBuffer, uFileSize, &byteOffset, NULL);
443.         if (!NT_SUCCESS(Status))
444.         {
445.                 ZwClose(FileHandle);
446.                 return 0;
447.         }
449.         // 取出导出表
450.         PIMAGE_DOS_HEADER pDosHeader;
451.         PIMAGE_NT_HEADERS pNtHeaders;
452.         PIMAGE_SECTION_HEADER pSectionHeader;
453.         ULONGLONG FileOffset;
454.         PIMAGE_EXPORT_DIRECTORY pExportDirectory;
456.         // DLL内存数据转成DOS头结构
457.         pDosHeader = (PIMAGE_DOS_HEADER)pBuffer;
459.         // 取出PE头结构
460.         pNtHeaders = (PIMAGE_NT_HEADERS)((ULONGLONG)pBuffer + pDosHeader->e_lfanew);
462.         // 判断PE头导出表表是否为空
463.         if (pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress == 0)
464.         {
465.                 return 0;
466.         }
468.         // 取出导出表偏移
469.         FileOffset = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
471.         // 取出节头结构
472.         pSectionHeader = (PIMAGE_SECTION_HEADER)((ULONGLONG)pNtHeaders + sizeof(IMAGE_NT_HEADERS));
473.         PIMAGE_SECTION_HEADER pOldSectionHeader = pSectionHeader;
475.         // 遍历节结构进行地址运算
476.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
477.         {
478.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
479.                 {
480.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
481.                 }
482.         }
484.         // 导出表地址
485.         pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)((ULONGLONG)pBuffer + FileOffset);
487.         // 取出导出表函数地址
488.         PULONG AddressOfFunctions;
489.         FileOffset = pExportDirectory->AddressOfFunctions;
491.         // 遍历节结构进行地址运算
492.         pSectionHeader = pOldSectionHeader;
493.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
494.         {
495.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
496.                 {
497.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
498.                 }
499.         }
501.         // 此处需要注意foa和rva转换过程
502.         AddressOfFunctions = (PULONG)((ULONGLONG)pBuffer + FileOffset);
504.         // 取出导出表函数名字
505.         PUSHORT AddressOfNameOrdinals;
506.         FileOffset = pExportDirectory->AddressOfNameOrdinals;
508.         // 遍历节结构进行地址运算
509.         pSectionHeader = pOldSectionHeader;
510.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
511.         {
512.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
513.                 {
514.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
515.                 }
516.         }
518.         // 此处需要注意foa和rva转换过程
519.         AddressOfNameOrdinals = (PUSHORT)((ULONGLONG)pBuffer + FileOffset);
521.         // 取出导出表函数序号
522.         PULONG AddressOfNames;
523.         FileOffset = pExportDirectory->AddressOfNames;
525.         // 遍历节结构进行地址运算
526.         pSectionHeader = pOldSectionHeader;
527.         for (UINT16 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
528.         {
529.                 if (pSectionHeader->VirtualAddress <= FileOffset && FileOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
530.                 {
531.                         FileOffset = FileOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
532.                 }
533.         }
535.         // 此处需要注意foa和rva转换过程
536.         AddressOfNames = (PULONG)((ULONGLONG)pBuffer + FileOffset);
538.         // 分析导出表
539.         ULONG uNameOffset;
540.         ULONG uOffset;
541.         LPSTR FunName;
542.         PVOID pFuncAddr;
543.         ULONG uServerIndex;
544.         ULONG uAddressOfNames;
546.         for (ULONG uIndex = 0; uIndex < pExportDirectory->NumberOfNames; uIndex++, AddressOfNames++, AddressOfNameOrdinals++)
547.         {
548.                 uAddressOfNames = *AddressOfNames;
549.                 pSectionHeader = pOldSectionHeader;
550.                 for (UINT32 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
551.                 {
552.                         if (pSectionHeader->VirtualAddress <= uAddressOfNames && uAddressOfNames <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
553.                         {
554.                                 uOffset = uAddressOfNames - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
555.                         }
556.                 }
558.                 FunName = (LPSTR)((ULONGLONG)pBuffer + uOffset);
560.                 // 判断开头是否是Zw
561.                 if (FunName[0] == 'Z' && FunName[1] == 'w')
562.                 {
563.                         pSectionHeader = pOldSectionHeader;
565.                         // 如果是则根据AddressOfNameOrdinals得到文件偏移
566.                         uOffset = (ULONG)AddressOfFunctions[*AddressOfNameOrdinals];
568.                         for (UINT32 Index = 0; Index < pNtHeaders->FileHeader.NumberOfSections; Index++, pSectionHeader++)
569.                         {
570.                                 if (pSectionHeader->VirtualAddress <= uOffset && uOffset <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData)
571.                                 {
572.                                         uNameOffset = uOffset - pSectionHeader->VirtualAddress + pSectionHeader->PointerToRawData;
573.                                 }
574.                         }
576.                         pFuncAddr = (PVOID)((ULONGLONG)pBuffer + uNameOffset);
577.                         uServerIndex = *(PULONG)((ULONGLONG)pFuncAddr + 4);
578.                         FunName[0] = 'N';
579.                         FunName[1] = 't';
581.                         // 获得指定的编号
582.                         if (!_stricmp(FunName, (const char *)function_name))
583.                         {
584.                                 ExFreePoolWithTag(pBuffer, (ULONG)"Ntdl");
585.                                 ZwClose(FileHandle);
586.                                 return uServerIndex;
587.                         }
588.                 }
589.         }
591.         ExFreePoolWithTag(pBuffer, (ULONG)"Ntdl");
592.         ZwClose(FileHandle);
593.         return 0;
594. }
596. // 获取模块导出函数
597. PVOID GetModuleExportAddress(IN PVOID ModuleBase, IN PCCHAR FunctionName, IN PEPROCESS EProcess)
598. {
599.         PIMAGE_DOS_HEADER ImageDosHeader = (PIMAGE_DOS_HEADER)ModuleBase;
600.         PIMAGE_NT_HEADERS32 ImageNtHeaders32 = NULL;
601.         PIMAGE_NT_HEADERS64 ImageNtHeaders64 = NULL;
602.         PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = NULL;
603.         ULONG ExportDirectorySize = 0;
604.         ULONG_PTR FunctionAddress = 0;
606.         if (ModuleBase == NULL)
607.         {
608.                 return NULL;
609.         }
611.         if (ImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
612.         {
613.                 return NULL;
614.         }
616.         ImageNtHeaders32 = (PIMAGE_NT_HEADERS32)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
617.         ImageNtHeaders64 = (PIMAGE_NT_HEADERS64)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
619.         // 判断PE结构位数
620.         if (ImageNtHeaders64->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
621.         {
622.                 ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
623.                 ExportDirectorySize = ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
624.         }
625.         else
626.         {
627.                 ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
628.                 ExportDirectorySize = ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
629.         }
631.         // 解析内存导出表
632.         PUSHORT pAddressOfOrds = (PUSHORT)(ImageExportDirectory->AddressOfNameOrdinals + (ULONG_PTR)ModuleBase);
633.         PULONG  pAddressOfNames = (PULONG)(ImageExportDirectory->AddressOfNames + (ULONG_PTR)ModuleBase);
634.         PULONG  pAddressOfFuncs = (PULONG)(ImageExportDirectory->AddressOfFunctions + (ULONG_PTR)ModuleBase);
636.         for (ULONG i = 0; i < ImageExportDirectory->NumberOfFunctions; ++i)
637.         {
638.                 USHORT OrdIndex = 0xFFFF;
639.                 PCHAR  pName = NULL;
641.                 // 如果函数名小于等于0xFFFF 则说明是序号导出
642.                 if ((ULONG_PTR)FunctionName <= 0xFFFF)
643.                 {
644.                         OrdIndex = (USHORT)i;
645.                 }
647.                 // 否则则说明是名字导出
648.                 else if ((ULONG_PTR)FunctionName > 0xFFFF && i < ImageExportDirectory->NumberOfNames)
649.                 {
650.                         pName = (PCHAR)(pAddressOfNames[i] + (ULONG_PTR)ModuleBase);
651.                         OrdIndex = pAddressOfOrds[i];
652.                 }
654.                 // 未知导出函数
655.                 else
656.                 {
657.                         return NULL;
658.                 }
660.                 // 对比模块名是否是我们所需要的
661.                 if (((ULONG_PTR)FunctionName <= 0xFFFF && (USHORT)((ULONG_PTR)FunctionName) == OrdIndex + ImageExportDirectory->Base) || ((ULONG_PTR)FunctionName > 0xFFFF && strcmp(pName, FunctionName) == 0))
662.                 {
663.                         // 是则保存下来
664.                         FunctionAddress = pAddressOfFuncs[OrdIndex] + (ULONG_PTR)ModuleBase;
665.                         break;
666.                 }
667.         }
668.         return (PVOID)FunctionAddress;
669. }
671. // 获取指定用户模块基址
672. PVOID GetUserModuleAddress(IN PEPROCESS EProcess, IN PUNICODE_STRING ModuleName, IN BOOLEAN IsWow64)
673. {
674.         if (EProcess == NULL)
675.         {
676.                 return NULL;
677.         }
679.         __try
680.         {
681.                 // 定时250ms毫秒
682.                 LARGE_INTEGER Time = { 0 };
683.                 Time.QuadPart = -250ll * 10 * 1000;
685.                 // 32位执行
686.                 if (IsWow64)
687.                 {
688.                         // 得到进程PEB进程环境块
689.                         PPEB32 Peb32 = (PPEB32)PsGetProcessWow64Process(EProcess);
690.                         if (Peb32 == NULL)
691.                         {
692.                                 return NULL;
693.                         }
695.                         // 等待 250ms * 10
696.                         for (INT i = 0; !Peb32->Ldr && i < 10; i++)
697.                         {
698.                                 // 等待一会在执行
699.                                 KeDelayExecutionThread(KernelMode, TRUE, &Time);
700.                         }
702.                         // 没有找到返回空
703.                         if (!Peb32->Ldr)
704.                         {
705.                                 return NULL;
706.                         }
708.                         // 搜索 InLoadOrderModuleList
709.                         for (PLIST_ENTRY32 ListEntry = (PLIST_ENTRY32)((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList.Flink; ListEntry != &((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList; ListEntry = (PLIST_ENTRY32)ListEntry->Flink)
710.                         {
711.                                 UNICODE_STRING UnicodeString;
712.                                 PLDR_DATA_TABLE_ENTRY32 LdrDataTableEntry32 = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks);
713.                                 RtlUnicodeStringInit(&UnicodeString, (PWCH)LdrDataTableEntry32->BaseDllName.Buffer);
715.                                 // 判断模块名是否符合要求
716.                                 if (RtlCompareUnicodeString(&UnicodeString, ModuleName, TRUE) == 0)
717.                                 {
718.                                         // 符合则返回模块基址
719.                                         return (PVOID)LdrDataTableEntry32->DllBase;
720.                                 }
721.                         }
722.                 }
724.                 // 64位执行
725.                 else
726.                 {
727.                         // 得到进程PEB进程环境块
728.                         PPEB Peb = PsGetProcessPeb(EProcess);
729.                         if (!Peb)
730.                         {
731.                                 return NULL;
732.                         }
734.                         // 等待
735.                         for (INT i = 0; !Peb->Ldr && i < 10; i++)
736.                         {
737.                                 // 将当前线程置于指定间隔的可警报或不可操作的等待状态
738.                                 KeDelayExecutionThread(KernelMode, TRUE, &Time);
739.                         }
740.                         if (!Peb->Ldr)
741.                         {
742.                                 return NULL;
743.                         }
745.                         // 遍历链表
746.                         for (PLIST_ENTRY ListEntry = Peb->Ldr->InLoadOrderModuleList.Flink; ListEntry != &Peb->Ldr->InLoadOrderModuleList; ListEntry = ListEntry->Flink)
747.                         {
748.                                 PLDR_DATA_TABLE_ENTRY LdrDataTableEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
750.                                 // 判断模块名是否符合要求
751.                                 if (RtlCompareUnicodeString(&LdrDataTableEntry->BaseDllName, ModuleName, TRUE) == 0)
752.                                 {
753.                                         // 返回模块基址
754.                                         return LdrDataTableEntry->DllBase;
755.                                 }
756.                         }
757.                 }
758.         }
759.         __except (EXCEPTION_EXECUTE_HANDLER)
760.         {
761.                 return NULL;
762.         }
764.         return NULL;
765. }
767. //得到ntos的基址
768. ULONGLONG GetOsBaseAddress(PDRIVER_OBJECT pDriverObject)
769. {
770.         UNICODE_STRING osName = { 0 };
771.         WCHAR wzData[0x100] = L"ntoskrnl.exe";
773.         RtlInitUnicodeString(&osName, wzData);
775.         LDR_DATA_TABLE_ENTRY *pDataTableEntry, *pTempDataTableEntry;
777.         // 双循环链表定义
778.         PLIST_ENTRY pList;
780.         // 指向驱动对象的DriverSection
781.         pDataTableEntry = (LDR_DATA_TABLE_ENTRY*)pDriverObject->DriverSection;
783.         // 判断是否为空
784.         if (!pDataTableEntry)
785.         {
786.                 return 0;
787.         }
789.         // 得到链表地址
790.         pList = pDataTableEntry->InLoadOrderLinks.Flink;
792.         // 判断是否等于头部
793.         while (pList != &pDataTableEntry->InLoadOrderLinks)
794.         {
795.                 pTempDataTableEntry = (LDR_DATA_TABLE_ENTRY *)pList;
797.                 // 如果是ntoskrnl.exe则返回该模块基址
798.                 if (RtlEqualUnicodeString(&pTempDataTableEntry->BaseDllName, &osName, TRUE))
799.                 {
800.                         return (ULONGLONG)pTempDataTableEntry->DllBase;
801.                 }
802.                 pList = pList->Flink;
803.         }
804.         return 0;
805. }
807. // 得到SSDT表的基地址
808. ULONGLONG GetKeServiceDescriptorTable64(PDRIVER_OBJECT DriverObject)
809. {
811.         /*
812.         nt!KiSystemServiceUser+0xdc:
813.         fffff806`42c79987 8bf8            mov     edi,eax
814.         fffff806`42c79989 c1ef07          shr     edi,7
815.         fffff806`42c7998c 83e720          and     edi,20h
816.         fffff806`42c7998f 25ff0f0000      and     eax,0FFFh
818.         nt!KiSystemServiceRepeat:
819.         fffff806`42c79994 4c8d15e59e3b00  lea     r10,[nt!KeServiceDescriptorTable (fffff806`43033880)]
820.         fffff806`42c7999b 4c8d1dde203a00  lea     r11,[nt!KeServiceDescriptorTableShadow (fffff806`4301ba80)]
821.         fffff806`42c799a2 f7437880000000  test    dword ptr [rbx+78h],80h
822.         fffff806`42c799a9 7413            je      nt!KiSystemServiceRepeat+0x2a (fffff806`42c799be)
823.         */
824.         char KiSystemServiceStart_pattern[14] = "\x8B\xF8\xC1\xEF\x07\x83\xE7\x20\x25\xFF\x0F\x00\x00";
826.         /*
827.         ULONG rva = GetRvaFromModule(L"\\SystemRoot\\system32\\ntoskrnl.exe", "_stricmp");
828.         DbgPrint("NtReadFile VA = %p \n", rva);
829.         ULONG _stricmp_offset = 0x19d710;
830.         */
832.         ULONGLONG CodeScanStart = GetSSDTRVA((UCHAR *)"_stricmp") + GetOsBaseAddress(DriverObject);
834.         ULONGLONG i, tbl_address, b;
835.         for (i = 0; i < 0x50000; i++)
836.         {
837.                 // 比较特征
838.                 if (!memcmp((char*)(ULONGLONG)CodeScanStart + i, (char*)KiSystemServiceStart_pattern, 13))
839.                 {
840.                         for (b = 0; b < 50; b++)
841.                         {
842.                                 tbl_address = ((ULONGLONG)CodeScanStart + i + b);
844.                                 // 4c 8d 15 e5 9e 3b 00  lea r10,[nt!KeServiceDescriptorTable (fffff802`64da4880)]
845.                                 // if (*(USHORT*)((ULONGLONG)tbl_address) == (USHORT)0x158d4c)
846.                                 if (*(USHORT*)((ULONGLONG)tbl_address) == (USHORT)0x8d4c)
847.                                 {
848.                                         return ((LONGLONG)tbl_address + 7) + *(LONG*)(tbl_address + 3);
849.                                 }
850.                         }
851.                 }
852.         }
853.         return 0;
854. }
856. // 根据SSDT序号得到函数基址
857. ULONGLONG GetSSDTFuncCurAddr(ULONG index)
858. {
859.         /*
860.         mov rax, rcx                   ; rcx=Native API 的 index
861.         lea r10,[rdx]                  ; rdx=ssdt 基址
862.         mov edi,eax                    ; index
863.         shr edi,7
864.         and edi,20h
865.         mov r10, qword ptr [r10+rdi]   ; ServiceTableBase
866.         movsxd r11,dword ptr [r10+rax] ; 没有右移的假ssdt的地址
867.         mov rax,r11
868.         sar r11,4
869.         add r10,r11
870.         mov rax,r10
871.         ret
872.         */
873.         LONG dwtmp = 0;
874.         PULONG ServiceTableBase = NULL;
875.         ServiceTableBase = (PULONG)KeServiceDescriptorTable->ServiceTableBase;
876.         dwtmp = ServiceTableBase[index];
878.         // 先右移4位之后加上基地址 就可以得到ssdt的地址
879.         dwtmp = dwtmp >> 4;
881.         return (LONGLONG)dwtmp + (ULONGLONG)ServiceTableBase;
882. }
884. // 根据进程ID返回进程EPROCESS
885. PEPROCESS LookupProcess(HANDLE Pid)
886. {
887.         PEPROCESS eprocess = NULL;
888.         if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
889.         {
890.                 return eprocess;
891.         }
892.         else
893.         {
894.                 return NULL;
895.         }
896. }
898. // 根据用户传入进程名得到该进程PID
899. HANDLE GetProcessID(PCHAR ProcessName)
900. {
901.         ULONG i = 0;
902.         PEPROCESS eproc = NULL;
903.         for (i = 4; i<100000000; i = i + 4)
904.         {
905.                 eproc = LookupProcess((HANDLE)i);
906.                 if (eproc != NULL)
907.                 {
908.                         ObDereferenceObject(eproc);
910.                         // 根据进程名得到进程EPEPROCESS
911.                         if (strstr(PsGetProcessImageFileName(eproc), ProcessName) != NULL)
912.                         {
913.                                 return PsGetProcessId(eproc);
914.                         }
915.                 }
916.         }
917.         return NULL;
918. }

复制代码

编译并运行如上代码片段，即可输出下标为10，11，12的SSDT函数基址，效果图如下所示；

GetSSDTRVA: 根据传入的函数名获取该函数的RVA地址，用户传入一个特定模块下导出函数的函数名，动态得到该函数的相对偏移地址。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. VOID Unload(PDRIVER_OBJECT pDriverObj)
9. {
10.         DbgPrint("[-] 驱动卸载 \n");
11. }
13. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
14. {
15.         DbgPrint("Hello LyShark.com \n");
17.         ULONGLONG kernel_base = GetOsBaseAddress(DriverObject);
18.         DbgPrint("ntoskrnl.exe 模块基址: %p \n", kernel_base);
20.         DriverObject->DriverUnload = Unload;
21.         return STATUS_SUCCESS;
22. }

复制代码

编译并运行如上代码片段，即可输出NtReadFile,NtCreateEnlistment两个内核函数的RVA地址，效果图如下所示；

GetIndexByName: 该函数接收用户传入的一个SSDT函数名，并返回该函数所对应的下标，调用代码如下；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. VOID Unload(PDRIVER_OBJECT pDriverObj)
9. {
10.         DbgPrint("[-] 驱动卸载 \n");
11. }
13. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
14. {
15.         DbgPrint("Hello LyShark.com \n");
17.         // 得到SSDT基地址
18.         KeServiceDescriptorTable = (PSYSTEM_SERVICE_TABLE)GetKeServiceDescriptorTable64(DriverObject);
19.         DbgPrint("SSDT基地址: %p \n", KeServiceDescriptorTable->ServiceTableBase);
21.         // 根据序号得到指定函数地址
22.         ULONGLONG address = NULL;
23.        
24.         address = GetSSDTFuncCurAddr(10);
25.         DbgPrint("得到函数地址: %p \n", address);
27.         address = GetSSDTFuncCurAddr(11);
28.         DbgPrint("得到函数地址: %p \n", address);
30.         address = GetSSDTFuncCurAddr(12);
31.         DbgPrint("得到函数地址: %p \n", address);
33.         DriverObject->DriverUnload = Unload;
34.         return STATUS_SUCCESS;
35. }

复制代码

编译并运行如上代码片段，即可输出NtCreateThreadEx,NtReadFile两个内核函数的下标，效果图如下所示；

GetUserModuleAddress: 该函数用于获取进程模块基址，在内核模式下附加到应用层指定进程上，并动态获取到该进程所加载的指定模块的基址，调用代码如下；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. VOID Unload(PDRIVER_OBJECT pDriverObj)
9. {
10.         DbgPrint("[-] 驱动卸载 \n");
11. }
13. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
14. {
15.         DbgPrint("Hello LyShark.com \n");
17.         ULONG64 ReadFile_RVA = GetSSDTRVA("NtReadFile");
18.         DbgPrint("NtReadFile = %p \n", ReadFile_RVA);
20.         ULONG64 NtCreateEnlistment_RVA = GetSSDTRVA("NtCreateEnlistment");
21.         DbgPrint("NtCreateEnlistment = %p \n", NtCreateEnlistment_RVA);
23.         DriverObject->DriverUnload = Unload;
24.         return STATUS_SUCCESS;
25. }

复制代码

编译并运行如上代码片段，则获取进程PID=6932里面的ntdll.dll模块的基址，输出效果图如下所示；

GetModuleExportAddress: 该函数可用于获取特定模块中特定函数的基址，此功能需要配合获取模块基址一起使用，调用代码如下；

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. VOID Unload(PDRIVER_OBJECT pDriverObj)
9. {
10.         DbgPrint("[-] 驱动卸载 \n");
11. }
13. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
14. {
15.         DbgPrint("Hello LyShark.com \n");
17.         ULONG index1 = GetIndexByName((UCHAR *)"NtCreateThreadEx");
18.         DbgPrint("函数NtCreateThreadEx下标: %d \n", index1);
20.         ULONG index2 = GetIndexByName((UCHAR *)"NtReadFile");
21.         DbgPrint("函数NtReadFile下标: %d \n", index2);
23.         DriverObject->DriverUnload = Unload;
24.         return STATUS_SUCCESS;
25. }

复制代码

编译并运行如上代码片段，则获取进程PID=6932里面的ntdll.dll模块里的LdrLoadDll函数基址，输出效果图如下所示；

SeCreateThreadEx: 该函数则是实际执行注入的函数，此段代码中需要注意的是pPrevMode中的偏移值，每个系统中都不相同，用户需要自行在WinDBG中输入!_KTHREAD得到线程信息，并找到PreviousMode字段，该字段中的偏移值需要(PUCHAR)PsGetCurrentThread() + 0x232才可得到正确位置。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: me@lyshark.com
6. #include "lyshark.h"
8. VOID Unload(PDRIVER_OBJECT pDriverObj)
9. {
10.         DbgPrint("[-] 驱动卸载 \n");
11. }
13. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
14. {
15.         DbgPrint("Hello LyShark.com \n");
17.         HANDLE ProcessID = (HANDLE)6932;
19.         PEPROCESS EProcess = NULL;
20.         NTSTATUS Status = STATUS_SUCCESS;
21.         KAPC_STATE ApcState;
23.         // 根据PID得到进程EProcess结构
24.         Status = PsLookupProcessByProcessId(ProcessID, &EProcess);
25.         if (Status != STATUS_SUCCESS)
26.         {
27.                 DbgPrint("[-] 获取EProcessID失败 \n");
28.                 return Status;
29.         }
31.         // 判断目标进程是32位还是64位
32.         BOOLEAN IsWow64 = (PsGetProcessWow64Process(EProcess) != NULL) ? TRUE : FALSE;
34.         // 验证地址是否可读
35.         if (!MmIsAddressValid(EProcess))
36.         {
37.                 DbgPrint("[-] 地址不可读 \n");
38.                 DriverObject->DriverUnload = Unload;
39.                 return STATUS_SUCCESS;
40.         }
42.         // 将当前线程连接到目标进程的地址空间(附加进程)
43.         KeStackAttachProcess((PRKPROCESS)EProcess, &ApcState);
45.         __try
46.         {
47.                 UNICODE_STRING NtdllUnicodeString = { 0 };
48.                 PVOID NtdllAddress = NULL;
50.                 // 得到进程内ntdll.dll模块基地址
51.                 RtlInitUnicodeString(&NtdllUnicodeString, L"Ntdll.dll");
53.                 NtdllAddress = GetUserModuleAddress(EProcess, &NtdllUnicodeString, IsWow64);
55.                 if (!NtdllAddress)
56.                 {
57.                         DbgPrint("[-] 没有找到基址 \n");
58.                         DriverObject->DriverUnload = Unload;
59.                         return STATUS_SUCCESS;
60.                 }
62.                 DbgPrint("[*] 模块ntdll.dll基址: %p \n", NtdllAddress);
63.         }
64.         __except (EXCEPTION_EXECUTE_HANDLER)
65.         {
66.         }
68.         // 取消附加
69.         KeUnstackDetachProcess(&ApcState);
70.         DriverObject->DriverUnload = Unload;
71.         return STATUS_SUCCESS;
72. }

复制代码

运行如上这段代码片段，将编译好的DLL文件放入到C：\\hook.dll目录下，并运行x32.exe程序，手动加载驱动即可注入成功，输出效果图如下所示；

回到应用层进程中，可看到我们的DLL已经被注入到目标进程内了，效果图如下所示；

参考文献

Blackbone OpenSource

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