Windows 内核驱动入门,调试环境与内核编程基础

4300 字
22 分钟
Windows 内核驱动入门,调试环境与内核编程基础
这篇文章也有English版。

这一篇是 2020 年两套内核笔记合起来重写的。先是搭调试环境的《Windows内核调试学习笔记》两篇,然后是《Windows内核学习笔记》两篇讲编程基础的。当时的实验环境是 VMware 里的 Windows 7 x86 加串口调试,到 2026 年这套早该换了,所以调试环境这部分整个重写成网络调试(KDNET);编程基础那部分主体仍然成立,但代码里有几处会真的让驱动死锁或者泄漏的 bug,这次一并改掉。

现在的内核调试环境怎么搭#

当年用的是 VMware 虚拟串口 + msconfig 开调试 + WinDbg 连命名管道。这套今天还能跑,但没必要了。从 Windows 8 起内核调试可以直接走网络,用 KDNET 一条命令配好,比配虚拟串口省事得多。

需要的东西#

开发机

  • Windows 10/11 x64
  • Visual Studio 2022,装”使用 C++ 的桌面开发”
  • Windows Driver Kit(和 VS 配套的那个版本)
  • WinDbg(现在直接在 Microsoft Store 装 “WinDbg”,就是原来 WinDbg Preview 的正式版)

测试机

  • Windows 10/11 x64 虚拟机
  • DebugView(看 DbgPrint 输出的老工具,Sysinternals 的)

配置 KDNET#

在测试机里用管理员权限跑 WDK 带的 kdnet.exe:

kdnet.exe <开发机的IP> <端口>

它会打印一串调试密钥,并自动把调试配置写进测试机的启动项,然后让你重启。注意每次重新配置都会生成新的密钥,要用新的那个。虚拟机的话,把网络设成桥接或者和开发机同一个 NAT 网段,让两边能互相 ping 通。

重启后,在开发机的 WinDbg 里选 File -> Attach to kernel -> Net,填端口和那串密钥,就能连上了。符号路径设成 SRV*C:\Symbols*https://msdl.microsoft.com/download/symbols,第一次连会自动下载对应的 PDB,慢一点是正常的。

当年笔记里还有一段用 VMware 序列号和迅雷链接下 Win7 镜像的步骤,这些当然都删掉了,今天也没人需要 Win7 x86 来学内核。

打开测试签名#

自己写的驱动没有正式签名,测试机上要么开测试模式,要么用 WinDbg 连上去之后直接改:

bcdedit /set testsigning on

改完重启,桌面右下角会出现”测试模式”的水印。虚拟机里做实验没问题;真机上最好不要长期开着,因为测试模式下任何没有签名的驱动都能加载,等于自己把最后一道门打开了。


用符号去看内核结构#

内核里绝大多数结构是不公开的,但微软给 Windows 发了 PDB 符号,所以只要有符号,WinDbg 就能把结构体的字段名和偏移都列出来。这是读内核最重要的一件事,不用去背偏移,让符号告诉你。

kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x440 UniqueProcessId : Ptr64 Void
+0x448 ActiveProcessLinks : _LIST_ENTRY
...
kd> dt nt!_EPROCESS -b // 展开子结构
kd> dt nt!_PEB

几个常用的:

  • dt 看结构,-b 递归展开,-r 看原始偏移
  • !process 0 0 列出所有进程的 EPROCESS 地址和名字
  • !peb 直接看某个进程的 PEB
  • kd> ? @@(nt!_EPROCESS.ActiveProcessLinks) 算某个字段的偏移

偏移随版本变,这是内核编程里最容易踩的坑。当年整理的 dt _EPROCESS 和 dt _PEB 完整输出(几百行)贴了两篇,只对 Win7 x86 SP1 有效,到 x64 上全都不一样了,所以这里不贴整段 dump,记住”怎么查”比记住”是多少”有用得多。

顺便说几个反调试点#

虽然现在看有点怀旧,但 PEB 里这几个字段至今还被用来判断是否被调试,讲恶意代码分析时经常遇到:

  • PEB->BeingDebugged(x86 +0x002,x64 +0x002) 表示进程是否被调试。这个字段在用户态就能改,所以单靠它做反调试很弱
  • PEB->NtGlobalFlag(x86 +0x068,x64 +0x0BC) 平时是 0,被调试器创建进程时会带上 FLG_HEAP_ENABLE_TAIL_CHECK(0x10) | FLG_HEAP_ENABLE_FREE_CHECK(0x20) | FLG_HEAP_VALIDATE_PARAMETERS(0x40),也就是 0x70
  • 堆上的 Flags/ForceFlags。调试状态下堆的标志位和 ForceFlags 会被改成非 0(ForceFlags 平时是 0)

