“进程内存管理器”这个程序实现的最基本功能也就是对内存的读写，之前的两篇文章也就是做的一个铺垫，介绍了内核模式切换和IoDeviceControl函数进行的应用程序与驱动程序通信的问题。接下来就进入正题了，对于内存查询，读写问题。

　　先来总结一下windows内存体系结构，这部分的学习主要是参照《windows核心编程》第13，14章的内容，以及网上前辈们的一些总结讨论。

　　先看看虚拟地址空间的分区（即虚拟地址空间布局）：

　　

　　　　

（1）空指针赋值分区
　　①为帮助程序员捕获对空指针的赋值，当线程试图读取或写入这一分区的内存地址，就会引发访问违规
　　②没有任何办法可以让我们分配到位于这一地址区间的虚拟内存。
（2）用户模式分区
　　①进程地址空间的驻地。对于应用程序来说，大部分数据都保存在这一分区。
　　②32位下，默认为2GB大小。打开/3GB开关时，可扩大到3GB空间，但同时内核空间缩小为1GB）
【x86 Windows下获得更大的用户模式分区】——修改Windows启动配置数据（Boot Configuration Data，BCD）
　　①运行BCDEdit.exe
　　②bcdedit /set IncreaseUserVa 3072，就可以为进程保留3GB用户模式地址空间，IncreaseUserVa可接受的最小值为2048，即默认的2GB。取消的话：bcdedit /deletevalue IncreaseUserVa。
　　③为了让应用程序可以访问2GB以上的地址空间（特别地，早期的应用程序是不允许这样做的）。在链接时，可以打开/LARGEADDRESSAWARE链接开关。
【在64位Windows下得到2GB用户模式分区】将32位应用程序移植到64位环境下
　　①因大量使用32位指针开发程序，仅重新编译程序会导致指针截断错误和不正确的内存访问。但可以让应用程序在地址空间沙箱（Address space sandbox）中运行，这也是默认的情况，系统能够保证高33位都为0的64地址截断为32位，这样进程可用的地址空间就被限制在最底部的2GB中。
　　②当运行64位应用程序时，默认下系统会保留用户模式地址空间中在2GB以下（即最底部的2GB），这就是所谓的地址空间沙箱。这空间对于大多数的应用程序来说是足够的。
　　③为了让64位应用程序能够访问整个用户地址空间，必须指定/LARGEADDRESSAWARE链接器开关来链接应用程序。
（3）内核模式分区
 　　操作系统代码的驻地。与线程调度、内存管理 、文件系统支持、网络支持以及设备驱动程序相关的代码都载入到这个分区中。该分区中的所有代码和数据都为所有进程共有，但这些代码和数据都是被保护起来的，如果试图在这分区的某个内存地址读取或写入数据时，会引发访问违规。
13.1.2 Windows内存安排（时间上的安排）
 
（1）每个应用程序都有自己的4GB寻址空间。该空间可存放操作系统、系统DLL和用户DLL代码，它们之中有各种函数供应用程序调用。再除去其他的一些空间，余下的是应用程序的代码、数据和可以分配的地址空间。
（2）不同应用程序的线性地址空间是隔离的。虽然它们在物理内存中同时存在，但在某个程序所属的时间片中，其他应用程序的代码和数据没有被映射到可寻址的线性地址中，所以是不可访问的。从编程的角度看，程序可供使用的4GB的寻址空间，而且这个空间是“私有的”。
（3）DLL程序没有自己的“私有”的空间。它们总是被映射到其他应用程序的地址空间中，当做其他应用程序的一部分运行。原因很简单，如果它不和其他程序同属一个地址空间，应用程序就不能调用它。
（4）操作系统和系统DLL的代码需要供每个应用程序调用，所以在所有的时间片中都必须被映射；
（5）用户程序只在自己所属的时间片内被映射。用户DLL则有选择地被映射。如程序B和C都调用了xxx.dll，那么物理内存中xxx.dll(注意在内存中已经存在了！)的代码在图中的时间片2和n中被映射，其他时间片就不需要被映射。（当然物理内存中只需要一份xxx.dll的代码）。
13.2 地址空间中的区域
（1）预定地址空间中的一块区域（预订：VirtualAlloc、释放：VirtualFree）
　　①起始地址：分配粒度（一般是64K）的整数倍。（注意：分配粒度与CPU平台有关，同时系统自己预订的区域的起始地址不一定非得是64KB的整数倍，如系统为进程环境块（PEB）和线程环境块（TEB）预定的区域地址就可能不是64KB的整数倍，但区域的大小仍是系统页面大小的整数倍。应用程序自己预订的区域，）
　　②预定空间的区域的大小：系统页面大小的整数倍（x86和x64的页面大小为4KB，I64系统使用的页面大小为8KB，关于x86,x64,IA64，X86架构的CPU 从早期的 8位,16位，32位，一直发展现在的64位；X64就是基于 x86 架构的64位CPU ,AMD 64位CPU 就是用这种的全称 X86-64；而IA64 是intel面向高端的新架构 IPF的64位 CPU 这种CPU 是不能兼容原先的 X86 下使用的程序，也就是说现在的windows程序都无法在这种CPU下面运行）

（2）将预订区域提交物理存储器
　　①提交时，可以只提交区域的一部分。如预订64KB空间大小，但可以只提交第2、第4两个页面（同样是调用VirtualAlloc函数，但传入的是MEM_COMMIT类型的参数）。
　　②撤消提交：VirtualFree，并传入MEM_DECOMMIT
13.3 物理存储器和页交换文件
（1）虚拟内存的实现：当应用程序调用VirtualAlloc函数将预订的空间区域提交物理存储器（物理内存或页交换文件）时，该空间实际上仍然不是从物理内存而是页交换文件中分配得到的！！！！！以后当访问该空间时，会因数据并不存在于物理内存而发生访问“页面错误”，从而引发操作系统利用异常处理机制将虚拟地址空间真正映射到对应的物理内存中，如下图所示。
 
（2）内存映射文件：把硬盘上的文件映像（如一个.exe或DLL文件）作为虚拟内存的一部分（注意是文件映像，而不是页交换文件）。当用户要执行一个可执行文件时，系统会打开应用程序对应的.exe文件并计算出应用程序的代码和数据的大小。然后预订一块地址空间，并注明与该区域相关的存储场所是.exe文件本身，而不是页交换文件。这样做可以将.exe的实际内容用作程序预订的地址空间区域，不仅载入程序速度快，而且可避免将为每个程序文件的代码和数据复制到页交换文件而造成页交换文件过于庞大和臃肿。
13.4 页面保护属性
保护属性
描述
PAGE_NOACCESS
不可访问。试图读取、写入或执行页面中的数据（代码）时将引发访问违规。
PAGE_READONLY
只读。试图写入页面或执行页面中的代码将引发访问违规
PAGE_READWRITE
读写属性。试图执行页面中的代码将引发访问违规 。
PAGE_EXECUTE
可执行属性。试图读取或写入页面将引发访问违规。
PAGE_EXECUTE_READ
可读、可执行。读图写入页面将引发访问违规。
PAGE_EXECUTE_READWRITE
可读可写可执行。对页面的任何操作都不会引发访问违规
PAGE_WRITECOPY
①写时复制。试图执行页面中的代码将引发访问违规。
②试图写入页面将使系统为进程单独创建一份该页面私有副本（以页交换文件为后备存储器）
PAGE_EXECUTE_WRITECOPY
对页面执行任何操作都不会引发访问违规。试图写入页面将使系统为进程单独创建一份该页面私有副本（以页交换文件为后备存储器）
★注意：如果Windows启用了数据执行保护（Data Execution Protection，DEP），当CPU试图执行某个页面中的代码，而该页面又没有PAGE_EXECUTE_*保护属性，那么CPU会抛出访问违规异常。（DEP开启方法：我的电脑→右键“属性”→高级系统设置→性能→设置→数据执行保护，选中“仅为基本Windows程序和服务启用DEP”）
13.4.1 写时复制
（1）写时复制属性的作用：节省内存和页交换文件的使用
Windows提供一种机制，允许两个或两个以上的进程共享一块存储器。如10个记事本进程正在运行，所有的进程会共享应用程序的代码页和数据页。当只读或执行时，这种共享存储页的方式极大地提高了性能。但当某个实例写入一个存储页时，就要求给共享的存储页指定写时复制属性，这样在映射地址空间时，系统会计算有多少可写页面，然后从页交换文件中分配空间来容纳这些可写页面，在程序真正写入的时候，就存储在页交换文件中。
（2）写入共享页面时，系统介入的操作
　　①系统在内存中找到一个空闲页面。注意，该空闲页的后备页面来自页交换文件。它是系统最初将模块映射到进程的地址空间时分配的。由于是第1次映射时就分配了所需的页交换文件空间。所以这步不可能失败。
　　②系统将要修改的页面内容复制到第1步找到的空闲页面，然后给这些空闲页面指定PAGE_READWRITE或PAGE_EXECUTE_READWRITE属性。（注意系统不会修改原始页面的保护属性和数据）
　　③然后系统更新进程的页面表，这样，原来的虚拟地址现在就对应到内存中一个新的页面了。以后进程就可以访问它自己的副本了。
（3）在预订地址空间或提交物理存储器时，不能使用PAGE_WRITECOPY或PAGE_EXECUTE_WRITECOPY保护属性，否则VirtualAlloc会失败，GetLastError将返回ERROR_INVALID_PARAMETER。
13.4.2 一些特殊的访问保护属性标志


保护属性
描述
PAGE_NOCACHE
禁止对己提交的页面进行缓存。该标志的目的是为了让需要操控内存缓冲区的驱动程序开发人员使用。一般不建议用将这标志用于除此以外的其他用途。
PAGE_WRITECOMBINE
允许把单个设备的多次写操作组合在一起，以提高性能。也是给驱动程序开发人员用的。
PAGE_GUARD
使应用程序能够在页面中的任何一个字节被写入时得到通知。

（1）基地址：
　　①从0x0000 0000开始，到0x7FFE 0000+ FFFF结束。
　　②几乎所有的非空闲区域的基地址都是64KB的整数倍（这是由系统地址空间的分配粒度决定的）。如果不是64KB的整数倍，这意味着该区域是由操作系统以进程名义分配的。
（2）区域类型

类型
描述
Free(空闲)
区域的虚拟地址没有任何后备存储器。该地址空间尚未预订，应用程序可以从基地址开始预订，也可以从空闲区域内的任何地方开始预订区域
Private(私有)
区域的虚拟地址以系统的页交换文件为后备存储器
Image(映像)
一开始以映像文件（如exe或DLL）为后备存储器，但以后不一定以映像文件为后备存储器（如程序写入映像文件中一个全局变量，那么写时复制会改用页交换文件来作为后备存储器）（映射文件可理解为exe或dll文件）
Mapped(己映射)
一开始以内存映射文件为后备存储器，此后不一定以内存映像文件为后备存储器。（如内存映射文件可能会使用写时复制保护属性。任何写操作会使对应的页面改用页交换文件来作为后备存储器）
  ★注意：对于每个区域整体而言，该区域的类型是推测出来的（除空闲外），详细见13.5.2节《区域内部》的内容。
