Hook 内核ntoskrnl'sZwQuerySystemInformation隐藏任务管理器进程名

合集下载

NtQuerySystemInformation的使用

NtQuerySystemInformation的使用今天，我们主要讨论的是一个函数NtQuerySystemInformation(ZwQuerySystemInformation)。

当然，你不要小看这么一个函数，它却为我们提供了丰富的系统信息，同时还包括对某些信息的控制和设置。

以下是这个函数的原型：typedef NTSTATUS (__stdcall *NTQUERYSYSTEMINFORMATION)(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,IN OUT PVOID SystemInformation,IN ULONG SystemInformationLength,OUT PULONG ReturnLength OPTIONAL);NTQUERYSYSTEMINFORMATION NtQuerySystemInformation;从中可以看到，SystemInformationClass是一个类型信息，它大概提供了50余种信息，也就是我们可以通过这个函数对大约50多种的系统信息进行探测或设置。

SystemInformation是一个LPVOID型的指针，它为我们提供需要获得的信息，或是我们需要设置的系统信息。

SystemInformationLength是SystemInformation的长度，它根据探测的信息类型来决定。

至于ReturnLength则是系统返回的需要的长度，通常可以设置为空指针(NULL)。

首先，我们来看看大家比较熟悉的系统进程/线程相关的信息。

这个题目在网上已经讨论了N多年了，所以我就不在老生常谈了，呵呵。

那么就提出这个结构类型的定义：typedef struct _SYSTEM_PROCESSES{ULONG NextEntryDelta; //构成结构序列的偏移量；ULONG ThreadCount; //线程数目；ULONG Reserved1[6];LARGE_INTEGER CreateTime; //创建时间；LARGE_INTEGER UserTime; //用户模式(Ring 3)的CPU时间；LARGE_INTEGER KernelTime; //内核模式(Ring 0)的CPU时间；UNICODE_STRING ProcessName; //进程名称；KPRIORITY BasePriority; //进程优先权；ULONG ProcessId; //进程标识符；ULONG InheritedFromProcessId; //父进程的标识符；ULONG HandleCount; //句柄数目；ULONG Reserved2[2];VM_COUNTERS VmCounters; //虚拟存储器的结构，见下；IO_COUNTERS IoCounters; //IO计数结构，见下；SYSTEM_THREADS Threads[1]; //进程相关线程的结构数组，见下；}SYSTEM_PROCESSES,*PSYSTEM_PROCESSES;typedef struct _SYSTEM_THREADS{LARGE_INTEGER KernelTime; //CPU内核模式使用时间；LARGE_INTEGER UserTime; //CPU用户模式使用时间；LARGE_INTEGER CreateTime; //线程创建时间；ULONG WaitTime; //等待时间；PVOID StartAddress; //线程开始的虚拟地址；CLIENT_ID ClientId; //线程标识符；KPRIORITY Priority; //线程优先级；KPRIORITY BasePriority; //基本优先级；ULONG ContextSwitchCount; //环境切换数目；THREAD_STATE State; //当前状态；KWAIT_REASON WaitReason; //等待原因；}SYSTEM_THREADS,*PSYSTEM_THREADS;typedef struct _VM_COUNTERS{ULONG PeakVirtualSize; //虚拟存储峰值大小；ULONG VirtualSize; //虚拟存储大小；ULONG PageFaultCount; //页故障数目；ULONG PeakWorkingSetSize; //工作集峰值大小；ULONG WorkingSetSize; //工作集大小；ULONG QuotaPeakPagedPoolUsage; //分页池使用配额峰值；ULONG QuotaPagedPoolUsage; //分页池使用配额；ULONG QuotaPeakNonPagedPoolUsage; //非分页池使用配额峰值；ULONG QuotaNonPagedPoolUsage; //非分页池使用配额；ULONG PagefileUsage; //页文件使用情况；ULONG PeakPagefileUsage; //页文件使用峰值；}VM_COUNTERS,*PVM_COUNTERS;typedef struct _IO_COUNTERS{LARGE_INTEGER ReadOperationCount; //I/O读操作数目；LARGE_INTEGER WriteOperationCount; //I/O写操作数目；LARGE_INTEGER OtherOperationCount; //I/O其他操作数目；LARGE_INTEGER ReadTransferCount; //I/O读数据数目；LARGE_INTEGER WriteTransferCount; //I/O写数据数目；LARGE_INTEGER OtherTransferCount; //I/O其他操作数据数目；}IO_COUNTERS,*PIO_COUNTERS;以上这些信息应该是比较全面的了，在Win32 API里为我们提供了PSAPI(进程状态)和ToolHelp32这两种探测系统进程/线程信息的方式，在Windows2K/XP/2003都支持它们。

内核层的三种Hook技术的使用

内核层的三种Hook技术的使⽤1.前⾔本⽂是在Win7 X86系统上进⾏实验，实验的内容是在内核层通过三种不同的Hook⽅法来实现进程保护，让运⾏的程序不被其他的程序关闭。

这⾥⽤来被保护的程序是⼀个简单的HelloWord弹窗程序，程序名是demo.exe。

2.实现原理⼀个程序要想关闭⼀个进程，⾸先就要获取这个进程的句柄，并且获得的这个句柄还需要具备进程关闭的访问掩码。

也就是说，在⽤户层我们想要关闭⼀个进程，⾸先就需要使⽤以下的代码来获得⼀个进程的句柄。

HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, dwPid);其中第⼀个参数PROCESS_TERMINATE就是让我们获得的进程句柄具有关闭进程的访问掩码，它在⽂档中的定义如下：#define PROCESS_TERMINATE (0x0001)那也就是说，如果HOOK了打开进程的函数，就可以在我们编写的函数中判断所打开的进程是否是我们要保护的进程，以及所要获得的进程句柄是否是要具备进程关闭的访问掩码，如果是的话就把它去掉。

这个时候，程序如果使⽤这个被删除掉进程关闭访问掩码的句柄来关闭进程，就会失败，这就完成了对进程的保护作⽤。

⽽在⽤户层所调⽤的OpenProcess到内核层以后，其实在内核中是调⽤ZwOpenProcess，所以只要在内核中监控这个函数就可以完成实验。

该函数在⽂档中的定义如下：NTSTATUSZwOpenProcess(__out PHANDLE ProcessHandle,__in ACCESS_MASK DesiredAccess,__in POBJECT_ATTRIBUTES ObjectAttributes,__in_opt PCLIENT_ID ClientId);参数2所代表的就是要打开的这个进程要具备的访问掩码，通过对它的判断与修改就可以实现进程保护。

SSDT内核钩子原理及检测程序的实现

kernel32! openprocess
ntdll! NtopenProcess
sysenter (int 2Eh)
ring3 ring0
nt! NtOpenProcess
图 1 OpenProcess 调用过程
3 SSDT 结构
Windows 可执行程序在内核模式中运行，并且对操作系统的所有子系统，如 Win32、 POSIX 和 OS/2 都提供本地支持。这些本地系统服务的地址在内核结构中称为系统服务调度表 (System Service Dispatch Table， SSDT) 中列出。该表可以基于系统调用编号进行索引，以便定位函数的内存地址。还有一个系统服务参数表 (System Service Parameter Table， SSPT) 指定了每个系统服务的函数参数的字节数。 [1]
以 OpenProcess 函数为例， OpenProcess 函数的定义位于 kernel32.dll，用 Windbg 来打开 kernel32.dll，然后可以发现在 OpenProcess 中有类似这样的汇编代码：
call ds:NtOpenProcess 这就是说， OpenProcess 调用了 ntdll.dll 的 NtOpenProcess 函数。 NtOpenProcess 的代码如下： mov eax, 7Ah mov edx, 7FFE0300h call dword ptr [edx] retn 10h call dword ptr [edx] 的实质是调用了 KiFastSystemCall： mov edx, esp sysenter

挂钩 NtResumeThread 实现全局Hook

/File/Safe/Programming/2008101720.html挂钩NtResumeThread 实现全局Hook浏览统计： 14创建时间：2008-10-17文章提交：Admin挂钩一直是Hack 编程中永恒的主题，基本高级的Rootkit 程序多多少少都会使用Hook 技术。

似乎Hook 都被讲烂了，不论是Ring3 的还是Ring0 的网上都有例子。

Ring0 的毋庸置疑当然是全局的了，这里说说ring3 的全局hook。

Ring 3 有Ring 3 的优势，稳定是压倒一切的，因此Mcafee 和其他一些商业的安全软件都还是使用了Ring3 的Hook 技术，无论如何用户是无法接受蓝屏和死机的。

感兴趣的可以装个Rootkit unhooker 自己看看。

:)1. 以往的Ring 3全局Hook纵观网上流行的全局Hook 程序都只用了一个Windows API， SetWindowsHookEx，此函数原型：HHOOK SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId);idhook 安装的钩子类型，如 WH_GETMESSAGE，WH_KEYBOARD 等lpfn hook procedure 的指针hmod 包含 hook procedure DLL 的handledwThread 为0使用这个这个API 时候有问题的，只能挂接系统中的所有G U I线程，换句通俗的话说就是有界面的程序，Windows console 类的程序就无能为力了。

还有一种通过插入注册表来实现HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs这种方法简单，但是还是只能挂钩GUI 程序，并且这个键值已经被广大HIPS 所关注，吃力不讨好。

HOOK技术的Ring0级进程保护组件设计与实现

基于SSDT HOOK技术的Ring0级进程保护组件设计与实现北京理工大学12110606 杨蛟龙(jiaolong@)摘要本文介绍了Windows下利用SSDT（系统服务描述符表）HOOK技术实现对进程的保护功能——包括进程信息隐藏（进程防打开）和进程防结束——的原理，同时介绍了通过开发Windows驱动程序的方式获得Ring0级权限实现对SSDT的读取操作，以及进程保护组件的DLL封装、接口定义；最后通过对组件的测试验证了SSDT HOOK技术实现进程保护的有效性以及本组件的可用性及可移植性。

关键字：SSDT，Hook，驱动，Ring0，进程保护目录1.背景介绍 (3)2.SSDT Hook技术 (4)2.1SSDT简介 (4)2.2进程保护功能分析 (5)2.3SSDT HOOK实现 (6)2.4钩子函数实现 (9)3.内核驱动程序 (11)3.1WDM基本结构 (11)3.2驱动程序开发 (12)4.组件封装 (15)4.1DLL简介 (15)4.2DLL开发 (16)5.组件测试 (18)5.1MFC程序调用测试 (18)5.2C#.Net程序调用测试 (20)6.参考文献 (21)1.背景介绍进程保护这一思想很早就出现，现在大多数的杀毒软件等安全防护软件均带有对自身进程保护的功能，这是为了防止病毒等恶意程序破坏进程的运行。

相对的，很多病毒为了防止被发现或终止，提高自己的运行权限，隐藏自己、保护自己不被终止。

