不用CR0或MDL修改内核非分页写保护内存的一种思路(x64)

零五零八

  开门见山，本文的核心思路就是通过填充页表项，将一块连续的虚拟地址映射到新的地址，同时将需要修改的只读内存对应页表项的Dirty位置位。在Windows操作系统下，写保护是通过保护特定虚拟地址实现的，若不建立新映射，则即使将Dirty位置位，尝试写只读内存照样会触发BugCheck，若建立了新映射但不置位Dirty则触发PAGE_FAULT的BugCheck，两个步骤缺一不可。填充页表项首先需要动态定位PTEBase，国际惯例是采用大表哥的页表自映射法，代码如下：

1. ULONG_PTR PTEBase = 0;
   
2. BOOLEAN hzqstGetPTEBase()
   
3. {
   
4.     BOOLEAN Result = FALSE;
   
5.     ULONG_PTR PXEPA = __readcr3() & 0xFFFFFFFFF000;
   
6.     PHYSICAL_ADDRESS PXEPAParam;
   
7.     PXEPAParam.QuadPart = (LONGLONG)PXEPA;
   
8.     ULONG_PTR PXEVA = (ULONG_PTR)MmGetVirtualForPhysical(PXEPAParam);
   
9.     if (PXEVA)
   
10.     {
    
11.         ULONG_PTR PXEOffset = 0;
    
12.         do
    
13.         {
    
14.             if ((*(PULONGLONG)(PXEVA + PXEOffset) & 0xFFFFFFFFF000) == PXEPA)
    
15.             {
    
16.                 PTEBase = (PXEOffset + 0xFFFF000) << 36;
    
17.                 Result = TRUE;
    
18.                 break;
    
19.             }
    
20.             PXEOffset += 8;
    
21.         } while (PXEOffset < PAGE_SIZE);
    
22.     }
    
23.     return Result;
    
24. }

复制代码

这里我顺便也给出另一种获取方案，基本思路是通过NT导出函数

1. NTKERNELAPI ULONG NTAPI KeCapturePersistentThreadState(PCONTEXT Context, PKTHREAD Thread, ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4, PVOID VirtualAddress);

复制代码

Dump下0x40000大小的数据，里面就存放有MmPfnDataBase，MmPfnDataBase是一个以物理地址页帧号为索引的内存信息数组，其中就有物理页对应的PTE项的地址PteAddress，我们传一个有效的物理地址进去（如当前CR3:_readcr3()&0xFFFFFFFFF000）取出其中的PteAddress，由于PTEBase必定是0x8000000000的倍数，因此可由PteAddress直接算出PTEBase。另外，从Win10RS1周年预览版开始，KeCapturePersistentThreadState开始受全局变量ForceDumpDisabled的控制，若注册表“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CrashControl”中有关子项满足条件，此变量会在开机启动时置为1，导致KeCapturePersistentThreadState调用失败。综上所述我们得到第二种获取PTEBase的代码如下：   

1. //若在Win10上测试，需要在这里加上"#define _WIN10 1"
   
2. 
   
3. #ifdef _WIN10
   
4. #define OFFSET_PTEADDRESS 0x8
   
5. #elif
   
6. #define OFFSET_PTEADDRESS 0x10
   
7. #endif
   
8. ULONG_PTR PTEBase = 0;
   
9. 
   
10. PBOOLEAN LocateForceDumpDisabledInRange(ULONG_PTR StartAddress, ULONG MaximumBytesToSearch)
    
11. {
    
12.     PBOOLEAN Result = 0;
    
13.     ULONG_PTR p = StartAddress;
    
14.     ULONG_PTR pEnd = p + MaximumBytesToSearch;
    
15.     do
    
16.     {
    
17.         //cmp cs:ForceDumpDisabled, al
    
18.         //jnz ...
    
19.         if ((*(PULONGLONG)p & 0xFFFF00000000FFFF) == 0x850F000000000538)
    
20.         {
    
21.             Result = p + 6 + *(PLONG)(p + 2);
    
22.             break;
    
23.         }
    
24.         p++;
    
25.     } while (p < pEnd);
    
26.     return Result;
    
27. }
    
28. 
    
29. BOOLEAN GetPTEBase()
    
