驱动开发：内核读写内存浮点数

如前所述，在前几章内容中笔者简单介绍了内存读写的基本实现方式，这其中包括了CR3切换读写，MDL映射读写，内存拷贝读写，本章将在如前所述的读写函数进一步封装，并以此来实现驱动读写内存浮点数的目的。内存浮点数的读写依赖于读写内存字节的实现，因为浮点数本质上也可以看作是一个字节集，对于单精度浮点数来说这个字节集列表是4字节，而对于双精度浮点数，此列表长度则为8字节。
如下代码片段摘取自本人的LyMemory驱动读写项目，函数ReadProcessMemoryByte用于读取内存特定字节类型的数据，函数WriteProcessMemoryByte则用于写入字节类型数据，完整代码如下所示；
这段代码中依然采用了《驱动开发：内核MDL读写进程内存》中所示的读写方法，通过MDL附加到进程并RtlCopyMemory拷贝数据，至于如何读写字节集只需要循环读写即可实现；

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 <windef.h>
9. // 读取内存字节
10. BYTE ReadProcessMemoryByte(HANDLE Pid, ULONG64 Address, DWORD Size)
11. {
12.         KAPC_STATE state = { 0 };
13.         BYTE OpCode;
15.         PEPROCESS Process;
16.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
18.         // 绑定进程对象,进入进程地址空间
19.         KeStackAttachProcess(Process, &state);
21.         __try
22.         {
23.                 // ProbeForRead 检查内存地址是否有效, RtlCopyMemory 读取内存
24.                 ProbeForRead((HANDLE)Address, Size, 1);
25.                 RtlCopyMemory(&OpCode, (BYTE *)Address, Size);
26.         }
27.         __except (EXCEPTION_EXECUTE_HANDLER)
28.         {
29.                 // 调用KeUnstackDetachProcess解除与进程的绑定,退出进程地址空间
30.                 KeUnstackDetachProcess(&state);
32.                 // 让内核对象引用数减1
33.                 ObDereferenceObject(Process);
34.                 // DbgPrint("读取进程 %d 的地址 %x 出错", ptr->Pid, ptr->Address);
35.                 return FALSE;
36.         }
38.         // 解除绑定
39.         KeUnstackDetachProcess(&state);
40.         // 让内核对象引用数减1
41.         ObDereferenceObject(Process);
42.         DbgPrint("[内核读字节] # 读取地址: 0x%x 读取数据: %x \n", Address, OpCode);
44.         return OpCode;
45. }
47. // 写入内存字节
48. BOOLEAN WriteProcessMemoryByte(HANDLE Pid, ULONG64 Address, DWORD Size, BYTE *OpCode)
49. {
50.         KAPC_STATE state = { 0 };
52.         PEPROCESS Process;
53.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
55.         // 绑定进程,进入进程的地址空间
56.         KeStackAttachProcess(Process, &state);
58.         // 创建MDL地址描述符
59.         PMDL mdl = IoAllocateMdl((HANDLE)Address, Size, 0, 0, NULL);
60.         if (mdl == NULL)
61.         {
62.                 return FALSE;
63.         }
65.         //使MDL与驱动进行绑定
66.         MmBuildMdlForNonPagedPool(mdl);
67.         BYTE* ChangeData = NULL;
69.         __try
70.         {
71.                 // 将MDL映射到我们驱动里的一个变量,对该变量读写就是对MDL对应的物理内存读写
72.                 ChangeData = (BYTE *)MmMapLockedPages(mdl, KernelMode);
73.         }
74.         __except (EXCEPTION_EXECUTE_HANDLER)
75.         {
76.                 // DbgPrint("映射内存失败");
77.                 IoFreeMdl(mdl);
79.                 // 解除映射
80.                 KeUnstackDetachProcess(&state);
81.                 // 让内核对象引用数减1
82.                 ObDereferenceObject(Process);
83.                 return FALSE;
84.         }
86.         // 写入数据到指定位置
87.         RtlCopyMemory(ChangeData, OpCode, Size);
88.         DbgPrint("[内核写字节] # 写入地址: 0x%x 写入数据: %x \n", Address, OpCode);
90.         // 让内核对象引用数减1
91.         ObDereferenceObject(Process);
92.         MmUnmapLockedPages(ChangeData, mdl);
93.         KeUnstackDetachProcess(&state);
94.         return TRUE;
95. }