（3）区域预订的字节数
　　①始终是CPU页面大小的整数倍（对于x86为4字节，即4096的倍数）
　　②为了节省磁盘空间，链接器会尽可能对对PE文件进行压缩，所以磁盘上的文件大小与映射到内存所需要的字节数是有差异的。
（4）预订区域内部的块的数量(block)
　　①块是一些连续的页面，这些页面具有相同的保护属性，并以相同类型的物理存储器为后备存储器。对闲置页面来说，由于不可能将存储器拨给他们，该值始终为0。
　　②每个区域最大能容纳的块的数量为：区域大小/页面大小，即当每个页面都是一个不同的块时，这里块的数量最多。
（5）区域的保护属性：
　　①E=execute,R=read,W=Write,C=copy on write。如果区域没有显示任保护属性，表示该区域没有任何访问保护。闲置区域没有与之相关联的保护属性。
　　②PAGE_GAUARD和PAGE_ONCACHE标志对地址空间没有意义，这些标志只有当用于物理存储时才有意义。
　　③如果同时给区域和物理存储器指定了保护属性，那么以后者为准。（见区域内部一节的分析）

13.6 数据对齐的重要性
（1）数据对齐：将数据的地址 % 数据大小 = 0时的数据是对齐的。
（2）x86CPU对错位数据的处理
　　①EFLAGS寄存器的AC标志位（AlignmentCheck）为0时，CPU自动执行必要的操作来访问错位数据）
　　②AC标志位为1时，如果试图访问错位数据，CPU会触发INT 17H中断。（对于x86版本的Windows从来不变为AC标志位（即永远为0），因此x86处理器上运行应用程序，绝对不会发生数据错位的异常，但IA-64CPU处理器不能自己处理数据错误的错误，因此当访问错位数据时，会抛出一个EXECPTION_DATATYPE_MISALIGNMENT异常，我们通用SetErrorMode函数并传为SEM_NOALIGNMENTFAULTEXCEPT标志，让系统自动修正数据错位的错误。（注意传入这个标志会影响进程中所有的线程，而且这个错误模式会被进程的子进程继承）

进入程序中的相关代码。直接进入到驱动程序接收到查询内存命令的case语句：

  1. case CTL_QUERY_PROCESS_MEMORY:
  2.     {
  3.         if (!MmIsAddressValid(OutputData))
  4.         {
  5.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  6.             Irp->IoStatus.Information = ;
  7.             break;
  8.         }
  9.         if (InputLength != sizeof(ULONG) || InputData == NULL)
  10.         {
  11.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  12.             Irp->IoStatus.Information = ;
  13.             break;
  14.         }
  15.         __try
  16.         {
  17.  
  18.             ProbeForWrite(OutputData, OutputLength, );  //检测内存是否可写,这个函数需要在用户模式下使用，详见MSDN:
  19.             //If Irp->RequestorMode = KernelMode, the Irp->AssociatedIrp.SystemBuffer and Irp->UserBuffer fields do not contain user-mode addresses,
  20.             //and a call to ProbeForWrite to probe a buffer pointed to by either field will raise an exception.
  21.  
  22.             Status = RtlQueryVirtualMemory(*(PULONG)InputData, OutputData, OutputLength);
  23.             Irp->IoStatus.Information = ;
  24.             Irp->IoStatus.Status = Status;
  25.  
  26.         }
  27.         __except (EXCEPTION_EXECUTE_HANDLER)
  28.         {
  29.             Irp->IoStatus.Information = ;
  30.             Status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  31.         }
  32.         break;
  33.     }

这段代码里首先用MmIsAddressValid函数，判断用作传出数据准备的缓冲区地址是否有效，之后对InputLength，InputData做一下判断，再用ProbeForWrite函数判断内存地址处是否可写，最后查询的操作在这个RtlQueryVirtualMemory函数中：

  1. RtlQueryVirtualMemory(ULONG ProcessID, PVOID BufferData, SIZE_T BufferLength)
  2. {
  3.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  4.     PEPROCESS EProcess = NULL;
  5.     SIZE_T    Count = ;
  6.     if (ProcessID)
  7.     {
  8.         Status = PsLookupProcessByProcessId((HANDLE)ProcessID, &EProcess);   //通过进程ID获取进程EPROCESS
  9.         if (!NT_SUCCESS(Status))
  10.         {
  11.             return Status;
  12.         }
  13.     }
  14.     ObfDereferenceObject(EProcess);                                      //减少一个内核对象的引用计数的，否则蓝屏！
  15.     if (IsRealProcess(EProcess))                                         //通过进程对象特征码判断EPROCESS是否有效
  16.     {
  17.         Count = (BufferLength - sizeof(RTL_PROCESS_MEMORY)) / sizeof(RTL_PROCESS_MEMORY_INFORMATION);
  18.         Status = ExQueryVirtualMemory(EProcess, (PRTL_PROCESS_MEMORY)BufferData, Count);
  19.         if (NT_SUCCESS(Status))
  20.         {
  21.             if (Count >= ((PRTL_PROCESS_MEMORY)BufferData)->NumberOfMemorys)
  22.             {
  23.                 Status = STATUS_SUCCESS;
  24.             }
  25.             else
  26.             {
  27.                 Status = STATUS_BUFFER_TOO_SMALL;
  28.             }
  29.         }
  30.     }
  31.     return Status;
  32. }

在RtlQueryVirtualMemory函数中，先计算出了进程内存信息的条数Count，再使用PsLookupProcessByProcessId函数，通过应用程序传入的进程ID得到进程EPROCESS，将EPROCESS传入自己编写的IsRealProcess函数来判断是否是一个真正的进程，最后调用了ExQueryVirtualMemory函数来查询内存。

关于Count的计算，涉及到的是自定义的进程内存信息结构体：

  1. typedef struct _RTL_PROCESS_MEMORY_INFORMATION
  2. {
  3.     PVOID     BaseAddress;
  4.     SIZE_T    RegionSize;
  5.     ULONG     Protect;
  6.     ULONG     State;
  7.     ULONG     Type;
  8. }RTL_PROCESS_MEMORY_INFORMATION, *PRTL_PROCESS_MEMORY_INFORMATION;
  9.  
  10. typedef struct _PROCESS_MEMORY_INFORMATION_
  11. {
  12.     ULONG                            NumberOfMemorys;
  13.     RTL_PROCESS_MEMORY_INFORMATION   Memorys[];
  14. }RTL_PROCESS_MEMORY, *PRTL_PROCESS_MEMORY;

通过EPROCESS判断是否为一个真正的进程：

  1. BOOLEAN IsRealProcess(PEPROCESS EProcess)
  2. {
  3.     ULONG_PTR    ObjectType;
  4.     ULONG_PTR    ObjectTypeAddress;
  5.     ULONG_PTR    ProcessType = ((ULONG_PTR)*PsProcessType);   //系统导出的全局变量
  6.     if (ProcessType && EProcess && MmIsAddressValid((PVOID)(EProcess)))
  7.     {
  8.         ObjectType = KeGetObjectType((PVOID)EProcess);  //通过EProcess 获得进程对象特征码
  9.         if (ObjectType &&
  10.             ProcessType == ObjectType)
  11.         {
  12.             return TRUE;
  13.         }
  14.     }
  15.     return FALSE;
  16. }

下面进入被调用的ExQueryVirtualMemory函数：

  1. NTSTATUS ExQueryVirtualMemory(PEPROCESS EProcess, PRTL_PROCESS_MEMORY ProcessMemory, SIZE_T Count)
  2. {
  3.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  4.     HANDLE   ProcessHandle = NULL;
  5.     MEMORY_BASIC_INFORMATION  mbi;
  6.     SIZE_T ReturnLength = ;
  7.  
  8.     //通过EProcess得到进程Handle
  9.     Status = ObOpenObjectByPointer(EProcess,
  10.         OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
  11.         NULL,
  12.         GENERIC_ALL,
  13.         *PsProcessType,
  14.         KernelMode,
  15.         &ProcessHandle);
  16.     if (NT_SUCCESS(Status))
  17.     {
  18.         PVOID VirtualAddress = ;
  19.  
  20.         PETHREAD EThread = PsGetCurrentThread();
  21.         CHAR PreviousMode = ChangePreviousMode(EThread);   //EThread KThread  0x1f6 内核模式
  22.  
  23.         while (VirtualAddress < RIN3_END)
  24.         {
  25.             Status = __NtQueryVirtualMemory(ProcessHandle,     //1.进程句柄
  26.                 (PVOID)VirtualAddress,     //2.被枚举空间的虚拟地址
  27.                 MemoryBasicInformation,    //3.枚举的方式
  28.                 &mbi,                      //4.事先准备好用于接收内存信息的缓冲区
  29.                 sizeof(MEMORY_BASIC_INFORMATION),//缓冲区大小
  30.                 &ReturnLength);            //6.本次调用实际使用缓冲区长度
  31.  
  32.             if (NT_SUCCESS(Status))
  33.             {
  34.                 if (Count > ProcessMemory->NumberOfMemorys)
  35.                 {
  36.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].BaseAddress = mbi.BaseAddress;
  37.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].RegionSize = mbi.RegionSize;
  38.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].Protect = mbi.Protect;
  39.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].State = mbi.State;
  40.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].Type = mbi.Type;
  41.                 }
  42.  
  43.                 ProcessMemory->NumberOfMemorys++;
  44.                 (PUINT8)VirtualAddress += mbi.RegionSize;
  45.             }
  46.             else
  47.             {
  48.                 (PUINT8)VirtualAddress += PAGE_SIZE;
  49.             }
  50.         }
  51.         NtClose(ProcessHandle);
  52.         RecoverPreviousMode(EThread, PreviousMode);
  53.     }
  54.     DbgPrint("%d\r\n", ProcessMemory->NumberOfMemorys);
  55.     return STATUS_SUCCESS;
  56. }

对比函数形参可以看到这里的ProcessMemory实际上就是应用程序中IoDeviceControl函数传给驱动程序的lpOutBuffer，用来接收驱动程序返回给应用程序数据的缓冲区，也就是接收进程内存信息的缓冲区，先回顾一下IoDeviceControl函数原型：

  1. WINBASEAPI
  2. BOOL
  3. WINAPI
  4. DeviceIoControl(
  5.     _In_ HANDLE hDevice,
  6.     _In_ DWORD dwIoControlCode,
  7.     _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
  8.     _In_ DWORD nInBufferSize,
  9.     _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
  10.     _In_ DWORD nOutBufferSize,
  11.     _Out_opt_ LPDWORD lpBytesReturned,
  12.     _Inout_opt_ LPOVERLAPPED lpOverlapped
  13.     );

切换到内核模式的原因不再赘述了，参见之前写的这篇博客：

http://www.cnblogs.com/lsh123/p/6884988.html

应用程序驱动程序通信也不多说了，参见之前写的这篇博客：

http://www.cnblogs.com/lsh123/p/6890797.html

