x64内核-页机制的研究

admin
admin
admin
103222
文章
87
评论
2023年10月30日01:27:44评论8 views字数 18417阅读61分23秒阅读模式
CR4寄存器

在白皮书的第三卷2.5章对控制寄存器有详细的介绍，下面是白皮书中CR寄存器的结构图（这里要说明一下cr4的第12位是由被使用的这个位在2.5章的后半部分有介绍是控制是否开启5级分页的位否则是四级分页）。
x64内核-页机制的研究
首先是smep和smap两个位，这部分因为之前的实验会用到所以已经在段机制的部分介绍过了，这里就不再赘述。

其余一些位置的功能后面用到了会继续介绍，这边有个结构的概念就可以了。

64位下分页机制的变化

下面我们来梳理一下64位cpu中分页机制的变化过程：

1.在64位内核中因为物理地址范围扩充到了48位所以页表也因此扩充了，首先大家思考一下我们现在是有64位的虚拟地址可以用还按照4k分页的话那么我们的虚拟地址中就要留出12位来作为4k物理页中的寻址。

2.其次我们还剩下了48位可以用，101012分页不知道大家还记得不，在32位的2级分页中我们是ptt和pdt中存放了1024个物理地址指向pte和pde，现在我们的物理地址位数增加到了64那么我们的一个页表里就只能存放512个页表项了，所以我们不在需要10位来寻址1024个页表项而是需要9位来寻址512个页表项。

3.然后我们还需要考虑到现在的64位下真正的地址线是有48根的那么我们真正的寻址范围是48位也就是512g我们现在用掉了12位那么就还剩下36位，每一级页表需要9位那么最终的分页机制就是9-9-9-9-12的四级分页（当然这只是我的理解，64位cpu还支持5级分页只是带上自己的思考能够更好的帮助自己理解分页机制的原理）。

然后我们看一下白皮书里对目前分页机制的一个图表介绍，如下：第一个图是32位下的三级分页机制2-9-9-12，第二个图是64位的四级分页（这边贴上三级分页希望能更好的帮助看文章的各位对照着32位下的pae模式来理解四级分页）。
x64内核-页机制的研究

x64内核-页机制的研究

简单的讲一下上面这张图。

图里的第一行是CR3的描述。

第二行PML5E是五级分页才会用到的这里不多赘述五级分页因为我还没有碰到五级分页的操作系统。

第三行的PML4E是一级页表项当p=1时说明当前页表项有效否则是无效。

第四行的PDPTE是二级页表项，当p=1时有效而且ps位=1的时候是1G的大页（第7位）1G的话大家可以拆分一下看看1G需要的页内寻址偏移为30位，我们的虚拟地址到拆分到二级的时候使用掉了18位正好剩下30位意味着我们的分页变为了9-9-30，如果ps=0的话就还按照9-9-9-9-12分页。

第五行的PDE是三级页表项，当p=1时有效而且ps位=1的时候是2MB的大页（第7位）2MB的话大家可以拆分一下看看2MB需要的页内寻址偏移为21位，我们的虚拟地址到拆分到三级的时候使用掉了27位正好剩下30位意味着我们的分页变为了9-9-9-21，如果ps=0的话就还按照9-9-9-9-12分页。

第六行的PTE是二级页表项目当p=1时有效。

图中在4级以及以上的位置使用了PMLXE的描述方式，后面的则跟2-9-9-12时候的命名一样我觉得可能记起来比较麻烦所以就按照页表的级别来描述几级就是几级页表里面的项就是X级页表项这种叫法。

各个位的介绍如下：
x64内核-页机制的研究

下面我们来拆分一个虚拟地址看一下。