30. {
    
31.     BOOLEAN Result = FALSE;
    
32.     CONTEXT Context = { 0 };
    
33.     Context.Rcx = (ULONG64)&Context;
    
34.     PUCHAR DumpData = ExAllocatePool(NonPagedPool, 0x40000);
    
35.     if (DumpData)
    
36.     {
    
37.         PBOOLEAN pForceDumpDisabled = LocateForceDumpDisabledInRange((ULONG_PTR)KeCapturePersistentThreadState, 0x300);
    
38.         if (pForceDumpDisabled) *pForceDumpDisabled = FALSE;
    
39.         if (KeCapturePersistentThreadState(&Context, 0, 0, 0, 0, 0, 0, DumpData) == 0x40000)
    
40.         {
    
41.             ULONG_PTR MmPfnDataBase = *(PULONG_PTR)(DumpData + 0x18);
    
42.             PTEBase = *(PULONG_PTR)(MmPfnDataBase + OFFSET_PTEADDRESS + (((ULONG_PTR)(__readcr3() & 0xFFFFFFFFF000) >> 8) * 3)) & 0xFFFFFF8000000000;
    
43.             Result = TRUE;
    
44.         }
    
45.         ExFreePool(DumpData);
    
46.     }
    
47.     return Result;
    
48. }

复制代码

  获取到PTEBase后，现在进入正题，下面代码的主要思路是：首先从某个有效的按512G对齐的内核虚拟地址开始，一直到0xFFFFFFFFFFFFFFFF，查找未被占用的PML4T（下文统称PXE）子项，即PXE的Valid位为0的子项。

  对于有效起始内核虚拟地址，一开始笔者选用的是MmSystemRangeStart，虚拟机测试发现对于8.1/10映射成功了，而Vista/7/8下CPU并没有承认映射地址的有效性触发了BugCheck，调试器发现Vista/7/8下MmSystemRangeStart=0xFFFF080000000000，而8.1/10下MmSystemRangeStart=0xFFFF800000000000，并且Vista/7/8下映射地址范围为[0xFFFF080000000000, 0xFFFF800000000000)时，调试器的CrashDump提示为Noncanonical Virtual Address。查阅了Intel手册后，笔者发现当前的IntelCPU支持的虚拟地址寻址最大位数限制为48位，对于64位Windows来说，第47位被用来区分用户层虚拟地址和内核层虚拟地址，即内核层地址实际上只有47位的有效位，于是得出有效起始内核虚拟地址为0xFFFF800000000000。当然严谨起见，可以使用CPUID的0x80000008号功能，此时eax寄存器的ah即为处理器支持的虚拟地址最大有效位数，设其为x，则对64位地址，只要将最高的(65-x)位全部置1，剩余的(x-1)位全部置0，即得有效起始内核虚拟地址。

  找到未使用的PXE子项后，申请一段连续的物理内存，初始大小为PXE子项以及PXE子项的512个PPE项所描述的页面大小，即(1 + 0x200) * PAGE_SIZE，若申请失败，则将申请的PPE项减半，以此类推……由于是连续物理内存，因此最好的方案是通过MmAllocateContiguousMemory申请，若使用ExAllocatePool，则当申请的页面不是2M大页面时，其虚拟地址对应的物理地址很可能不是连续的，这会给我们后续填充512个PPE项的物理页帧号徒增不少麻烦。申请到连续物理地址后，第一个页面填充至目标PXE子项，第2到513个页面的物理页帧号按顺序填充到PXE子项页面描述的512个PPE项中。随后给定任一个需要映射的虚拟地址，我们先将它按0x8000000000（512G）进行对齐，再依次检索其PXE、PPE、PDE项，若PXE项Valid为0或LargePage为1则不映射，否则开始依次检索PPE和PDE。若PPE项Valid为0，则把映射地址对应的PPE页面清零。若Valid为1则分别处理是否LargePage的情形，若为1G大页面，则将其等分成512个2M大页面，再把对应的物理页帧号按顺序填充到PPE描述的512个PDE项中；若不是大页面，则将被映射地址的PPE项对应的一页全部复制到映射地址对应的PPE页面中。从这里开始，基本的地址映射已经完成，接下来对欲修改的页面只要把其对应的PTE或大页面PDE或大页面PPE项的Dirty位置1即可。

1. ULONG_PTR AllocateSinglePXEDirectory(OUT PULONG_PTR BaseAddress, OUT PULONG SizeOfPPEPages)
   