第一个驱动#

还是用最经典的 HelloWorld 开始:

#include <ntddk.h>
VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
DbgPrint("[%ws] Driver Unload, Driver Object Address: %p\n", __FUNCTIONW__, DriverObject);
}
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
DbgPrint("[%ws] Hello Kernel World!\n", __FUNCTIONW__);
if (DriverObject != NULL)
{
DbgPrint("[%ws] Driver Object Address: %p\n", __FUNCTIONW__, DriverObject);
DriverObject->DriverUnload = DriverUnload;
}
if (RegistryPath != NULL)
{
DbgPrint("[%ws] Driver Registry Path: %wZ\n", __FUNCTIONW__, RegistryPath);
}
return STATUS_SUCCESS;
}

DriverEntry 是入口,相当于 main;给它设上 DriverUnload 之后,sc stop 才能正常卸载。编译成 .sys,用 sc create 注册成内核服务再 sc start,或者直接拿 OSR 的 loader 之类工具加载。

驱动跑在哪个进程里#

这个问题我第一次写驱动时特别好奇,加一句 PsGetCurrentProcessId() 就知道了:

DbgPrint("[%ws] Hello Kernel World, Current Process Id=0x%p\n", __FUNCTIONW__, PsGetCurrentProcessId());

结果无论是 DriverEntry 还是卸载回调,拿到的都是 PID 4,也就是 System 进程。System 不是普通意义上的进程,是系统虚拟出来代表内核的一个进程,驱动就是在它的上下文里跑的。

这件事的实际含义是:驱动的上下文和应用层的上下文要严格分开。如果进程 A 正在运行(CPU 当前在 A 的虚拟地址空间里),而驱动恰好也在这个 CPU 上执行,那驱动访问到的”用户态地址”就是 A 的地址空间;换一个进程调用同一个驱动,那些地址指向的东西就完全不同了。所以驱动里拿到用户态指针,第一件事是校验它、并且用 ProbeForRead/ProbeForWrite 或者在 try/except 里访问,绝不能想当然。

IRQL#

线程有优先级,调度器按时间片和优先级调度;驱动层对应的是 IRQL(中断请求级别),高 IRQL 的代码可以打断、抢占低 IRQL 的代码。这是内核编程里最重要的一个概念,因为它决定了你在这个时刻能调用什么函数、能访问什么内存。

IRQL数值典型场景能做什么
PASSIVE_LEVEL0应用层线程、大部分内核函数几乎可以调用所有内核 API,可以访问分页和非分页内存,可以等
APC_LEVEL1APC、页错误处理时可以用大部分内核 API,仍可访问分页内存
DISPATCH_LEVEL2DPC、持有自旋锁时只能用特定 API,只能访问非分页内存,不能等

DriverEntry 的 IRQL 是 PASSIVE_LEVEL,这是系统保证的。想知道当前值就调 KeGetCurrentIrql()。第一次跑出来看到是 0,对照表就知道自己处在最宽松的状态。

写代码之前的习惯,是调每个函数前先看文档里写的 “IRQL: <= DISPATCH_LEVEL” 这类要求,对不上就等着蓝屏。

主动蓝屏#

驱动写错导致系统崩溃就是蓝屏(BSOD),常见原因就三类,高 IRQL 下死锁、内存访问违规、函数栈不平衡。

有时候代码已经进了不可恢复的错误状态,与其带着错误继续跑把内存写花,不如主动 KeBugCheckEx 拉起蓝屏,至少 dump 里能看清第一现场。


字符串#

内核里用 UNICODE_STRING 表示字符串,注意长度以 Length 成员为准,不是靠 '\0'。

typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

初始化用 RtlInitUnicodeString,IRQL <= DISPATCH_LEVEL:

UNICODE_STRING uFirstString = {0};
RtlInitUnicodeString(&uFirstString, L"HelloWorld\n");
DbgPrint("String:%wZ", &uFirstString);
注意

坑:它不分配 Buffer,只是让 Buffer 指向你传进去的那个字符串。所以那个字符串必须一直有效。如果是栈上的临时变量,函数返回后 uFirstString 就成了野指针。

要复制一份到自己准备好的缓冲区里,用 RtlUnicodeStringCopyString(需要包含 Ntstrsafe.h),IRQL 是 PASSIVE_LEVEL,返回 NTSTATUS:

WCHAR strBuf[128] = {0};
UNICODE_STRING uFirstString = {0};
RtlInitEmptyUnicodeString(&uFirstString, strBuf, sizeof(strBuf));
RtlUnicodeStringCopyString(&uFirstString, L"Hello Kernel\n");
DbgPrint("String: %wZ", &uFirstString);
注意

坑:不能往一个”定长 buf 的 String”里 copy 超长内容,否则它会直接按你给的长度写过去,蓝屏报内存读写错误。MaximumLength 是硬边界,传参时永远要保证它等于缓冲区真实大小。


链表#

WDK 的链表是侵入式的,把 LIST_ENTRY 放进你自己的结构体里,而不是让链表节点去持有数据。

typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink; // 后一个
struct _LIST_ENTRY *Blink; // 前一个
} LIST_ENTRY, *PLIST_ENTRY;
typedef struct _TestListEntry {
ULONG m_ulData1;
ULONG m_ulData2;
LIST_ENTRY m_ListEntry;
ULONG m_ulData3;
ULONG m_ulData4;
} TestListEntry, *PTestListEntry;

一般会有一个不装数据的头节点,只作链表锚点。

LIST_ENTRY ListHeader = {0};
InitializeListHead(&ListHeader);
InsertHeadList(&ListHeader, &Entry2.m_ListEntry);
InsertHeadList(&ListHeader, &Entry1.m_ListEntry);
InsertTailList(&ListHeader, &Entry3.m_ListEntry);

遍历的时候,pListEntry 拿到的是 LIST_ENTRY 的地址,不是结构体首地址,要用 CONTAINING_RECORD 换算回去。

PLIST_ENTRY pListEntry = ListHeader.Flink;
while (pListEntry != &ListHeader)
{
PTestListEntry pTestEntry = CONTAINING_RECORD(pListEntry, TestListEntry, m_ListEntry);
DbgPrint("ListPtr=%p, Entry=%p, Tag=%c\n", pListEntry, pTestEntry, (CHAR)pTestEntry->m_ulData1);
pListEntry = pListEntry->Flink;
}

CONTAINING_RECORD(Address, Type, Field) 就是”已知某字段的地址,求整个结构体的地址”,靠的是编译器算出的字段偏移。这套写法在内核里到处都是(ActiveProcessLinks、ThreadListHead 全是这么用的)。

移除和判断:

  • RemoveHeadList / RemoveTailList 成功时返回被移除节点的地址,链空时返回 NULL
  • RemoveEntryList 移除指定节点,移除后链表为空返回 TRUE
  • IsListEmpty 空的时候返回 TRUE

一个安全习惯,多线程环境下遍历链表必须持锁,否则你 Flink 到一半,另一个 CPU 把下一个节点删了,就是经典的 UAF。


自旋锁#

自旋锁是内核提供的高 IRQL 锁,用独占的方式来保护某个资源。

注意事项:自旋锁变量不能放在函数栈上,否则每次进函数都重新初始化一遍,等于没加锁。它必须是全局变量,或者挂在设备扩展这类生命周期和锁匹配的对象上。

KSPIN_LOCK my_spin_lock; // 全局
void initLock()
{
KeInitializeSpinLock(&my_spin_lock);
}
void TestFuncLock()
{
KIRQL irql;
KeAcquireSpinLock(&my_spin_lock, &irql);
// 临界区:这里 IRQL 已经被抬到 DISPATCH_LEVEL
KeReleaseSpinLock(&my_spin_lock, irql);
}

KeAcquireSpinLock 会把当前 IRQL 抬到 DISPATCH_LEVEL 并把原值存进 irql,释放时再还原。所以临界区里不能访问分页内存、不能调任何可能阻塞的函数、不能等,这也是上面 IRQL 那节的实际用途。

这里当年写了个会死锁的例子#

当年的笔记里,链表那节是这样写的:

KeAcquireSpinLock(&my_spin_lock, &irql);
ExInterlockedInsertHeadList(&listHead, &my_file_info.m_ListEntry, &my_spin_lock);
KeReleaseSpinLock(&my_spin_lock, irql);

这段会自己把自己锁死。ExInterlockedInsertHeadList 这个 “Ex” 前缀的函数是”我帮你加锁”的意思,它内部会先 KeAcquireSpinLock 拿 my_spin_lock;可你在外面已经拿着同一把锁了。自旋锁不可重入,于是在同一个 CPU 上无限自旋,系统就卡在那了(如果开了死锁检测,会直接 DRIVER_VERIFIER_DETECTED_VIOLATION)。

两种正确写法,二选一就行。