fffff803`45299fc0  00209b00`00000000 00409300`00000000
0: kd> r cr3
cr3=00000000001aa000
这是我环境中的GDT表中的一项，我的cr3是=00000000001aa000，下面让我门来拆一下
11111111 11111111 11111000 00000011 01000101 00101001 10011111 10110000
上面是拆成二进制的形式
高16位不关注：fffff
1级页表偏移：11111000 0 -- 1f0
2级页表偏移：0000011 01 -- 0d
3级页表偏移：000101 001 -- 29
4级页表偏移：01001 1001 -- 99
页内偏移：fc0
 kd> !dq 00000000001aa000 + 1f0 * 8
#  1aaf80 00000000`05209063 00000000`00000000
#  1aaf90 00000000`00000000 00000000`00000000
#  1aafa0 00000000`00000000 00000000`00000000
#  1aafb0 00000000`00000000 00000000`00000000
#  1aafc0 00000000`00000000 00000000`00000000
#  1aafd0 00000000`00000000 00000000`00000000
#  1aafe0 00000000`00000000 00000000`00000000
#  1aaff0 00000000`00000000 00000000`05123063
0: kd> !dq 00000000`05209000 + d * 8
# 5209068 00000000`05215063 0a000000`33a85863
# 5209078 0a000001`0ed50863 0a000000`88607863
# 5209088 00000000`00000000 00000000`00000000
# 5209098 00000000`00000000 00000000`00000000
# 52090a8 00000000`00000000 00000000`00000000
# 52090b8 00000000`00000000 00000000`00000000
# 52090c8 00000000`00000000 00000000`00000000
# 52090d8 00000000`00000000 00000000`00000000
0: kd> !dq 00000000`05215000 + 29 * 8
# 5215148 00000000`05122063 0a000001`1cd12863
# 5215158 0a000000`01009863 0a000000`0100a863
# 5215168 0a000000`0120b863 0a000000`05d35863
# 5215178 0a000001`03748863 0a000001`044a2863
# 5215188 0a000001`044a3863 0a000001`044a4863
# 5215198 0a000001`044a5863 0a000001`044be863
# 52151a8 0a000001`044bf863 0a000001`0442c863
# 52151b8 0a000001`0442d863 0a000001`0442e863
0: kd> !dq  00000000`05122000 + 99 * 8
# 51224c8 89000000`06499963 89000000`0649a963
# 51224d8 89000000`0649b963 89000000`0649c963
# 51224e8 00000000`00000000 89000000`0649e963
# 51224f8 89000000`0649f963 89000000`064a0963
# 5122508 89000000`064a1963 89000000`064a2963
# 5122518 89000000`064a3963 00000000`00000000
# 5122528 89000000`064a5963 89000000`064a6963
# 5122538 89000000`064a7963 89000000`064a8963
0: kd> !dq 6499000 + fc0
# 6499fc0 00209b00`00000000 00409300`00000000

