句柄表篇——进程句柄表
写在前面
此系列是本人一个字一个字码出来的，包括示例和实验截图。由于系统内核的复杂性，故可能有错误或者不全面的地方，如有错误，欢迎批评指正，本教程将会长期更新。 如有好的建议，欢迎反馈。码字不易，如果本篇文章有帮助你的，如有闲钱，可以打赏支持我的创作。如想转载，请把我的转载信息附在文章后面，并声明我的个人信息和本人博客地址即可，但必须事先通知我。
你如果是从中间插过来看的，请仔细阅读 羽夏看Win系统内核——简述 ，方便学习本教程。
看此教程之前，问几个问题，基础知识储备好了吗？保护模式篇学会了吗？练习做完了吗？没有的话就不要继续了。
🔒 华丽的分割线 🔒
句柄
句柄是一种内核对象，当一个进程创建或者打开一个内核对象时，将获得一个句柄，通过这个句柄可以访问内核对象。
HANDLE g_hMutex = ::CreateMutex( NULL , FALSE, "XYZ");
HANDLE g_hMutex = ::OpenMutex( MUTEX_ALL_ACCESSFALSE, "XYZ");
HANDLE g_hEvent = ::CreateEvent( NULL, TRUE, FALSE, NULL);
HANDLE g_hThread = ::CreateThread( NULL, 0, Proc,NULL, 0, NULL);
那么，句柄到底是何方神圣？为什么操作系统要使用这个句柄？句柄存在的目的是为了避免在应用层直接修改内核对象，而句柄就是一个索引，通过这个索引，我就可以在内核轻松找到对应的内核对象结构体的地址。
注意，我在这里强调一下 句柄是给3环用的，而不是给内核用的 。所以在写驱动的时候，不要搞句柄花里胡哨的东西。Windows所有涉及句柄的API，一旦到了真正函数实现的部分，就立刻使用ObReferenceObjectByHandle把它转化为真正的指向内核对象的指针，举个例子，由于篇幅，只列出开头部分：
; int __stdcall PspCreateProcess(int, ACCESS_MASK DesiredAccess, int, HANDLE Handle, int, HANDLE, HANDLE, HANDLE, int)
_PspCreateProcess@36 proc near ; CODE XREF: NtCreateProcessEx(x,x,x,x,x,x,x,x,x)+72↓p
; PsCreateSystemProcess(x,x,x)+1B↓p ...
; __unwind { // __SEH_prolog
push 11Ch
push offset stru_402EB0
call __SEH_prolog
mov eax, large fs:124h
mov [ebp+var_84], eax
mov cl, [eax+140h]
mov [ebp+AccessMode], cl
mov eax, [eax+44h]
mov [ebp+RunRef], eax
xor esi, esi
mov [ebp+var_1D], 0
mov [ebp+var_48], esi
mov [ebp+var_44], esi
test [ebp+arg_10], 0FFFFFFF0h
jnz short loc_4EFB0B
cmp [ebp+Handle], esi
jz short loc_4EFB1A
push esi ; HandleInformation
lea eax, [ebp+Object]
push eax ; Object
push dword ptr [ebp+AccessMode] ; AccessMode
push _PsProcessType ; ObjectType
push 80h ; '€' ; DesiredAccess
push [ebp+Handle] ; Handle
call _ObReferenceObjectByHandle@24 ; ObReferenceObjectByHandle(x,x,x,x,x,x)
mov ecx, [ebp+Object] ; Object
mov [ebp+var_1C], ecx
cmp eax, esi
jl loc_4F01FB
cmp [ebp+arg_20], esi
jz short loc_4EFB15
cmp [ecx+134h], esi
jnz short loc_4EFB15
call @ObfDereferenceObject@4 ; ObfDereferenceObject(x)
loc_4EFB0B: ; CODE XREF: PspCreateProcess(x,x,x,x,x,x,x,x,x)+3D↑j
mov eax, 0C000000Dh
jmp loc_4F01FB
; ---------------------------------------------------------------------------
下面是微软官方对ObReferenceObjectByHandle的解释：
The ObReferenceObjectByHandle routine provides access validation on the object handle, and, if access can be granted, returns the corresponding pointer to the object's body.
句柄表
上面介绍了句柄是什么，我们来介绍句柄表这个东西。不加特殊说明，我们所说的句柄表是进程句柄表。那么句柄表在哪里呢？看下面的结构体：
kd> dt _EPROCESS
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x06c ProcessLock : _EX_PUSH_LOCK
+0x070 CreateTime : _LARGE_INTEGER
+0x078 ExitTime : _LARGE_INTEGER
+0x080 RundownProtect : _EX_RUNDOWN_REF
+0x084 UniqueProcessId : Ptr32 Void
+0x088 ActiveProcessLinks : _LIST_ENTRY
+0x090 QuotaUsage : [3] Uint4B
+0x09c QuotaPeak : [3] Uint4B
+0x0a8 CommitCharge : Uint4B
+0x0ac PeakVirtualSize : Uint4B
+0x0b0 VirtualSize : Uint4B
+0x0b4 SessionProcessLinks : _LIST_ENTRY
+0x0bc DebugPort : Ptr32 Void
+0x0c0 ExceptionPort : Ptr32 Void
+0x0c4 ObjectTable : Ptr32 _HANDLE_TABLE
这个结构体我们之前接触过，由于这个结构体十分庞大，只显示了一部分。在0xc4这个偏移就是存放句柄表的。我们来看看它的结构是什么：
kd> dt _HANDLE_TABLE
ntdll!_HANDLE_TABLE
+0x000 TableCode : Uint4B
+0x004 QuotaProcess : Ptr32 _EPROCESS
+0x008 UniqueProcessId : Ptr32 Void
+0x00c HandleTableLock : [4] _EX_PUSH_LOCK
+0x01c HandleTableList : _LIST_ENTRY
+0x024 HandleContentionEvent : _EX_PUSH_LOCK
+0x028 DebugInfo : Ptr32 _HANDLE_TRACE_DEBUG_INFO
+0x02c ExtraInfoPages : Int4B
+0x030 FirstFree : Uint4B
+0x034 LastFree : Uint4B
+0x038 NextHandleNeedingPool : Uint4B
+0x03c HandleCount : Int4B
+0x040 Flags : Uint4B
+0x040 StrictFIFO : Pos 0, 1 Bit
TableCode就是所谓的句柄表，但句柄表是有结构的，下面我们来看看它的结构：
①：这一块共计两个字节，高位字节是给SetHandleInformation这个函数用的，比如写成如下形式，那么这个位置将被写入0x02：
SetHandleInformation(Handle,HANDLE_FLAG_PROTECT_FROM_CLOSE,HANDLE_FLAG_PROTECT_FROM_CLOSE);
HANDLE_FLAG_PROTECT_FROM_CLOSE宏的值为0x00000002，取最低字节，最终 ① 这块是0x0200。
②：这块是访问掩码，是给OpenProcess这个函数用的，具体的存的值就是这个函数的第一个参数的值。
③ 和 ④ 这两个块共计四个字节，其中bit0-bit2存的是这个句柄的属性，其中bit2和bit0默认为0和1; bit1表示的函数是该句柄是否可继承，OpenProcess的第二个参数与bit1有关，
bit31-bit3则是存放的该内核对象在内核中的具体的地址。
上述句柄的结构没有官方公开化文档，是经过逆向分析得到，如果以后如有本文没有的，可以根据自己的需要进行逆向分析。
句柄表结构
句柄表的结构还是比较复杂的，具体结构如下：
TableCode从上图可知，指明句柄表的级数，如果低两位是0，那么指向的句柄表里面存放的就是真正的句柄；如果低两位是1，那么指向的第一张句柄表的每一个成员都是一个地址，每一个地址指向每一个真正的句柄表，以此类推低两位是2的情况。
句柄表索引查找
既然我们了解了结构，我们来看看如何通过句柄查找对应的结构体地址，首先我们的测试代码如下：
#include "stdafx.h"
#include <stdlib.h>
#include <windows.h>
int main(int argc, char* argv[])
{
int pid;
printf("请输入程序的pid：");
scanf("%d",&pid);
HANDLE hprocess=OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid);
if (hprocess==INVALID_HANDLE_VALUE)
{
puts("进程句柄无效！！！");
}
else
{
printf("打开进程获得句柄成功！句柄为：%d\n",hprocess);
}
system("pause");
CloseHandle(hprocess);
return 0;
}
然后我打开了一个notepad进程，从任务管理器找到它的PID，输入进去，得到输出十进制的2024。
然后我们输入指令获取我们写代码运行的进程的EPROCESS结构体：
kd> !process 0 0
**** NT ACTIVE PROCESS DUMP ****
Failed to get VadRoot
PROCESS 89b6a7e8 SessionId: 0 Cid: 0110 Peb: 7ffd5000 ParentCid: 05f4
DirBase: 13a40260 ObjectTable: e1cef910 HandleCount: 46.
Image: notepad.exe
Failed to get VadRoot
PROCESS 89b84500 SessionId: 0 Cid: 0640 Peb: 7ffdf000 ParentCid: 06fc
DirBase: 13a40320 ObjectTable: e1d84558 HandleCount: 22.
Image: HandleTest.exe
然后我们读取HandleTest.exe，也就是我们调用OpenProcess函数的进程，找到它的句柄表（ …… 表示省略）：
kd> dt _EPROCESS 89b84500
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x06c ProcessLock : _EX_PUSH_LOCK
+0x070 CreateTime : _LARGE_INTEGER 0x01d80d3a`c4dffca0
+0x078 ExitTime : _LARGE_INTEGER 0x0
+0x080 RundownProtect : _EX_RUNDOWN_REF
+0x084 UniqueProcessId : 0x00000640 Void
+0x088 ActiveProcessLinks : _LIST_ENTRY [ 0x899782d8 - 0x89b24470 ]
+0x090 QuotaUsage : [3] 0x460
+0x09c QuotaPeak : [3] 0x650
+0x0a8 CommitCharge : 0x41
+0x0ac PeakVirtualSize : 0x824000
+0x0b0 VirtualSize : 0x7b2000
+0x0b4 SessionProcessLinks : _LIST_ENTRY [ 0x89978304 - 0x89b2449c ]
+0x0bc DebugPort : 0x89b16020 Void
+0x0c0 ExceptionPort : 0xe13a3f08 Void
+0x0c4 ObjectTable : 0xe1d84558 _HANDLE_TABLE
……
kd> dx -id 0,0,805539a0 -r1 ((ntdll!_HANDLE_TABLE *)0xe1d84558)
((ntdll!_HANDLE_TABLE *)0xe1d84558) : 0xe1d84558 [Type: _HANDLE_TABLE *]
[+0x000] TableCode : 0xe1f97000 [Type: unsigned long]
[+0x004] QuotaProcess : 0x89b84500 [Type: _EPROCESS *]
[+0x008] UniqueProcessId : 0x640 [Type: void *]
[+0x00c] HandleTableLock [Type: _EX_PUSH_LOCK [4]]
[+0x01c] HandleTableList [Type: _LIST_ENTRY]
[+0x024] HandleContentionEvent [Type: _EX_PUSH_LOCK]
[+0x028] DebugInfo : 0x0 [Type: _HANDLE_TRACE_DEBUG_INFO *]
[+0x02c] ExtraInfoPages : 0 [Type: long]
[+0x030] FirstFree : 0x7dc [Type: unsigned long]
[+0x034] LastFree : 0x0 [Type: unsigned long]
[+0x038] NextHandleNeedingPool : 0x800 [Type: unsigned long]
[+0x03c] HandleCount : 22 [Type: long]
[+0x040] Flags : 0x0 [Type: unsigned long]
[+0x040 ( 0: 0)] StrictFIFO : 0x0 [Type: unsigned char]
我们看看这里句柄表存的是什么：
kd> dq 0xe1f97000
ReadVirtual: e1f97000 not properly sign extended
e1f97000 fffffffe`00000000 00000000`00000000
e1f97010 00000004`00000000 00000008`00000000
e1f97020 0000000c`00000000 00000010`00000000
e1f97030 00000014`00000000 00000018`00000000
e1f97040 0000001c`00000000 00000020`00000000
e1f97050 00000024`00000000 00000028`00000000
e1f97060 0000002c`00000000 00000030`00000000
e1f97070 00000034`00000000 00000038`00000000
如何根据句柄查找对应的结构体地址呢？首先我们对得到的句柄进行除4就是索引。即我们偏移就是得到的句柄乘2，我们来看看示例：
kd> dq 0xe1f97000+FD0
ReadVirtual: e1f97fd0 not properly sign extended
e1f97fd0 001f0fff`89b6a7d1 021f0001`e1d4a1f9
e1f97fe0 000f000f`e14134b1 000007b8`00000000
e1f97ff0 00000003`e14114e9 000f0003`e1009681
注意，最后两位是句柄表的属性，我们需要清零才能得到结构体的地址，也就是0x89b6a7d0就是结构体的地址，但是，这个结构体指向的不是EPROCESS，而是_OBJECT_HEADER结构体，这个是每一个内核对象都有的，被称为对象头：
kd> dt _OBJECT_HEADER
nt!_OBJECT_HEADER
+0x000 PointerCount : Int4B
+0x004 HandleCount : Int4B
+0x004 NextToFree : Ptr32 Void
+0x008 Type : Ptr32 _OBJECT_TYPE
+0x00c NameInfoOffset : UChar
+0x00d HandleInfoOffset : UChar
+0x00e QuotaInfoOffset : UChar
+0x00f Flags : UChar
+0x010 ObjectCreateInfo : Ptr32 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : Ptr32 Void
+0x014 SecurityDescriptor : Ptr32 Void
+0x018 Body : _QUAD
也就是说，我们还需要对这个地址+0x18的偏移，我们来看看：
kd> dt _EPROCESS 89b6a7d0+0x018
ntdll!_EPROCESS
……
+0x170 Session : 0xbadca000 Void
+0x174 ImageFileName : [16] "notepad.exe"
+0x184 JobLinks : _LIST_ENTRY [ 0x0 - 0x0 ]
正好就是我们的notepad进程。
句柄表不是仅仅只有进程结构体句柄，还有线程、文件等句柄，我们如何判断呢？就是通过_OBJECT_HEADER这个结构体判断的，如下指令所示：
kd> dt _OBJECT_HEADER 89b6a7d0
nt!_OBJECT_HEADER
+0x000 PointerCount : 0n16
+0x004 HandleCount : 0n3
+0x004 NextToFree : 0x00000003 Void
+0x008 Type : 0x89db0040 _OBJECT_TYPE
+0x00c NameInfoOffset : 0 ''
+0x00d HandleInfoOffset : 0 ''
+0x00e QuotaInfoOffset : 0 ''
+0x00f Flags : 0x20 ' '
+0x010 ObjectCreateInfo : 0x89cbdb98 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x89cbdb98 Void
+0x014 SecurityDescriptor : 0xe17b15f6 Void
+0x018 Body : _QUAD
kd> dx -id 0,0,805539a0 -r1 ((ntkrnlpa!_OBJECT_TYPE *)0x89db0040)
((ntkrnlpa!_OBJECT_TYPE *)0x89db0040) : 0x89db0040 [Type: _OBJECT_TYPE *]
[+0x000] Mutex : Unowned Resource [Type: _ERESOURCE]
[+0x038] TypeList [Type: _LIST_ENTRY]
[+0x040] Name : "Process" [Type: _UNICODE_STRING]
[+0x048] DefaultObject : 0x0 [Type: void *]
[+0x04c] Index : 0x5 [Type: unsigned long]
[+0x050] TotalNumberOfObjects : 0x1a [Type: unsigned long]
[+0x054] TotalNumberOfHandles : 0x68 [Type: unsigned long]
[+0x058] HighWaterNumberOfObjects : 0x1b [Type: unsigned long]
[+0x05c] HighWaterNumberOfHandles : 0x69 [Type: unsigned long]
[+0x060] TypeInfo [Type: _OBJECT_TYPE_INITIALIZER]
[+0x0ac] Key : 0x636f7250 [Type: unsigned long]
[+0x0b0] ObjectLocks [Type: _ERESOURCE [4]]
我们通过Type里面的Name属性，很容易判断出它是Process类型，也就是进程结构体。
本节练习
本节的答案将会在下一节进行讲解，务必把本节练习做完后看下一个讲解内容。不要偷懒，实验是学习本教程的捷径。
俗话说得好，光说不练假把式，如下是本节相关的练习。如果练习没做好，就不要看下一节教程了，越到后面，不做练习的话容易夹生了，开始还明白，后来就真的一点都不明白了。本节练习不多，请保质保量的完成。
1️⃣ 思考当我用函数打开一个内核对象时，如果用CloseHandle，这个内核对象一定会被销毁吗？假设我用OpenProcess打开了一个现有的进程，但打开后，这个进程被关闭了，这个内核对象还存在吗？
2️⃣ 使用循环打开100次某个内核对象，分析句柄表的结构；然后打开1000次某个内核对象，继续分析上述操作。
下一篇
本文来自博客园，作者：寂静的羽夏 ，一个热爱计算机技术的菜鸟
转载请注明原文链接：https://www.cnblogs.com/wingsummer/p/15823780.html
