IT评测·应用市场-qidao123.com

标题: 驱动开发：内核读写内存多级偏移 [打印本页]
作者: 滴水恩情    时间: 2023-6-27 16:44
标题: 驱动开发：内核读写内存多级偏移
让我们继续在《内核读写内存浮点数》的基础之上做一个简单的延申，如何实现多级偏移读写，其实很简单，读写函数无需改变，只是在读写之前提前做好计算工作，以此来得到一个内存偏移值，并通过调用内存写入原函数实现写出数据的目的。
以读取偏移内存为例，如下代码同样来源于本人的LyMemory读写驱动项目，其中核心函数为WIN10_ReadDeviationIntMemory()该函数的主要作用是通过用户传入的基地址与偏移值，动态计算出当前的动态地址。
函数首先将基地址指向要读取的变量，并将其转换为LPCVOID类型的指针。然后将指向变量值的缓冲区转换为LPVOID类型的指针。接下来，函数使用PsLookupProcessByProcessId函数查找目标进程并返回其PEPROCESS结构体。随后，函数从偏移地址数组的最后一个元素开始迭代，每次循环都从目标进程中读取4字节整数型数据，并将其存储在Value变量中。然后，函数将基地址指向Value和偏移地址的和，以便在下一次循环中读取更深层次的变量。最后，函数将基地址指向最终变量的地址，读取变量的值，并返回。
如下案例所示，用户传入进程基址以及offset偏移值时，只需要动态计算出该偏移地址，并与基址相加即可得到动态地址。
  1. #include <ntifs.h>
  2. #include <ntintsafe.h>
  3. #include <windef.h>
  5. // 普通Ke内存读取
  6. NTSTATUS KeReadProcessMemory(PEPROCESS Process, PVOID SourceAddress, PVOID TargetAddress, SIZE_T Size)
  7. {
  8.         PEPROCESS SourceProcess = Process;
  9.         PEPROCESS TargetProcess = PsGetCurrentProcess();
  10.         SIZE_T Result;
  11.         if (NT_SUCCESS(MmCopyVirtualMemory(SourceProcess, SourceAddress, TargetProcess, TargetAddress, Size, KernelMode, &Result)))
  12.                 return STATUS_SUCCESS;
  13.         else
  14.                 return STATUS_ACCESS_DENIED;
  15. }
  17. // 读取整数内存多级偏移
  18. /*
  19.   Pid: 目标进程的进程ID。
  20.   Base: 变量的基地址。
  21.   offset: 相对基地址的多级偏移地址，用于定位变量。
  22.   len: 偏移地址的数量。
  23. */
  24. INT64 WIN10_ReadDeviationIntMemory(HANDLE Pid, LONG Base, DWORD offset[32], DWORD len)
  25. {
  26.         INT64 Value = 0;
  27.         LPCVOID pbase = (LPCVOID)Base;
  28.         LPVOID rbuffer = (LPVOID)&Value;
  30.         PEPROCESS Process;
  31.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
  33.         for (int x = len - 1; x >= 0; x--)
  34.         {
  35.                 __try
  36.                 {
  37.                         KeReadProcessMemory(Process, pbase, rbuffer, 4);
  38.                         pbase = (LPCVOID)(Value + offset[x]);
  39.                 }
  40.                 __except (EXCEPTION_EXECUTE_HANDLER)
  41.                 {
  42.                         return 0;
  43.                 }
  44.         }
  46.         __try
  47.         {
  48.                 DbgPrint("读取基址：%x \n", pbase);
  49.                 KeReadProcessMemory(Process, pbase, rbuffer, 4);
  50.         }
  51.         __except (EXCEPTION_EXECUTE_HANDLER)
  52.         {
  53.                 return 0;
  54.         }
  56.         return Value;
  57. }
  59. // 驱动卸载例程
  60. VOID UnDriver(PDRIVER_OBJECT driver)
  61. {
  62.         DbgPrint("Uninstall Driver \n");
  63. }
  65. // 驱动入口地址
  66. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  67. {
  68.         DbgPrint("Hello LyShark \n");
  70.         DWORD PID = 4884;
  71.         LONG PBase = 0x6566e0;
  72.         LONG Size = 4;
  73.         DWORD Offset[32] = { 0 };
  75.         Offset[0] = 0x18;
  76.         Offset[1] = 0x0;
  77.         Offset[2] = 0x14;
  78.         Offset[3] = 0x0c;
  80.         // 读取内存数据
  81.         INT64 read = WIN10_ReadDeviationIntMemory(PID, PBase, Offset, Size);
  83.         DbgPrint("PID: %d 基址: %p 偏移长度: %d \n", PID, PBase, Size);
  84.         DbgPrint("[+] 1级偏移: %x \n", Offset[0]);
  85.         DbgPrint("[+] 2级偏移: %x \n", Offset[1]);
  86.         DbgPrint("[+] 3级偏移: %x \n", Offset[2]);
  87.         DbgPrint("[+] 4级偏移: %x \n", Offset[3]);
  89.         DbgPrint("[ReadMemory] 读取偏移数据: %d \n", read);
  91.         Driver->DriverUnload = UnDriver;
  92.         return STATUS_SUCCESS;
  93. }