这个函数体的核心就是调用了内核层的的NtQueryVirtualMemory函数，这个函数并能直接调用，这里的做法是通过SSDT表索引找到内核中NtQueryVirtualMemory函数的地址，通过typedef定义出NtQueryVirtualMemory函数的参数形式来进行调用：

  1. typedef
  2. NTSTATUS
  3. (*pfnNtQueryVirtualMemory)(HANDLE ProcessHandle, 
    　　 PVOID BaseAddress,
  4.     MEMORY_INFORMATION_CLASS MemoryInformationClass,
  5.     PVOID   MemoryInformation,
  6.     SIZE_T  MemoryInformationLength,
  7.     PSIZE_T ReturnLength);

NtQueryVirtualMemory大法好吖！

这里是一个暴力查询的方式NtQueryVirtualMemory查询不正确的话，就地址放过去一页，+4096个字节，继续调用NtQueryVirtualMemory函数，成功的话，就将对应的内存属性填充到应用程序准备好的缓冲区中返回给应用程序。直至Count = ProcessMemory->NumberOfMemorys为止。到此查询功能可谓是功成身退了~

看一下运行效果：

附录源码：

ProcessMemoryManagerDlg.h

  1. // ProcessMemoryManagerDlg.h : 头文件
  2. //
  3.  
  4. #pragma once
  5. #include "afxcmn.h"
  6. #include <WinIoCtl.h>
  7. #include <afxtempl.h>
  8. #include <vector>
  9. using namespace std;
  10.  
  11. #define CTL_QUERY_PROCESS_MEMORY \
  12.     CTL_CODE(FILE_DEVICE_UNKNOWN,0x830,METHOD_NEITHER,FILE_ANY_ACCESS)
  13.  
  14. typedef struct _RTL_PROCESS_MEMORY_INFORMATION
  15. {
  16.     PVOID     BaseAddress;
  17.     SIZE_T    RegionSize;
  18.     ULONG     Protect;
  19.     ULONG     State;
  20.     ULONG     Type;
  21. }RTL_PROCESS_MEMORY_INFORMATION, *PRTL_PROCESS_MEMORY_INFORMATION;
  22.  
  23. typedef struct _PROCESS_MEMORY_INFORMATION_
  24. {
  25.     ULONG                            NumberOfMemorys;
  26.     RTL_PROCESS_MEMORY_INFORMATION   Memorys[];
  27. }RTL_PROCESS_MEMORY, *PRTL_PROCESS_MEMORY;
  28.  
  29. enum
  30. {
  31.     QUERY_PROCESS_MEMORY =
  32. };
  33.  
  34. // CProcessMemoryManagerDlg 对话框
  35. class CProcessMemoryManagerDlg : public CDialogEx
  36. {
  37. // 构造
  38. public:
  39.     CProcessMemoryManagerDlg(CWnd* pParent = NULL);    // 标准构造函数
  40.     ~CProcessMemoryManagerDlg()
  41.     {
  42.         m_Vector.clear();
  43.         if (m_DeviceHandle != NULL)
  44.         {
  45.             CloseHandle(m_DeviceHandle);
  46.             m_DeviceHandle = NULL;
  47.         }
  48.     }
  49. // 对话框数据
  50. #ifdef AFX_DESIGN_TIME
  51.     enum { IDD = IDD_PROCESSMEMORYMANAGER_DIALOG };
  52. #endif
  53.  
  54.     protected:
  55.     virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
  56.  
  57. // 实现
  58. protected:
  59.     HICON m_hIcon;
  60.  
  61.     // 生成的消息映射函数
  62.     virtual BOOL OnInitDialog();
  63.     afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
  64.     afx_msg void OnPaint();
  65.     afx_msg HCURSOR OnQueryDragIcon();
  66.     DECLARE_MESSAGE_MAP()
  67.  
  68. private:
  69.     vector<RTL_PROCESS_MEMORY_INFORMATION> m_Vector;
  70.  
  71. public:
  72.     HANDLE m_DeviceHandle;
  73.     afx_msg void OnEnChangeEditProcessId();
  74.     UINT m_CEdit_Process_ID;
  75.     CListCtrl m_CListCtrl_Process_Memory;
  76.     afx_msg void OnBnClickedOk();
  77.     BOOL CProcessMemoryManagerDlg::RtlQueryVirtualMemory();
  78.     BOOL OpenDeviceObject(LPCTSTR DeviceFullPathData)
  79.     {
  80.         m_DeviceHandle = CreateFile(DeviceFullPathData,
  81.             GENERIC_READ | GENERIC_WRITE,
  82.             FILE_SHARE_READ | FILE_SHARE_WRITE,
  83.             NULL,
  84.             OPEN_EXISTING,
  85.             FILE_ATTRIBUTE_NORMAL,
  86.             NULL);
  87.  
  88.         if (m_DeviceHandle == INVALID_HANDLE_VALUE)
  89.         {
  90.             return FALSE;
  91.         }
  92.  
  93.         return TRUE;
  94.  
  95.     }
  96.     BOOL SendIoControlCode(ULONG32 IoControlCode);
  97.     VOID CProcessMemoryManagerDlg::AddItemToControlList(RTL_PROCESS_MEMORY_INFORMATION MemoryBasicInfo);
  98.     VOID CProcessMemoryManagerDlg::InitSolidMenu();
  99.     afx_msg void OnMemoryReadOperation();
  100.     afx_msg void OnMemoryWriteOperation();
  101.     afx_msg void OnMemoryModifyOperation();
  102. };