// 写法一:自己持锁,用普通的链表函数
KeAcquireSpinLock(&my_spin_lock, &irql);
InsertHeadList(&listHead, &my_file_info.m_ListEntry);
KeReleaseSpinLock(&my_spin_lock, irql);
// 写法二:不持锁,交给 Ex 版本自己去加
ExInterlockedInsertHeadList(&listHead, &my_file_info.m_ListEntry, &my_spin_lock);

顺带一提,ExInterlocked* 这组函数在现代 Windows 上基本属于历史遗留了,微软文档里也建议直接用 KeAcquireSpinLock + 普通链表函数,可读性好得多。

另外那个例子里还有个更隐蔽的问题:listHead 和 my_file_info 都是函数内的局部变量,函数一返回,链表头和数据就都在栈上了,任何还引用这个链表的地方立刻失效。要么把这个链表做成全局/设备扩展的一部分,要么在函数返回前把节点摘干净。

队列自旋锁#

多 CPU 平台上队列自旋锁性能更好,而且严格先来先得。初始化一样,但一把锁初始化之后不能混着用两种方式:

KLOCK_QUEUE_HANDLE my_lock_queue_handle;
KeAcquireInStackQueuedSpinLock(&my_spin_lock, &my_lock_queue_handle);
// 临界区
KeReleaseInStackQueuedSpinLock(&my_lock_queue_handle);

注意队列锁的那个 handle 是放在栈上的,这是它设计上允许的,锁在全局,handle 在栈上只记状态。


池内存#

常规分配#

PVOID buffer = ExAllocatePoolWithTag(NonPagedPoolNx, 512, 'tag1');
if (buffer)
{
ExFreePoolWithTag(buffer, 'tag1');
}

2026 年要改的地方。ExAllocatePoolWithTag 从 Windows 10 2004 起已被弃用,官方推荐的替代是 ExAllocatePool2。新代码应该这么写:

PVOID buffer = ExAllocatePool2(POOL_FLAG_NON_PAGED, 512, 'tag1');
if (buffer)
{
ExFreePoolWithTag(buffer, 'tag1');
}

ExAllocatePool2 默认就把内存清零了(不用再写 HEAP_ZERO_MEMORY 那套),并且在传入 0 长度这类参数错误时会直接返回 NULL,比老 API 老实得多。tag 必须是 1 到 4 个可打印 ASCII 字符,同一段分配路径用同一个 tag,出问题的时候 poolmon 和 !pool 靠它定位。

快表#

频繁申请释放同样大小的内存时,用快表(lookaside list,有些地方叫”旁视列表”)会快很多,因为它在自己内部缓存一批固定大小的块,不用每次都过一遍堆分配器。

当年这个例子写得比较长,逻辑是对的,就是把”分配 → 释放 → 再分配”跑一遍,验证再分配拿到的是刚释放的那块。这里只留骨架:

PNPAGED_LOOKASIDE_LIST pLookasideList;
pLookasideList = ExAllocatePool2(POOL_FLAG_NON_PAGED, sizeof(NPAGED_LOOKASIDE_LIST), 'test');
ExInitializeNPagedLookasideList(pLookasideList, NULL, NULL, 0, 128, 'test', 0);
PVOID pFirstMemory = ExAllocateFromNPagedLookasideList(pLookasideList);
PVOID pSecondMemory = ExAllocateFromNPagedLookasideList(pLookasideList);
ExFreeToNPagedLookasideList(pLookasideList, pFirstMemory);
pFirstMemory = NULL;
pFirstMemory = ExAllocateFromNPagedLookasideList(pLookasideList); // 大概率拿到刚才那块
// 收尾:先还块,再删表,最后释放表本身
if (pFirstMemory != NULL) { ExFreeToNPagedLookasideList(pLookasideList, pFirstMemory); pFirstMemory = NULL; }
if (pSecondMemory != NULL) { ExFreeToNPagedLookasideList(pLookasideList, pSecondMemory); pSecondMemory = NULL; }
ExDeleteNPagedLookasideList(pLookasideList);
ExFreePoolWithTag(pLookasideList, 'test');
注意

这里有个必须改的 bug。当年笔记里收尾那几段判断全写成 == NULL 才去释放,等于”没分配成功的时候去释放一个空指针,分配成功的那些反而全泄漏”,全反了。上面已经改成 != NULL。这类 bug 编译器不会报,Driver Verifier 的 UnsafeAllocatePool 和 pool tracking 能抓到。

另外,如果快表是驱动级的长期结构,应该放在设备扩展里、在 DriverEntry 初始化、在 DriverUnload 删掉,而不是在一次函数调用的 do { } while(FALSE) 里建了又拆,那样反而比直接用池分配还慢。