2. {
   
3.     ULONG_PTR Result = 0;
   
4.     ULONG_PTR PteBase = PTEBase;
   
5.     ULONG_PTR OffsetMask = 0x7FFFFFFFF8;
   
6.     ULONG_PTR PXEVA = PteBase + (((PteBase + (((PteBase + ((PteBase >> 9) & OffsetMask)) >> 9) & OffsetMask)) >> 9) & OffsetMask) + 0x800; //有效起始内核虚拟地址0xFFFF800000000000对应的PXE子项
   
7.     ULONG_PTR PXEVAEnd = PXEVA + 0x800; //0x800 + 0x800 == 0x1000 == PAGE_SIZE
   
8.     do
   
9.     {
   
10.         if (!(*(PULONGLONG)PXEVA & 0xFFFFFFFFF001))
    
11.         {
    
12.             PHYSICAL_ADDRESS Alloc;
    
13.             Alloc.QuadPart = MAXULONG64;
    
14.             ULONG TotalSizeOfValidPPEPages = 0x200 * PAGE_SIZE;
    
15.             while (TotalSizeOfValidPPEPages >= PAGE_SIZE && !(Result = (ULONG_PTR)MmAllocateContiguousMemory(TotalSizeOfValidPPEPages + PAGE_SIZE, Alloc)))
    
16.                 TotalSizeOfValidPPEPages >>= 1;
    
17.             if (Result)
    
18.             {
    
19.                 if (SizeOfPPEPages) *SizeOfPPEPages = TotalSizeOfValidPPEPages;
    
20.                 ULONG64 OringinalIRQL = __readcr8();
    
21.                 __writecr8(DISPATCH_LEVEL);
    
22.                 if (BaseAddress) *BaseAddress = ((PXEVA & 0xFF8) + 0xFFFF000) << 36;
    
23.                 ULONG_PTR PTEVA = PteBase + ((Result >> 9) & OffsetMask);
    
24.                 ULONG_PTR PDEVA = PteBase + ((PTEVA >> 9) & OffsetMask);
    
25.                 ULONG_PTR PPEVA = PteBase + ((PDEVA >> 9) & OffsetMask);
    
26.                 ULONGLONG StartValue = *(PULONGLONG)PPEVA;
    
27.                 if (StartValue & 0x80)
    
28.                 {
    
29.                     StartValue &= ~0x80;
    
30.                     StartValue += (Result & 0x3FFFF000);
    
31.                 }
    
32.                 else
    
33.                 {
    
34.                     StartValue = *(PULONGLONG)PDEVA;
    
35.                     if (StartValue & 0x80)
    
36.                     {
    
37.                         StartValue &= ~0x80;
    
38.                         StartValue += (Result & 0x1FF000);
    
39.                     }
    
40.                     else StartValue = *(PULONGLONG)PTEVA;
    
41.                 }
    
42.                 *(PULONGLONG)PXEVA = StartValue;
    
43.                 ULONG PPEOffset = 0;
    
44.                 ULONG PPEOffsetEnd = TotalSizeOfValidPPEPages >> 9;
    
45.                 ULONG_PTR PPEBase = Result;
    
46.                 do
    
47.                 {
    
48.                     *(PULONGLONG)(PPEBase + PPEOffset) = StartValue + ((PPEOffset + 8) << 9);
    
49.                     PPEOffset += 8;
    
50.                 } while (PPEOffset < PPEOffsetEnd);
    
51.                 RtlZeroMemory((PVOID)(PPEBase + PPEOffset), PAGE_SIZE - PPEOffset);
    
52.                 __writecr8(OringinalIRQL);
    
53.             }
    
54.             break;
    
55.         }
    
56.         PXEVA += 8;
    
57.     } while (PXEVA < PXEVAEnd);
    
58.     return Result;
    
59. }
    
60. 
    
61. ULONG_PTR FillPDEArrayForAllValidPPEs(ULONG_PTR PagePointer, ULONG_PTR BaseAddress, ULONG SizeOfPPEPages, ULONG_PTR VirtualAddress)
    