ProcessMemoryManagerDlg.cpp

  1. // ProcessMemoryManagerDlg.cpp : 实现文件
  2. //
  3. #include "stdafx.h"
  4. #include "ProcessMemoryManager.h"
  5. #include "ProcessMemoryManagerDlg.h"
  6. #include "afxdialogex.h"
  7. #include "ReadOperationDlg.h"
  8. #include "WriteOperationDlg.h"
  9.  
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #endif
  13. // 用于应用程序“关于”菜单项的 CAboutDlg 对话框
  14.  
  15. class CAboutDlg : public CDialogEx
  16. {
  17. public:
  18.     CAboutDlg();
  19.  
  20. // 对话框数据
  21. #ifdef AFX_DESIGN_TIME
  22.     enum { IDD = IDD_ABOUTBOX };
  23. #endif
  24.  
  25.     protected:
  26.     virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持
  27.  
  28. // 实现
  29. protected:
  30.     DECLARE_MESSAGE_MAP()
  31. };
  32.  
  33. CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
  34. {
  35. }
  36.  
  37. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  38. {
  39.     CDialogEx::DoDataExchange(pDX);
  40. }
  41.  
  42. BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
  43. END_MESSAGE_MAP()
  44.  
  45. // CProcessMemoryManagerDlg 对话框
  46.  
  47. CProcessMemoryManagerDlg::CProcessMemoryManagerDlg(CWnd* pParent /*=NULL*/)
  48.     : CDialogEx(IDD_PROCESSMEMORYMANAGER_DIALOG, pParent)
  49.     , m_CEdit_Process_ID()
  50. {
  51.     m_DeviceHandle = NULL;
  52.     m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  53. }
  54.  
  55. void CProcessMemoryManagerDlg::DoDataExchange(CDataExchange* pDX)
  56. {
  57.     CDialogEx::DoDataExchange(pDX);
  58.     DDX_Text(pDX, IDC_EDIT_PROCESS_ID, m_CEdit_Process_ID);
  59.     DDX_Control(pDX, IDC_LIST1, m_CListCtrl_Process_Memory);
  60. }
  61.  
  62. BEGIN_MESSAGE_MAP(CProcessMemoryManagerDlg, CDialogEx)
  63.     ON_WM_SYSCOMMAND()
  64.     ON_WM_PAINT()
  65.     ON_WM_QUERYDRAGICON()
  66.     ON_EN_CHANGE(IDC_EDIT_PROCESS_ID, &CProcessMemoryManagerDlg::OnEnChangeEditProcessId)
  67.     ON_BN_CLICKED(IDOK, &CProcessMemoryManagerDlg::OnBnClickedOk)
  68.     ON_COMMAND(ID_MEMORY_READ_OPERATION, &CProcessMemoryManagerDlg::OnMemoryReadOperation)
  69.     ON_COMMAND(ID_MEMORY_WRITE_OPERATION, &CProcessMemoryManagerDlg::OnMemoryWriteOperation)
  70.     ON_COMMAND(ID_MEMORY_MODIFY_OPERATION, &CProcessMemoryManagerDlg::OnMemoryModifyOperation)
  71. END_MESSAGE_MAP()
  72.  
  73. // CProcessMemoryManagerDlg 消息处理程序
  74.  
  75. BOOL CProcessMemoryManagerDlg::OnInitDialog()
  76. {
  77.     CDialogEx::OnInitDialog();
  78.  
  79.     // 将“关于...”菜单项添加到系统菜单中。
  80.  
  81.     // IDM_ABOUTBOX 必须在系统命令范围内。
  82.     ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  83.     ASSERT(IDM_ABOUTBOX < 0xF000);
  84.  
  85.     CMenu* pSysMenu = GetSystemMenu(FALSE);
  86.     if (pSysMenu != NULL)
  87.     {
  88.         BOOL bNameValid;
  89.         CString strAboutMenu;
  90.         bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
  91.         ASSERT(bNameValid);
  92.         if (!strAboutMenu.IsEmpty())
  93.         {
  94.             pSysMenu->AppendMenu(MF_SEPARATOR);
  95.             pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  96.         }
  97.     }
  98.  
  99.     // 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
  100.     //  执行此操作
  101.     SetIcon(m_hIcon, TRUE);            // 设置大图标
  102.     SetIcon(m_hIcon, FALSE);        // 设置小图标
  103.  
  104.     // TODO: 在此添加额外的初始化代码
  105.     if (m_DeviceHandle == NULL)
  106.     {
  107.         OpenDeviceObject(L"\\\\.\\KProcessMemoryLinkName");
  108.     }
  109.  
  110.     m_CListCtrl_Process_Memory.SetExtendedStyle(LVS_EX_FULLROWSELECT);
  111.     m_CListCtrl_Process_Memory.InsertColumn(, L"内存基地址", LVCFMT_LEFT, );
  112.     m_CListCtrl_Process_Memory.InsertColumn(, L"范围", LVCFMT_LEFT, );
  113.     m_CListCtrl_Process_Memory.InsertColumn(, L"保护", LVCFMT_LEFT, );
  114.     m_CListCtrl_Process_Memory.InsertColumn(, L"状态", LVCFMT_LEFT, );
  115.     m_CListCtrl_Process_Memory.InsertColumn(, L"类型", LVCFMT_LEFT, );
  116.  
  117.     InitSolidMenu();
  118.     return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
  119. }
  120.  
  121. VOID CProcessMemoryManagerDlg::InitSolidMenu()
  122. {
  123.     HMENU  Menu;
  124.     Menu = LoadMenu(NULL, MAKEINTRESOURCE(IDR_MENU_MAIN));               //载入菜单资源
  125.     ::SetMenu(this->GetSafeHwnd(), Menu);                                //为窗口设置菜单
  126.     ::DrawMenuBar(this->GetSafeHwnd());                                  //显示菜单
  127. }
  128.  
  129. void CProcessMemoryManagerDlg::OnSysCommand(UINT nID, LPARAM lParam)
  130. {
  131.     if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  132.     {
  133.         CAboutDlg dlgAbout;
  134.         dlgAbout.DoModal();
  135.     }
  136.     else
  137.     {
  138.         CDialogEx::OnSysCommand(nID, lParam);
  139.     }
  140. }
  141.  
  142. // 如果向对话框添加最小化按钮，则需要下面的代码
  143. //  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
  144. //  这将由框架自动完成。
  145.  
  146. void CProcessMemoryManagerDlg::OnPaint()
  147. {
  148.     if (IsIconic())
  149.     {
  150.         CPaintDC dc(this); // 用于绘制的设备上下文
  151.  
  152.         SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), );
  153.  
  154.         // 使图标在工作区矩形中居中
  155.         int cxIcon = GetSystemMetrics(SM_CXICON);
  156.         int cyIcon = GetSystemMetrics(SM_CYICON);
  157.         CRect rect;
  158.         GetClientRect(&rect);
  159.         int x = (rect.Width() - cxIcon + ) / ;
  160.         int y = (rect.Height() - cyIcon + ) / ;
  161.  
  162.         // 绘制图标
  163.         dc.DrawIcon(x, y, m_hIcon);
  164.     }
  165.     else
  166.     {
  167.         CDialogEx::OnPaint();
  168.     }
  169. }
  170.  
  171. //当用户拖动最小化窗口时系统调用此函数取得光标
  172. //显示。
  173. HCURSOR CProcessMemoryManagerDlg::OnQueryDragIcon()
  174. {
  175.     return static_cast<HCURSOR>(m_hIcon);
  176. }
  177.  
  178. void CProcessMemoryManagerDlg::OnEnChangeEditProcessId()
  179. {
  180.     // TODO:  如果该控件是 RICHEDIT 控件，它将不
  181.     // 发送此通知，除非重写 CDialogEx::OnInitDialog()
  182.     // 函数并调用 CRichEditCtrl().SetEventMask()，
  183.     // 同时将 ENM_CHANGE 标志“或”运算到掩码中。
  184.  
  185.     // TODO:  在此添加控件通知处理程序代码
  186. }
  187.  
  188. void CProcessMemoryManagerDlg::OnBnClickedOk()
  189. {
  190.     // TODO: 在此添加控件通知处理程序代码
  191.     UpdateData(TRUE);//FALSE是将变量映射到控件,TRUE则是从控件到变量
  192.  
  193.     if (m_CEdit_Process_ID == )
  194.     {
  195.         MessageBox(L"ID错误");
  196.         return;
  197.     }
  198.     SendIoControlCode(QUERY_PROCESS_MEMORY);
  199. }
  200.  
  201. BOOL CProcessMemoryManagerDlg::SendIoControlCode(ULONG32 IoControlCode)
  202. {
  203.  
  204.     switch (IoControlCode)
  205.     {
  206.     case QUERY_PROCESS_MEMORY:
  207.     {
  208.         RtlQueryVirtualMemory();
  209.  
  210.         if (m_Vector.empty())
  211.         {
  212.             return FALSE;
  213.         }
  214.  
  215.         for (vector <RTL_PROCESS_MEMORY_INFORMATION>::iterator Travel = m_Vector.begin();
  216.             Travel != m_Vector.end();
  217.             Travel++)
  218.         {
  219.             AddItemToControlList(*Travel);
  220.         }
  221.  
  222.         break;
  223.     }
  224.     default:
  225.         break;
  226.     }
  227.  
  228.     return TRUE;
  229. }
  230.  
  231. BOOL CProcessMemoryManagerDlg::RtlQueryVirtualMemory()
  232. {
  233.     BOOL IsOk = FALSE;
  234.     DWORD ReturnLength = ;
  235.     BOOL IsReturn = FALSE;
  236.     m_Vector.clear();
  237.     m_CListCtrl_Process_Memory.DeleteAllItems();
  238.     ULONG32 Count = 0x10;
  239.     PRTL_PROCESS_MEMORY ProcessMemory = NULL;
  240.     do
  241.     {
  242.         ULONG32 BufferLength = ;
  243.  
  244.         if (ProcessMemory)
  245.         {
  246.             free(ProcessMemory);
  247.             ProcessMemory = NULL;
  248.         }
  249.  
  250.         BufferLength = sizeof(RTL_PROCESS_MEMORY) + Count * sizeof(RTL_PROCESS_MEMORY_INFORMATION);
  251.  
  252.         ProcessMemory = (PRTL_PROCESS_MEMORY)malloc(BufferLength);
  253.         if (!ProcessMemory)
  254.         {
  255.             break;
  256.         }
  257.  
  258.         memset(ProcessMemory, , BufferLength);
  259.  
  260.         IsReturn = DeviceIoControl(m_DeviceHandle, CTL_QUERY_PROCESS_MEMORY,
  261.             &m_CEdit_Process_ID,
  262.             sizeof(ULONG),
  263.             ProcessMemory,
  264.             BufferLength,
  265.             &ReturnLength,
  266.             NULL);
  267.  
  268.         Count = ProcessMemory->NumberOfMemorys + ;
  269.  
  270.     } while (IsReturn == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER);
  271.  
  272.     if (IsReturn && ProcessMemory)
  273.     {
  274.         for (ULONG i = ; i < ProcessMemory->NumberOfMemorys; i++)
  275.         {
  276.             m_Vector.push_back(ProcessMemory->Memorys[i]);
  277.         }
  278.  
  279.         IsOk = TRUE;
  280.     }
  281.  
  282.     if (ProcessMemory)
  283.     {
  284.         free(ProcessMemory);
  285.         ProcessMemory = NULL;
  286.     }
  287.  
  288.     return IsOk;
  289. }
  290.  
  291. VOID CProcessMemoryManagerDlg::AddItemToControlList(RTL_PROCESS_MEMORY_INFORMATION MemoryBasicInfo)
  292. {
  293.     CString BaseAddress, RegionSize, Protect, State, Type;
  294.  
  295.     BaseAddress.Format(L"0x%04p", MemoryBasicInfo.BaseAddress);
  296.     RegionSize.Format(L"0x%08p", MemoryBasicInfo.RegionSize);
  297.  
  298.     Protect.Format(L"%d", MemoryBasicInfo.Protect);
  299.     State.Format(L"%p", MemoryBasicInfo.State);
  300.     Type.Format(L"%p", MemoryBasicInfo.Type);
  301.  
  302.     switch (MemoryBasicInfo.Type)
  303.     {
  304.     case 0x1000000:
  305.     {
  306.         Type = L"Image";
  307.         break;
  308.     }
  309.     case 0x40000:
  310.     {
  311.         Type = L"Map";
  312.         break;
  313.     }
  314.     case 0x20000:
  315.     {
  316.  
  317.         Type = L"Private";
  318.  
  319.         break;
  320.     }
  321.     default:
  322.     {
  323.         Type = L"";
  324.         break;
  325.     }
  326.     }
  327.     switch (MemoryBasicInfo.State)
  328.     {
  329.     case 0x10000:
  330.     {
  331.  
  332.         State = L"Free";
  333.         break;
  334.     }
  335.     case 0x2000:
  336.     {
  337.         State = L"Reserve";
  338.         break;
  339.     }
  340.     case 0x1000:
  341.     {
  342.         State = L"Commit";
  343.         break;
  344.     }
  345.     default:
  346.     {
  347.         State = L"";
  348.         break;
  349.     }
  350.     }
  351.     switch (MemoryBasicInfo.Protect)
  352.     {
  353.     case :
  354.     {
  355.         Protect = L"No Access";
  356.         break;
  357.     }
  358.     case :
  359.     {
  360.         Protect = L"Read";
  361.         break;
  362.     }
  363.     case :
  364.     {
  365.         Protect = L"ReadWrite";
  366.         break;
  367.     }
  368.     case :
  369.     {
  370.         Protect = L"ReadWrite GUARD";
  371.         break;
  372.     }
  373.     case :
  374.     {
  375.         Protect = L"ReadExecute";
  376.         break;
  377.     }
  378.     case :
  379.     {
  380.         Protect = L"WriteCopy";
  381.         break;
  382.     }
  383.  
  384.     default:
  385.     {
  386.         Protect = L"";
  387.         break;
  388.     }
  389.     }
  390.     int n = m_CListCtrl_Process_Memory.InsertItem(m_CListCtrl_Process_Memory.GetItemCount(), BaseAddress);
  391.     m_CListCtrl_Process_Memory.SetItemText(n, , RegionSize);
  392.     m_CListCtrl_Process_Memory.SetItemText(n, , Protect);
  393.     m_CListCtrl_Process_Memory.SetItemText(n, , State);
  394.     m_CListCtrl_Process_Memory.SetItemText(n, , Type);
  395. }
  396.  
  397. void CProcessMemoryManagerDlg::OnMemoryReadOperation()
  398. {
  399.     // TODO: 在此添加命令处理程序代码
  400.     UpdateData(TRUE);
  401.     if (m_CEdit_Process_ID == )
  402.     {
  403.         return;
  404.     }
  405.     CReadOperationDlg Dlg(m_CEdit_Process_ID, this);
  406.     Dlg.DoModal();
  407. }
  408.  
  409. void CProcessMemoryManagerDlg::OnMemoryWriteOperation()
  410. {
  411.     // TODO: 在此添加命令处理程序代码
  412.     UpdateData(TRUE);
  413.     if (m_CEdit_Process_ID == )
  414.     {
  415.         return;
  416.     }
  417.     CWriteOperationDlg Dlg(m_CEdit_Process_ID, this);
  418.     Dlg.DoModal();
  419. }
  420.  
  421. void CProcessMemoryManagerDlg::OnMemoryModifyOperation()
  422. {
  423.     // TODO: 在此添加命令处理程序代码
  424. }