可以看到我们手工拆分查出来的跟虚拟地址里存的是一样的，我们还可以通过!pte命令来验证
0: kd> !pte fffff803`45299fc0
                                           VA fffff80345299fc0
PXE at FFFFEEF77BBDDF80    PPE at FFFFEEF77BBF0068    PDE at FFFFEEF77E00D148    PTE at FFFFEEFC01A294C8
contains 0000000005209063  contains 0000000005215063  contains 0000000005122063  contains 8900000006499963
pfn 5209      ---DA--KWEV  pfn 5215      ---DA--KWEV  pfn 5122      ---DA--KWEV  pfn 6499      -G-DA--KW-V

然后我们就可以做几个实验来熟悉一下这个拆分过程。

实验1：编写驱动，用代码拆分获取idt表的物理地址（复现我们刚刚手工的拆分过程）并手工拆分验证。

实验代码：

x64Common.h

#pragma once
#include <wdm.h>
#include <intrin.h>
#pragma pack(1)
struct Attribute
{
    UINT64 offset1 : 16;
    UINT64 p : 1;
    UINT64 dpl : 2;
    UINT64 s : 1;
    UINT64 type : 4;
    UINT64 unuse : 6;
    UINT64 ist : 2;
    UINT64 selector : 16;
    UINT64 offset2 : 16;
};
typedef struct _IDT_ENTRY64 {

    union hightStruct
    {
        UINT64 lower;
        struct Attribute attribute;
    };
    UINT64 hight;
}IDT_ENTRY64, * PIDT_ENTRY64;

typedef struct _IDTR
{
    UINT16 limit;
    UINT64 base;
}IDTR, * PIDTR;
/// <summary>
/// cr4结构体
/// </summary>
typedef union _CR4 {
    UINT64 value;
    struct
    {
        UINT64 VME : 1;
        UINT64 PVI : 1;
        UINT64 TSD : 1;
        UINT64 DE : 1;
        UINT64 PSE : 1;
        UINT64 PAE : 1;
        UINT64 MCE : 1;
        UINT64 PGE : 1;
        UINT64 PCE : 1;
        UINT64 OSFXSR : 1;
        UINT64 OSXMMEXCPT : 1;
        UINT64 UMIP : 1;
        UINT64 LA57 : 1;
        UINT64 VMXE : 1;
        UINT64 SMXE : 1;
        UINT64 unuse1 : 1;
        UINT64 FSGSBASE : 1;
        UINT64 PCIDE : 1;
        UINT64 OSXSAVE : 1;
        UINT64 KL : 1;
        UINT64 SMEP : 1;
        UINT64 SMAP : 1;
        UINT64 PKE : 1;
        UINT64 CET : 1;
        UINT64 PKS : 1;
        UINT64 Ressrved : 63 - 24;
    }Fields;
}CR4, * PCR4;
static_assert(sizeof(CR4) == 8, "sizeof CR4");
/// <summary>
/// cr3结构体
/// </summary>
typedef union _CR3 {
    UINT64 value;
    struct
    {
        UINT64 ignore1 : 3;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 ignore2 : 7;
        UINT64 PPN : 40;
        UINT64 Reserved1 : 12;
    }Fields;

}CR3, * PCR3;
static_assert(sizeof(CR3) == 8, "sizeof CR3");
/// <summary>
/// 各页表项结构体
/// </summary>
typedef union _PA {
    UINT64 vaule;
    LARGE_INTEGER AsLargeInteger;
    struct
    {
        UINT64 PPO : 12;
        UINT64 PPN : 40;
        UINT64 UnUse1 : 12;
    }Fileds4KB;
    struct
    {
        UINT64 PPO : 21;
        UINT64 PPN : 31;
        UINT64 UnUse1 : 12;
    }Fileds2MB;
    struct
    {
        UINT64 PPO : 30;
        UINT64 PPN : 22;
        UINT64 UnUse1 : 12;
    }Fileds1GB;
}PA, * P_PA;
static_assert(sizeof(PA) == 8, "sizeof PA");
/// <summary>
/// 虚拟地址结构体
/// </summary>
typedef union _VA {
    UINT64 vaule;
    LARGE_INTEGER AsLargeInteger;
    struct
    {
        UINT64 VPO : 12;
        UINT64 VPN4 : 9;
        UINT64 VPN3 : 9;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds4KB;
    struct
    {
        UINT64 VPO : 21;
        UINT64 VPN3 : 9;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds2MB;
    struct
    {
        UINT64 VPO : 30;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds1GB;

}VA, * P_VA;
static_assert(sizeof(VA) == 8, "sizeof VA");

typedef union _PML4E {
    UINT64 value;
    struct 
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 5;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign2 : 15;
        UINT64 XD : 1;
    }Fields4K;
}PML4E, *PPML4E, L1PTE, *PL1PTE;
static_assert(sizeof(PML4E) == 8, "sizeof PML4E");
typedef union _PDPTE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 Reserved : 18;
        UINT64 PPN : 18;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields1G;
}PDPTE, *PPDPTE, L2PTE, *PL2PTE;
static_assert(sizeof(PDPTE) == 8, "sizeof PDPTE");
typedef union _PDE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 Reserved : 9;
        UINT64 PPN : 27;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields2MB;
}PDE, *PPDE, L3PTE, *PL3PTE;
static_assert(sizeof(PDE) == 8, "sizeof PDE");
typedef union _PTE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
}PTE, *PPTE, L4PTE, *PL4PTE;
static_assert(sizeof(PDE) == 8, "sizeof PTE");
#pragma pack()
//各个页表存储了512个页表项
#define MIX_PAGETABLEENTRY_SIZE 512
//------内核导出函数声明：begin------//
extern PVOID __stdcall MmGetVirtualForPhysical(LARGE_INTEGER AsLargeInteger);
extern NTSTATUS PsLookupProcessByProcessId(HANDLE ProcessId, PEPROCESS* Process);
//------内核导出函数声明: end------//

main.c

#include <wdm.h>
//#include <ntifs.h>
#define NTSTRSAFE_LIB
#include <ntstrsafe.h>
#include "x64Common.h"

VOID Unload(PDRIVER_OBJECT pDriver) {
    KdPrint(("unloadrn"));

}


NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pRegPath) {
    NTSTATUS status = STATUS_SUCCESS;

    pDriver->DriverUnload = Unload;
    KdPrint(("startrn"));
    
    CR4 cr4 = { .value = __readcr4() };
    cr4.Fields.SMAP = 0;
    cr4.Fields.SMEP = 0;
    __writecr4(cr4.value);
    
    IDTR idtr = { 0 };
    __sidt(&idtr);
    VA idtVa = { .vaule = idtr.base };
    CR3 cr3 = { .value = __readcr3() };
    PA pa = { 0 };
    pa.Fileds4KB.PPN = cr3.Fields.PPN;
    //
    PL1PTE L1 = MmGetVirtualForPhysical(pa.AsLargeInteger);
    KdPrint(("当前idt1级页表对应的虚拟地址地址0x%prn", L1));
    pa.Fileds4KB.PPN = L1[idtVa.Fileds4KB.VPN1].Fields4K.PPN;
    KdPrint(("当前idt1级页表项对应的物理地址地址0x%llxrn", pa.vaule));
    

    PL2PTE L2 = MmGetVirtualForPhysical(pa.AsLargeInteger);
    KdPrint(("当前idt2级页表对应的虚拟地址地址0x%prn", L2));
    pa.Fileds4KB.PPN = L2[idtVa.Fileds4KB.VPN2].Fields4K.PPN;
    KdPrint(("当前idt2级页表项对应的物理地址地址0x%llxrn", pa.vaule));
    


    PL3PTE L3 = MmGetVirtualForPhysical(pa.AsLargeInteger);
    KdPrint(("当前idt3级页表对应的虚拟地址地址0x%prn", L3));
    pa.Fileds4KB.PPN = L3[idtVa.Fileds4KB.VPN3].Fields4K.PPN;
    KdPrint(("当前idt3级页表项对应的物理地址地址0x%llxrn", pa.vaule));
    


    PL4PTE L4 = MmGetVirtualForPhysical(pa.AsLargeInteger);
    KdPrint(("当前idt4级页表对应的虚拟地址地址0x%prn", L4));
    pa.Fileds4KB.PPN = L4[idtVa.Fileds4KB.VPN4].Fields4K.PPN;
    pa.Fileds4KB.PPO = idtVa.Fileds4KB.VPO;
    KdPrint(("当前idt对应的物理地址地址0x%llxrn", pa.vaule));
    
    
    
    KdPrint(("endrn"));
    return status;
}

打印结果如下：

start
当前idt1级页表对应的虚拟地址地址0xFFFFC06030180000
当前idt1级页表项对应的物理地址地址0x4f2e000
当前idt2级页表对应的虚拟地址地址0xFFFFC06030190000
当前idt2级页表项对应的物理地址地址0x4f2f000
当前idt3级页表对应的虚拟地址地址0xFFFFC06032001000
当前idt3级页表项对应的物理地址地址0x11cc6f000
当前idt4级页表对应的虚拟地址地址0xFFFFC06400206000
当前idt对应的物理地址地址0x2851000
end

手工拆分

1: kd> r idtr
idtr=ffffc80040dd5000
Binary:  11111111 11111111 11001000 00000000 01000000 11011101 01010000 00000000
高16位不关注：fffff
1级页表偏移：11001000 0 -- 190
2级页表偏移：0000000 01 -- 01
3级页表偏移：000000 110 -- 06
4级页表偏移：11101 0101 -- 1d5
页内偏移：000
 kd> r cr3
cr3=00000000001aa000
1: kd> !dq 00000000001aa000 + 190*8
#  1aac80 0a000000`04f2e863 00000000`00000000
#  1aac90 00000000`00000000 00000000`00000000
#  1aaca0 00000000`00000000 00000000`00000000
#  1aacb0 00000000`00000000 00000000`00000000
#  1aacc0 00000000`00000000 00000000`00000000
#  1aacd0 00000000`00000000 00000000`00000000
#  1aace0 00000000`00000000 00000000`00000000
#  1aacf0 00000000`00000000 00000000`00000000
1: kd> !dq 4f2e000 + 8
# 4f2e008 0a000000`04f2f863 00000000`00000000
# 4f2e018 00000000`00000000 00000000`00000000
# 4f2e028 00000000`00000000 00000000`00000000
# 4f2e038 00000000`00000000 00000000`00000000
# 4f2e048 00000000`00000000 00000000`00000000
# 4f2e058 00000000`00000000 00000000`00000000
# 4f2e068 00000000`00000000 00000000`00000000
# 4f2e078 00000000`00000000 00000000`00000000
1: kd> !dq 4f2f000 + 6 * 8
# 4f2f030 0a000001`1cc6f863 0a000001`1cce3863
# 4f2f040 0a000001`1cd78863 0a000001`1cd62863
# 4f2f050 0a000000`0411b863 0a000001`1ff1c863
# 4f2f060 0a000000`0651d863 0a000000`01f1e863
# 4f2f070 0a000000`0131f863 0a000000`0559f863
# 4f2f080 0a000000`013a0863 0a000000`010a2863
# 4f2f090 0a000000`013a3863 0a000000`010a4863
# 4f2f0a0 0a000000`013a5863 0a000000`011a6863
1: kd> !dq 1`1cc6f000 + 1d5 * 8
#11cc6fea8 8a000000`02851121 8a000000`02852963
#11cc6feb8 8a000000`02853963 8a000000`02854963
#11cc6fec8 8a000000`02855963 8a000000`02856963
#11cc6fed8 8a000000`dffc1963 8a000000`dffc2963
#11cc6fee8 8a000000`dffc3963 00000000`00000000
#11cc6fef8 00000000`00000000 00000000`00000000
#11cc6ff08 00000000`00000000 00000000`00000000
#11cc6ff18 00000000`00000000 8a000000`dffbe963
1: kd> !dq 2851000
# 2851000 48e08e00`00106300 00000000`fffff805
# 2851010 48e08e04`00106640 00000000`fffff805
# 2851020 48e08e03`00106b00 00000000`fffff805
# 2851030 48e0ee00`00106fc0 00000000`fffff805
# 2851040 48e0ee00`00107300 00000000`fffff805
# 2851050 48e08e00`00107640 00000000`fffff805
# 2851060 48e08e00`00107c80 00000000`fffff805
# 2851070 48e08e00`00108280 00000000`fffff805
1: kd> dq idtr
ffffc800`40dd5000  48e08e00`00106300 00000000`fffff805
ffffc800`40dd5010  48e08e04`00106640 00000000`fffff805
ffffc800`40dd5020  48e08e03`00106b00 00000000`fffff805
ffffc800`40dd5030  48e0ee00`00106fc0 00000000`fffff805
ffffc800`40dd5040  48e0ee00`00107300 00000000`fffff805
ffffc800`40dd5050  48e08e00`00107640 00000000`fffff805
ffffc800`40dd5060  48e08e00`00107c80 00000000`fffff805
ffffc800`40dd5070  48e08e00`00108280 00000000`fffff805