62. {
    
63.     ULONG_PTR Result = 0;
    
64.     ULONG_PTR PteBase = PTEBase;
    
65.     ULONG_PTR OffsetMask = 0x7FFFFFFFF8;
    
66.     ULONG_PTR PDEVA = PteBase + (((PteBase + (((VirtualAddress & 0xFFFFFF8000000000) >> 9) & OffsetMask)) >> 9) & OffsetMask);
    
67.     ULONG_PTR PPEVA = PteBase + ((PDEVA >> 9) & OffsetMask);
    
68.     ULONG_PTR PXEVA = PteBase + ((PPEVA >> 9) & OffsetMask);
    
69.     if ((*(PUCHAR)PXEVA & 0x81) == 1) //不支持512G超大页面
    
70.     {
    
71.         if (SizeOfPPEPages >= PAGE_SIZE)
    
72.         {
    
73.             ULONG_PTR NewPDEVA = PagePointer + PAGE_SIZE;
    
74.             ULONG_PTR NewPDEVAEnd = NewPDEVA + SizeOfPPEPages;
    
75.             ULONG64 OringinalIRQL = __readcr8();
    
76.             __writecr8(DISPATCH_LEVEL);
    
77.             do
    
78.             {
    
79.                 UCHAR ByteFlag = *(PUCHAR)PPEVA;
    
80.                 if (ByteFlag & 1)
    
81.                 {
    
82.                     if ((CHAR)ByteFlag < 0) //为了不改变原先填充的PPE项，将1G大页面等分成512个2M大页面
    
83.                     {
    
84.                         ULONGLONG PDEStartValue = *(PULONGLONG)PPEVA;
    
85.                         ULONG PDEOffset = 0;
    
86.                         do
    
87.                         {
    
88.                             *(PULONGLONG)(NewPDEVA + PDEOffset) = PDEStartValue + (PDEOffset << 9);
    
89.                             PDEOffset += 8;
    
90.                         } while (PDEOffset < PAGE_SIZE);
    
91.                     }
    
92.                     else memcpy((PVOID)NewPDEVA, (PVOID)PDEVA, PAGE_SIZE);
    
93.                 }
    
94.                 else RtlZeroMemory((PVOID)NewPDEVA, PAGE_SIZE);              
    
95.                 PDEVA += PAGE_SIZE;
    
96.                 PPEVA += 8;
    
97.                 NewPDEVA += PAGE_SIZE;
    
98.             } while (NewPDEVA < NewPDEVAEnd);
    
99.             __writecr8(OringinalIRQL);
    
100.             __writecr3(__readcr3());
     
101.             Result = BaseAddress + (VirtualAddress & 0x7FFFFFFFFF);
     
102.         }
     
103.     }  
     
104.     return Result;
     
105. }
     
106. 
     
107. BOOLEAN MakeDirtyPage(ULONG_PTR VirtualAddress)
     
108. {
     
109.     BOOLEAN Result = FALSE;
     
110.     ULONG_PTR PteBase = PTEBase;
     
111.     ULONG_PTR OffsetMask = 0x7FFFFFFFF8;
     
112.     ULONG_PTR PTEVA = PteBase + ((VirtualAddress >> 9) & OffsetMask);
     
113.     ULONG_PTR PDEVA = PteBase + ((PTEVA >> 9) & OffsetMask);
     
114.     ULONG_PTR PPEVA = PteBase + ((PDEVA >> 9) & OffsetMask);
     
115.     ULONG_PTR PXEVA = PteBase + ((PPEVA >> 9) & OffsetMask);
     
116.     if ((*(PUCHAR)PXEVA & 0x81) == 1) //不支持512G超大页面
     
117.     {
     
118.         UCHAR ByteFlag = *(PUCHAR)PPEVA;
     
119.         if (ByteFlag & 1)
     
120.         {
     
121.             if ((CHAR)ByteFlag < 0)
     
122.             {
     
123.                 *(PUCHAR)PPEVA |= 0x42; //Dirty1 & Dirty
     
124.                 Result = TRUE;
     
125.             }
     
126.             else
     
127.             {
     
128.                 ByteFlag = *(PUCHAR)PDEVA;
     
129.                 if (ByteFlag & 1)
     
130.                 {
     
131.                     if ((CHAR)ByteFlag < 0)
     
132.                     {
     
133.                         *(PUCHAR)PDEVA |= 0x42;
     
134.                         Result = TRUE;
     
135.                     }
     
136.                     else
     
137.                     {
     
138.                         if (_bittest((PLONG)PTEVA, 0))
     
139.                         {
     
140.                             *(PUCHAR)PTEVA |= 0x42;
     
141.                             Result = TRUE;
     
142.                         }
     
143.                     }
     
144.                 }
     
145.             }
     
146.         }
     
147.     }
     
148.     __invlpg((PVOID)VirtualAddress);
     
149.     return Result;
     
150. }
     
151. 
     
152. void FreeSinglePXEDirectory(ULONG_PTR PagePointer, ULONG_PTR BaseAddress)
     