复制代码
编译并运行如上这段代码，则可获取到PID=4884的PBase的动态地址中的数据，如下图所示；

至于如何将数据写出四级偏移的基址上面，则只需要取出pbase里面的基址，并通过原函数WIN10_WriteProcessMemory直接写出数据即可，此出的原函数在《内核MDL读写进程内存》中已经做了详细介绍，实现写出代码如下所示；
  1. #include <ntifs.h>
  2. #include <ntintsafe.h>
  3. #include <windef.h>
  5. // 普通Ke内存读取
  6. NTSTATUS KeReadProcessMemory(PEPROCESS Process, PVOID SourceAddress, PVOID TargetAddress, SIZE_T Size)
  7. {
  8.         PEPROCESS SourceProcess = Process;
  9.         PEPROCESS TargetProcess = PsGetCurrentProcess();
  10.         SIZE_T Result;
  11.         if (NT_SUCCESS(MmCopyVirtualMemory(SourceProcess, SourceAddress, TargetProcess, TargetAddress, Size, KernelMode, &Result)))
  12.                 return STATUS_SUCCESS;
  13.         else
  14.                 return STATUS_ACCESS_DENIED;
  15. }
  17. // Win10 内存写入函数
  18. BOOLEAN WIN10_WriteProcessMemory(HANDLE Pid, PVOID Address, SIZE_T BYTE_size, PVOID VirtualAddress)
  19. {
  20.         PVOID buff1;
  21.         VOID *buff2;
  22.         int MemoryNumerical = 0;
  23.         KAPC_STATE KAPC = { 0 };
  25.         PEPROCESS Process;
  26.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
  28.         __try
  29.         {
  30.                 //分配内存
  31.                 buff1 = ExAllocatePoolWithTag((POOL_TYPE)0, BYTE_size, 1997);
  32.                 buff2 = buff1;
  33.                 *(int*)buff1 = 1;
  34.                 if (MmIsAddressValid((PVOID)VirtualAddress))
  35.                 {
  36.                         // 复制内存
  37.                         memcpy(buff2, VirtualAddress, BYTE_size);
  38.                 }
  39.                 else
  40.                 {
  41.                         return FALSE;
  42.                 }
  44.                 // 附加到要读写的进程
  45.                 KeStackAttachProcess((PRKPROCESS)Process, &KAPC);
  46.                 if (MmIsAddressValid((PVOID)Address))
  47.                 {
  48.                         // 判断地址是否可写
  49.                         ProbeForWrite(Address, BYTE_size, 1);
  50.                         // 复制内存
  51.                         memcpy(Address, buff2, BYTE_size);
  52.                 }
  53.                 else
  54.                 {
  55.                         return FALSE;
  56.                 }
  57.                 // 剥离附加的进程
  58.                 KeUnstackDetachProcess(&KAPC);
  59.                 ExFreePoolWithTag(buff2, 1997);
  60.         }
  61.         __except (EXCEPTION_EXECUTE_HANDLER)
  62.         {
  63.                 return FALSE;
  64.         }
  65.         return FALSE;
  66. }
  68. // 写入整数内存多级偏移
  69. INT64 WIN10_WriteDeviationIntMemory(HANDLE Pid, LONG Base, DWORD offset[32], DWORD len, INT64 SetValue)
  70. {
  71.         INT64 Value = 0;
  72.         LPCVOID pbase = (LPCVOID)Base;
  73.         LPVOID rbuffer = (LPVOID)&Value;
  75.         PEPROCESS Process;
  76.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
  78.         for (int x = len - 1; x >= 0; x--)
  79.         {
  80.                 __try
  81.                 {
  82.                         KeReadProcessMemory(Process, pbase, rbuffer, 4);
  83.                         pbase = (LPCVOID)(Value + offset[x]);
  84.                 }
  85.                 __except (EXCEPTION_EXECUTE_HANDLER)
  86.                 {
  87.                         return 0;
  88.                 }
  89.         }
  91.         __try
  92.         {
  93.                 KeReadProcessMemory(Process, pbase, rbuffer, 4);
  94.         }
  95.         __except (EXCEPTION_EXECUTE_HANDLER)
  96.         {
  97.                 return 0;
  98.         }
  100.         // 使用原函数写入
  101.         BOOLEAN ref = WIN10_WriteProcessMemory(Pid, (void *)pbase, 4, &SetValue);
  102.         if (ref == TRUE)
  103.         {
  104.                 DbgPrint("[内核写成功] # 写入地址: %x \n", pbase);
  105.                 return 1;
  106.         }
  107.         return 0;
  108. }
  110. // 驱动卸载例程
  111. VOID UnDriver(PDRIVER_OBJECT driver)
  112. {
  113.         DbgPrint("Uninstall Driver \n");
  114. }
  116. // 驱动入口地址
  117. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  118. {
  119.         DbgPrint("Hello LyShark \n");
  121.         DWORD PID = 4884;
  122.         LONG PBase = 0x6566e0;
  123.         LONG Size = 4;
  124.         INT64 SetValue = 100;
  126.         DWORD Offset[32] = { 0 };
  128.         Offset[0] = 0x18;
  129.         Offset[1] = 0x0;
  130.         Offset[2] = 0x14;
  131.         Offset[3] = 0x0c;
  133.         // 写出内存数据
  134.         INT64 write = WIN10_WriteDeviationIntMemory(PID, PBase, Offset, Size, SetValue);
  136.         DbgPrint("PID: %d 基址: %p 偏移长度: %d \n", PID, PBase, Size);
  137.         DbgPrint("[+] 1级偏移: %x \n", Offset[0]);
  138.         DbgPrint("[+] 2级偏移: %x \n", Offset[1]);
  139.         DbgPrint("[+] 3级偏移: %x \n", Offset[2]);
  140.         DbgPrint("[+] 4级偏移: %x \n", Offset[3]);
  142.         DbgPrint("[WriteMemory] 写出偏移数据: %d \n", SetValue);
  144.         Driver->DriverUnload = UnDriver;
  145.         return STATUS_SUCCESS;
  146. }