阶段实验

做个实验回顾一下之前的页机制，以达到熟悉页机制的目的。

实验1：编写驱动读取某个进程的某个虚拟地址内容并打印出物理地址，然后手工修改这个物理地址里的内容来验证找到的是否正确（驱动代码共享内存然后修改内存的方式后面再讲现在只手工实验），这边我默认大家都学过x32的内核知识，不过会在代码注释中将页之外的动作加上对应的说明。

实验代码：

测试应用程序：

#include <Windows.h>
#include <stdio.h>

DWORD32 testVal = 111;

int main() {
    
    printf("pid: %drn",GetCurrentProcessId());
    while (true)
    {
        system("pause");
        printf("addr: 0x%prn", &testVal);
        printf("val: %drn", testVal);
    }
    return 0;
}

根据pid和addr编写我们的驱动代码。

驱动：

x64Common.h

#pragma once
#include <ntifs.h>
#include <ntddk.h>
#define NTSTRSAFE_LIB
#include <ntstrsafe.h>
#include <intrin.h>
#pragma pack(1)
struct Attribute
{
    UINT64 offset1 : 16;
    UINT64 p : 1;
    UINT64 dpl : 2;
    UINT64 s : 1;
    UINT64 type : 4;
    UINT64 unuse : 6;
    UINT64 ist : 2;
    UINT64 selector : 16;
    UINT64 offset2 : 16;
};
typedef struct _IDT_ENTRY64 {

    union hightStruct
    {
        UINT64 lower;
        struct Attribute attribute;
    };
    UINT64 hight;
}IDT_ENTRY64, * PIDT_ENTRY64;