153. {
     
154.     ULONG_PTR PteBase = PTEBase;
     
155.     ULONG_PTR OffsetMask = 0x7FFFFFFFF8;
     
156.     *(PULONGLONG)(PteBase + (((PteBase + (((PteBase + (((PteBase + ((BaseAddress >> 9) & OffsetMask)) >> 9) & OffsetMask)) >> 9) & OffsetMask)) >> 9) & OffsetMask)) = 0;
     
157.     MmFreeContiguousMemory((PVOID)PagePointer);
     
158.     __writecr3(__readcr3());
     
159. }

复制代码

在Win10 18362.207 x64上的测试代码与结果：

1. NTKERNELAPI NTSTATUS ObReferenceObjectByName(IN PUNICODE_STRING ObjectName, IN ULONG Attributes, IN PACCESS_STATE PassedAccessState OPTIONAL, IN ACCESS_MASK DesiredAccess OPTIONAL, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, OUT PVOID *Object);
   
2. extern POBJECT_TYPE *IoDriverObjectType;
   
3. 
   
4. NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
   
5. {
   
6.     ULONG_PTR PagePointer = 0;
   
7.     ULONG_PTR BaseAddress = 0;
   
8.     ULONG SizeOfValidPPEPages = 0;
   
9.     if (GetPTEBase())
   
10.     {
    
11.         UNICODE_STRING UDrvName;
    
12.         PDRIVER_OBJECT DrvObj = 0;
    
13.         if (NT_SUCCESS(RtlInitUnicodeString(&UDrvName, L"\\Driver\\kbdclass")) && NT_SUCCESS(ObReferenceObjectByName(&UDrvName, OBJ_CASE_INSENSITIVE, 0, 0, *IoDriverObjectType, KernelMode, 0, (PVOID*)&DrvObj)))
    
14.         {
    
15.             ObDereferenceObject(DrvObj);
    
16.             PagePointer = AllocateSinglePXEDirectory(&BaseAddress, &SizeOfValidPPEPages);
    
17.             ULONG_PTR MappedKbdClassBase = FillPDEArrayForAllValidPPEs(PagePointer, BaseAddress, SizeOfValidPPEPages, (ULONG_PTR)DrvObj->DriverStart);
    
18.             if (MakeDirtyPage(MappedKbdClassBase)) *(PULONG)(MappedKbdClassBase + 4) = 0x78563412;
    
19.             FreeSinglePXEDirectory(PagePointer, BaseAddress);
    
20.         }
    
21.     }
    
22.     return STATUS_UNSUCCESSFUL;
    
23. }

复制代码

另外附上Win10的_MMPTE_HARDWARE以供参考

1. typedef struct _MMPTE_HARDWARE
   
2. {
   
3.     ULONGLONG Valid : 1;
   
4.     ULONGLONG Dirty1 : 1;
   
5.     ULONGLONG Owner : 1;
   
6.     ULONGLONG WriteThrough : 1;
   
7.     ULONGLONG CacheDisable : 1;
   
8.     ULONGLONG Accessed : 1;
   
9.     ULONGLONG Dirty : 1;
   
10.     ULONGLONG LargePage : 1;
    
11.     ULONGLONG Global : 1;
    
12.     ULONGLONG CopyOnWrite : 1;
    
13.     ULONGLONG Unused : 1;
    
14.     ULONGLONG Write : 1;
    
15.     ULONGLONG PageFrameNumber : 36; //Vista SP0为28，Vista SP1--10通用36
    
16.     ULONGLONG ReservedForHardware : 4;
    
17.     ULONGLONG ReservedForSoftware : 4;
    
18.     ULONGLONG WsleAge : 4;
    
19.     ULONGLONG WsleProtection : 3;
    
20.     ULONGLONG NoExecute : 1;
    
21. } MMPTE_HARDWARE, *PMMPTE_HARDWARE;

复制代码

    总结一下，以上实现的代码大概类似弟中弟中弟版MmBuildMdlForNonPagedPool和MmMapLockedPagesSpecifyCache，不同的是本文的代码更多地相当于一份512G的虚拟地址空间物理内存的分布快照，这其中可能存在部分分页内存在快照过程中被放入物理内存而快照后再次被分回硬盘的情况，因此在映射地址空间使用MmIsAddressValid远远不如在原地址空间使用靠谱。

   测试发现刷TLB的确不需要KeFlushTb，只要对要访问或修改的映射页面invlpg刷新单个PTE对应的TLB项即可。以上代码在Vista SP0至Win10 18363均测试有效。