复制代码

实现读取内存字节集并将读入的数据放入到LySharkReadByte字节列表中，这段代码如下所示，通过调用ReadProcessMemoryByte都内存字节并每次0x401000 + i在基址上面增加变量i以此来实现字节集读取；

1. // 驱动入口地址
2. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
3. {
4.         DbgPrint("Hello LyShark \n");
6.         // 读内存字节集
7.         BYTE LySharkReadByte[8] = { 0 };
9.         for (size_t i = 0; i < 8; i++)
10.         {
11.                 LySharkReadByte[i] = ReadProcessMemoryByte(4884, 0x401000 + i, 1);
12.         }
14.         // 输出读取的内存字节
15.         for (size_t i = 0; i < 8; i++)
16.         {
17.                 DbgPrint("[+] 打印数据: %x \n", LySharkReadByte[i]);
18.         }
20.         Driver->DriverUnload = UnDriver;
21.         return STATUS_SUCCESS;
22. }

复制代码

运行如上代码片段，你会看到如下图所示的读取效果；

那么如何实现写内存字节集呢？其实写入内存字节集与读取基本类似，通过填充LySharkWriteByte字节集列表，并调用WriteProcessMemoryByte函数依次循环字节集列表即可实现写出字节集的目的；

1. // 驱动入口地址
2. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
3. {
4.         DbgPrint("Hello LyShark \n");
6.         // 内存写字节集
7.         BYTE LySharkWriteByte[8] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
9.         for (size_t i = 0; i < 8; i++)
10.         {
11.                 BOOLEAN ref = WriteProcessMemoryByte(4884, 0x401000 + i, 1, LySharkWriteByte[i]);
12.                 DbgPrint("[*] 写出状态: %d \n", ref);
13.         }
15.         Driver->DriverUnload = UnDriver;
16.         return STATUS_SUCCESS;
17. }

复制代码

运行如上代码片段，即可将LySharkWriteByte[8]中的字节集写出到内存0x401000 + i的位置处，输出效果图如下所示；

接下来不如本章的重点内容，首先如何实现读内存单精度与双精度浮点数的目的，实现原理是通过读取BYTE类型的前4或者8字节的数据，并通过*((FLOAT*)buffpyr)将其转换为浮点数，通过此方法即可实现字节集到浮点数的转换，而决定是单精度还是双精度则只是一个字节集长度问题，这段读写代码实现原理如下所示；

1. // 读内存单精度浮点数
2. FLOAT ReadProcessFloat(DWORD Pid, ULONG64 Address)
3. {
4.         BYTE buff[4] = { 0 };
5.         BYTE* buffpyr = buff;
7.         for (DWORD x = 0; x < 4; x++)
8.         {
9.                 BYTE item = ReadProcessMemoryByte(Pid, Address + x, 1);
10.                 buff[x] = item;
11.         }
13.         return *((FLOAT*)buffpyr);
14. }
16. // 读内存双精度浮点数
17. DOUBLE ReadProcessMemoryDouble(DWORD Pid, ULONG64 Address)
18. {
19.         BYTE buff[8] = { 0 };
20.         BYTE* buffpyr = buff;
22.         for (DWORD x = 0; x < 8; x++)
23.         {
24.                 BYTE item = ReadProcessMemoryByte(Pid, Address + x, 1);
25.                 buff[x] = item;
26.         }
28.         return *((DOUBLE*)buffpyr);
29. }
31. // 驱动卸载例程
32. VOID UnDriver(PDRIVER_OBJECT driver)
33. {
34.         DbgPrint("Uninstall Driver \n");
35. }
37. // 驱动入口地址
38. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
39. {
40.         DbgPrint("Hello LyShark \n");
42.         // 读取单精度
43.         FLOAT fl = ReadProcessFloat(4884, 0x401000);
44.         DbgPrint("[读取单精度] = %d \n", fl);
46.         // 读取双精度浮点数
47.         DOUBLE fl = ReadProcessMemoryDouble(4884, 0x401000);
48.         DbgPrint("[读取双精度] = %d \n", fl);
50.         Driver->DriverUnload = UnDriver;
51.         return STATUS_SUCCESS;
52. }