kProcessMemory.h

  1. #include <ntifs.h>
  2. #include <ntimage.h>
  3.  
  4. #define DEVICE_NAME   L"\\Device\\KProcessMemoryDeviceName"
  5. #define LINK_NAME       L"\\DosDevices\\KProcessMemoryLinkName"
  6.  
  7. #define CTL_QUERY_PROCESS_MEMORY \
  8.     CTL_CODE(FILE_DEVICE_UNKNOWN,0x830,METHOD_NEITHER,FILE_ANY_ACCESS)
  9.  
  10. #define CTL_READ_PROCESS_MEMORY \
  11.     CTL_CODE(FILE_DEVICE_UNKNOWN,0x831,METHOD_NEITHER,FILE_ANY_ACCESS)
  12.  
  13. #define CTL_WRITE_PROCESS_MEMORY \
  14.     CTL_CODE(FILE_DEVICE_UNKNOWN,0x832,METHOD_NEITHER,FILE_ANY_ACCESS)
  15.  
  16. #define CTL_MODIFY_PROCESS_MEMORY \
  17.     CTL_CODE(FILE_DEVICE_UNKNOWN,0x833,METHOD_NEITHER,FILE_ANY_ACCESS)
  18. /*
  19. #define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
  20. ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
  21. )*/
  22.  
  23. /*
  24. Function功能号
  25. FunctionDefines an action within the device category.
  26.  
  27. Function codes 0-2047 are reserved for Microsoft; codes 2048-4095 are reserved for OEMs and IHVs.
  28.  
  29. A function code can be no larger then 4095.
  30. */
  31.  
  32. /*
  33. Ring0与Ring3的四种通信方式，
  34.  
  35. #define METHOD_BUFFERED                 0
  36. #define METHOD_IN_DIRECT                1
  37. #define METHOD_OUT_DIRECT               2
  38. #define METHOD_NEITHER                  3
  39. */
  40.  
  41. /*
  42. 对应Ring3层DeviceIoControl函数中的dwIoControlCode参数，第二个
  43.  
  44. WINBASEAPI
  45. BOOL
  46. WINAPI
  47. DeviceIoControl(
  48. _In_ HANDLE hDevice,
  49. _In_ DWORD dwIoControlCode,
  50. _In_reads_bytes_opt_(nInBufferSize) LPVOID lpInBuffer,
  51. _In_ DWORD nInBufferSize,
  52. _Out_writes_bytes_to_opt_(nOutBufferSize, *lpBytesReturned) LPVOID lpOutBuffer,
  53. _In_ DWORD nOutBufferSize,
  54. _Out_opt_ LPDWORD lpBytesReturned,
  55. _Inout_opt_ LPOVERLAPPED lpOverlapped
  56. );
  57. */
  58.  
  59. //Ring3  Ring0
  60. typedef struct _RTL_PROCESS_MEMORY_INFORMATION
  61. {
  62.     PVOID     BaseAddress;
  63.     SIZE_T    RegionSize;
  64.     ULONG     Protect;
  65.     ULONG     State;
  66.     ULONG     Type;
  67. }RTL_PROCESS_MEMORY_INFORMATION, *PRTL_PROCESS_MEMORY_INFORMATION;
  68.  
  69. typedef struct _PROCESS_MEMORY_INFORMATION_
  70. {
  71.     ULONG                            NumberOfMemorys;
  72.     RTL_PROCESS_MEMORY_INFORMATION   Memorys[];
  73. }RTL_PROCESS_MEMORY, *PRTL_PROCESS_MEMORY;
  74.  
  75. typedef struct _SYSTEM_SERVICE_DESCRIPTOR_TABLE_
  76. {
  77.     PVOID Unknow0;
  78.     PVOID Unknow1;
  79.     PVOID Unknow2;
  80.     PVOID Unknow3;
  81. }SYSTEM_SERVICE_DESCRIPTOR_TABLE, *PSYSTEM_SERVICE_DESCRIPTOR_TABLE;
  82. BOOLEAN GetSSDTFunctionAddressByFunctionName(char* FunctionName, PVOID* FunctionAddress);
  83. BOOLEAN GetSSDTAddress(ULONG64* SSDTAddress);
  84. BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionName(CHAR* FunctionName, ULONG32* SSDTFunctionIndex);
  85. BOOLEAN MappingPEFileInRing0Space(WCHAR* FileFullPathData, PVOID* MappingModuleBase, PSIZE_T MappingModuleSize);
  86.  
  87. BOOLEAN   IsRealProcess(PEPROCESS EProcess);
  88.  
  89. NTSTATUS
  90. RtlQueryVirtualMemory(ULONG ProcessID, PVOID BufferData, SIZE_T BufferLength);
  91. NTSTATUS ExQueryVirtualMemory(PEPROCESS EProcess, PRTL_PROCESS_MEMORY ProcessMemory, SIZE_T Count);
  92. VOID DriverUnload(PDRIVER_OBJECT DriverObject);
  93. NTSTATUS PassThroughDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp);
  94. NTSTATUS DeviceControlDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp);
  95. ULONG_PTR KeGetObjectType(PVOID ObjectBody);
  96.  
  97. PVOID
  98. GetFunctionAddressByName(WCHAR *FunctionName);
  99. typedef
  100. ULONG_PTR
  101. (*pfnObGetObjectType)(PVOID ObjectBody);
  102. CHAR ChangePreviousMode(PETHREAD EThread);
  103. VOID RecoverPreviousMode(PETHREAD EThread, CHAR PreviousMode);
  104.  
  105. typedef
  106. NTSTATUS
  107. (*pfnNtQueryVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress,
  108.     MEMORY_INFORMATION_CLASS MemoryInformationClass,
  109.     PVOID   MemoryInformation,
  110.     SIZE_T  MemoryInformationLength,
  111.     PSIZE_T ReturnLength);
  112. extern
  113. PIMAGE_NT_HEADERS
  114. NTAPI
  115. RtlImageNtHeader(PVOID BaseAddress);
  116.  
  117. extern
  118. POBJECT_TYPE* PsProcessType;
  119.  
  120. typedef struct _READ_OPERATION_
  121. {
  122.     PVOID      BaseAddress;
  123.     SIZE_T     RegionSize;
  124.     ULONG      ProcessID;
  125. }READ_OPERATION, *PREAD_OPERATION;
  126. NTSTATUS RtlReadVirtualMemory(PVOID InputData, PVOID OutputData, SIZE_T OutputLength);
  127. NTSTATUS ExReadVirtualMemory(PREAD_OPERATION InputData, PVOID OutputData, SIZE_T OutputLength);
  128.  
  129. typedef
  130. NTSTATUS
  131. (*pfnNtProtectVirtualMemory)(
  132.     IN HANDLE ProcessHandle,
  133.     IN OUT PVOID *BaseAddress,
  134.     IN OUT PSIZE_T RegionSize,
  135.     IN ULONG NewProtect,
  136.     OUT PULONG OldProtect);
  137.  
  138. #pragma pack(1)
  139. typedef struct _WRITE_OPERATION_
  140. {
  141.     PVOID      BaseAddress;
  142.     SIZE_T     RegionSize;
  143.     ULONG      ProcessID;
  144.     char*      BufferData;
  145. }WRITE_OPERATION, *PWRITE_OPERATION;
  146. NTSTATUS RtlWriteVirtualMemory(PVOID InputData);
  147. NTSTATUS ExWriteVirtualMemory(PWRITE_OPERATION InputData);