typedef struct _IDTR
{
    UINT16 limit;
    UINT64 base;
}IDTR, * PIDTR;
/// <summary>
/// cr4结构体
/// </summary>
typedef union _CR4 {
    UINT64 value;
    struct
    {
        UINT64 VME : 1;
        UINT64 PVI : 1;
        UINT64 TSD : 1;
        UINT64 DE : 1;
        UINT64 PSE : 1;
        UINT64 PAE : 1;
        UINT64 MCE : 1;
        UINT64 PGE : 1;
        UINT64 PCE : 1;
        UINT64 OSFXSR : 1;
        UINT64 OSXMMEXCPT : 1;
        UINT64 UMIP : 1;
        UINT64 LA57 : 1;
        UINT64 VMXE : 1;
        UINT64 SMXE : 1;
        UINT64 unuse1 : 1;
        UINT64 FSGSBASE : 1;
        UINT64 PCIDE : 1;
        UINT64 OSXSAVE : 1;
        UINT64 KL : 1;
        UINT64 SMEP : 1;
        UINT64 SMAP : 1;
        UINT64 PKE : 1;
        UINT64 CET : 1;
        UINT64 PKS : 1;
        UINT64 Ressrved : 63 - 24;
    }Fields;
}CR4, * PCR4;
static_assert(sizeof(CR4) == 8, "sizeof CR4");
/// <summary>
/// cr3结构体
/// </summary>
typedef union _CR3 {
    UINT64 value;
    struct
    {
        UINT64 ignore1 : 3;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 ignore2 : 7;
        UINT64 PPN : 40;
        UINT64 Reserved1 : 12;
    }Fields;

}CR3, * PCR3;
static_assert(sizeof(CR3) == 8, "sizeof CR3");
/// <summary>
/// 各页表项结构体
/// </summary>
typedef union _PA {
    UINT64 vaule;
    LARGE_INTEGER AsLargeInteger;
    struct
    {
        UINT64 PPO : 12;
        UINT64 PPN : 40;
        UINT64 UnUse1 : 12;
    }Fileds4KB;
    struct
    {
        UINT64 PPO : 21;
        UINT64 PPN : 31;
        UINT64 UnUse1 : 12;
    }Fileds2MB;
    struct
    {
        UINT64 PPO : 30;
        UINT64 PPN : 22;
        UINT64 UnUse1 : 12;
    }Fileds1GB;
}PA, * P_PA;
static_assert(sizeof(PA) == 8, "sizeof PA");
/// <summary>
/// 虚拟地址结构体
/// </summary>
typedef union _VA {
    UINT64 vaule;
    LARGE_INTEGER AsLargeInteger;
    struct
    {
        UINT64 VPO : 12;
        UINT64 VPN4 : 9;
        UINT64 VPN3 : 9;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds4KB;
    struct
    {
        UINT64 VPO : 21;
        UINT64 VPN3 : 9;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds2MB;
    struct
    {
        UINT64 VPO : 30;
        UINT64 VPN2 : 9;
        UINT64 VPN1 : 9;
        UINT64 UnUse1 : 16;
    }Fileds1GB;

}VA, * P_VA;
static_assert(sizeof(VA) == 8, "sizeof VA");

typedef union _PML4E {
    UINT64 value;
    struct 
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 5;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign2 : 15;
        UINT64 XD : 1;
    }Fields4K;
}PML4E, *PPML4E, L1PTE, *PL1PTE;
static_assert(sizeof(PML4E) == 8, "sizeof PML4E");
typedef union _PDPTE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 Reserved : 18;
        UINT64 PPN : 18;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields1G;
}PDPTE, *PPDPTE, L2PTE, *PL2PTE;
static_assert(sizeof(PDPTE) == 8, "sizeof PDPTE");
typedef union _PDE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 Reserved : 9;
        UINT64 PPN : 27;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields2MB;
}PDE, *PPDE, L3PTE, *PL3PTE;
static_assert(sizeof(PDE) == 8, "sizeof PDE");
typedef union _PTE {
    UINT64 value;
    struct
    {
        UINT64 P : 1;
        UINT64 R_W : 1;
        UINT64 US : 1;
        UINT64 PWT : 1;
        UINT64 PCD : 1;
        UINT64 A : 1;
        UINT64 ign : 1;
        UINT64 PS : 1;
        UINT64 ign2 : 3;
        UINT64 R : 1;
        UINT64 PPN : 36;
        UINT64 ign3 : 15;
        UINT64 XD : 1;
    }Fields4K;
}PTE, *PPTE, L4PTE, *PL4PTE;
static_assert(sizeof(PDE) == 8, "sizeof PTE");
#pragma pack()
//各个页表存储了512个页表项
#define MIX_PAGETABLEENTRY_SIZE 512
//------内核导出函数声明：begin------//
extern PVOID __stdcall MmGetVirtualForPhysical(LARGE_INTEGER AsLargeInteger);
//extern NTSTATUS PsLookupProcessByProcessId(HANDLE ProcessId, PEPROCESS* Process);