复制代码

如上代码就是实现浮点数读写的关键所在，这段代码中的浮点数传值如果在内核中会提示无法解析的外部符号 _fltused此处只用于演示核心原理，如果想要实现不报错，该代码中的传值操作应在应用层进行，而传入参数也应改为字节类型即可。
同理，对于写内存浮点数而言依旧如此，只是在接收到用户层传递参数后应对其dtoc双精度浮点数转为CHAR或者ftoc单精度浮点数转为CHAR类型，再写出即可；

1. // 将DOUBLE适配为合适的Char类型
2. VOID dtoc(double dvalue, unsigned char* arr)
3. {
4.         unsigned char* pf;
5.         unsigned char* px;
6.         unsigned char i;
8.         // unsigned char型指针取得浮点数的首地址
9.         pf = (unsigned char*)&dvalue;
11.         // 字符数组arr准备存储浮点数的四个字节,px指针指向字节数组arr
12.         px = arr;
14.         for (i = 0; i < 8; i++)
15.         {
16.                 // 使用unsigned char型指针从低地址一个字节一个字节取出
17.                 *(px + i) = *(pf + i);
18.         }
19. }
21. // 将Float适配为合适的Char类型
22. VOID ftoc(float fvalue, unsigned char* arr)
23. {
24.         unsigned char* pf;
25.         unsigned char* px;
26.         unsigned char i;
28.         // unsigned char型指针取得浮点数的首地址
29.         pf = (unsigned char*)&fvalue;
31.         // 字符数组arr准备存储浮点数的四个字节,px指针指向字节数组arr
32.         px = arr;
34.         for (i = 0; i < 4; i++)
35.         {
36.                 // 使用unsigned char型指针从低地址一个字节一个字节取出
37.                 *(px + i) = *(pf + i);
38.         }
39. }
41. // 写内存单精度浮点数
42. BOOL WriteProcessMemoryFloat(DWORD Pid, ULONG64 Address, FLOAT write)
43. {
44.         BYTE buff[4] = { 0 };
45.         ftoc(write, buff);
47.         for (DWORD x = 0; x < 4; x++)
48.         {
49.                 BYTE item = WriteProcessMemoryByte(Pid, Address + x, buff[x], 1);
50.                 buff[x] = item;
51.         }
53.         return TRUE;
54. }
56. // 写内存双精度浮点数
57. BOOL WriteProcessMemoryDouble(DWORD Pid, ULONG64 Address, DOUBLE write)
58. {
59.         BYTE buff[8] = { 0 };
60.         dtoc(write, buff);
62.         for (DWORD x = 0; x < 8; x++)
63.         {
64.                 BYTE item = WriteProcessMemoryByte(Pid, Address + x, buff[x], 1);
65.                 buff[x] = item;
66.         }
68.         return TRUE;
69. }
71. // 驱动卸载例程
72. VOID UnDriver(PDRIVER_OBJECT driver)
73. {
74.         DbgPrint("Uninstall Driver \n");
75. }
77. // 驱动入口地址
78. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
79. {
80.         DbgPrint("Hello LyShark \n");
82.         // 写单精度
83.         FLOAT LySharkFloat1 = 12.5;
84.         INT fl = WriteProcessMemoryFloat(4884, 0x401000, LySharkFloat1);
85.         DbgPrint("[写单精度] = %d \n", fl);
87.         // 读取双精度浮点数
88.         DOUBLE LySharkFloat2 = 12.5;
89.         INT d1 = WriteProcessMemoryDouble(4884, 0x401000, LySharkFloat2);
90.         DbgPrint("[写双精度] = %d \n", d1);
92.         Driver->DriverUnload = UnDriver;
93.         return STATUS_SUCCESS;
94. }

复制代码

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