kProcessMemory.c

  1. #include "KProcessMemory.h"
  2. //bp KProcessMemory!DriverEntry
  3.  
  4. #define   PREVIOUSMODE_KTHREAD   0x1f6
  5. #define   RIN3_END               0x80000000000
  6.  
  7. #define SEC_IMAGE  0x001000000
  8. #define MAX_LENGTH 20
  9.  
  10. pfnNtQueryVirtualMemory   __NtQueryVirtualMemory = NULL;
  11. pfnNtProtectVirtualMemory __NtProtectVirtualMemory = NULL;
  12. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
  13. {
  14.     NTSTATUS Status = STATUS_SUCCESS;
  15.     PDEVICE_OBJECT  DeviceObject = NULL;
  16.     UNICODE_STRING  DeviceName;
  17.     UNICODE_STRING  LinkName;
  18.     int i = ;
  19.  
  20.     DriverObject->DriverUnload = DriverUnload;
  21.  
  22.     RtlInitUnicodeString(&DeviceName, DEVICE_NAME);
  23.     Status = IoCreateDevice(DriverObject, , &DeviceName, FILE_DEVICE_UNKNOWN, , FALSE, &DeviceObject);
  24.     if (!NT_SUCCESS(Status))
  25.     {
  26.         return Status;
  27.     }
  28.     RtlInitUnicodeString(&LinkName, LINK_NAME);
  29.     Status = IoCreateSymbolicLink(&LinkName, &DeviceName);
  30.     if (!NT_SUCCESS(Status))
  31.     {
  32.         IoDeleteDevice(DeviceObject);
  33.  
  34.         return Status;
  35.     }
  36.     for (i = ; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
  37.     {
  38.         DriverObject->MajorFunction[i] = PassThroughDispatch;
  39.     }
  40.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceControlDispatch;
  41.  
  42.     if (GetSSDTFunctionAddressByFunctionName("NtQueryVirtualMemory", (PVOID*)&__NtQueryVirtualMemory) == FALSE)
  43.     {
  44.         return Status;
  45.     }
  46.  
  47.     return Status;
  48. }
  49. BOOLEAN GetSSDTFunctionAddressByFunctionName(char* FunctionName, PVOID* FunctionAddress)
  50. {
  51.  
  52.     ULONG64  SSDTAddress = ;
  53.     PVOID    ServiceTableBase = NULL;
  54.     ULONG32  SSDTFunctionIndex = ;
  55.     ULONG32  Offset = ;
  56.     ULONG32  v1 = ;
  57.     if (GetSSDTAddress(&SSDTAddress) == FALSE)
  58.     {
  59.         return FALSE;
  60.     }
  61.     ServiceTableBase = ((PSYSTEM_SERVICE_DESCRIPTOR_TABLE)SSDTAddress)->Unknow0;
  62.     if (GetSSDTFunctionIndexFromNtdllExportTableByFunctionName(FunctionName,
  63.         &SSDTFunctionIndex) == FALSE)
  64.     {
  65.         return FALSE;
  66.     }
  67.     Offset = ((PULONG32)ServiceTableBase)[SSDTFunctionIndex];
  68.     v1 = Offset >> ;
  69.     *FunctionAddress = (PVOID)((PUINT8)ServiceTableBase + v1);
  70.  
  71. }
  72. BOOLEAN GetSSDTAddress(ULONG64* SSDTAddress)
  73. {
  74.     //kd>  rdmsr c0000082
  75.     PUCHAR StartSearchAddress = (PUCHAR)__readmsr(0xC0000082);
  76.     PUCHAR EndSearchAddress = StartSearchAddress + PAGE_SIZE;
  77.     PUCHAR i = NULL;
  78.     UCHAR   v1 = , v2 = , v3 = ;
  79.     INT64   Offset = ;    //002320c7
  80.     ULONG64 VariableAddress = ;
  81.     *SSDTAddress = NULL;
  82.     for (i = StartSearchAddress; i < EndSearchAddress; i++)
  83.     {
  84.         if (MmIsAddressValid(i) && MmIsAddressValid(i + ) && MmIsAddressValid(i + ))
  85.         {
  86.             v1 = *i;
  87.             v2 = *(i + );
  88.             v3 = *(i + );
  89.             if (v1 == 0x4c && v2 == 0x8d && v3 == 0x15)
  90.             {
  91.                 memcpy(&Offset, i + , );
  92.                 *SSDTAddress = Offset + (ULONG64)i + ;
  93.                 break;
  94.             }
  95.         }
  96.     }
  97.     if (*SSDTAddress == NULL)
  98.     {
  99.         return FALSE;
  100.     }
  101.     return TRUE;
  102. }
  103. BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionName(CHAR* FunctionName, ULONG32* SSDTFunctionIndex)
  104. {
  105.  
  106.     ULONG    i;
  107.     BOOLEAN  IsOk = FALSE;
  108.     WCHAR     FileFullPathData[] = L"\\SystemRoot\\System32\\ntdll.dll";     //C:\Windows\
  109.     SIZE_T   MappingModuleSize = ;
  110.     PVOID    MappingModuleBase = NULL;
  111.     PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = NULL;
  112.     PIMAGE_NT_HEADERS  ImageNtHeaders = NULL;
  113.     UINT32*  AddressOfFunctions = NULL;
  114.     UINT32*  AddressOfNames = NULL;
  115.     UINT16*  AddressOfNameOrdinals = NULL;
  116.     CHAR*    v1 = NULL;
  117.     ULONG32  FunctionOrdinal = ;
  118.     PVOID    FunctionAddress = ;
  119.     ULONG32  Offset_SSDTFunctionIndex = ;
  120.     //将Ntdll.dll 当前的空间中
  121.  
  122.     *SSDTFunctionIndex = -;
  123.     IsOk = MappingPEFileInRing0Space(FileFullPathData, &MappingModuleBase, &MappingModuleSize);
  124.     if (IsOk == FALSE)
  125.     {
  126.         return FALSE;
  127.     }
  128.     else
  129.     {
  130.         __try {
  131.             ImageNtHeaders = RtlImageNtHeader(MappingModuleBase);   //extern
  132.             if (ImageNtHeaders && ImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  133.             {
  134.                 ImageExportDirectory = (IMAGE_EXPORT_DIRECTORY*)((UINT8*)MappingModuleBase +
  135.                     ImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  136.  
  137.                 AddressOfFunctions = (UINT32*)((UINT8*)MappingModuleBase + ImageExportDirectory->AddressOfFunctions);
  138.                 AddressOfNames = (UINT32*)((UINT8*)MappingModuleBase + ImageExportDirectory->AddressOfNames);
  139.                 AddressOfNameOrdinals = (UINT16*)((UINT8*)MappingModuleBase + ImageExportDirectory->AddressOfNameOrdinals);
  140.                 for (i = ; i < ImageExportDirectory->NumberOfNames; i++)
  141.                 {
  142.                     v1 = (char*)((ULONG64)MappingModuleBase + AddressOfNames[i]);   //获得函数名称
  143.                     if (_stricmp(FunctionName, v1) == )
  144.                     {
  145.                         FunctionOrdinal = AddressOfNameOrdinals[i];
  146.                         FunctionAddress = (PVOID)((UINT8*)MappingModuleBase + AddressOfFunctions[FunctionOrdinal]);
  147.  
  148.                         *SSDTFunctionIndex = *(ULONG32*)((UINT8*)FunctionAddress + Offset_SSDTFunctionIndex);
  149.                         break;
  150.                     }
  151.                 }
  152.             }
  153.         }
  154.         __except (EXCEPTION_EXECUTE_HANDLER)
  155.         {
  156.             ;
  157.         }
  158.     }
  159.     ZwUnmapViewOfSection(NtCurrentProcess(), MappingModuleBase);  //解除映射
  160.  
  161.     if (*SSDTFunctionIndex == -)
  162.     {
  163.         return FALSE;
  164.     }
  165.  
  166.     return TRUE;
  167. }
  168. BOOLEAN MappingPEFileInRing0Space(WCHAR* FileFullPathData, PVOID* MappingModuleBase, PSIZE_T MappingModuleSize)
  169. {
  170.  
  171.     NTSTATUS          Status;
  172.     UNICODE_STRING    v1;
  173.     OBJECT_ATTRIBUTES ObjectAttributes;
  174.     IO_STATUS_BLOCK   IoStatusBlock;
  175.     HANDLE   FileHandle = NULL;
  176.     HANDLE   SectionHandle = NULL;
  177.  
  178.     if (!FileFullPathData &&MmIsAddressValid(FileFullPathData))
  179.     {
  180.         return FALSE;
  181.     }
  182.  
  183.     if (!MappingModuleBase&&MmIsAddressValid(MappingModuleBase))
  184.     {
  185.         return FALSE;
  186.     }
  187.  
  188.     RtlInitUnicodeString(&v1, FileFullPathData);
  189.     InitializeObjectAttributes(&ObjectAttributes,
  190.         &v1,
  191.         OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
  192.         NULL,
  193.         NULL
  194.     );
  195.  
  196.     //获得文件句柄
  197.     Status = IoCreateFile(&FileHandle,
  198.         GENERIC_READ | SYNCHRONIZE,
  199.         &ObjectAttributes,   //文件绝对路径
  200.         &IoStatusBlock,
  201.         NULL,
  202.         FILE_ATTRIBUTE_NORMAL,
  203.         FILE_SHARE_READ,
  204.         FILE_OPEN,
  205.         FILE_SYNCHRONOUS_IO_NONALERT,
  206.         NULL,
  207.         ,
  208.         CreateFileTypeNone,
  209.         NULL,
  210.         IO_NO_PARAMETER_CHECKING
  211.     );
  212.     if (!NT_SUCCESS(Status))
  213.     {
  214.         return FALSE;
  215.     }
  216.  
  217.     ObjectAttributes.ObjectName = NULL;
  218.     Status = ZwCreateSection(&SectionHandle,
  219.         SECTION_QUERY | SECTION_MAP_READ,
  220.         &ObjectAttributes,
  221.         NULL,
  222.         PAGE_WRITECOPY,
  223.         SEC_IMAGE, //内存对齐  0x1000
  224.         FileHandle
  225.     );
  226.     ZwClose(FileHandle);
  227.     if (!NT_SUCCESS(Status))
  228.     {
  229.         return FALSE;
  230.     }
  231.     Status = ZwMapViewOfSection(SectionHandle,
  232.         NtCurrentProcess(),    //映射到当前进程的内存空间中
  233.         MappingModuleBase,
  234.         ,
  235.         ,
  236.         ,
  237.         MappingModuleSize,
  238.         ViewUnmap,
  239.         ,
  240.         PAGE_WRITECOPY
  241.     );
  242.  
  243.     ZwClose(SectionHandle);
  244.     if (!NT_SUCCESS(Status))
  245.     {
  246.         return FALSE;
  247.     }
  248.     return TRUE;
  249. }
  250.  
  251. NTSTATUS DeviceControlDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
  252. {
  253.  
  254.     NTSTATUS Status = STATUS_SUCCESS;
  255.     ULONG    IoControlCode = ;
  256.     ULONG    InputLength = ;
  257.     SIZE_T   OutputLength = ;
  258.     PVOID    InputData = NULL;
  259.     PVOID    OutputData = NULL;
  260.  
  261.     PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
  262.     IoControlCode = IoStackLocation->Parameters.DeviceIoControl.IoControlCode;
  263.     //BufferIO
  264.     //InputData = OutputData = Irp->AssociatedIrp.SystemBuffer;
  265.     /*
  266.     直接方式DO_DIRECT_IO / 非直接方式(缓冲方式)DO_BUFFERD_IO
  267.         1) 在buffered(AssociatedIrp.SystemBuffer)方式中，I/O管理器先创建一个与用户模式数据缓冲区大小相等的系统缓冲区。而你的驱动程序将使用这个系统缓冲区工作。
  268.            I/O管理器负责在系统缓冲区和用户模式缓冲区之间复制数据。
  269.         2) 在direct(MdlAddress)方式中，I/O管理器锁定了包含用户模式缓冲区的物理内存页，并创建一个称为MDL(内存描述符表)的辅助数据结构来描述锁定页。
  270.            因此你的驱动程序将使用MDL工作。
  271.         3) 在neither(UserBuffer)方式中，I/O管理器仅简单地把用户模式的虚拟地址传递给你。
  272.            而使用用户模式地址的驱动程序应十分小心。
  273.     */
  274.     //Neither方式提高了通信效率，但是不够安全，在读写之前应使用ProbeForRead和ProbeForWrite函数探测地址是可读和可写
  275.     //详见eDiary笔记中“Driver——DeviceIoControl函数与IoControlCode”
  276.     InputData = IoStackLocation->Parameters.DeviceIoControl.Type3InputBuffer;//得到Ring3的输入缓冲区地址
  277.     OutputData = Irp->UserBuffer;                                            //得到Ring3的输出缓冲区地址
  278.     InputLength = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
  279.     OutputLength = IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength;
  280.  
  281.     switch (IoControlCode)   //IO控制码
  282.     {
  283.     case CTL_QUERY_PROCESS_MEMORY:
  284.     {
  285.         if (!MmIsAddressValid(OutputData))
  286.         {
  287.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  288.             Irp->IoStatus.Information = ;
  289.             break;
  290.         }
  291.         if (InputLength != sizeof(ULONG) || InputData == NULL)
  292.         {
  293.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  294.             Irp->IoStatus.Information = ;
  295.             break;
  296.         }
  297.         __try
  298.         {
  299.  
  300.             ProbeForWrite(OutputData, OutputLength, );  //检测内存是否可写,这个函数需要在用户模式下使用，详见MSDN:
  301.             //If Irp->RequestorMode = KernelMode, the Irp->AssociatedIrp.SystemBuffer and Irp->UserBuffer fields do not contain user-mode addresses,
  302.             //and a call to ProbeForWrite to probe a buffer pointed to by either field will raise an exception.
  303.  
  304.             Status = RtlQueryVirtualMemory(*(PULONG)InputData, OutputData, OutputLength);
  305.             Irp->IoStatus.Information = ;
  306.             Irp->IoStatus.Status = Status;
  307.  
  308.         }
  309.         __except (EXCEPTION_EXECUTE_HANDLER)
  310.         {
  311.             Irp->IoStatus.Information = ;
  312.             Status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  313.         }
  314.         break;
  315.     }
  316.     case CTL_READ_PROCESS_MEMORY:
  317.     {
  318.  
  319.         if (!MmIsAddressValid(OutputData) || OutputLength>MAX_LENGTH)
  320.         {
  321.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  322.             Irp->IoStatus.Information = ;
  323.             break;
  324.         }
  325.  
  326.         if (InputLength != sizeof(READ_OPERATION) || InputData == NULL)
  327.         {
  328.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  329.             Irp->IoStatus.Information = ;
  330.  
  331.             break;
  332.         }
  333.         __try
  334.         {
  335.  
  336.             ProbeForWrite(OutputData, OutputLength, );
  337.             Status = RtlReadVirtualMemory(InputData, OutputData, OutputLength);
  338.             Irp->IoStatus.Information = ;
  339.             Irp->IoStatus.Status = Status;
  340.  
  341.         }
  342.         __except (EXCEPTION_EXECUTE_HANDLER)
  343.         {
  344.             Irp->IoStatus.Information = ;
  345.             Status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  346.         }
  347.  
  348.         break;
  349.     }
  350.     case CTL_WRITE_PROCESS_MEMORY:
  351.     {
  352.  
  353.         if (InputLength < sizeof(WRITE_OPERATION) || InputData == NULL)
  354.         {
  355.             Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  356.             Irp->IoStatus.Information = ;
  357.  
  358.             break;
  359.         }
  360.         __try
  361.         {
  362.             Status = RtlWriteVirtualMemory(InputData);
  363.             Irp->IoStatus.Information = ;
  364.             Irp->IoStatus.Status = Status;
  365.  
  366.         }
  367.         __except (EXCEPTION_EXECUTE_HANDLER)
  368.         {
  369.             Irp->IoStatus.Information = ;
  370.             Status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  371.         }
  372.         break;
  373.     }
  374.     default:
  375.     {
  376.  
  377.         Irp->IoStatus.Information = ;
  378.         Status = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
  379.         break;
  380.     }
  381.     }
  382.  
  383.     IoCompleteRequest(Irp, IO_NO_INCREMENT);       //将Irp返回给IO管理器
  384.     return Status;
  385. }
  386.  
  387. NTSTATUS PassThroughDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
  388. {
  389.  
  390.     Irp->IoStatus.Information = ;
  391.     Irp->IoStatus.Status = STATUS_SUCCESS;
  392.     IoCompleteRequest(Irp, IO_NO_INCREMENT);   //将Irp返回给IO管理器
  393.     return STATUS_SUCCESS;
  394.  
  395. }
  396. VOID DriverUnload(PDRIVER_OBJECT DriverObject)
  397. {
  398.     PDEVICE_OBJECT DeviceObject = NULL;
  399.     PDEVICE_OBJECT v1 = NULL;
  400.     UNICODE_STRING LinkName;
  401.  
  402.     RtlInitUnicodeString(&LinkName, LINK_NAME);
  403.     IoDeleteSymbolicLink(&LinkName);
  404.     DeviceObject = DriverObject->DeviceObject;
  405.     v1 = DeviceObject;
  406.     while (DeviceObject != NULL)
  407.     {
  408.         v1 = DeviceObject->NextDevice;
  409.         IoDeleteDevice(DeviceObject);
  410.         DeviceObject = v1;
  411.     }
  412. }
  413. NTSTATUS
  414. RtlQueryVirtualMemory(ULONG ProcessID, PVOID BufferData, SIZE_T BufferLength)
  415. {
  416.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  417.     PEPROCESS EProcess = NULL;
  418.     SIZE_T    Count = ;
  419.     if (ProcessID)
  420.     {
  421.         Status = PsLookupProcessByProcessId((HANDLE)ProcessID, &EProcess);   //通过进程ID获取进程EPROCESS
  422.         if (!NT_SUCCESS(Status))
  423.         {
  424.             return Status;
  425.         }
  426.     }
  427.     ObfDereferenceObject(EProcess);                                      //减少一个内核对象的引用计数的，否则蓝屏！
  428.     if (IsRealProcess(EProcess))                                         //通过进程对象特征码判断EPROCESS是否有效
  429.     {
  430.         Count = (BufferLength - sizeof(RTL_PROCESS_MEMORY)) / sizeof(RTL_PROCESS_MEMORY_INFORMATION);
  431.         Status = ExQueryVirtualMemory(EProcess, (PRTL_PROCESS_MEMORY)BufferData, Count);
  432.         if (NT_SUCCESS(Status))
  433.         {
  434.             if (Count >= ((PRTL_PROCESS_MEMORY)BufferData)->NumberOfMemorys)
  435.             {
  436.                 Status = STATUS_SUCCESS;
  437.             }
  438.             else
  439.             {
  440.                 Status = STATUS_BUFFER_TOO_SMALL;
  441.             }
  442.         }
  443.     }
  444.     return Status;
  445. }
  446.  
  447. NTSTATUS ExQueryVirtualMemory(PEPROCESS EProcess, PRTL_PROCESS_MEMORY ProcessMemory, SIZE_T Count)
  448. {
  449.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  450.     HANDLE   ProcessHandle = NULL;
  451.     MEMORY_BASIC_INFORMATION  mbi;
  452.     SIZE_T ReturnLength = ;
  453.  
  454.     //通过EProcess得到进程Handle
  455.     Status = ObOpenObjectByPointer(EProcess,
  456.         OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
  457.         NULL,
  458.         GENERIC_ALL,
  459.         *PsProcessType,
  460.         KernelMode,
  461.         &ProcessHandle);
  462.     if (NT_SUCCESS(Status))
  463.     {
  464.         PVOID VirtualAddress = ;
  465.  
  466.         PETHREAD EThread = PsGetCurrentThread();
  467.         CHAR PreviousMode = ChangePreviousMode(EThread);   //EThread KThread  0x1f6 内核模式
  468.  
  469.         while (VirtualAddress < RIN3_END)
  470.         {
  471.             Status = __NtQueryVirtualMemory(ProcessHandle,     //1.进程句柄
  472.                 (PVOID)VirtualAddress,     //2.被枚举空间的虚拟地址
  473.                 MemoryBasicInformation,    //3.枚举的方式
  474.                 &mbi,                      //4.事先准备好用于接收内存信息的缓冲区
  475.                 sizeof(MEMORY_BASIC_INFORMATION),//缓冲区大小
  476.                 &ReturnLength);            //6.本次调用实际使用缓冲区长度
  477.  
  478.             if (NT_SUCCESS(Status))
  479.             {
  480.                 if (Count > ProcessMemory->NumberOfMemorys)
  481.                 {
  482.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].BaseAddress = mbi.BaseAddress;
  483.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].RegionSize = mbi.RegionSize;
  484.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].Protect = mbi.Protect;
  485.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].State = mbi.State;
  486.                     ProcessMemory->Memorys[ProcessMemory->NumberOfMemorys].Type = mbi.Type;
  487.                 }
  488.  
  489.                 ProcessMemory->NumberOfMemorys++;
  490.                 (PUINT8)VirtualAddress += mbi.RegionSize;
  491.             }
  492.             else
  493.             {
  494.                 (PUINT8)VirtualAddress += PAGE_SIZE;
  495.             }
  496.         }
  497.         NtClose(ProcessHandle);
  498.         RecoverPreviousMode(EThread, PreviousMode);
  499.     }
  500.     DbgPrint("%d\r\n", ProcessMemory->NumberOfMemorys);
  501.     return STATUS_SUCCESS;
  502. }
  503. BOOLEAN IsRealProcess(PEPROCESS EProcess)
  504. {
  505.     ULONG_PTR    ObjectType;
  506.     ULONG_PTR    ObjectTypeAddress;
  507.     ULONG_PTR    ProcessType = ((ULONG_PTR)*PsProcessType);   //系统导出的全局变量
  508.     if (ProcessType && EProcess && MmIsAddressValid((PVOID)(EProcess)))
  509.     {
  510.         ObjectType = KeGetObjectType((PVOID)EProcess);  //通过EProcess 获得进程对象特征码
  511.         if (ObjectType &&
  512.             ProcessType == ObjectType)
  513.         {
  514.             return TRUE;
  515.         }
  516.     }
  517.     return FALSE;
  518. }
  519. ULONG_PTR KeGetObjectType(PVOID ObjectBody)
  520. {
  521.     ULONG_PTR ObjectType = NULL;
  522.     pfnObGetObjectType        ObGetObjectType = NULL;
  523.     if (!MmIsAddressValid || !ObjectBody || !MmIsAddressValid(ObjectBody))
  524.     {
  525.         return NULL;
  526.     }
  527.     ObGetObjectType = (pfnObGetObjectType)GetFunctionAddressByName(L"ObGetObjectType");
  528.     if (ObGetObjectType)
  529.     {
  530.         ObjectType = ObGetObjectType(ObjectBody);
  531.     }
  532.     return ObjectType;
  533. }
  534. PVOID GetFunctionAddressByName(WCHAR *FunctionName)
  535. {
  536.     UNICODE_STRING v1;
  537.     PVOID FunctionAddress = NULL;
  538.  
  539.     if (FunctionName && wcslen(FunctionName) > )
  540.     {
  541.         RtlInitUnicodeString(&v1, FunctionName);
  542.         FunctionAddress = MmGetSystemRoutineAddress(&v1);   //在系统第一个模块ntoskrnl.exe 导出表中搜索
  543.     }
  544.  
  545.     return FunctionAddress;
  546. }
  547. CHAR ChangePreviousMode(PETHREAD EThread)
  548. {
  549.     CHAR PreviousMode = *(PCHAR)((PUINT8)EThread + PREVIOUSMODE_KTHREAD);
  550.     *(PCHAR)((ULONG_PTR)EThread + PREVIOUSMODE_KTHREAD) = KernelMode;
  551.     return PreviousMode;
  552. }
  553. VOID RecoverPreviousMode(PETHREAD EThread, CHAR PreviousMode)
  554. {
  555.     *(PCHAR)((PUINT8)EThread + PREVIOUSMODE_KTHREAD) = PreviousMode;
  556. }
  557.  
  558. //读内存
  559. NTSTATUS RtlReadVirtualMemory(PVOID InputData, PVOID OutputData, SIZE_T OutputLength)
  560. {
  561.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  562.     PREAD_OPERATION v1 = (PREAD_OPERATION)InputData;
  563.     if (v1->BaseAddress < RIN3_END && v1->BaseAddress >  && v1->ProcessID&&v1->RegionSize <= MAX_LENGTH)
  564.     {
  565.         Status = ExReadVirtualMemory(v1, OutputData, OutputLength);
  566.     }
  567.     return Status;
  568. }
  569.  
  570. NTSTATUS ExReadVirtualMemory(PREAD_OPERATION InputData, PVOID OutputData, SIZE_T OutputLength)
  571. {
  572.     NTSTATUS  Status = STATUS_UNSUCCESSFUL;
  573.     PEPROCESS EProcess;
  574.     PVOID     BufferData = NULL;
  575.     BOOLEAN   IsAttach = FALSE;
  576.     KAPC_STATE ApcState;
  577.     if (InputData->ProcessID)
  578.     {
  579.         Status = PsLookupProcessByProcessId((HANDLE)InputData->ProcessID, &EProcess);
  580.  
  581.         if (NT_SUCCESS(Status) && EProcess != NULL && IsRealProcess(EProcess))
  582.         {
  583.             ObfDereferenceObject(EProcess);
  584.             BufferData = ExAllocatePool(PagedPool, OutputLength);
  585.             if (BufferData == NULL)
  586.             {
  587.                 return STATUS_UNSUCCESSFUL;
  588.             }
  589.             memset(BufferData, , OutputLength);
  590.             __try
  591.             {
  592.  
  593.                 ULONG32 ProcessID = InputData->ProcessID;
  594.                 PVOID   BaseAddress = InputData->BaseAddress;
  595.                 SIZE_T  RegionSize = InputData->RegionSize;
  596.  
  597.                 KeStackAttachProcess(EProcess, &ApcState);
  598.                 IsAttach = TRUE;
  599.  
  600.                 ProbeForRead(BaseAddress, RegionSize, );
  601.                 memcpy(BufferData, (PVOID)BaseAddress, RegionSize);
  602.  
  603.                 if (IsAttach)
  604.                 {
  605.                     KeUnstackDetachProcess(&ApcState);
  606.                     IsAttach = FALSE;
  607.                 }
  608.  
  609.                 memcpy(OutputData, BufferData, OutputLength);
  610.  
  611.                 if (BufferData != NULL)
  612.                 {
  613.                     ExFreePool(BufferData);
  614.                 }
  615.  
  616.                 Status = STATUS_SUCCESS;
  617.             }
  618.  
  619.             __except ()
  620.             {
  621.                 if (IsAttach == TRUE)
  622.                 {
  623.                     KeUnstackDetachProcess(&ApcState);
  624.                 }
  625.  
  626.                 if (BufferData != NULL)
  627.                 {
  628.                     ExFreePool(BufferData);
  629.                 }
  630.  
  631.                 Status = STATUS_UNSUCCESSFUL;
  632.             }
  633.         }
  634.     }
  635.  
  636.     return Status;
  637. }
  638.  
  639. //写内存
  640. NTSTATUS RtlWriteVirtualMemory(PVOID InputData)
  641. {
  642.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  643.     PWRITE_OPERATION v1 = (PWRITE_OPERATION)InputData;
  644.  
  645.     if (v1->BaseAddress < RIN3_END && v1->BaseAddress >  && v1->ProcessID)
  646.     {
  647.         Status = ExWriteVirtualMemory(v1);
  648.     }
  649.  
  650.     return Status;
  651. }
  652.  
  653. NTSTATUS ExWriteVirtualMemory(PWRITE_OPERATION InputData)
  654. {
  655.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  656.     PEPROCESS EProcess;
  657.     PVOID     BufferData = NULL;
  658.     BOOLEAN   IsAttach = FALSE;
  659.     KAPC_STATE ApcState;
  660.     PETHREAD EThread;
  661.     CHAR PreviousMode;
  662.     HANDLE ProcessHandle = NULL;
  663.     ULONG  OldProtect = ;
  664.     if (InputData->ProcessID)
  665.     {
  666.         Status = PsLookupProcessByProcessId((HANDLE)InputData->ProcessID, &EProcess);
  667.  
  668.         if (NT_SUCCESS(Status) && EProcess &&IsRealProcess(EProcess))
  669.         {
  670.             ObfDereferenceObject(EProcess);
  671.  
  672.             BufferData = ExAllocatePool(PagedPool, InputData->RegionSize);
  673.  
  674.             if (BufferData == NULL)
  675.             {
  676.                 return STATUS_UNSUCCESSFUL;
  677.             }
  678.  
  679.             memcpy(BufferData, InputData->BufferData, InputData->RegionSize);
  680.  
  681.             __try
  682.             {
  683.  
  684.                 PVOID   BaseAddress = InputData->BaseAddress;
  685.                 SIZE_T  RegionSize = InputData->RegionSize;
  686.  
  687.                 PVOID   v5 = BaseAddress;
  688.                 SIZE_T  v7 = RegionSize;
  689.  
  690.                 KeStackAttachProcess(EProcess, &ApcState);
  691.                 IsAttach = TRUE;
  692.  
  693.                 __try
  694.                 {
  695.                     memcpy((PVOID)BaseAddress, (PVOID)BufferData, RegionSize);    //修改目标进程数据   ReadOnly
  696.  
  697.                     if (IsAttach)
  698.                     {
  699.                         KeUnstackDetachProcess(&ApcState);
  700.                         IsAttach = FALSE;
  701.                     }
  702.  
  703.                     if (BufferData != NULL)
  704.                     {
  705.                         ExFreePool(BufferData);
  706.                     }
  707.  
  708.                     return STATUS_SUCCESS;
  709.  
  710.                 }
  711.                 __except ()
  712.                 {
  713.                     if (IsAttach)
  714.                     {
  715.                         KeUnstackDetachProcess(&ApcState);
  716.                         IsAttach = FALSE;
  717.                     }
  718.  
  719.                     EThread = PsGetCurrentThread();
  720.                     PreviousMode = ChangePreviousMode(EThread);
  721.  
  722.                     Status = ObOpenObjectByPointer(EProcess,
  723.                         OBJ_KERNEL_HANDLE, NULL, GENERIC_ALL, *PsProcessType, KernelMode, &ProcessHandle);
  724.  
  725.                     if (!NT_SUCCESS(Status))
  726.                     {
  727.  
  728.                         RecoverPreviousMode(EThread, PreviousMode);
  729.                         if (BufferData != NULL)
  730.                         {
  731.                             ExFreePool(BufferData);
  732.                         }
  733.  
  734.                         return STATUS_UNSUCCESSFUL;
  735.                     }
  736.  
  737.                     Status = __NtProtectVirtualMemory(ProcessHandle,
  738.                         &v5, &v7, PAGE_READWRITE, &OldProtect);
  739.  
  740.                     if (!NT_SUCCESS(Status))
  741.                     {
  742.  
  743.                         ZwClose(ProcessHandle);
  744.                         RecoverPreviousMode(EThread, PreviousMode);
  745.                         if (BufferData != NULL)
  746.                         {
  747.                             ExFreePool(BufferData);
  748.                         }
  749.  
  750.                         return STATUS_UNSUCCESSFUL;
  751.                     }
  752.  
  753.                     RecoverPreviousMode(EThread, PreviousMode);
  754.  
  755.                     __try
  756.                     {
  757.                         KeStackAttachProcess(EProcess, &ApcState);
  758.                         IsAttach = TRUE;
  759.                         memcpy((PVOID)BaseAddress, (PVOID)BufferData, RegionSize);    //修改目标进程数据   ReadOnly
  760.  
  761.                         if (IsAttach)
  762.                         {
  763.                             KeUnstackDetachProcess(&ApcState);
  764.                             IsAttach = FALSE;
  765.                         }
  766.  
  767.                         EThread = PsGetCurrentThread();
  768.                         PreviousMode = ChangePreviousMode(EThread);
  769.  
  770.                         Status = __NtProtectVirtualMemory(ProcessHandle,
  771.                             &v5, &v7, OldProtect, NULL);
  772.  
  773.                         RecoverPreviousMode(EThread, PreviousMode);
  774.  
  775.                         ZwClose(ProcessHandle);
  776.  
  777.                         if (BufferData != NULL)
  778.                         {
  779.                             ExFreePool(BufferData);
  780.                         }
  781.                         if (!NT_SUCCESS(Status))
  782.                         {
  783.                             return STATUS_UNSUCCESSFUL;
  784.                         }
  785.  
  786.                         return STATUS_SUCCESS;
  787.  
  788.                     }
  789.                     __except ()
  790.                     {
  791.                         if (IsAttach)
  792.                         {
  793.                             KeUnstackDetachProcess(&ApcState);
  794.                             IsAttach = FALSE;
  795.                         }
  796.  
  797.                         if (BufferData != NULL)
  798.                         {
  799.                             ExFreePool(BufferData);
  800.                         }
  801.  
  802.                         return STATUS_UNSUCCESSFUL;
  803.                     }
  804.  
  805.                 }
  806.             }
  807.             __except ()
  808.             {
  809.                 if (IsAttach)
  810.                 {
  811.                     KeUnstackDetachProcess(&ApcState);
  812.                     IsAttach = FALSE;
  813.                 }
  814.  
  815.                 if (BufferData != NULL)
  816.                 {
  817.                     ExFreePool(BufferData);
  818.                 }
  819.                 return STATUS_UNSUCCESSFUL;
  820.             }
  821.         }
  822.     }
  823.     return STATUS_UNSUCCESSFUL;
  824. }