//------内核导出函数声明: end------//


//------导出函数声明-------//

/// <summary>
/// 虚拟地址转换为物理地址
/// </summary>
/// <param name="cr3">目标进程的cr3</param>
/// <param name="pVa">虚拟地址结构指针</param>
/// <param name="outPa">出参：物理地址结构指针</param>
/// <returns></returns>
NTSTATUS Va2Pa(_In_ const PCR3 cr3, _In_ const P_VA pVa, _Out_ P_PA outPa);

x64Common.c

#include "x64Common.h"

NTSTATUS Va2Pa(PCR3 cr3, P_VA pVa, P_PA outPa)
{
    __try {
        PA pa = { .Fileds4KB.PPN = cr3->Fields.PPN };
        PL1PTE L1PT = MmGetVirtualForPhysical(pa.AsLargeInteger);
        PL1PTE pL1PTE = &L1PT[pVa->Fileds4KB.VPN1];
        if (pL1PTE->Fields4K.P == 0)
            return STATUS_UNSUCCESSFUL;
        pa.Fileds4KB.PPN = pL1PTE->Fields4K.PPN;

        PL2PTE L2PT = MmGetVirtualForPhysical(pa.AsLargeInteger);
        PL2PTE pL2PTE = &L2PT[pVa->Fileds4KB.VPN2];
        if (pL2PTE->Fields4K.P == 0)
            return STATUS_UNSUCCESSFUL;
        if (pL2PTE->Fields1G.PS == 1) {
            outPa->Fileds1GB.PPN = pL2PTE->Fields1G.PPN;
            outPa->Fileds1GB.PPO = pVa->Fileds1GB.VPO;
            return STATUS_SUCCESS;
        }
        pa.Fileds4KB.PPN = pL2PTE->Fields4K.PPN;

        PL3PTE L3PT = MmGetVirtualForPhysical(pa.AsLargeInteger);
        PL3PTE pL3PTE = &L3PT[pVa->Fileds4KB.VPN3];
        if (pL3PTE->Fields4K.P == 0)
            return STATUS_UNSUCCESSFUL;
        if (pL3PTE->Fields2MB.PS == 1) {
            outPa->Fileds2MB.PPN = pL3PTE->Fields2MB.PPN;
            outPa->Fileds2MB.PPO = pVa->Fileds2MB.VPO;
            return STATUS_SUCCESS;
        }
        pa.Fileds4KB.PPN = pL3PTE->Fields4K.PPN;

        PL4PTE L4PT = MmGetVirtualForPhysical(pa.AsLargeInteger);
        PL4PTE pL4PTE = &L4PT[pVa->Fileds4KB.VPN4];
        if (pL4PTE->Fields4K.P == 0)
            return STATUS_UNSUCCESSFUL;
        outPa->Fileds4KB.PPN = pL4PTE->Fields4K.PPN;
        outPa->Fileds4KB.PPO = pVa->Fileds4KB.VPO;
    }
    __except (1) {
        KdPrint(("Failed exper Va2Pa"));
        return STATUS_UNSUCCESSFUL;
    }

    return STATUS_SUCCESS;
}