然而并不是只有病毒及杀毒软件有对自己的进程进行保护的需求，很多软件，如网吧、机房等的监控系统、计费系统等，以及一些必须确保自身运行过程中不被强行中断，否则会导致数据丢失、操作系统崩溃等严重后果的软件系统，都需要对自身进行必要的防护，防止恶意行为或者操作者的误操作引起的损失。

高权限的进程保护关系到操作系统底层，并不是所有语言都容易开发高权限进程保护功能，尤其是基于代码托管的语言。

目前，实现进程保护的软件均将进程保护功能嵌入在软件内，没有专门的组件提供进程保护功能。

HOOKNtOpenProcess保护指定进程

HOOKNtOpenProcess保护指定进程hook-dt本部分设定了隐藏,您已回复过了,以下是隐藏的内容汇编写的一个简单的HOOKSSDT例子[lit=1];HOOKNtOpenProce保护指定进程;Code:zzage.modelflat,tdcalloptioncaemap:noneincludeD:\\RadASM\\mam32\\include\\w2k\\nttatu.incincludeD:\ \RadASM\\mam32\\include\\w2k\\ntddk.incincludeD:\\RadASM\\mam32\ \include\\w2k\\ntokrnl.incincludelibD:\\RadASM\\mam32\\lib\\w2k\\ntokrnl.libincludeD:\ \RadASM\\mam32\\Macro\\String.mac_NTOPENPROCESStypedefproto:DWORD,:DWORD,:DWORD,:DWORDNTOPENP ROCESStypedefptr_NTOPENPROCESS.dataOldNtOpenProceNTOPENPROCESSdwNtOpenProce_AddrdddwImageFileNa meOffetdd.codeGetImageFileNameOffetprocueeieb某;获取EPROCESS结构的ImageFileName偏移量函数invokeIoGetCurrentProcemovei,ea某某oreb某,eb某.whileeb某<1000hleaea某,[ei+eb某]invoke_trnicmp,ea某,$CTA0(\6.break.ifea某==0inceb某.endw.ifea某==0movea某,eb某.ele某orea某,ea某.endifretGetImageFileNameOffetendpMyNtOpenProceprochProce,DeiredAcce,pObjectAttribute,pClientI dlocallpEPROCESS:PVOIDmovec某,pClientIdaumeec某:ptrCLIENT_IDinvokePLookupProceByProceId,[ec某].UniqueProce,addrlpEPROCESS;获取打开的目标进程的EPROCESS结构aumeec某:nothing.ifea某==STATUS_SUCCESSmovei,lpEPROCESSaddei,dwImageFileNameOffet;指向EPROCESS结构的ImageFileName 地址invoke_trnicmp,ei,$CTA0(\;判断开打的目标进程是否为我们要保护的进程.ifea某==0movea某,STATUS_ACCESS_DENIED;如果是打开我们保护的进程，就返回拒绝！ret.endif.endifinvokeOldNtOpenProce,hProce,DeiredAcce,pObjectAttribute,pCli entId;如果不是打开我们保护的进程，就返回到原来的NtOpenProce函数retMyNtOpenProceendpDriverUnloadprocpDriverObject:PDRIVER_OBJECTpuhadinvokeDbgPrint,$CTA0(\卸载成功\\n\climovea某,cr0某orea某,10000hmovcr0,ea某movei,dwNtOpenProce_Addrmovea某,OldNtOpenProcemovdwordptr[ei],ea某;还原旧的NtOpenProce函数地址movea某,cr0某orea某,10000hmovcr0,ea某tipopadretDriverUnloadendpDriverEntryprocpDriverObject:PDRIVER_OBJECT,pRegitryPath:PUN ICODE_STRINGpuhadinvokeDbgPrint,$CTA0(\安装成功\\n\invokeGetImageFileNameOffetmovdwImageFileNameOffet,ea某;获取EPROCESS结构的ImageFileName偏移量movea某,KeServiceDecriptorTable;获取KeServiceDecriptorTable的地址movei,[ea某]movei,[ei];获取KeServiceDecriptorTable->ServiceTableBaeinvokeMmGetSytemRoutineAddre,$CCOUNTED_UNICODE_STRING(\;获取ZwOpenProce的地址incea某movz某ec某,byteptr[ea某];取NtOpenProce服务号alec某,2addei,ec某movdwNtOpenProce_Addr,eimovedi,dwordptr[ei]movOldNtOpenProce,edi;保存旧NtOpenProce函数地址invokeDbgPrint,$CTA0(\%某\\n\movedi,offetMyNtOpenProcecli movea某,cr0某orea某,10000hmovcr0,ea某movdwordptr[ei],edi;替换成我们自己的MyNtOpenProce函数movea 某,cr0某orea某,10000hmovcr0,ea某tiinvokeDbgPrint,$CTA0(\%某\\n\MyNtOpenProcemovei,pDriverObjectmov[ei+34h],offetDriverUnload;设置卸载例程popadmovea某,STATUS_SUCCESSretDriverEntryendpendDriverEntry下面是原帖一些精彩回复：恩。

Hook内核函数（KiReadyThread）检测进程

Hook内核函数（KiReadyThread）检测进程Hook 内核函数（KiReadyThread）检测进程1. 介绍通用Hook内核函数的方法当我们要拦截目标函数的时候，只要修改原函数头5个字节的机器代码为一个JMP XXXXXXXX（XXXXXXXX是距自己的Hook函数的偏移量）就行了。

并且保存原来修改前的5个字节。

在跳入原函数时，恢复那5个字节即可。

char JmpMyCode [] = {0xE9,0x00,0x00,0x00,0x00};//E9对应Jmp偏移量指令*((ULONG*)(JmpMyCode+1))=(ULONG)MyFunc-(ULONG)OrgDestFunction-5;//获得偏移量memcpy(OrgCode,(char*)OrgDestFunction,5);//保存原来的代码memcpy((char*)OrgDestFunction,JmpMyCode,5);//覆盖前一个命令为一个跳转指令在系统内核级中，MS的很多信息都没公开，包括函数的参数数目，每个参数的类型等。

在系统内核中，访问了大量的寄存器，而很多寄存器的值，是上层调用者提供的。

如果值改变系统就会变得不稳定。

很可能出现不可想象的后果。

另外有时候对需要Hook的函数的参数不了解，所以不能随便就去改变它的堆栈，如果不小心也有可能导致蓝屏。

所以Hook的最佳原则是在自己的Hook函数中呼叫原函数的时候，所有的寄存器值，堆栈里面的值和Hook前的信息一样。

这样就能保证在原函数中不会出错。

一般我们自己的Hook的函数都是写在C文件里面的。

例如Hook的目标函数KiReadyThread。

那么一般就自己实现一个：MyKiReadyThread（...）{......call KiReadyThread......}但是用C编译器编译出来的代码会出现一个堆栈帧:Push ebpmov ebp,esp这就和我们的初衷不改变寄存器的数违背了。

利用NtQuerySystemInformation函数遍历进程,遍历线程,获取线程挂起或运行状态

利⽤NtQuerySystemInformation函数遍历进程,遍历线程,获取线程挂起或运⾏状态版权声明：专注于计算机⽹络安全学习 https:///u011672712/article/details/515860301 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#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)#define STATUS_SUCCESS ((NTSTATUS) 0x00000000) #define SystemProcessesAndThreadsInformation 5 // 功能号#define NTAPI __stdcall// 线程状态的枚举常量typedef enum_THREAD_STATE{StateInitialized , // 初始化状态StateReady , // 准备状态StateRunning , // 运⾏状态StateStandby , //StateTerminated ,//关闭StateWait , // 等待StateTransition , // 切换???StateUnknown}THREAD_STATE;// 线程处于等待的原因的枚举常量typedef enum_KWAIT_REASON{Executive ,FreePage ,PageIn ,PoolAllocation ,DelayExecution ,Suspended ,UserRequest ,WrExecutive ,WrFreePage ,WrPageIn ,WrPoolAllocation ,WrDelayExecution ,WrSuspended ,WrUserRequest ,WrEventPair ,WrQueue ,WrLpcReceive ,WrLpcReply ,WrVirtualMemory ,WrPageOut ,WrRendezvous ,Spare2 ,Spare3 ,Spare4 ,Spare5 ,Spare6 ,WrKernel ,MaximumWaitReason}KWAIT_REASON;typedef LONG NTSTATUS;typedef LONG KPRIORITY;typedef struct_CLIENT_ID{DWORD UniqueProcess;DWORD UniqueThread;} CLIENT_ID , *PCLIENT_ID;63 6465 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 118119 120 121 122 123 124 125 126 127 128 129 130typedef struct_VM_COUNTERS{SIZE_T PeakVirtualSize;SIZE_T VirtualSize;ULONG PageFaultCount;SIZE_T PeakWorkingSetSize;SIZE_T WorkingSetSize;SIZE_T QuotaPeakPagedPoolUsage;SIZE_T QuotaPagedPoolUsage;SIZE_T QuotaPeakNonPagedPoolUsage;SIZE_T QuotaNonPagedPoolUsage;SIZE_T PagefileUsage;SIZE_T PeakPagefileUsage;} VM_COUNTERS;// 线程信息结构体typedef struct_SYSTEM_THREAD_INFORMATION{LARGE_INTEGER KernelTime;LARGE_INTEGER UserTime;LARGE_INTEGER CreateTime;ULONG WaitTime;PVOID StartAddress;CLIENT_ID ClientId;KPRIORITY Priority;KPRIORITY BasePriority;ULONG ContextSwitchCount;LONG State;// 状态,是THREAD_STATE枚举类型中的⼀个值LONG WaitReason;//等待原因, KWAIT_REASON中的⼀个值} SYSTEM_THREAD_INFORMATION , *PSYSTEM_THREAD_INFORMATION;typedef struct_UNICODE_STRING{USHORT Length;USHORT MaximumLength;PWSTR Buffer;} UNICODE_STRING , *PUNICODE_STRING;// 进程信息结构体typedef struct_SYSTEM_PROCESS_INFORMATION{ULONG NextEntryDelta; // 指向下⼀个结构体的指针ULONG ThreadCount; // 本进程的总线程数ULONG Reserved1[ 6 ]; // 保留LARGE_INTEGER CreateTime; // 进程的创建时间LARGE_INTEGER UserTime; // 在⽤户层的使⽤时间LARGE_INTEGER KernelTime; // 在内核层的使⽤时间UNICODE_STRING ProcessName; // 进程名KPRIORITY BasePriority; //ULONG ProcessId; // 进程IDULONG InheritedFromProcessId;ULONG HandleCount; // 进程的句柄总数ULONG Reserved2[ 2 ]; // 保留VM_COUNTERS VmCounters;IO_COUNTERS IoCounters;SYSTEM_THREAD_INFORMATION Threads[ 5 ]; // ⼦线程信息数组}SYSTEM_PROCESS_INFORMATION , *PSYSTEM_PROCESS_INFORMATION;// NtQuerySystemInformation 函数的原型// 由于该没有导出,所以得⾃⼰定义函数的原型typedef DWORD(WINAPI* PQUERYSYSTEM)(UINT, PVOID, DWORD, PDWORD); /*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 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198/*※※* 函数名 : IsThreadSuspend※※* 功能 : 获取线程是被是否被挂起※※* 返回值 : int 1：表⽰线程被挂起 , 0：表⽰线程正常。

NT内核级进程隐藏3-线程调度链表及Hook 内核函数

NT内核级进程隐藏3-线程调度链表及Hook内核函数基于线程调度链表的检测和隐藏技术1.什么是ETHREAD和KTHREAD块学习各种外挂制作技术，马上去百度搜索"魔鬼作坊"点击第一个站进入、快速成为做挂达人。

Windows2000是由执行程序线程（ETHREAD）块表示的，ETHREAD成员都是指向的系统空间，进程环境块（TEB）除外。

ETHREAD块中的第一个结构体就是内核线程（KTHREAD）块。

在KTHREAD块中包含了windows2000内核需要访问的信息。

这些信息用于执行线程的调度和同步正在运行的线程。

kd>!kthreadstruct_KTHREAD(sizeof=432)+000struct_DISPA TCHER_HEADER Header+010struct_LIST_ENTRY MutantListHead+018void*InitialStack+01c void*StackLimit+020void*Teb+024void*TlsArray+028void*KernelStack+02c byte DebugActive+02d byte State+02e byte Alerted[2]+030byte Iopl+031byte NpxState+032char Saturation+033char Priority+034struct_KAPC_STATE ApcState+034struct_LIST_ENTRY ApcListHead[2] +044struct_KPROCESS*Process+04c uint32ContextSwitches+050int32WaitStatus+054byte WaitIrql+055char WaitMode+056byte WaitNext+057byte WaitReason+058struct_KWAIT_BLOCK*WaitBlockList +05c struct_LIST_ENTRY WaitListEntry+064uint32WaitTime+068char BasePriority+069byte DecrementCount+06a char PriorityDecrement+06b char Quantum+06c struct_KWAIT_BLOCK WaitBlock[4] +0cc void*LegoData+0d0uint32KernelApcDisable+0d4uint32UserAffinity+0d8byte SystemAffinityActive+0d9byte PowerState+0da byte NpxIrql+0db byte Pad[1]+0dc void*ServiceTable+0e0struct_KQUEUE*Queue+0e4uint32ApcQueueLock+0e8struct_KTIMER Timer+110struct_LIST_ENTRY QueueListEntry+118uint32Affinity+11c byte Preempted+11d byte ProcessReadyQueue+11e byte KernelStackResident+11f byte NextProcessor+120void*CallbackStack+124void*Win32Thread+128struct_KTRAP_FRAME*TrapFrame+12c struct_KAPC_STATE*ApcStatePointer[2] +134char PreviousMode+135byte EnableStackSwap+136byte LargeStack+137byte ResourceIndex+138uint32KernelTime+13c uint32UserTime+140struct_KAPC_STATE SavedApcState+158byte Alertable+159byte ApcStateIndex+15a byte ApcQueueable+15b byte AutoAlignment+15c void*StackBase+160struct_KAPC SuspendApc+190struct_KSEMAPHORE SuspendSemaphore+1a4struct_LIST_ENTRY ThreadListEntry+1ac char FreezeCount+1ad char SuspendCount+1ae byte IdealProcessor+1af byte DisableBoost在偏移0x5c处有一个WaitListEntry成员，这个就是用来链接到线程调度链表的。

HOOK监控任务管理器

HOOK监控任务管理器思路：其实比较简单，还是利用DLL，首写跟据API函数OpenProcess与TerminateProcess的结构自已编写两个与这两个API一样的函数，再利用GetProcAddress获取系统的那两个API函数入口地址，最后用WriteProcessMemory将你写的函数的地址替换掉原来系统的函数地址。

这样所有调用这两系统API都将先执行你的函数。

如果只Hook其中一个函数比如只hook OpenProcess的话那么任务管理器将不能获取到你的进程信息那么会出错。

如果只hook TerminateProcess那样也不行，因为一个进程的句柄在本进程与别的进程中是不一样的，所以如果你不知道自已进程在别人进程中的句柄那么是没办法hook TerminateProcess的。

本例中首先利用OpenProcess获取自已在别的进程中的句柄，然后hook TerminateProcess进程监控，如果发现有程序调用TerminateProcess并且所结束的对象正是自已，那么就给出提示窗口。

貌似讲了一大堆废话。

还是看代码直接------------------------------------------------调用部分unit Unit1;interfaceusesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, StdCtrls;typeTForm1 = class(TForm)Button1: TButton;Button2: TButton;procedure Button1Click(Sender: TObject);procedure Button2Click(Sender: TObject);private{ Private declarations }public{ Public declarations }end;varForm1: TForm1;procedure StartHook(pid: DWORD); stdcall; external 'hookdll.dll';procedure EndHook; stdcall; external 'hookdll.dll';implementation{$R *.dfm}procedure TForm1.Button1Click(Sender: TObject);beginStartHook(GetCurrentProcessId);end;procedure TForm1.Button2Click(Sender: TObject);beginEndHook;end;end.-----------------------------------------------------------------------------------------DLL文件，全部实现都在这里--------------------- Hookdll.dprlibrary Hookdll;usesSysUtils,Classes,Windows,Dialogs,unitHook in 'unitHook.pas';constHOOK_MEM_FILENAME = 'tmp.hkt';varhhk: HHOOK;Hook: array[0..2] of TNtHookClass;//内存映射MemFile: THandle;startPid: PDWORD; //保存PIDfhProcess: THandle; //保存本进程在远程进程中的句柄//拦截 OpenProcessfunction NewOpenProcess(dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwProcessId: DWORD): THand le; stdcall;typeTNewOpenProcess = function (dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwProcessId: DWORD): T Handle; stdcall;beginif startPid^ = dwProcessId then beginHook[1].UnHook;Result := TNewOpenProcess(Hook[1].BaseAddr)(dwDesiredAccess, bInheritHandle, dwProcessId);fhProcess:=Result;Hook[1].Hook;exit;end;Hook[1].UnHook;Result := TNewOpenProcess(Hook[1].BaseAddr)(dwDesiredAccess, bInheritHandle, dwProcessId);Hook[1].Hook;end;function NewTerminateProcess(hProcess: THandle;uExitCode: UINT): BOOL; Stdcall;typeTNewTerminateProcess = function (hProcess: THandle;uExitCode: UINT): BOOL; Stdcall;beginif fhProcess = hProcess then beginshowmessage('不准关闭我！');result := true;exit;end;Hook[2].UnHook;Result := TNewTerminateProcess(Hook[2].BaseAddr)(hProcess, uExitCode );Hook[2].Hook;end;procedure InitHook; //安装 HookbeginHook[1] := TNtHookClass.Create('kernel32.dll', 'OpenProcess', @NewOpenProcess);hook[2] := TNtHookClass.Create('kernel32.dll', 'TerminateProcess', @NewTerminateProcess);end;procedure UninitHook; //删除 HookvarI: Integer;beginfor I := 0 to High(Hook) dobeginFreeAndNil(Hook[I]);end;end;procedure MemShared();beginMemFile:=OpenFileMapping(FILE_MAP_ALL_ACCESS,False, HOOK_MEM_FILENAME); //打开内存映射文件if MemFile = 0 then beginMemFile := CreateFileMapping($FFFFFFFF, nil, PAGE_READWRITE, 0, 4, HOOK_MEM_FILENAME);end;if MemFile <> 0 then//映射文件到变量startPid := MapViewOfFile(MemFile,FILE_MAP_ALL_ACCESS,0,0,0); end;//传递消息function HookProc(nCode, wParam, lParam: Integer): Integer; stdcall;beginResult := CallNextHookEx(hhk, nCode, wParam, lParam);end;//开始HOOKprocedure StartHook(pid: DWORD); stdcall;beginstartPid^ := pid;hhk := SetWindowsHookEx(WH_CALLWNDPROC, HookProc, hInstance, 0); end;//结束HOOKprocedure EndHook; stdcall;beginif hhk <> 0 thenUnhookWindowsHookEx(hhk);end;//环境处理procedure DllEntry(dwResaon: DWORD);begincase dwResaon ofDLL_PROCESS_A TTACH: InitHook; //DLL载入DLL_PROCESS_DETACH: UninitHook; //DLL删除end;end;exportsStartHook, EndHook;beginMemShared;{ 分配DLL程序到 DllProc 变量 }DllProc := @DllEntry;{ 调用DLL加载处理 }DllEntry(DLL_PROCESS_A TTACH);end.--------------------------- 单元unitHook.pasunit unitHook;interfaceusesWindows, Messages, Classes, SysUtils;type//NtHook类相关类型TNtJmpCode=packed record //8字节MovEax:Byte;Addr:DWORD;JmpCode:Word;dwReserved:Byte;end;TNtHookClass=class(TObject)privatehProcess:THandle;NewAddr:TNtJmpCode;OldAddr:array[0..7] of Byte;ReadOK:Boolean;publicBaseAddr:Pointer;constructor Create(DllName,FuncName:string;NewFunc:Pointer);destructor Destroy; override;procedure Hook;procedure UnHook;end;implementation//==================================================//NtHOOK 类开始//==================================================constructor TNtHookClass.Create(DllName: string; FuncName: string;NewFunc:Pointer);varDllModule:HMODULE;dwReserved:DWORD;begin//获取模块句柄DllModule:=GetModuleHandle(PChar(DllName));//如果得不到说明未被加载if DllModule=0 then DllModule:=LoadLibrary(PChar(DllName));//得到模块入口地址（基址）BaseAddr:=Pointer(GetProcAddress(DllModule,PChar(FuncName)));//获取当前进程句柄hProcess:=GetCurrentProcess;//指向新地址的指针NewAddr.MovEax:=$B8;NewAddr.Addr:=DWORD(NewFunc);NewAddr.JmpCode:=$E0FF;//保存原始地址ReadOK:=ReadProcessMemory(hProcess,BaseAddr,@OldAddr,8,dwReserved); //开始拦截Hook;end;//释放对象destructor TNtHookClass.Destroy;beginUnHook;CloseHandle(hProcess);inherited;end;//开始拦截procedure TNtHookClass.Hook;vardwReserved:DWORD;beginif (ReadOK=False) then Exit;//写入新的地址WriteProcessMemory(hProcess,BaseAddr,@NewAddr,8,dwReserved);end;//恢复拦截procedure TNtHookClass.UnHook;vardwReserved:DWORD;beginif (ReadOK=False) then Exit;//恢复地址WriteProcessMemory(hProcess,BaseAddr,@OldAddr,8,dwReserved); end;end.。

windows内核Api的学习

windows内核Api的学习windows内核api就是ntoskrnl.exe导出的函数。

我们可以跟调⽤应⽤层的api⼀样，调⽤内核api。

不过内核api需要注意的是，如果函数导出了，并且函数⽂档化（也就是可以直接在msdn上搜索到）。

ExFreePool函数导出，并且⽂档化，那么我们可以直接调⽤。

导出了未⽂档化，那么我们就要声明。

什么叫⽂档化和未⽂档化呢？⼤家来看⼀个函数：UCHAR *PsGetProcessImageFileName(IN PEPROCESS Process);⽂档化：就是假设函数导出了，并且在msdn上可以搜索到。

就是⽂档化我们调⽤⽂档化的函数就是直接调⽤。

未⽂档化：就是假设函数已经导出了，但是在msdn上没有搜到，就是未⽂档化函数我们要调⽤它，就得⾃⼰⼿动声明。

内核编程就跟应⽤层⼀样，都是api的调⽤，都是Hook，都是反Hook，⼀样的编程思维。

它们本质的区别只是在于⼀个先后顺序，⽐如看图-什么叫本质的区别:顺序掉从ring3到SSDT层主体实现函数的调⽤顺序：OpenProcesss-->ntdll!ZwOpenProcess-->ntos!ZwOpenProcess-->ntos!NtOpenProcess-->后⾯。

如果你以内核层和应⽤的⾓度去理解，那么就是openprocess⼀直调⽤到NtOpenProcess还有后⾯。

⽰例代码：KernelApiCode.c#include <ntifs.h>#include <ntimage.h>//调⽤功能号#define SystemModuleInformation 11#define SystemProcessesAndThreadsInformation 5// 系统进程信息结构体typedef struct _SYSTEM_PROCESSES{ULONG NextEntryDelta;ULONG ThreadCount;ULONG Reserved[6];LARGE_INTEGER CreateTime;LARGE_INTEGER UserTime;LARGE_INTEGER KernelTime;UNICODE_STRING ProcessName; //进程的名称KPRIORITY BasePriority;ULONG ProcessId; //进程的PIDULONG InheritedFromProcessId;ULONG HandleCount;ULONG Reserved2[2];VM_COUNTERS VmCounters;IO_COUNTERS IoCounters;} _SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;// 系统模块信息结构体节点typedef struct _SYSTEM_MODULE_INFORMATION{ULONG Reserved[2];ULONG Base; //模块的基址ULONG Size; //模块的⼤⼩ULONG Flags;USHORT Index;USHORT Unknown;USHORT LoadCount;USHORT ModuleNameOffset;CHAR ImageName[256]; //模块的名称} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;//模块链结构typedef struct _tagSysModuleList{ULONG ulCount;SYSTEM_MODULE_INFORMATION smi[1];} MODULES, *PMODULES;//ZwQuerySystemInformation函数导出了，但是未⽂档化，所以要⼿动声明NTSTATUS __stdcall ZwQuerySystemInformation(ULONG_PTR SystemInformationClass, //调⽤功能号PVOID SystemInformation, //信息结构体ULONG SystemInformationLength, //信息结构体的字节长度PULONG ReturnLength //返回的实际长度);//在驱动层遍历进程VOID EnumProcessList(){//声明变量NTSTATUS status;ULONG NeededSize,i;PVOID pBuffer = NULL; //⽤来指向缓冲区PSYSTEM_PROCESSES pInfo = NULL; //指向SYSTEM_PROCESSES的指针__try{//获取存放系统的进程和线程信息的实际字节长度status = ZwQuerySystemInformation(SystemProcessesAndThreadsInformation,NULL,0,&NeededSize);if (status != STATUS_INFO_LENGTH_MISMATCH){//长度不匹配DbgPrint("!= STATUS_INFO_LENGTH_MISMATCH");return;}//根据获取的NeededSize申请⾮分页内存pBuffer = ExAllocatePool(NonPagedPool, NeededSize);if (pBuffer != NULL){DbgPrint("NeededSize:%d\r\n", NeededSize);//使⽤5号功能来获取系统的进程和线程的信息status = ZwQuerySystemInformation(SystemProcessesAndThreadsInformation, //SystemProcessesAndThreadsInformation = 5pBuffer,NeededSize,NULL);//如果调⽤成功if (NT_SUCCESS(status)){DbgPrint("ZwQuerySystemInformation() success\r\n");//指针类型转换pInfo = (PSYSTEM_PROCESSES)pBuffer;while (TRUE){//PID=0，系统的if (pInfo->ProcessId == 0){DbgPrint("PID %5d System Idle Process\r\n", pInfo->ProcessId);}else{ //打印进程的PID和进程的名称DbgPrint("PID %5d %ws\r\n", pInfo->ProcessId, pInfo->ProcessName.Buffer);//这⾥是unicode }//如果没有下⼀个就结束if (pInfo->NextEntryDelta == 0){break;}//遍历下⼀个pInfo = (PSYSTEM_PROCESSES)(((PUCHAR)pInfo) + pInfo->NextEntryDelta);}}}}//异常的处理__except(EXCEPTION_EXECUTE_HANDLER){//输出异常信息codeDbgPrint("%08x\r\n", GetExceptionCode());}//释放申请的⾮分页内存资源if (pBuffer != NULL){ExFreePool(pBuffer);pBuffer = NULL;}}//驱动层遍历系统模块VOID GetKernelModuleInfo(){//变量的声明NTSTATUS status;ULONG NeededSize, i;PVOID pBuffer = NULL; //⽤来指向缓冲区PMODULES pModuleList = NULL; //指向MODULES指针__try{//获取存放系统模块信息结构体的缓冲区的⼤⼩status = ZwQuerySystemInformation(SystemModuleInformation,NULL,0,&NeededSize);if (status != STATUS_INFO_LENGTH_MISMATCH){DbgPrint("!= STATUS_INFO_LENGTH_MISMATCH");return;}//根据NeededSize的⼤⼩，申请⾮分页内存的⼤⼩pBuffer = ExAllocatePool(NonPagedPool, NeededSize);if (pBuffer){//调⽤功能号11来获取系统的模块的信息status=ZwQuerySystemInformation(SystemModuleInformation, //SystemModuleInformation = 11pBuffer,NeededSize,NULL);if (NT_SUCCESS(status)){//指针类型转换pModuleList = (PMODULES)pBuffer;//遍历系统的模块的信息for (i = 0; i< pModuleList->ulCount; i++){//打印系统模块的基址、模块的⼤⼩、模块的名称DbgPrint("0x%08X:%d:%s\r\n", pModuleList->smi[i].Base, pModuleList->smi[i].Size, pModuleList->smi[i].ImageName); }}}}__except(EXCEPTION_EXECUTE_HANDLER){//打印异常的代码DbgPrint("%08x\r\n", GetExceptionCode());}//释放申请的⾮分页内存资源if (pBuffer){ExFreePool(pBuffer);pBuffer = NULL;}}/**创建注册表*SafeKey注册表的路径*Reg_Type注册表的键值类型*ValueName注册表的键值的名称*Value注册表的键值的值*/BOOLEAN Safe_CreateValueKey(PWCHAR SafeKey, ULONG_PTR Reg_Type, PWCHAR ValueName, PWCHAR Value) {//声明变量OBJECT_ATTRIBUTES objectAttributes;UNICODE_STRING RegUnicodeString, Unicode_ValueName;NTSTATUS ntStatus;HANDLE hRegister;ULONG_PTR ulValue_DWORD;ULONG_PTR ulResult = 0;BOOLEAN bRetOK = FALSE;//WCHAR字符串转UNICODE_STRING字符串RtlInitUnicodeString(&Unicode_ValueName, ValueName); //键值的名称 RtlInitUnicodeString(&RegUnicodeString, SafeKey); //注册表的路径//初始化objectAttributesInitializeObjectAttributes(&objectAttributes,&RegUnicodeString, //注册表的路径OBJ_CASE_INSENSITIVE, //对⼤⼩写敏感NULL,NULL);//打开注册表ntStatus = ZwCreateKey(&hRegister, //返回注册表的句柄KEY_ALL_ACCESS, //注册表的权限&objectAttributes,0,NULL,REG_OPTION_NON_VOLATILE,&ulResult);if (NT_SUCCESS(ntStatus)){bRetOK = TRUE;//根据传⼊参数Reg_Type来实现各种功能//调⽤ZwSetValueKey函数来设置注册表的switch (Reg_Type){case REG_SZ:{ZwSetValueKey(hRegister,&Unicode_ValueName, //键值的名称0,Reg_Type, //键值的类型Value, //键值的值wcslen(Value)*2);DbgPrint("REG_SZ--注册表创建成功!\n");break;}case REG_EXPAND_SZ:{ZwSetValueKey(hRegister,&Unicode_ValueName, //键值的名称0,Reg_Type, //键值的类型Value, //键值的值wcslen(Value)*2);DbgPrint("REG_EXPAND_SZ--注册表创建成功!\n");break;}case REG_DWORD:{ulValue_DWORD = sizeof(REG_DWORD);ZwSetValueKey(hRegister,&Unicode_ValueName, //键值的名称0,Reg_Type, //键值的类型&Value,sizeof(ulValue_DWORD) //键值的值);DbgPrint("REG_DWORD--注册表创建成功!\n");break;}}//关闭句柄ZwClose(hRegister);}return bRetOK;}//******************************************************************************************************************************//驱动卸载例程函数VOID DriverUnload(IN PDRIVER_OBJECT DriverObject){DbgPrint("卸载完成!\n");}//驱动⼊⼝函数DriverEntryNTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath){//设置驱动的卸载例程函数DriverObject->DriverUnload = DriverUnload;//遍历系统的进程EnumProcessList();//遍历系统的驱动模块GetKernelModuleInfo();//创建注册表Safe_CreateValueKey(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services\\", REG_DWORD, L"Start", (PWCHAR)0x3); Safe_CreateValueKey(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services\\", REG_SZ, L"Start_String", L"Hi~ i am agp"); return STATUS_SUCCESS;}makefile⽂件：## DO NOT EDIT THIS FILE Edit .\sources. if you want to add a new source# file to this component. This file merely indirects to the real make file# that is shared by all the driver components of the Windows NT DDK#!INCLUDE $(NTMAKEENV)\makefile.defsources⽂件TARGETNAME=KernelApiCodeTARGETPATH=objTARGETTYPE=DRIVER# Additional defines for the C/C++ preprocessorC_DEFINES=$(C_DEFINES)SOURCES=KernelApiCode.c\drvversion.rc整理好的代码和⽂档的下载地址：参考资料：AGP讲课资料整理和学习。

SSDT HOOK基本原理与实例介绍

#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
#define HOOK_SYSCALL(_Function, _Hook, _Orig ) \
_Orig = (PVOID) InterlockedExchange( (PLONG) \
unsigned int *ServiceTableBase;
unsigned int *ServiceCounterTableBase;
unsigned int NumberOfServices;
unsigned char *ParamTable)
南邮王下邀月熊·HOOK 学习笔记之 Ring0 下 SSDT HOOK
ServiceTableBase System Service Dispatch Table 的基地址。 NumberOfServices 由 ServiceTableBase 描述的服务的数目。 ServiceCounterTable 此域用于操作系统的 checked builds，包含着 SSDT 中每个服务被调用次数的计数器。这个计数器由 INT 2Eh 处理程序 (KiSystemService)更新。 ParamTableBase 包含每个系统服务参数字节数表的基地址。 System Service Dispath Table（SSDT）：系统服务分发表，给出了服务函数的地址，每个地址 4 子节长。 System Service Parameter Table(SSPT)：系统服务参数表，定义了对应函数的参数字节，每个函数对应一个字节。如在 0x804AB3BF 处的函数需 0x18 字节的参数。
南邮王下邀月熊·HOOK 学习笔记之 Ring0 下 SSDT HOOK

[整理版]windowsnt内核函数大全

Nt内核函数大全NtLoadDriver 服务控制管理器加载设备驱动.NtUnloadDriver 服务控制管理器支持卸载指定的驱动程序. NtRegisterNewDevice 加载新驱动文件.NtQueryIntervalProfile 返回数据.NtSetIntervalProfile 指定采样间隔.NtStartProfile 开始取样.NtStopProfile 停止采样.NtSystemDebugControl 实施了一系列的调试器支持的命令. NtRegisterThreadTerminatePort 一个调试登记通知线程终止. NtCreateDebugObject 创建一个调试对象.NtDebugActiveProcess 使调试器附加到一个积极的过程和调试它. NtDebugContinue 允许一个进程,以线程产生了调试事件. NtQueryDebugFilterState 查询调试过滤国家一级的具体组成部分. NtRemoveProcessDebug 停止调试指定的进程.NtSetDebugFilterState 设置调试输出滤波器一级指定的组成部分. NtSetInformationDebugObject 设置属性的调试对象. NtWaitForDebugEvent 等待调试事件的进程正在调试. NtFlushInstructionCache 清空指定进程的指令缓冲区. NtInitiatePowerAction 启动电源事件.NtPowerInformation 获得该系统的电源状态. NtSetThreadExecutionState 设置一个线程的系统电源状态的要求. NtRequestWakeupLatency 设置一个进程唤醒延迟.NtClose 关闭处理任何对象类型.NtDuplicateObject 复制句柄的对象.NtCreateDirectoryObject 创建一个目录中的对象管理器命名空间. NtCreateSymbolicLinkObject 创建一个符号链接的对象管理器命名空间. NtOpenDirectoryObject 打开对象管理器名字空间目录. NtQueryDirectoryObject 用列举的对象位于一个目录对象. NtOpenSymbolicLinkObject 打开一个符号链接对象. NtQuerySymbolicLinkObject 归来的名称,对象,符号链接点.NtQueryObject 查询对象的属性,如它的名字.NtSetInformationObject 树立了一个对象的属性.NtTranslateFilePath 转换的文件路径的格式.NtCreateKey 创建或打开一个注册表项.NtOpenKey 打开一个现有的注册表项.NtDeleteKey 删除注册表项.NtDeleteV alueKey 删除价值.NtEnumerateKey 枚举子项中的一个关键.NtEnumerateV alueKey 列举了价值的一个关键.NtFlushKey 刷新变化回到注册表在磁盘上.NtInitializeRegistry 获取注册滚动.单参数对这一规定是否安装启动或正常开机. NtNotifyChangeKey 允许一个程序的通知改变某一关键或其子项. NtQueryKey 查询信息的一个关键.NtQueryMultiplV alueKey 检索信息多个指定值.NtQueryV alueKey 资讯检索指定的值.NtReplaceKey 变化的支持文件的一个关键和其子项,用于备份/恢复. NtSaveKey 保存的内容中的一个关键和子项文件.NtRestoreKey 装载的内容主要从一个指定的文件. NtSetInformationKey 集属性中的一个关键.NtSetV alueKey 集相关的数据的价值.NtCreatePort 创建一个港口对象.NtAcceptConnectPort 接受一个端口连接.NtCompleteConnectPort 完成了连接.NtConnectPort 连接一个端口到另一个端口,接受连接. NtImpersonateClientOfPort 线程模拟确定的进程的另一端的一个港口. NtListenPort 侦听端口的连接请求.NtQueryInformationPort 获取信息的一个港口.NtReadRequestData 阅读相关资料港口信息.NtReplyPort 发送一个回复邮件.NtReplyWaitReceivePort 发送一个回复邮件,然后等待传入请求消息. NtReplyWaitReplyPort 发送一个回复邮件,然后等待传入的回复邮件. NtRequestPort 发送请求信息.NtRequestWaitReplyPort 发送请求信息,并等待传入的回复邮件. NtWriteRequestData 填写数据的请求消息.NtSecureConnectPort 创建一个安全的连接端口. NtQueryPortInformationProcess 用于确定某个进程有相关的例外或调试端口. NtAccessCheck 检查当前线程是否已进入一个对象根据其安全描述符. NtAccessCheckAndAuditAlarm 生成相关的审计信息存取检查. NtAdjustGroupsToken 加注或删除群体与象征. NtAdjustPrivilegesToken 启用或禁用特权与象征. NtCloseObjectAuditAlarm 生成审计讯息,指出一个对象被关闭了. NtCreateToken 创建令牌对象.NtDeleteObjectAuditAlarm 产生了审计事件表明,一个对象已删除. NtDuplicateToken 重复象征对象.NtImpersonateThread 允许一个线程假冒身份的其他用户. NtOpenObjectAuditAlarm 产生了审计事件表明,一个物体开幕. NtOpenProcessToken 获得句柄令牌在指定的进程. NtOpenThreadToken 打开的句柄令牌在指定线程.NtPrivilegeCheck 检查,以查看是否有人员令牌已指定特权启用. NtPrivilegeObjectAuditAlarm 生成审核事件记录与特权检查. NtPrivilegedServiceAuditAlarm 生成审计信息表明尝试使用指定的特权. NtQueryInformationToken 获取信息的象征.NtQuerySecurityObject 检索信息的对象的安全设置. NtSetInformationToken 树立了一个象征性的属性.NtSetSecurityObject 设置安全信息的一个对象. NtAccessCheckByType 新的物件具体的安全支持. NtAccessCheckByTypeAndAuditAlarm 新的物件具体的安全支持.NtAccessCheckByTypeResultList 新的物件具体的安全支持. NtFilterToken 新的物件具体的安全支持. NtCompareToken 比较了两个令牌. NtOpenProcessTokenEx 打开一个进程令牌. NtOpenThreadTokenEx 打开一个线程令牌. NtAlertResumeThread 恢复线程.NtAlertThread 发出警报,以一个线程.NtTestAlert 检验是否有线程在等待警报. NtCreateProcess 创建一个新的进程.NtCreateThread 创建一个新线程.NtCurrentTeb 返回一个指针,一个线程环境块. NtDelayExecution 睡眠,暂停一个线程在指定的时间. NtGetContextThread 检索硬件方面的线程. NtSetContextThread 集硬件方面的线程. NtOpenProcess 打开的句柄指定的进程.NtOpenThread 打开的句柄指定的线程. NtQueryInformationProcess 获取一个线程的属性. NtQueueApcThread 程序呼叫到一个线程. NtResumeThread 唤醒暂停线程. NtSetInformationProcess 设置一个进程的属性. NtSetInformationThread 设置一个线程的属性. NtSuspendThread 暂停一个线程的执行. NtTerminateProcess 删除进程.NtTerminateThread 删除线程.NtYieldExecution 原因线程放弃CPU. NtCreateProcessEx 创建一个新的进程. NtResumeProcess 恢复被暂停的进程. NtSuspendProcess 暂停一个进程.NtCancelTimer 取消计时器.NtCreateTimer 创建一个计时器.NtOpenTimer 打开一个计时器对象.NtQueryTimer 查询计时器的属性. NtQueryTimerResolution 查询系统的计时器决议. NtSetTimer 设置一个定时器到期活动. NtSetTimerResolution 设定系统计时器决议. NtQueryPerformanceCounter 查询系统的性能计数器. NtQuerySystemTime 取得当前时间.NtSetSystemTime 设置系统时间.NtGetTickCount 获取系统开机以来时间.NtCreateEvent 创建一个事件对象.NtOpenEvent 打开事件对象.NtClearEvent 清除标志着国家的事件.NtPulseEvent 信号的事件,然后重置它.NtQueryEvent 查询状况的一个事件.NtResetEvent 重置事件向非标志着国家.NtSetEvent 树立了一个活动,标志着国家.NtCreateEventPair 创建一个事件一双.NtOpenEventPair 打开一个事件对.NtSetHighEventPair 集高一半的活动,以表明对国家.NtSetHighWaitLowEventPair 集高一半的活动,以表明对国家和等待低一半,成为示意. NtSetLowEventPair 集低一半的事件对.NtSetLowWaitHighEventPair 集低一半的事件,并等待对高一半将成为标志. NtWaitHighEventPair 等待高一半事件对成为暗示.NtWaitLowEventPair 等待低一半事件对成为暗示.NtCreateMutant 创建一个突变的对象,称为互斥在用户模式.NtOpenMutant 打开一个突变对象,称为互斥用户模式.NtCreateSemaphore 创建一个信号灯对象.NtOpenSemaphore 打开一个信号灯对象.NtQuerySemaphore 查询状态的信号.NtReleaseSemaphore 标志着信号灯.NtSignalAndWaitForSingleObject 等待它标志着一次.NtWaitForMultipleObjects 等待多个对象,成为暗示.NtWaitForSingleObject 等待一个单一的对象,成为暗示.NtCreateKeyedEvent 创建一个输入事件对象.NtOpenKeyedEvent 打开一个名为键控事件对象.NtReleaseKeyedEvent 标志着键控事件对象.NtWaitForKeyedEvent 等待事件成为键控信号.NtAllocateVirtualMemory 分配虚拟内存.NtFreeVirtualMemory 释放虚拟内存.NtQueryVirtualMemory 查询范围的虚拟内存的属性.NtProtectV irtualMemory 集保护的一系列虚拟内存.NtLockVirtualMemory 锁一系列的虚拟内存.NtUnlockV irtualMemory 解锁一系列的虚拟内存.NtReadVirtualMemory 读取范围内的虚拟内存从进程.NtWriteVirtualMemory 写了一系列的虚拟内存从进程.NtFlushVirtualMemory 刷新记忆体映射的记忆体范围的文件在磁盘上.NtCreateSection 创建了一系列的内存支持文件.NtOpenSection 打开一个名为内存映射节对象.NtExtendSection 延长现有的各种虚拟内存支持文件.NtMapViewOfSection 地图一个文件中的虚拟内存.NtUnmapViewOfSection 一部分虚拟内存的支持文件.NtAreMappedFilesTheSame 装载机使用这一有效看看是否一个给定的文件已经被映射到内存中.NtCancelIoFile 取消I/O请求.NtCreateFile 创建或打开一个文件,目录或设备对象.NtCreateIoCompletion 告诉I/O管理器,一个线程希望时得到通知的I/O完成. NtOpenIoCompletion 打开一个名为I/O完成对象.NtSetIoCompletion 树立了一个I/O完成对象的属性.NtQueryIoCompletion 具体信息检索的I/O完成对象.NtRemoveIoCompletion 消除了一个I/O完成回调.NtDeleteFile 删除一个文件对象.NtDeviceIoControlFile 发送IOCTL装置的设备驱动,这是一个打开的文件对象.NtFlushBuffersFile 清除内存中的文件数据到磁盘.NtFsControlFile 发送一个I/O控制IOCTL为代表的公开设备对象.通常用于文件系统有关的特别命令. NtLockFile 锁了一系列文件的同步访问.NtUnlockFile 解锁了一系列文件的同步访问.NtNotifyChangeDirectoryFile 寄存器一个线程希望得到通知时,一个目录的内容发生变化. NtOpenFile 打开一个现有的文件.NtQueryAttributesFile 取得一个文件的属性.NtQueryDirectoryFile 检索目录的内容.NtQueryEaFile 检索文件的扩展属性.NtSetEaFile 集的扩展属性文件.NtQueryFullAttributesFile 获得文件的全部属性.NtQueryInformationFile 检索方面的具体资料的档案.NtSetInformationFile 确定具体的资料档案.NtQueryV olumeInformationFile 检索有关特定磁盘卷.NtSetV olumeInformationFile 集资讯量.NtReadFile 读取数据文件.NtWriteFile 写入数据文件.NtQueryQuotaInformationFile 查询NTFS磁盘配额信息.NtSetQuotaInformationFile 设置NTFS磁盘配额信息.NtQuerySystemInformation 性能计数器注册表中的出口的大量信息可通过这一呼吁. NtSetSystemInformation 各种行政程序使用此功能.NtShutdownSystem 关闭与选择重新启动.NtCreateJobObject 创建一个作业对象.NtOpenJobObject 打开一个作业对象.NtQueryInformationJobObject 撷取资讯作业对象.NtAssignProcessToJobObject 指定一个进程作业对象.NtSetInformationJobObject 树立了一个作业对象的属性.NtTerminateJobObject 终止作业对象,终止其所有相关的进程.NtCreateJobSet 创建了一个集多种就业工作的对象.NTSYSAPINTSTA TUSNTAPINtAcceptConnectPort(OUT PHANDLE PortHandle,IN PVOID PortIdentifier,IN PPORT_MESSAGE Message,IN BOOLEAN Accept,IN OUT PPORT_VIEW ServerView OPTIONAL,OUT PREMOTE_PORT_VIEW ClientView OPTIONAL);NTSYSAPINTSTA TUSNTAPINtAccessCheck(IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN HANDLE TokenHandle,IN ACCESS_MASK DesiredAccess,IN PGENERIC_MAPPING GenericMapping,OUT PPRIVILEGE_SET PrivilegeSet,IN PULONG PrivilegeSetLength,OUT PACCESS_MASK GrantedAccess,OUT PBOOLEAN AccessStatus);NTSYSAPINTSTA TUSNTAPINtAccessCheckAndAuditAlarm(IN PUNICODE_STRING SubsystemName,IN PVOID HandleId,IN PUNICODE_STRING ObjectTypeName,IN PUNICODE_STRING ObjectName,IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN ACCESS_MASK DesiredAccess,IN PGENERIC_MAPPING GenericMapping,IN BOOLEAN ObjectCreation,OUT PACCESS_MASK GrantedAccess,OUT PBOOLEAN AccessStatus,OUT PBOOLEAN GenerateOnClose);NTSYSAPINTSTA TUSNTAPINtAccessCheckByType(IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN PSID PrincipalSelfSid,IN HANDLE TokenHandle,IN ULONG DesiredAccess,IN POBJECT_TYPE_LIST ObjectTypeList,IN ULONG ObjectTypeListLength,IN PGENERIC_MAPPING GenericMapping,IN PPRIVILEGE_SET PrivilegeSet,IN PULONG PrivilegeSetLength,OUT PACCESS_MASK GrantedAccess,OUT PULONG AccessStatus);NTSYSAPINTSTA TUSNTAPI NtAccessCheckByTypeAndAuditAlarm(IN PUNICODE_STRING SubsystemName,IN PVOID HandleId,IN PUNICODE_STRING ObjectTypeName,IN PUNICODE_STRING ObjectName,IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN PSID PrincipalSelfSid,IN ACCESS_MASK DesiredAccess,IN AUDIT_EVENT_TYPE AuditType,IN ULONG Flags,IN POBJECT_TYPE_LIST ObjectTypeList,IN ULONG ObjectTypeListLength,IN PGENERIC_MAPPING GenericMapping,IN BOOLEAN ObjectCreation,OUT PACCESS_MASK GrantedAccess,OUT PULONG AccessStatus,OUT PBOOLEAN GenerateOnClose);NTSYSAPINTSTA TUSNTAPINtAccessCheckByTypeResultList(IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN PSID PrincipalSelfSid,IN HANDLE TokenHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_TYPE_LIST ObjectTypeList,IN ULONG ObjectTypeListLength,IN PGENERIC_MAPPING GenericMapping,IN PPRIVILEGE_SET PrivilegeSet,IN PULONG PrivilegeSetLength,OUT PACCESS_MASK GrantedAccessList,OUT PULONG AccessStatusList);NTSYSAPINTSTA TUSNTAPI NtAccessCheckByTypeResultListAndAuditAlarm(IN PUNICODE_STRING SubsystemName,IN PVOID HandleId,IN PUNICODE_STRING ObjectTypeName,IN PUNICODE_STRING ObjectName,IN PSECURITY_DESCRIPTOR SecurityDescriptor,IN PSID PrincipalSelfSid,IN ACCESS_MASK DesiredAccess,IN AUDIT_EVENT_TYPE AuditType,IN ULONG Flags,IN POBJECT_TYPE_LIST ObjectTypeList,IN ULONG ObjectTypeListLength,IN PGENERIC_MAPPING GenericMapping,IN BOOLEAN ObjectCreation,OUT PACCESS_MASK GrantedAccessList,OUT PULONG AccessStatusList,OUT PULONG GenerateOnClose);NTSYSAPINTSTA TUSNTAPI NtAccessCheckByTypeResultListAndAuditAlarmByHandle( IN PUNICODE_STRING SubsystemName,IN PVOID HandleId,IN HANDLE TokenHandle,IN PUNICODE_STRING ObjectTypeName,IN PUNICODE_STRING ObjectName,IN PSECURITY_DESCRIPTOR SecurityDescriptor,IN PSID PrincipalSelfSid,IN ACCESS_MASK DesiredAccess,IN AUDIT_EVENT_TYPE AuditType,IN ULONG Flags,IN POBJECT_TYPE_LIST ObjectTypeList,IN ULONG ObjectTypeListLength,IN PGENERIC_MAPPING GenericMapping,IN BOOLEAN ObjectCreation,OUT PACCESS_MASK GrantedAccessList,OUT PULONG AccessStatusList,OUT PULONG GenerateOnClose);NTSYSAPINTSTA TUSNTAPINtAddAtom(IN PWSTR String,IN ULONG StringLength,OUT PUSHORT Atom);NTSYSAPINTSTA TUSNTAPINtAddBootEntry(IN PUNICODE_STRING EntryName,IN PUNICODE_STRING EntryV alue);NTSYSAPINTSTA TUSNTAPINtAddDriverEntry(IN PUNICODE_STRING DriverName,IN PUNICODE_STRING DriverPath);NTSYSAPINTSTA TUSNTAPINtAdjustGroupsToken(IN HANDLE TokenHandle,IN BOOLEAN ResetToDefault,IN PTOKEN_GROUPS NewState,IN ULONG BufferLength,OUT PTOKEN_GROUPS PreviousState OPTIONAL,OUT PULONG ReturnLength);NTSYSAPINTSTA TUSNTAPINtAdjustPrivilegesToken(IN HANDLE TokenHandle,IN BOOLEAN DisableAllPrivileges,IN PTOKEN_PRIVILEGES NewState,IN ULONG BufferLength,OUT PTOKEN_PRIVILEGES PreviousState OPTIONAL, OUT PULONG ReturnLength OPTIONAL);NTSYSAPINTSTA TUSNTAPINtAlertResumeThread(IN HANDLE ThreadHandle,OUT PULONG PreviousSuspendCount OPTIONAL);NTSYSAPINTSTA TUSNTAPINtAllocateLocallyUniqueId(OUT PLUID Luid);NTSYSAPINTSTA TUSNTAPINtAllocateUserPhysicalPages(IN HANDLE ProcessHandle,IN PULONG NumberOfPages,OUT PULONG PageFrameNumbers);NTSYSAPINTSTA TUSNTAPINtAllocateUuids(OUT PLARGE_INTEGER UuidLastTimeAllocated,OUT PULONG UuidDeltaTime,OUT PULONG UuidSequenceNumber,OUT PUCHAR UuidSeed);NTSYSAPINTSTA TUSNTAPINtAllocateVirtualMemory(IN HANDLE ProcessHandle,IN OUT PVOID *BaseAddress,IN ULONG ZeroBits,IN OUT PULONG AllocationSize,IN ULONG AllocationType,IN ULONG Protect);NTSYSAPINTSTA TUSNTAPINtApphelpCacheControl(IN APPHELPCACHECONTROL ApphelpCacheControl, IN PUNICODE_STRING ApphelpCacheObject);NTSYSAPINTSTA TUSNTAPINtAreMappedFilesTheSame(IN PVOID Address1,IN PVOID Address2);NTSYSAPINTSTA TUSNTAPI NtAssignProcessToJobObject(IN HANDLE JobHandle,IN HANDLE ProcessHandle);NTSYSAPINTSTA TUSNTAPINtCallbackReturn(IN PVOID Result OPTIONAL,IN ULONG ResultLength,IN NTSTA TUS Status);NTSYSAPINTSTA TUSNTAPI NtCancelDeviceWakeupRequest(IN HANDLE DeviceHandle);NTSYSAPINTSTA TUSNTAPINtCancelIoFile(IN HANDLE FileHandle,OUT PIO_STA TUS_BLOCK IoStatusBlock );NTSYSAPINTSTA TUSNTAPINtCancelTimer(IN HANDLE TimerHandle,OUT PBOOLEAN PreviousState OPTIONAL );NTSYSAPINTSTA TUSNTAPINtClearEvent(IN HANDLE EventHandle);NTSYSAPINTSTA TUSNTAPINtClose(IN HANDLE Handle);NTSYSAPINTSTA TUSNTAPINtCloseObjectAuditAlarm(IN PUNICODE_STRING SubsystemName, IN PVOID HandleId,IN BOOLEAN GenerateOnClose);NTSYSAPINTSTA TUSNTAPINtCompactKeys(IN ULONG Length,IN HANDLE Key);NTSYSAPINTSTA TUSNTAPINtCompareTokens(IN HANDLE FirstTokenHandle,IN HANDLE SecondTokenHandle,OUT PBOOLEAN IdenticalTokens );NTSYSAPINTSTA TUSNTAPINtCompleteConnectPort(IN HANDLE PortHandle);NTSYSAPINTSTA TUSNTAPINtCompressKey(IN HANDLE Key);NTSYSAPINTSTA TUSNTAPINtConnectPort(OUT PHANDLE PortHandle,IN PUNICODE_STRING PortName,IN PSECURITY_QUALITY_OF_SERVICE SecurityQos, IN OUT PPORT_VIEW ClientView OPTIONAL,OUT PREMOTE_PORT_VIEW ServerV iew OPTIONAL, OUT PULONG MaxMessageLength OPTIONAL,IN OUT PVOID ConnectInformation OPTIONAL,IN OUT PULONG ConnectInformationLength OPTIONAL );NTSYSAPINTSTA TUSNTAPINtContinue(IN PCONTEXT Context,IN BOOLEAN TestAlert);NTSYSAPINTSTA TUSNTAPINtCreateDebugObject(OUT PHANDLE DebugObject,IN ULONG AccessRequired,IN POBJECT_A TTRIBUTES ObjectAttributes,IN BOOLEAN KillProcessOnExit);NTSYSAPINTSTA TUSNTAPINtCreateDirectoryObject(OUT PHANDLE DirectoryHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes);NTSYSAPINTSTA TUSNTAPINtCreateEvent(OUT PHANDLE EventHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN EVENT_TYPE EventType,IN BOOLEAN InitialState);NTSYSAPINTSTA TUSNTAPINtCreateEventPair(OUT PHANDLE EventPairHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes );NTSYSAPINTSTA TUSNTAPINtCreateFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes,IN ULONG ShareAccess,IN ULONG CreateDisposition,IN ULONG CreateOptions,IN PVOID EaBuffer OPTIONAL,IN ULONG EaLength);NTSYSAPINTSTA TUSNTAPINtCreateIoCompletion(OUT PHANDLE IoCompletionHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN ULONG NumberOfConcurrentThreads);NTSYSAPINTSTA TUSNTAPINtCreateJobObject(OUT PHANDLE JobHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes );NTSYSAPINTSTA TUSNTAPINtCreateJobSet(IN ULONG Jobs,IN PJOB_SET_ARRAY JobSet,IN ULONG Reserved);NTSYSAPINTSTA TUSNTAPINtCreateKey(OUT PHANDLE KeyHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN ULONG TitleIndex,IN PUNICODE_STRING Class OPTIONAL,IN ULONG CreateOptions,OUT PULONG Disposition OPTIONAL);NTSYSAPINTSTA TUSNTAPINtCreateKeyedEvent(OUT PHANDLE KeyedEventHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN ULONG Reserved);NTSYSAPINTSTA TUSNTAPINtCreateMailslotFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN ULONG CreateOptions,IN ULONG InBufferSize,IN ULONG MaxMessageSize,IN PLARGE_INTEGER ReadTimeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtCreateMutant(OUT PHANDLE MutantHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN BOOLEAN InitialOwner);NTSYSAPINTSTA TUSNTAPINtCreateNamedPipeFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN ULONG ShareAccess,IN ULONG CreateDisposition,IN ULONG CreateOptions,IN BOOLEAN TypeMessage,IN BOOLEAN ReadmodeMessage,IN BOOLEAN Nonblocking,IN ULONG MaxInstances,IN ULONG InBufferSize,IN ULONG OutBufferSize,IN PLARGE_INTEGER DefaultTimeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtCreatePagingFile(IN PUNICODE_STRING FileName,IN PULARGE_INTEGER InitialSize,IN PULARGE_INTEGER MaximumSize,IN ULONG Priority OPTIONAL);NTSYSAPINTSTA TUSNTAPINtCreatePort(OUT PHANDLE PortHandle,IN POBJECT_A TTRIBUTES ObjectAttributes,IN ULONG MaxConnectionInfoLength,IN ULONG MaxMessageLength,IN ULONG MaxPoolUsage);NTSYSAPINTSTA TUSNTAPINtCreateProcess(OUT PHANDLE ProcessHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN HANDLE InheritFromProcessHandle,IN BOOLEAN InheritHandles,IN HANDLE SectionHandle OPTIONAL,IN HANDLE DebugPort OPTIONAL,IN HANDLE ExceptionPort OPTIONAL );NTSYSAPINTSTA TUSNTAPINtCreateProcessEx(OUT PHANDLE ProcessHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN HANDLE InheritFromProcessHandle,IN ULONG CreateFlags,IN HANDLE SectionHandle OPTIONAL,IN HANDLE DebugObject OPTIONAL,IN HANDLE ExceptionPort OPTIONAL,IN ULONG JobMemberLevel);NTSYSAPINTSTA TUSNTAPINtCreateProfile(OUT PHANDLE ProfileHandle,IN HANDLE ProcessHandle,IN PVOID Base,IN ULONG Size,IN ULONG BucketShift,IN PULONG Buffer,IN ULONG BufferLength,IN KPROFILE_SOURCE Source,IN ULONG ProcessorMask);NTSYSAPINTSTA TUSNTAPIOUT PHANDLE SectionHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN PLARGE_INTEGER SectionSize OPTIONAL, IN ULONG Protect,IN ULONG Attributes,IN HANDLE FileHandle);NTSYSAPINTSTA TUSNTAPINtCreateSemaphore(OUT PHANDLE SemaphoreHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN LONG InitialCount,IN LONG MaximumCount);NTSYSAPINTSTA TUSNTAPINtCreateSymbolicLinkObject(OUT PHANDLE SymbolicLinkHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN PUNICODE_STRING TargetName);NTSYSAPINTSTA TUSNTAPINtCreateThread(OUT PHANDLE ThreadHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle,OUT PCLIENT_ID ClientId,IN PCONTEXT ThreadContext,IN PUSER_STACK UserStack,IN BOOLEAN CreateSuspended);NTSYSAPINTSTA TUSNTAPIOUT PHANDLE TimerHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN TIMER_TYPE TimerType);NTSYSAPINTSTA TUSNTAPINtCreateToken(OUT PHANDLE TokenHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes, IN TOKEN_TYPE Type,IN PLUID AuthenticationId,IN PLARGE_INTEGER ExpirationTime,IN PTOKEN_USER User,IN PTOKEN_GROUPS Groups,IN PTOKEN_PRIVILEGES Privileges,IN PTOKEN_OWNER Owner,IN PTOKEN_PRIMARY_GROUP PrimaryGroup, IN PTOKEN_DEFAULT_DACL DefaultDacl,IN PTOKEN_SOURCE Source);NTSYSAPINTSTA TUSNTAPINtCreateWaitablePort(OUT PHANDLE PortHandle,IN POBJECT_A TTRIBUTES ObjectAttributes, IN ULONG MaxConnectionInfoLength,IN ULONG MaxMessageLength,IN ULONG MaxPoolUsage);NTSYSAPINTSTA TUSNTAPINtDebugActiveProcess(IN HANDLE Process,IN HANDLE DebugObject);NTSYSAPINTSTA TUSNTAPINtDebugContinue(IN HANDLE DebugObject,IN PCLIENT_ID AppClientId,IN NTSTA TUS ContinueStatus);NTSYSAPINTSTA TUSNTAPINtDelayExecution(IN BOOLEAN Alertable,IN PLARGE_INTEGER Interval);NTSYSAPINTSTA TUSNTAPINtDeleteAtom(IN USHORT Atom);NTSYSAPINTSTA TUSNTAPINtDeleteBootEntry(IN PUNICODE_STRING EntryName,IN PUNICODE_STRING EntryV alue );NTSYSAPINTSTA TUSNTAPINtDeleteDriverEntry(IN PUNICODE_STRING DriverName,IN PUNICODE_STRING DriverPath);NTSYSAPINTSTA TUSNTAPINtDeleteFile(IN POBJECT_A TTRIBUTES ObjectAttributes );NTSYSAPINTSTA TUSNTAPINtDeleteKey(IN HANDLE KeyHandle);NTSYSAPINTSTA TUSNTAPINtDeleteObjectAuditAlarm(IN PUNICODE_STRING SubsystemName,IN PVOID HandleId,IN BOOLEAN GenerateOnClose);NTSYSAPINTSTA TUSNTAPINtDeleteV alueKey(IN HANDLE KeyHandle,IN PUNICODE_STRING V alueName);NTSYSAPINTSTA TUSNTAPINtDeviceIoControlFile(IN HANDLE FileHandle,IN HANDLE Event OPTIONAL,IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN ULONG IoControlCode,IN PVOID InputBuffer OPTIONAL,IN ULONG InputBufferLength,OUT PVOID OutputBuffer OPTIONAL,IN ULONG OutputBufferLength);NTSYSAPINTSTA TUSNTAPINtDisplayString(IN PUNICODE_STRING String);NTSYSAPINTSTA TUSNTAPINtDuplicateObject(IN HANDLE SourceProcessHandle,IN HANDLE SourceHandle,IN HANDLE TargetProcessHandle,OUT PHANDLE TargetHandle OPTIONAL,IN ACCESS_MASK DesiredAccess,IN ULONG Attributes,IN ULONG Options);NTSYSAPINTSTA TUSNTAPINtDuplicateToken(IN HANDLE ExistingTokenHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_A TTRIBUTES ObjectAttributes,IN BOOLEAN EffectiveOnly,IN TOKEN_TYPE TokenType,OUT PHANDLE NewTokenHandle);NTSYSAPINTSTA TUSNTAPINtEnumerateBootEntries(IN ULONG Unknown1,IN ULONG Unknown2);NTSYSAPINTSTA TUSNTAPINtEnumerateKey(IN HANDLE KeyHandle,IN ULONG Index,IN KEY_INFORMA TION_CLASS KeyInformationClass, OUT PVOID KeyInformation,IN ULONG KeyInformationLength,OUT PULONG ResultLength);NTSYSAPINTSTA TUSNTAPINtEnumerateSystemEnvironmentV aluesEx(IN ULONG Unknown1,IN ULONG Unknown2,IN ULONG Unknown3);NTSYSAPINTSTA TUSNTAPINtEnumerateV alueKey(IN HANDLE KeyHandle,IN ULONG Index,IN KEY_V ALUE_INFORMA TION_CLASS KeyV alueInformationClass, OUT PVOID KeyV alueInformation,IN ULONG KeyV alueInformationLength,OUT PULONG ResultLength);NTSYSAPINTSTA TUSNTAPINtExtendSection(IN HANDLE SectionHandle,IN PLARGE_INTEGER SectionSize);NTSYSAPINTSTA TUSNTAPINtFilterToken(IN HANDLE ExistingTokenHandle,IN ULONG Flags,IN PTOKEN_GROUPS SidsToDisable,IN PTOKEN_PRIVILEGES PrivilegesToDelete,IN PTOKEN_GROUPS SidsToRestricted,OUT PHANDLE NewTokenHandle);NTSYSAPINTSTA TUSNTAPINtFindAtom(IN PWSTR String,IN ULONG StringLength,OUT PUSHORT Atom);NTSYSAPINTSTA TUSNTAPINtFlushBuffersFile(IN HANDLE FileHandle,OUT PIO_STA TUS_BLOCK IoStatusBlock);NTSYSAPINTSTA TUSNTAPINtFlushInstructionCache(IN HANDLE ProcessHandle,IN PVOID BaseAddress OPTIONAL,IN ULONG FlushSize);NTSYSAPINTSTA TUSNTAPINtFlushKey(IN HANDLE KeyHandle);NTSYSAPINTSTA TUSNTAPINtFlushVirtualMemory(IN HANDLE ProcessHandle,IN OUT PVOID *BaseAddress,IN OUT PULONG FlushSize,OUT PIO_STA TUS_BLOCK IoStatusBlock );NTSYSAPINTSTA TUSNTAPINtFlushWriteBuffer(VOID);NTSYSAPINTSTA TUSNTAPINtYieldExecution(VOID);NTSYSAPINTSTA TUSNTAPINtWriteVirtualMemory(IN HANDLE ProcessHandle,IN PVOID BaseAddress,IN PVOID Buffer,IN ULONG BufferLength,OUT PULONG ReturnLength OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWriteRequestData(IN HANDLE PortHandle,IN PPORT_MESSAGE Message,IN ULONG Index,IN PVOID Buffer,IN ULONG BufferLength,OUT PULONG ReturnLength OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWriteFileGather(IN HANDLE FileHandle,IN HANDLE Event OPTIONAL,IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN PFILE_SEGMENT_ELEMENT Buffer,IN ULONG Length,IN PLARGE_INTEGER ByteOffset OPTIONAL, IN PULONG Key OPTIONAL);NTSYSAPINTSTA TUSNTAPINtWriteFile(IN HANDLE FileHandle,IN HANDLE Event OPTIONAL,IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN PVOID Buffer,IN ULONG Length,IN PLARGE_INTEGER ByteOffset OPTIONAL, IN PULONG Key OPTIONAL);NTSYSAPINTSTA TUSNTAPINtWaitLowEventPair(IN HANDLE EventPairHandle);NTSYSAPINTSTA TUSNTAPINtWaitHighEventPair(IN HANDLE EventPairHandle);NTSYSAPINTSTA TUSNTAPINtWaitForSingleObject(IN HANDLE Handle,IN BOOLEAN Alertable,IN PLARGE_INTEGER Timeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWaitForMultipleObjects32(IN ULONG HandleCount,IN PHANDLE Handles,IN W AIT_TYPE WaitType,IN BOOLEAN Alertable,IN PLARGE_INTEGER Timeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWaitForMultipleObjects(IN ULONG HandleCount,IN PHANDLE Handles,IN W AIT_TYPE WaitType,IN BOOLEAN Alertable,IN PLARGE_INTEGER Timeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWaitForKeyedEvent(IN HANDLE KeyedEventHandle,IN PVOID Key,IN BOOLEAN Alertable,IN PLARGE_INTEGER Timeout OPTIONAL );NTSYSAPINTSTA TUSNTAPINtWaitForDebugEvent(IN HANDLE DebugObject,IN BOOLEAN Alertable,IN PLARGE_INTEGER Timeout OPTIONAL,OUT PDBGUI_WAIT_STA TE_CHANGE StateChange );NTSYSAPINTSTA TUSNTAPINtVdmControl(IN VDMSERVICECLASS Service,IN OUT PVOID ServiceData);NTSYSAPINTSTA TUSNTAPINtUnmapViewOfSection(IN HANDLE ProcessHandle,IN PVOID BaseAddress);NTSYSAPINTSTA TUSNTAPINtUnlockV irtualMemory(IN HANDLE ProcessHandle,IN OUT PVOID *BaseAddress,IN OUT PULONG LockSize,IN ULONG LockType);NTSYSAPINTSTA TUSNTAPINtUnlockFile(IN HANDLE FileHandle,OUT PIO_STA TUS_BLOCK IoStatusBlock,IN PULARGE_INTEGER LockOffset,IN PULARGE_INTEGER LockLength,IN ULONG Key);NTSYSAPINTSTA TUSNTAPINtUnloadKeyEx(。

Hook原理

Hook原理Hook原理对于会Hook的⼈来说，Hook其实也就那么回事。

对于没有Hook过的⼈来说，会感觉Hook很⾼⼤上(其实也没⽑病)。

那么今天我们就来探讨⼀些Hook的原理是什么。

我认为任何Hook都可以分为以下三步(简称WFH)：1. 需要Hook的是什么,在哪⾥(后⾯简称Where)2. 寻找到Hook的地⽅.(后⾯简称Find)3. 进⾏Hook.(后⾯简称Hook)当然了同⼀个类型的Hook所在的地⽅⼀般是⼀样的。

但寻找到Hook的地⽅，和进⾏Hook却会有许多不同的⽅法。

我们要抓住的是不变的地⽅。

根据这3点我们举例来验证⼀下：Hook API第⼀个我尽量说得详细⼀些。

举例⼦：Hook API:OpenProcess 让win10 64位的任务管理器关闭不了任何程序。

1、WhereHook API：OpenProcess. 在kernelbase.dll⾥⾯。

2、Find⽅式1：1. 通过LoadLibrary加载kernelbase.dll模块基地址；2. 通过 GetProcAddress 获取 OpenProcess 的地址。

⽅式2：编程直接引⽤OpenProcess的地址，因为在Windows下3⼤模块user32.dll,kernelbase.dll,ntdll.dll 的加载基地址在每个应⽤程序中都是⼀样的.⽅式3：通过寻找⽬标的IAT找到OpenProcess。

3、Hook⽅式1：通过注⼊dll到⽬标进程进⾏，可以替换 kernelbase.dll ⾥⾯的OpenProcess 的前⾯5个字节为jmp跳转到我们⾃⼰的地址，也可以修改⽬标进程的IAT。

⽅式2：通过WriteProcessMemory写⼊代码，修改⽬标进程的 OpenProcess 跳转到我们的代码。

代码实例：F1+H1(Find的第⼆种⽅式,Hook的第⼀种⽅式,后⾯不再说明)：（1）新建⼀个dll⽂件：（2）在dll⽂件⾥⾯写如下代码：如果你的win10是64位的就编译64位的，32位就编译32位的// dllmain.cpp : 定义 DLL 应⽤程序的⼊⼝点。

NT内核级进程隐藏2-Hook SSDT及EPROCESS(1)

NT内核级进程隐藏2-Hook SSDT及EPROCESS(1)学习各种外挂制作技术，马上去百度搜索"魔鬼作坊"点击第一个站进入、快速成为做挂达人。

通过Hook SSDT(System Service Dispath Table)隐藏进程1.原理介绍:Windows操作系统是一种分层的架构体系。

应用层的程序是通过API来访问操作系统。

而API又是通过ntdll里面的核心API来进行系统服务的查询。

核心API通过对int2e的切换，从用户模式转换到内核模式。

2Eh中断的功能是通过NTOSKRNL.EXE的一个函数KiSystemService()来实现的。

在你使用了一个系统调用时，必须首先装载要调用的函数索引号到EAX寄存器中。

把指向参数区的指针被保存在EDX寄存器中。

中断调用后，EAX寄存器保存了返回的结果。

KiSystemService()是根据EAX的值来决定哪个函数将被调用。

而系统在SSDT中维持了一个数组，专门用来索引特定的函数服务地址。

在Windows2000中有一个未公开的由ntoskrnl.exe导出的KeServiceDescriptorTable变量，我们可以通过它来完成对SSDT的访问与修改。

KeServiceDescriptorTable对应于一个数据结构，定义如下：typedef struct SystemServiceDescriptorTable{UINT*ServiceTableBase;UINT*ServiceCounterTableBase;UINT NumberOfService;UCHAR*ParameterTableBase;}SystemServiceDescriptorTable,*PSystemServiceDescriptorTable;其中ServiceTableBase指向系统服务程序的地址(SSDT)，ParameterTableBase则指向SSPT 中的参数地址，它们都包含了NumberOfService这么多个数组单元。

内核编程之SSDTHook（1）原理

内核编程之SSDTHook（1）原理转载：/zuishikonghuan/article/details/50717936 说驱动开发这么长时间了，也玩玩内核钩子，钩子（Hook）技术是一种截获对某一对象访问的技术，不仅在Windows平台，Linux平台上也有Hook技术。

Hook技术种类繁多，实现细节也不同，还可以灵活使用。

我之前写过两篇Ring3下的API Inline Hook的博文，这两篇博文通过Inline Hook OpenProcess 实现对指定进程的保护，从而保护进程不能被其他进程打开、结束、写内存等等。

我们先来看看都有那些常见的Hook技术：首先是Ring3层下的Hook技术，Ring3层下的Hook包括消息钩子和API Hook，消息钩子又分为全局消息钩子和进程内消息钩子，API Hook又分为IAT Hook和API Inline Hook，这两种钩子的区别和原理，看我上面的那两篇博文。

内核下Hook就比较多了，比如Object Hook，SSDT Hook，SSDT Shadow Hook，Inline Hook，IDT Hook，SysEnter Hook等等。

我就来说说SSDT Hook，当年SSDT Hook火的时候，我可能当时连编程都不知道，这是一种非常古老的技术，据说这是RootKit病毒第一次采用的技术，当然也是杀软和各种防护软件青睐的技术。

首先大家要知道Windows系统的内核和执行体层是ntoskrnl.exe，这是整个系统的内核，而ntdll.dll是用户模式到内核模式的接口，ntoskrnl中有两张表，分别是：KeServiceDescriptorTable 和KeServiceDescriptorTableShadowRing3层Kernel32.dll 中的API经过ntdll.dll后一般由KeServiceDescriptorTable中的函数处理。