内核对象与句柄#

内核中创建、由内核管理和销毁的对象叫内核对象。用户态拿到的是句柄(一个进程句柄表里的索引),内核态要拿到对象本身,得用 ObReferenceObjectByHandle 把句柄翻成指针。

HANDLE hCreateEvent = NULL;
PVOID pCreateEventObject = NULL;
OBJECT_ATTRIBUTES ObjAttr = { 0 };
UNICODE_STRING uNameString = { 0 };
RtlInitUnicodeString(&uNameString, L"\\BaseNamedObjects\\TestEvent");
InitializeObjectAttributes(&ObjAttr, &uNameString,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
NTSTATUS status = ZwCreateEvent(&hCreateEvent, EVENT_ALL_ACCESS, &ObjAttr,
SynchronizationEvent, FALSE);
if (!NT_SUCCESS(status)) { /* 处理失败 */ }
status = ObReferenceObjectByHandle(hCreateEvent, EVENT_ALL_ACCESS,
*ExEventObjectType, KernelMode,
&pCreateEventObject, NULL);

还有几个要点:

  • 判断成功与否要看 NTSTATUS,不是看句柄是不是 NULL,ZwCreateEvent 失败时句柄不会被赋值
  • OBJ_KERNEL_HANDLE 让句柄只在内核句柄表里可见,用户态打不开,这是驱动开对象时的默认选择
  • ObReferenceObjectByHandle 会加一次引用计数,用完必须 ObDereferenceObject,否则对象永远释放不掉
  • 句柄要 ZwClose 关掉,对象引用要 ObDereferenceObject 减掉,这是两笔不同的账
注意

同样必须改的还有清理条件,当年全写反了,if (pCreateEventObject == NULL) ObDereferenceObject(...),也就是对空指针解引用,而真正需要减引用的那些都漏了。正确的收尾是:

if (pCreateEventObject != NULL) { ObDereferenceObject(pCreateEventObject); pCreateEventObject = NULL; }
if (hCreateEvent != NULL) { ZwClose(hCreateEvent); hCreateEvent = NULL; }
注意

还有个小坑,ntddk.h 和 ntifs.h 一起包含时会冲突,把 ntifs.h 放在前面就行。

当年还有个”注册表”小节只写了段 HIVE 的介绍,代码是空的、标着”未完待续”,这里就不留了。内核里读写注册表无非 ZwOpenKey / ZwQueryValueKey / ZwSetValueKey 那几个,配 OBJ_KERNEL_HANDLE 用,和上面开 Event 的路子一样。


今天再看#

这几篇是 2020 年写的,环境从 Win7 换到 Win10 的时候,最大的变化其实不是 API,是微软对第三方驱动的态度变了。

2020 年那会儿,新驱动要进硬件开发者门户做签名,门槛已经是 EV 证书了;而按微软的文档,从 Windows 10 1607 起,系统就不再加载任何没经过开发者门户签名的新内核驱动了,自己拿个证书签一个已经不管用(那套交叉签名在 2015 年之后就已经不行了)。同时 HVCI(Hypervisor-protected Code Integrity,内存完整性) 越来越普及,Windows 11 上很多机器默认就开着。它把代码完整性检查搬到一个 Hyper-V 隔离出来的安全环境里,内核自己都没法绕过,这直接堵死了”改内核代码再执行”这类手法。

另一件和这个领域关系很大的事是 BYOVD(Bring Your Own Vulnerable Driver)。攻击者不去找 Windows 本身的漏洞,而是找一个合法的、签过名的、但自身有漏洞的第三方驱动,加载它,再用它的漏洞去干内核里想干的事。因为驱动是签过名的,HVCI 也拦不住。微软的应对是维护一份易受攻击驱动黑名单(Microsoft Vulnerable Driver Blocklist),HVCI 开着的时候它就生效,Windows 11 上默认启用,名单一年更新一两次,里面全是历史上被利用过的签名驱动。

所以现在写内核驱动,除了把代码写对,还要意识到一件事,驱动一旦加载就是最高权限,任何一点输入校验的疏忽都可能被拿去当 BYOVD 的原料。这也是为什么今天 WDK 默认给你打开一堆 Driver Verifier 检查,编译时还会对 ExAllocatePool 这类老 API 报 deprecated,它们就是在推着你写出不容易被利用的代码。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

Windows 内核驱动入门,调试环境与内核编程基础
https://blog.lumysia.net/zh-cn/posts/windows-kernel-driver-basics/
作者
Livia
发布于
2020-10-17
许可协议
CC BY-NC 4.0

评论区

文章目录