Windows 内核驱动入门,调试环境与内核编程基础
这一篇是 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直接看某个进程的 PEBkd> ? @@(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_LEVEL | 0 | 应用层线程、大部分内核函数 | 几乎可以调用所有内核 API,可以访问分页和非分页内存,可以等 |
| APC_LEVEL | 1 | APC、页错误处理时 | 可以用大部分内核 API,仍可访问分页内存 |
| DISPATCH_LEVEL | 2 | DPC、持有自旋锁时 | 只能用特定 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成功时返回被移除节点的地址,链空时返回 NULLRemoveEntryList移除指定节点,移除后链表为空返回 TRUEIsListEmpty空的时候返回 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,它们就是在推着你写出不容易被利用的代码。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!