windows内存体系结构 内存查询，读，写（附录源码）的更多相关文章

  1. Java并发指南10：Java 读写锁 ReentrantReadWriteLock 源码分析

    Java 读写锁 ReentrantReadWriteLock 源码分析 转自:https://www.javadoop.com/post/reentrant-read-write-lock#toc5 ...

  2. 如何读懂Framework源码？如何从应用深入到Framework?

    如何读懂Framework源码? 首先,我也是一个应用层开发者,我想大部分有"如何读懂Framework源码?"这个疑问的,应该大都是应用层开发. 那对于我们来讲,读源码最大的问题 ...

  3. 读源码【读mybatis的源码的思路】

    ✿ 需要掌握的编译器知识 ★ 编译器为eclipse为例子 调试准备工作(步骤:Window -> Show View ->...): □ 打开调试断点Breakpoint: □ 打开变量 ...

  4. Spring学习之——手写Spring源码V2.0(实现IOC、D、MVC、AOP)

    前言 在上一篇<Spring学习之——手写Spring源码(V1.0)>中,我实现了一个Mini版本的Spring框架,在这几天,博主又看了不少关于Spring源码解析的视频,受益匪浅,也 ...

  5. C++STL内存配置的设计思想与关键源码分析

    说明:我认为要读懂STL中allocator部分的源码,并汲取它的思想,至少以下几点知识你要了解:operator new和operator delete.handler函数以及一点模板知识.否则,下 ...

  6. 从原子类和Unsafe来理解Java内存模型，AtomicInteger的incrementAndGet方法源码介绍，valueOffset偏移量的理解

    众所周知,i++分为三步: 1. 读取i的值 2. 计算i+1 3. 将计算出i+1赋给i 可以使用锁来保持操作的原子性和变量可见性,用volatile保持值的可见性和操作顺序性: 从一个小例子引发的 ...

  7. 读Hadoop3.2源码，深入了解java调用HDFS的常用操作和HDFS原理

    本文将通过一个演示工程来快速上手java调用HDFS的常见操作.接下来以创建文件为例,通过阅读HDFS的源码,一步步展开HDFS相关原理.理论知识的说明. 说明:本文档基于最新版本Hadoop3.2. ...

  8. 深入理解读写锁—ReadWriteLock源码分析

    转载:https://blog.csdn.net/qq_19431333/article/details/70568478 ReadWriteLock管理一组锁,一个是只读的锁,一个是写锁.读锁可以在 ...

  9. 手写koa-static源码，深入理解静态服务器原理

    这篇文章继续前面的Koa源码系列,这个系列已经有两篇文章了: 第一篇讲解了Koa的核心架构和源码:手写Koa.js源码 第二篇讲解了@koa/router的架构和源码:手写@koa/router源码 ...

