驱动开发：内核R3与R0内存映射拷贝

在上一篇博文《驱动开发：内核通过PEB得到进程参数》中我们通过使用KeStackAttachProcess附加进程的方式得到了该进程的PEB结构信息，本篇文章同样需要使用进程附加功能，但这次我们将实现一个更加有趣的功能，在某些情况下应用层与内核层需要共享一片内存区域通过这片区域可打通内核与应用层的隔离，此类功能的实现依附于MDL内存映射机制实现。
应用层(R3)数据映射到内核层(R0)
先来实现将R3内存数据拷贝到R0中，功能实现所调用的API如下:

• IoAllocateMdl 该函数用于创建MDL(类似初始化)
  
• MmProbeAndLockPages 用于锁定创建的地址其中UserMode代表用户层,IoReadAccess以读取的方式锁定
  
• MmGetSystemAddressForMdlSafe 用于从MDL中得到映射内存地址
  
• RtlCopyMemory 用于内存拷贝,将DstAddr应用层中的数据拷贝到pMappedSrc中
  
• MmUnlockPages 拷贝结束后解锁pSrcMdl
  
• IoFreeMdl 释放MDL
  

内存拷贝SafeCopyMemory_R3_to_R0函数封装代码如下:

1. #include <ntifs.h>
2. #include <windef.h>
4. // 分配内存
5. void* RtlAllocateMemory(BOOLEAN InZeroMemory, SIZE_T InSize)
6. {
7.         void* Result = ExAllocatePoolWithTag(NonPagedPool, InSize, 'lysh');
8.         if (InZeroMemory && (Result != NULL))
9.                 RtlZeroMemory(Result, InSize);
10.         return Result;
11. }
13. // 释放内存
14. void RtlFreeMemory(void* InPointer)
15. {
16.         ExFreePool(InPointer);
17. }
19. /*
20. 将应用层中的内存复制到内核变量中
22. SrcAddr  r3地址要复制
23. DstAddr  R0申请的地址
24. Size     拷贝长度
25. */
26. NTSTATUS SafeCopyMemory_R3_to_R0(ULONG_PTR SrcAddr, ULONG_PTR DstAddr, ULONG Size)
27. {
28.         NTSTATUS status = STATUS_UNSUCCESSFUL;
29.         ULONG nRemainSize = PAGE_SIZE - (SrcAddr & 0xFFF);
30.         ULONG nCopyedSize = 0;
32.         if (!SrcAddr || !DstAddr || !Size)
33.         {
34.                 return status;
35.         }
37.         while (nCopyedSize < Size)
38.         {
39.                 PMDL pSrcMdl = NULL;
40.                 PVOID pMappedSrc = NULL;
42.                 if (Size - nCopyedSize < nRemainSize)
43.                 {
44.                         nRemainSize = Size - nCopyedSize;
45.                 }
47.                 // 创建MDL
48.                 pSrcMdl = IoAllocateMdl((PVOID)(SrcAddr & 0xFFFFFFFFFFFFF000), PAGE_SIZE, FALSE, FALSE, NULL);
49.                 if (pSrcMdl)
50.                 {
51.                         __try
52.                         {
53.                                 // 锁定内存页面(UserMode代表应用层)
54.                                 MmProbeAndLockPages(pSrcMdl, UserMode, IoReadAccess);
56.                                 // 从MDL中得到映射内存地址
57.                                 pMappedSrc = MmGetSystemAddressForMdlSafe(pSrcMdl, NormalPagePriority);
58.                         }
59.                         __except (EXCEPTION_EXECUTE_HANDLER)
60.                         {
61.                         }
62.                 }
64.                 if (pMappedSrc)
65.                 {
66.                         __try
67.                         {
68.                                 // 将MDL中的映射拷贝到pMappedSrc内存中
69.                                 RtlCopyMemory((PVOID)DstAddr, (PVOID)((ULONG_PTR)pMappedSrc + (SrcAddr & 0xFFF)), nRemainSize);
70.                         }
71.                         __except (1)
72.                         {
73.                                 // 拷贝内存异常
74.                         }
76.                         // 释放锁
77.                         MmUnlockPages(pSrcMdl);
78.                 }
80.                 if (pSrcMdl)
81.                 {
82.                         // 释放MDL
83.                         IoFreeMdl(pSrcMdl);
84.                 }
86.                 if (nCopyedSize)
87.                 {
88.                         nRemainSize = PAGE_SIZE;
89.                 }
91.                 nCopyedSize += nRemainSize;
92.                 SrcAddr += nRemainSize;
93.                 DstAddr += nRemainSize;
94.         }
96.         status = STATUS_SUCCESS;
97.         return status;
98. }

复制代码