main.c

#include "x64Common.h"

VOID Unload(PDRIVER_OBJECT pDriver) {
    KdPrint(("unloadrn"));

}


NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pRegPath) {
    NTSTATUS status = STATUS_SUCCESS;

    pDriver->DriverUnload = Unload;
    KdPrint(("startrn"));
    CR4 cr4;
    cr4.value = __readcr4();
    cr4.Fields.SMEP = 0;
    cr4.Fields.SMAP = 0;
    __writecr4(cr4.value);
    PEPROCESS pEprocess;
    DWORD64 pid = 7756;
    status = PsLookupProcessByProcessId((HANDLE)pid, &pEprocess);
    if (!NT_SUCCESS(status))
        KdPrint(("获取eprocess失败rn"));
    KAPC_STATE apcState;
    VA va = { .vaule = 0x00007FF749C63034 };
    PA pa = { 0 };
    
    
    KeStackAttachProcess(pEprocess, &apcState);
    CR3 cr3 = { .value = __readcr3() };
    status = Va2Pa(&cr3, &va, &pa);
    if (!NT_SUCCESS(status)) 
        KdPrint(("获取物理地址失败rn"));
    KdPrint(("物理地址为：0x%llx", pa.vaule));
    KeUnstackDetachProcess(&apcState);
    
    
    
    KdPrint(("endrn"));
    return STATUS_SUCCESS;
}