随机推荐

  1. guulp配置编译ES6

    下面是gulp的配置文件,gulp具体使用点击查看 首先全局安装下 cnpm install gulp -g gulpfile.js  gulp配置文件 var gulp = require(&quo ...

  2. org.apache.axis2.AxisFault: org.apache.axis2.databinding.ADBException: Unexpected subelement profile

    原创:转载请注明出处 1.异常情况 org.apache.axis2.AxisFault: org.apache.axis2.databinding.ADBException: Unexpected ...

  3. MVC ---- Lambda表达式

    Lambda表达式是比匿名函数还简洁的一种匿名方法语法 Lambda表达式缩写推演 new Func<string,int>(delegate(string str){return str ...

  4. Python CSV Reader/Writer 例子--转载

    CSV(comma-separated values) 是跨多种形式导入导出数据的标准格式,比如 MySQL.Excel. 它以纯文本存储数和文本.文件的每一行就代表一条数据,每条记录包含了由逗号分隔 ...

  5. Struts2 文件下载（中文处理方法以及控制下载文件名称和扩展名）

    Struts2的框架提供了现成的文件下载方式,大大简化了开发下载功能的便利性.网上的例子有很多,我把一些大家普遍比较关注的点,集中一下,给出一个整体方案. 一般我们照着书本或者网上的列子写出了一个De ...

  6. hdu 5524 Subtrees dfs

    Subtrees Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Probl ...

  7. 为什么Rebase是有害的

    Rebase Considered Harmful Merge的两种方式 向上游提交"干净"的patch.不包含历史信息--日常提交.BUG fix.与上游的Merge记录等.就如 ...

  8. Python四大主流网络编程框架

    目前的4种主流Python网络框架:Django.Tornado.Flask.Twisted.

  9. c++ 指定长度容器元素的拷贝（copy_n）

    #include <iostream>     // cout #include <algorithm>    // copy #include <vector> ...

  10. MVC项目发布IIS CSS无法加载

    IIS配置网站在本地服务器调用不了CSS,新装了一个WIN8系统,IIS配置好之后做好的网站样式表浏览器不调用 处理方法 : 把静态内网 勾选打上即可 如果上述方法操作完成还是访问不鸟就继续往下看 权 ...