复制代码
运行如上代码将在0x6566e0所在的基址上，将数据替换为100，实现效果图如下所示；

那么如何实现读写内存浮点数，字节集等多级偏移呢？
其实我们可以封装一个WIN10_ReadDeviationMemory函数，让其只计算得出偏移地址，而所需要写出的类型则根据自己的实际需求配合不同的写入函数完成，也就是将两者分离开，如下则是一段实现计算偏移的代码片段，该代码同样来自于本人的LyMemory驱动读写项目；
  1. #include <ntifs.h>
  2. #include <ntintsafe.h>
  3. #include <windef.h>
  5. // 普通Ke内存读取
  6. NTSTATUS KeReadProcessMemory(PEPROCESS Process, PVOID SourceAddress, PVOID TargetAddress, SIZE_T Size)
  7. {
  8.         PEPROCESS SourceProcess = Process;
  9.         PEPROCESS TargetProcess = PsGetCurrentProcess();
  10.         SIZE_T Result;
  11.         if (NT_SUCCESS(MmCopyVirtualMemory(SourceProcess, SourceAddress, TargetProcess, TargetAddress, Size, KernelMode, &Result)))
  12.                 return STATUS_SUCCESS;
  13.         else
  14.                 return STATUS_ACCESS_DENIED;
  15. }
  17. // 读取多级偏移内存动态地址
  18. DWORD64 WIN10_ReadDeviationMemory(HANDLE Pid, LONG Base, DWORD offset[32], DWORD len)
  19. {
  20.         INT64 Value = 0;
  21.         LPCVOID pbase = (LPCVOID)Base;
  22.         LPVOID rbuffer = (LPVOID)&Value;
  24.         PEPROCESS Process;
  25.         PsLookupProcessByProcessId((HANDLE)Pid, &Process);
  27.         for (int x = len - 1; x >= 0; x--)
  28.         {
  29.                 __try
  30.                 {
  31.                         KeReadProcessMemory(Process, pbase, rbuffer, 4);
  32.                         pbase = (LPCVOID)(Value + offset[x]);
  33.                 }
  34.                 __except (EXCEPTION_EXECUTE_HANDLER)
  35.                 {
  36.                         return 0;
  37.                 }
  38.         }
  40.         return pbase;
  41. }
  43. // 驱动卸载例程
  44. VOID UnDriver(PDRIVER_OBJECT driver)
  45. {
  46.         DbgPrint("Uninstall Driver \n");
  47. }
  49. // 驱动入口地址
  50. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  51. {
  52.         DbgPrint("Hello LyShark \n");
  54.         DWORD PID = 4884;
  55.         LONG PBase = 0x6566e0;
  56.         LONG Size = 4;
  58.         DWORD Offset[32] = { 0 };
  60.         Offset[0] = 0x18;
  61.         Offset[1] = 0x0;
  62.         Offset[2] = 0x14;
  63.         Offset[3] = 0x0c;
  65.         // 写出内存数据
  66.         DWORD64 offsets = WIN10_ReadDeviationMemory(PID, PBase, Offset, Size);
  68.         DbgPrint("PID: %d 基址: %p 偏移长度: %d \n", PID, PBase, Size);
  69.         DbgPrint("[+] 1级偏移: %x \n", Offset[0]);
  70.         DbgPrint("[+] 2级偏移: %x \n", Offset[1]);
  71.         DbgPrint("[+] 3级偏移: %x \n", Offset[2]);
  72.         DbgPrint("[+] 4级偏移: %x \n", Offset[3]);
  74.         DbgPrint("[CheckMemory] 计算偏移地址: %x \n", offsets);
  76.         Driver->DriverUnload = UnDriver;
  77.         return STATUS_SUCCESS;
  78. }
复制代码
运行如上代码将动态计算出目前偏移地址的pbase实际地址，实现效果图如下所示；


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



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4