得到打印出的物理地址：

start
物理地址为：0x77ee3034
end
unload

手动修改地址内容为123

0: kd> !dd 0x77ee3034
#77ee3034 0000006f 00000000 00000000 00000000
#77ee3044 00000000 00000000 00000000 00000000
#77ee3054 00000000 00000000 00000000 00000000
#77ee3064 00000000 00000000 00000000 00000000
#77ee3074 00000000 00000000 00000000 00000000
#77ee3084 00000000 00000000 00000000 00000000
#77ee3094 00000000 00000000 00000000 00000000
#77ee30a4 00000000 00000000 00000000 00000000
0: kd> !ed 0x77ee3034 7b
0: kd> !dd 0x77ee3034
#77ee3034 0000007b 00000000 00000000 00000000
#77ee3044 00000000 00000000 00000000 00000000
#77ee3054 00000000 00000000 00000000 00000000
#77ee3064 00000000 00000000 00000000 00000000
#77ee3074 00000000 00000000 00000000 00000000
#77ee3084 00000000 00000000 00000000 00000000
#77ee3094 00000000 00000000 00000000 00000000
#77ee30a4 00000000 00000000 00000000 00000000

查看测试程序的输出。

x64内核-页机制的研究



x64内核-页机制的研究


看雪ID：幺幺满地乱爬

https://bbs.kanxue.com/user-home-987725.htm

*本文为看雪论坛优秀文章，由 幺幺满地乱爬 原创，转载请注明来自看雪社区

x64内核-页机制的研究

# 往期推荐

1、IOFILE exploit入门

2、入门编译原理之前端体验

3、如何用纯猜的方式逆向喜马拉雅xm文件加密(wasm部分)

4、反恶意软件扫描接口(AMSI)如何帮助您防御恶意软件

5、sRDI — Shellcode反射式DLL注入技术

6、对APP的检测以及参数计算分析


x64内核-页机制的研究


x64内核-页机制的研究

球分享

x64内核-页机制的研究

球点赞

x64内核-页机制的研究

球在看

原文始发于微信公众号（看雪学苑）：x64内核-页机制的研究

  • 左青龙
  • 微信扫一扫
  • weinxin
  • 右白虎
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2023年10月30日01:27:44
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出)：
                   x64内核-页机制的研究https://cn-sec.com/archives/2155592.html

发表评论

匿名网友 填写信息