SSDT表函数Hook原理
其实 SSDT Hook 的原理是很简单的，我们可以知道在 SSDT 这个数组中呢，保存了系统服务的地址，比如对于 Ring0 下的 NtQuerySystemInformation 这个系统服务的地址，就保存在 KeServiceDescriptorTable[105h] 中（计算公式 address = SSDT首地址+服务号*4）
lkd> u 84647e3e
nt!NtQuerySystemInformation:
84647e3e 8bff mov edi,edi
84647e40 55 push ebp
84647e41 8bec mov ebp,esp
84647e43 8b5508 mov edx,dword ptr [ebp+8]
既然是 Hook 的话，我们就可以将这个 KeServiceDescriptorTable[105h] 下保存的服务地址替换掉，将我们自己的 Hook 处理函数的地址来替换掉原来的地址，
Mov eax,84496170h
Mov [eax],MyHookFunction
这样当每次调用 KeServiceDescriptorTable[105h]时就会调用我们自己的这个 Hook 处理函数了,就执行了我们的代码，达到hook原理。
我给大家画个图便以理解:
所有我们只要修改 KeServiceDescriptorTable[105h] 即可达到目的。
所以这就是我们在平时所讲的SSDT Hook原理。
大家都知道在SSDT Hook都时候都看到如下代码：
修改内存属性
__asm
{
cli
mov eax, cr0
and eax, not 10000h
mov cr0, eax
}
恢复内存属性
__asm
{
mov eax, cr0
or eax, 10000h
mov cr0, eax
sti
}
这是为什么呢？原因在于Windows系统对部分内存起用了写保护，IAT 内存属性，来防止内存页被修改，SSDT表的内存属性只是只读。如果你试图对一个只读属性的表进行写入操作，那么等待你的就是无情的蓝屏。因此，要修改ssdt表的话，首先要让表变为可写属性。
注：
修改系统分页内存属性的方法也可以参考：
http://blog.csdn.net/qq1084283172/article/details/40987347这里提供三种修改分页内存的方法。
有两种方法可以绕过写保护，一种是修改控制寄存器的CR0中的写保护位(WP)来绕过，另一种是利用MDL(Memory Descriptor List)来绕过写保护.
第一种方法比较简单，也就是把CR0重的WP(写保护)位设置为0，就可以禁止内存保护了。
比如大家看到看雪上的大部分代码，都是通过修改cr0的wp来禁止内存保护：
http://bbs.pediy.com/showthread.php?t=168061
http://bbs.pediy.com/showthread.php?t=148831
第二种是根据MDL。我们可以根据Mdl分配一段虚拟地址映射到SSDT所在的物理地址，同时因为我们映射的MDL内存属性却是可写，所以就可以修改SSDT，这样就替代了cr0方式。
MDL有很多标志：
1 //MDL Flags
2 #define MDL_MAPPED_TO_SYSTEM_VA 0x0001
3 #define MDL_PAGES_LOCKED 0x0002
4 #define MDL_SOURCE_IS_NONPAGED_POOL 0x0004
5 #define MDL_ALLOCATED_FIXED_SIZE 0x0008
6 #define MDL_PARTIAL 0x0010
7 #define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020
8 #define MDL_IO_PAGE_READ 0x0040
9 #define MDL_WRITE_OPERATION 0x0080
10 #define MDL_PARENT_MAPPED_SYSTEM_VA 0x0100
11 #define MDL_LOCK_HELD 0x0200
12 #define MDL_PHYSICAL_VIEW 0x0400
13 #define MDL_IO_SPACE 0x0800
14 #define MDL_NETWORK_HEADER 0x1000
15 #define MDL_MAPPING_CAN_FAIL 0x2000
16 #define MDL_ALLOCATED_MUST_SUCCEED 0x4000
我们在SSDTHook过程中，只关心MDL_MAPPED_TO_SYSTEM_VA这个标志位，因为他表示我们申请的MDL内存页池是可读可写的。
下面是采用Cr0和Mdl的方式进行SSDT表的函数Hook的示例：
SSDT.h头文件
//SSDT.h
#ifndef _SSDT_H_
#define _SSDT_H_
#include <ntifs.h>
//SSDT表的结构体
#pragma pack(1)
typedef struct _SERVICE_DESCRIPTOR_TABLE
{
//System Service Dispatch Table的基地址
PULONG ServiceTable;
//SSDT中每个服务被调用次数的计数器。
PULONG CounterTable;
//由 ServiceTableBase 描述的服务数目。
ULONG TableSize;
//每个系统服务参数字节数表的基地址-系统服务参数表SSPT
PUCHAR ArgumentTable;
} SERVICE_DESCRIPTOR_TABLE, *PSERVICE_DESCRIPTOR_TABLE;
#pragma pack()
//进行ssdt表KeServiceDescriptorTable的导出声明
extern PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable;
/*
_Hook为自定义用于Hook SSDT中函数的函数地址
_Function为SSDT表中被Hook函数原始地址
pdword_mapped_table申请的非分页内存的地址
*/
//内存描述符列表
PMDL pmdl_system_call;
PVOID *pdword_mapped_table;
//获取SSDT表中函数的调用序号Index
#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
//Mdl方式的SSDT表函数Hook
#define HOOK_SYSCALL(_Function, _Hook, _Orig ) \
_Orig = (PVOID) InterlockedExchange( (PLONG) &pdword_mapped_table[SYSCALL_INDEX(_Function)], (LONG) _Hook)
//移除Mdl方式的SSDT表函数Hook
#define UNHOOK_SYSCALL(_Function, _Hook, _Orig ) \
InterlockedExchange( (PLONG) &pdword_mapped_table[SYSCALL_INDEX(_Function)], (LONG) _Hook)
//开启内存写保护
VOID WPON();
//关闭内存写保护
VOID WPOFF();
//采用Cr0方式SSDT表函数Hook
VOID Cr0SSDTHook(int *Index, ULONG_PTR *ul_save_real_addrsss, ULONG_PTR ul_hook_address);
//移除采用Cr0方式SSDT表函数Hook
VOID Cr0RemoveSSDTHook(int *Index, ULONG_PTR ul_save_real_addrsss);
//采用Mdl方式SSDT表函数Hook
NTSTATUS MdlSSDTHook(ULONG_PTR ul_real_function, ULONG_PTR hook_function_addr, ULONG_PTR *ul_save_real_function_addr);
//移除采用Mdl方式SSDT表函数Hook
NTSTATUS MdlRemoveSSDTHook(ULONG_PTR ul_real_function, ULONG_PTR hook_function_addr, ULONG_PTR *ul_save_real_function_addr);
/*
驱动中输出提示信息推荐使用 KdPrint函数 ：
驱动编程学习中，往往需要通过DbgPrint或者KdPrint来输出调试信息，
对于Check版本，KdPrint只是DbgPrint的一个宏定义，而对于Free版本，KdPrint将被优化掉。
*/
/*
LONG InterlockedExchange(
IN OUT PLONG Target,
IN LONG Value);
InterlockedExchange(a,b)能以原子操作的方式交换俩个参数a, b，并返回a以前的值；
因为InterlockedExchange 是原子函数，不会要求中止中断，所以交换指针的方式是安全的。
*/
/*
#define SYSTEMSERVICE(_Function)
KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_Function+1)]
#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
#define HOOK_SYSCALL(_Function, _Hook, _Orig )
_Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable
[SYSCALL_INDEX(_Function)], (LONG) _Hook)
#define UNHOOK_SYSCALL(_Function, _Hook, _Orig) InterlockedExchange((PLONG)
&MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
而SYSTEMSERVICE宏是采用由ntoskrnl.exe导出的Zw*函数地址，并返回对应的Nt*函数在SSDT中的地址，SYSCALL_INDEX采用Zw*函数地址并返回它在SSDT中相应的索引号。
由于ZwCreateThread没有被ntoskrnl.exe导出，所以这时我们就无法直接使用上述的宏.
*/
/*
MDL的全称是Memory Descriptor List，即内存描述符表。我们可以通过MDL描述一块内存区域，
在MDL中包含了该内存区域的起始地址、拥有者进程、字节数量、标记等信息，如下所示：
typedef struct _MDL
{
struct _MDL *Next;
CSHORT Size;
CSHORT MdlFlags;
struct _EPROCESS *Process;
PVOID MappedSystemVa;
PVOID StartVa;
ULONG ByteCount;
ULONG ByteOffset;
} MDL, *PMDL;
*/
/*
#define SYSTEMSERVICE(_function) KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]
*/
#endifSSDTHook.h头文件
//SSDTHook.h
#ifndef _SSDT_HOOK_H_
#define _SSDT_HOOK_H_
#include "SSDT.h"
//自定义的ZwOpenProcess函数
NTSTATUS NewZwOpenProcess(OUT PHANDLE ProcessHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PCLIENT_ID ClientId
);
//声明ZwOpenProcess函数指针类型
typedef NTSTATUS (__stdcall *ZWOPENPROCESS)(OUT PHANDLE ProcessHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PCLIENT_ID ClientId
);
ZWOPENPROCESS RealZwOpenProcess;
//决定我们使用哪种hook
BOOLEAN bool_hook_type = TRUE;
//设置SSDT表Hook函数的Index
int int_hook_index = 190;
//保存ZwOpenProcess函数的真实值
ULONG_PTR ul_ZwOpenProcess;
UNICODE_STRING unicode_string;
#endifSSDT.c文件
//SSDT.c
#include "SSDT.h"
//关闭内存写保护
VOID WPOFF()
{
__asm
{
cli //屏蔽中断
mov eax, cr0
and eax, not 10000h
mov cr0, eax
}
}
//开启内存写保护
VOID WPON()
{
__asm
{
mov eax, cr0
or eax, 10000h
mov cr0, eax
sti //回复中断
}
}
/*
第一个参数Index就是服务号，
第二个参数ul_save_real_addrsss就是保存函数原始地址。因为我们要在过滤函数中调用原始地址
第三个参数ul_hook_address就是我们的hook代码的函数
*/
//Cr0方式SSDT表的函数Hook
VOID Cr0SSDTHook(int *Index, ULONG_PTR *ul_save_real_addrsss, ULONG_PTR ul_hook_address)
{
ULONG_PTR ul_real_service_address;
ULONG_PTR num = *Index;
//设置断点
//__asm int 3
//根据计算公式
//ul_real_service_address = 0x84495d5c + 105*4;
//ul_real_service_address = 0x84496170;
//获取被Hook函数的原始地址
ul_real_service_address = (ULONG)KeServiceDescriptorTable->ServiceTable + num*4;
if (ul_real_service_address)
{
//0x84647e3e
/*
nt!NtQuerySystemInformation:
84647e3e 8bff mov edi,edi
84647e40 55 push ebp
84647e41 8bec mov ebp,esp
84647e43 8b5508 mov edx,dword ptr [ebp+8]
84647e46 83fa53 cmp edx,53h
*/
//保存SSDT表中原始函数地址
*ul_save_real_addrsss = *((ULONG*)ul_real_service_address);
//关闭wp写保护
WPOFF();
//修改SSDT表中的Hook函数的地址为自定函数的地址
*((ULONG*)ul_real_service_address) = ul_hook_address;
//开启wp写保护
WPON();
}
}
//移除Cr0方式SSDT表的函数Hook即恢复SSDT中被Hook的函数
VOID Cr0RemoveSSDTHook(int *Index, ULONG_PTR ul_save_real_addrsss)
{
ULONG_PTR ul_real_service_address;
ULONG_PTR num = *Index;
//关闭wp写保护
WPOFF();
//根据计算公式
ul_real_service_address = (ULONG)KeServiceDescriptorTable->ServiceTable + num*4;
if (ul_real_service_address)
{
//恢复SSDT表中被Hook函数的地址
*((ULONG*)ul_real_service_address) = ul_save_real_addrsss;
}
//开启wp写保护
WPON();
}
//******************************************************************************************
//采用比较安全的方法修改ssdt表
//因为SSDT的虚拟地址分页属性是只读的，我们不能够直接修改它，否则会产生蓝屏
//我们借助Mdl分配一段虚拟地址映射到SSDT所在的物理地址，
//同时因为我们映射的MDL内存属性却可以是可写，所以就可以修改ssdt，这样就替代了cr0方式。
//******************************************************************************************
//采用Mdl方式的SSDT表函数Hook
NTSTATUS MdlSSDTHook(ULONG_PTR ul_real_function, ULONG_PTR hook_function_addr, ULONG_PTR *ul_save_real_function_addr)
{
//设置断点
//__asm int 3
//创建内存描述符列表Mdl，映射到SSDT表所在的内存物理地址
pmdl_system_call = MmCreateMdl(NULL, KeServiceDescriptorTable->ServiceTable, KeServiceDescriptorTable->TableSize*sizeof(ULONG_PTR));
//判断内存描述符列表Mdl
if(!pmdl_system_call)
{
return STATUS_UNSUCCESSFUL;
}
//构建非分页内存，建立虚拟地址与物理地址的映射关系
MmBuildMdlForNonPagedPool(pmdl_system_call);
//改变MDL的标志，设置为MDL_MAPPED_TO_SYSTEM_VA标志，让这块内存变可写
pmdl_system_call->MdlFlags = pmdl_system_call->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;
//锁定非分页内存
pdword_mapped_table = MmMapLockedPages(pmdl_system_call, KernelMode);
if (pdword_mapped_table)
{
//开始Mdl方式的SSDT表函数Hook
HOOK_SYSCALL(ul_real_function, hook_function_addr, *ul_save_real_function_addr);
}
return STATUS_SUCCESS;
}
//移除采用Mdl方式的SSDT表函数Hook
NTSTATUS MdlRemoveSSDTHook(ULONG_PTR ul_real_function, ULONG_PTR hook_function_addr, ULONG_PTR *ul_save_real_function_addr)
{
//恢复SSDT表中被Hook的函数
UNHOOK_SYSCALL(ul_real_function, *ul_save_real_function_addr, hook_function_addr);
if(pmdl_system_call)
{
//解锁非分页内存
MmUnmapLockedPages(pdword_mapped_table, pmdl_system_call);
//释放申请的非分页内存
IoFreeMdl(pmdl_system_call);
return STATUS_SUCCESS;
}
return STATUS_UNSUCCESSFUL;
}SSDTHook.c文件
//SSDTHook.c
#include "SSDTHook.h"
//卸载函数
VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
if (bool_hook_type)
{
//移除采用Cr0方式的SSDT表函数Hook
Cr0RemoveSSDTHook(&int_hook_index, RealZwOpenProcess);
DbgPrint("ZwOpenProcess Remove Cr0RemoveSSDTHook success\r\n");
}
else
{
//移除采用Mdl方式的SSDT表函数Hookook
if (MdlRemoveSSDTHook((ULONG_PTR)ul_ZwOpenProcess, NewZwOpenProcess, &RealZwOpenProcess) == STATUS_SUCCESS)
{
DbgPrint("ZwOpenProcess Remove MdlRemoveSSDTHook success\r\n");
}
}
DbgPrint("卸载完成!\n");
}
//因为这节只是阐述SSDTHOOK原理，所以只是简单的弄一个过滤函数
/*
lkd> u 8a114070 l 30
8a114070 8bff mov edi,edi
8a114072 55 push ebp
8a114073 8bec mov ebp,esp
8a114075 8b4514 mov eax,dword ptr [ebp+14h]
8a114078 50 push eax
8a114079 8b4d10 mov ecx,dword ptr [ebp+10h]
8a11407c 51 push ecx
8a11407d 8b550c mov edx,dword ptr [ebp+0Ch]
8a114080 52 push edx
8a114081 8b4508 mov eax,dword ptr [ebp+8]
8a114084 50 push eax
8a114085 ff151c60118a call dword ptr ds:[8A11601Ch]
8a11408b 5d pop ebp
8a11408c c21000 ret 10h
*/
/*
HOOK,SSDT表的内容：
lkd> dd 84495d5c+be*4
84496054 8a114070
我们unhook：
lkd> dd 84495d5c+be*4
84496054 84629ad4
*/
//自定义的ZwOpenProcess函数NewZwOpenProcess
NTSTATUS NewZwOpenProcess(OUT PHANDLE ProcessHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PCLIENT_ID ClientId
)
{
//Your OEM code
DbgPrint("You Have Hooked Me\r\n");
//在过滤函数当中，要调用，所以我们在hook的时候要保存好
return RealZwOpenProcess(ProcessHandle,
DesiredAccess,
ObjectAttributes,
ClientId
);
}
//****************************************************************************************************************
//驱动入口函数DriverEntry
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
//设置卸载例程函数
DriverObject->DriverUnload = DriverUnload;
//定义一个BOOLEAN
if (bool_hook_type)
{
//Cr0方式SSDT表函数Hook
Cr0SSDTHook(&int_hook_index, &RealZwOpenProcess, (ULONG_PTR)NewZwOpenProcess);
DbgPrint("ZwOpenProcess start Cr0RemoveSSDTHook success\r\n");
}
else
{
DbgPrint("ZwOpenProcess start MdlRemoveSSDTHook success\r\n");
RtlInitUnicodeString(&unicode_string, L"ZwOpenProcess");
//获取函数ZwOpenProcess的原始调用地址
ul_ZwOpenProcess = (ULONG_PTR)MmGetSystemRoutineAddress(&unicode_string);
if (ul_ZwOpenProcess)
{
//Mdl方式SSDT表函数Hook
if (MdlSSDTHook(ul_ZwOpenProcess, (ULONG_PTR)NewZwOpenProcess, &RealZwOpenProcess) == STATUS_SUCCESS)
{
DbgPrint("ZwOpenProcess MdlSSDTHook success\r\n");
}
}
}
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=ssdtHook
TARGETTYPE=DRIVER
TARGETPATH=obj
INCLUDE=.\
SOURCES = SSDTHook.c\
SSDT.c \文档和代码的下载地址：http://download.csdn.net/detail/qq1084283172/8838535
参考资料：
AGP讲课资料的整理和修改。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章