调用该函数实现拷贝，如下代码中首先PsLookupProcessByProcessId得到进程EProcess结构，并KeStackAttachProcess附加进程，声明pTempBuffer指针用于存储RtlAllocateMemory开辟的内存空间，nSize则代表读取应用层进程数据长度，ModuleBase则是读入进程基址，调用SafeCopyMemory_R3_to_R0即可将应用层数据拷贝到内核空间，并最终BYTE* data转为BYTE字节的方式输出。

1. VOID UnDriver(PDRIVER_OBJECT driver)
2. {
3.         DbgPrint(("Uninstall Driver Is OK \n"));
4. }
6. // lyshark.com
7. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
8. {
9.         DbgPrint("hello lyshark.com \n");
11.         NTSTATUS status = STATUS_UNSUCCESSFUL;
12.         PEPROCESS eproc = NULL;
13.         KAPC_STATE kpc = { 0 };
15.         __try
16.         {
17.                 // HANDLE 进程PID
18.                 status = PsLookupProcessByProcessId((HANDLE)4556, &eproc);
20.                 if (NT_SUCCESS(status))
21.                 {
22.                         // 附加进程
23.                         KeStackAttachProcess(eproc, &kpc);
25.                         // -------------------------------------------------------------------
26.                         // 开始映射
27.                         // -------------------------------------------------------------------
29.                         // 将用户空间内存映射到内核空间
30.                         PVOID pTempBuffer = NULL;
31.                         ULONG nSize = 0x1024;
32.                         ULONG_PTR ModuleBase = 0x0000000140001000;
34.                         // 分配内存
35.                         pTempBuffer = RtlAllocateMemory(TRUE, nSize);
36.                         if (pTempBuffer)
37.                         {
38.                                 // 拷贝数据到R0
39.                                 status = SafeCopyMemory_R3_to_R0(ModuleBase, (ULONG_PTR)pTempBuffer, nSize);
40.                                 if (NT_SUCCESS(status))
41.                                 {
42.                                         DbgPrint("[*] 拷贝应用层数据到内核里 \n");
43.                                 }
45.                                 // 转成BYTE方便读取
46.                                 BYTE* data = pTempBuffer;
48.                                 for (size_t i = 0; i < 10; i++)
49.                                 {
50.                                         DbgPrint("%02X \n", data[i]);
51.                                 }
52.                         }
54.                         // 释放空间
55.                         RtlFreeMemory(pTempBuffer);
57.                         // 脱离进程
58.                         KeUnstackDetachProcess(&kpc);
59.                 }
60.         }
61.         __except (EXCEPTION_EXECUTE_HANDLER)
62.         {
63.                 Driver->DriverUnload = UnDriver;
64.                 return STATUS_SUCCESS;
65.         }
67.         Driver->DriverUnload = UnDriver;
68.         return STATUS_SUCCESS;
69. }

复制代码

代码运行后即可将进程中0x0000000140001000处的数据读入内核空间并输出：


内核层(R0)数据映射到应用层(R3)
与上方功能实现相反SafeCopyMemory_R0_to_R3函数则用于将一个内核层中的缓冲区写出到应用层中，写出过程:

• IoAllocateMdl 分别调用MDL分配,源地址SrcAddr目标地址DstAddr均创建
  
• MmBuildMdlForNonPagedPool 该 MDL 指定非分页虚拟内存缓冲区，并对其进行更新以描述基础物理页
  
• MmGetSystemAddressForMdlSafe 调用两次得到源地址，分别获取pSrcMdl,pDstMdl两个MDL的
  
• MmProbeAndLockPages 以写入方式锁定用户层中pDstMdl的地址
  

内存拷贝SafeCopyMemory_R0_to_R3函数封装代码如下:

1. // 分配内存
2. void* RtlAllocateMemory(BOOLEAN InZeroMemory, SIZE_T InSize)
3. {
4.         void* Result = ExAllocatePoolWithTag(NonPagedPool, InSize, 'lysh');
5.         if (InZeroMemory && (Result != NULL))
6.                 RtlZeroMemory(Result, InSize);
7.         return Result;
8. }
10. // 释放内存
11. void RtlFreeMemory(void* InPointer)
12. {
13.         ExFreePool(InPointer);
14. }
16. /*
17. 将内存中的数据复制到R3中
19. SrcAddr  R0要复制的地址
20. DstAddr  返回R3的地址
21. Size     拷贝长度
22. */
23. NTSTATUS SafeCopyMemory_R0_to_R3(PVOID SrcAddr, PVOID DstAddr, ULONG Size)
24. {
25.         PMDL  pSrcMdl = NULL, pDstMdl = NULL;
26.         PUCHAR pSrcAddress = NULL, pDstAddress = NULL;
27.         NTSTATUS st = STATUS_UNSUCCESSFUL;
29.         // 分配MDL 源地址
30.         pSrcMdl = IoAllocateMdl(SrcAddr, Size, FALSE, FALSE, NULL);
31.         if (!pSrcMdl)
32.         {
33.                 return st;
34.         }
36.         // 该 MDL 指定非分页虚拟内存缓冲区，并对其进行更新以描述基础物理页。
37.         MmBuildMdlForNonPagedPool(pSrcMdl);
39.         // 获取源地址MDL地址
40.         pSrcAddress = MmGetSystemAddressForMdlSafe(pSrcMdl, NormalPagePriority);
43.         if (!pSrcAddress)
44.         {
45.                 IoFreeMdl(pSrcMdl);
46.                 return st;
47.         }
49.         // 分配MDL 目标地址
50.         pDstMdl = IoAllocateMdl(DstAddr, Size, FALSE, FALSE, NULL);
51.         if (!pDstMdl)
52.         {
53.                 IoFreeMdl(pSrcMdl);
54.                 return st;
55.         }
57.         __try
58.         {
59.                 // 以写入的方式锁定目标MDL
60.                 MmProbeAndLockPages(pDstMdl, UserMode, IoWriteAccess);
62.                 // 获取目标地址MDL地址
63.                 pDstAddress = MmGetSystemAddressForMdlSafe(pDstMdl, NormalPagePriority);
64.         }
65.         __except (EXCEPTION_EXECUTE_HANDLER)
66.         {
67.         }
69.         if (pDstAddress)
70.         {
71.                 __try
72.                 {
73.                         // 将源地址拷贝到目标地址
74.                         RtlCopyMemory(pDstAddress, pSrcAddress, Size);
75.                 }
76.                 __except (1)
77.                 {
78.                         // 拷贝内存异常
79.                 }
80.                 MmUnlockPages(pDstMdl);
81.                 st = STATUS_SUCCESS;
82.         }
84.         IoFreeMdl(pDstMdl);
85.         IoFreeMdl(pSrcMdl);
87.         return st;
88. }

复制代码

调用该函数实现拷贝，此处除去附加进程以外，在拷贝之前调用了ZwAllocateVirtualMemory将内存属性设置为PAGE_EXECUTE_READWRITE可读可写可执行状态，然后在向该内存中写出pTempBuffer变量中的内容，此变量中的数据是0x90填充的区域。

1. VOID UnDriver(PDRIVER_OBJECT driver)
2. {
3.         DbgPrint(("Uninstall Driver Is OK \n"));
4. }
6. // lyshark.com
7. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
8. {
9.         DbgPrint("hello lyshark.com \n");
11.         NTSTATUS status = STATUS_UNSUCCESSFUL;
12.         PEPROCESS eproc = NULL;
13.         KAPC_STATE kpc = { 0 };
15.         __try
16.         {
17.                 // HANDLE 进程PID
18.                 status = PsLookupProcessByProcessId((HANDLE)4556, &eproc);
20.                 if (NT_SUCCESS(status))
21.                 {
22.                         // 附加进程
23.                         KeStackAttachProcess(eproc, &kpc);
25.                         // -------------------------------------------------------------------
26.                         // 开始映射
27.                         // -------------------------------------------------------------------
29.                         // 将用户空间内存映射到内核空间
30.                         PVOID pTempBuffer = NULL;
31.                         ULONG nSize = 0x1024;
32.                         PVOID ModuleBase = 0x0000000140001000;
34.                         // 分配内存
35.                         pTempBuffer = RtlAllocateMemory(TRUE, nSize);
36.                         if (pTempBuffer)
37.                         {
38.                                 memset(pTempBuffer, 0x90, nSize);
40.                                 // 设置内存属性 PAGE_EXECUTE_READWRITE
41.                                 ZwAllocateVirtualMemory(NtCurrentProcess(), &ModuleBase, 0, &nSize, MEM_RESERVE, PAGE_EXECUTE_READWRITE);
42.                                 ZwAllocateVirtualMemory(NtCurrentProcess(), &ModuleBase, 0, &nSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
44.                                 // 将数据拷贝到R3中
45.                                 status = SafeCopyMemory_R0_to_R3(pTempBuffer, &ModuleBase, nSize);
46.                                 if (NT_SUCCESS(status))
47.                                 {
48.                                         DbgPrint("[*] 拷贝内核数据到应用层 \n");
49.                                 }
50.                         }
52.                         // 释放空间
53.                         RtlFreeMemory(pTempBuffer);
55.                         // 脱离进程
56.                         KeUnstackDetachProcess(&kpc);
57.                 }
58.         }
59.         __except (EXCEPTION_EXECUTE_HANDLER)
60.         {
61.                 Driver->DriverUnload = UnDriver;
62.                 return STATUS_SUCCESS;
63.         }
65.         Driver->DriverUnload = UnDriver;
66.         return STATUS_SUCCESS;
67. }

复制代码

拷贝成功后，应用层进程内将会被填充为Nop指令。


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