构建API调用框架绕过杀软hook

二进制内核

字数统计: 2.3k阅读时长: 9 min

 2022/04/13 

我们知道杀软在API函数的监控上一般有两种手段，一种是在3环直接通过挂钩到自己的函数判断是否调用了这个API，另外一种方式就是在0环去往SSDT表的路径上挂钩来判断进0环后的操作。那么我们如果不想杀软监控我们的行为，之前提过的内核重载是一种绕过的方式，但是内核重载的动静太大，这里我们就通过直接重写3环到0环的API，通过重写KiFastCallEntry来自己调用内核的函数，以达到规避杀软的效果。

调用过程

我们首先来看一下API函数的调用过程，这里以OpenProcess函数为例

首先在kernel32.dll里面找到OpenProcess函数

往下走这里调用了NtOpenProcess

这里去导出模块看一下调用了ntdll.dll的NtOpenProcess

这里在ntdll.dll里面定位到NtOpenProcess，这里使用7A的调用号，通过call dword ptr [edx]即sysenter进入0环

这里进入0环之后首先会通过KiFastCallEntry，这个函数细节是很值得探究的，限于篇幅这里就不赘述了

我们直接去到关键的汇编语句，我们可以看到这里就是找到SSDT函数表的地址，通过3环传入的调用号，去SSDT表里面寻址

通过SSDT定位到NtOpenProcess函数

思路

我们总结一下调用过程

3环API(kernel32.dll) -> ntdll.dll -> sysenter -> KiFastCallentry -> SSDT -> 真正调用的0环API

我们可以在3环直接自己写asm汇编通过中断门的方式进入0环，因为在进入0环之后无论是KiFastCallentry还是KiSystemService最终都是会找到SSDT表的地址再去调用内核函数的，那么我们要实现的几个功能如下

重写3环API通过中断门进0环
重写KiFastCallEntry以免挂钩
自己创建一个SSDT表
编写内核函数挂到自己创建的SSDT表里面

实现

这里直接通过中断门的方式进入0环，IDT表的索引这里我定义为0x20

void __declspec(naked)MyTestAPI(int a, int b)
{
	__asm
	{
		mov eax, 0
		mov edx, esp
		add edx, 4

		int 0x20

		ret
	}
}

然后这里我们首先定义一个我们自己的SSDT结构

typedef struct _SSDT
{
	ULONG FunctionAddrTable;
	ULONG ArgumentSizeTable;
	ULONG Count;
}SSDT, *pSSDT;

然后构造中断门提权，这里需要首先了解一个段权限检查的知识

段权限检查

CPU权限等级划分如下，在windows里面ring0和ring3使用得较多

如何查看程序处于几环？(CPL)

CPL(Current Privilege Level) ：当前特权级，CS和SS中存储的段选择子后2位

拖入程序到od，可以看到cs段为0023，拆开即为00100011，那么CPL取最后两位即为11，那么就是一个三环程序

这里再去windbg里面下个断点查看cs的情况，可以直接使用r命令，或者点击窗口查看，这里cs=8，拆分之后就是1000，后两位为00，说明CPL=0，为0环程序

DPL(Descriptor Privilege Level) 描述符特权级别

DPL存储在段描述符中，规定了访问该段所需要的特权级别是什么。通俗的理解：如果你想访问我，那么你应该具备什么特权。

举例说明：

mov DS,AX

如果AX指向的段DPL = 0，但当前程序的CPL = 3，这行指令是不会成功的，因为只有0环的程序才能访问0环的内存

RPL(Request Privilege Level) 请求特权级别

RPL是针对段选择子而言的，每个段的选择子都有自己的RPL

举例说明：

1
2
3

Mov ax,0x0008 与 Mov ax,0x000B //段选择子

Mov ds,ax Mov ds,ax

指向的是同一个段描述符,但RPL是不一样的

数据段权限检查举例

比如当前程序处于0环，也就是说CPL=0

1
2
3

Mov ax,000B //1011 RPL = 3

Mov ds,ax //ax指向的段描述符的DPL = 0

数据段的权限检查：

CPL <= DPL 并且 RPL <= DPL (数值上的比较)

注意：代码段和系统段描述符中的检查方式并不一样

总结：

CPL CPU当前的权限级别
DPL 如果你想访问我，你应该具备什么样的权限
RPL 用什么权限去访问一个段

那么为什么会有RPL的存在呢?

因为我们本可以用“读写”的权限去打开一个文件，但为了避免出错，有些时候我们使用“只读”的权限去打开。

然后我们再回到中断门，中断门的结构如下，首先肯定要设置P位为1才有效，因为是从3环进0环提权，那么DPL就需要设置为3即11，再就是8-12位的第11位这个D，代表的是default，当系统为32位的时候置1，当系统为16位的时候置0，那么D位为1，只有当CPL=DPL的时候才能成功触发中断

偏移这里我们暂时先不设置，那么高四字节就可以得到0000EE00

然后我们再看段选择子，这里因为我们是在0环，这里即需要设置RPL=0，那么这里就可以得出低4位为0008

组合起来构造得到0000EE00 00080000，存放到数组里面

1	UCHAR Descriptor[8] = { 0x00, 0x00, 0x08, 0x00, 0x00, 0xee, 0x00, 0x00 };

然后通过SIDT aryIDT将构造得到的4字节通过RtlCopyMemory存放到IDT表里面，这里IDT的索引我设置的是0x20

*(PUSHORT)Descriptor = *(PUSHORT)(&Temp_FunctionAddr);	// 低2字节
*(PUSHORT)((ULONG)Descriptor + 6) = *(PUSHORT)((ULONG)&Temp_FunctionAddr + 2);	// 高2字节

__asm
{
	SIDT aryIDT
}
IDTAddr = *((PULONG)((ULONG)aryIDT + 2));

RtlCopyMemory((PUCHAR)(IDTAddr + 0x20 * 8), Descriptor, 8);

再生成一个新的SSDT表，首先使用ExAllocatePool申请一块内存，判断一下是否生成成功

extern SSDT stSSDT = { 0 };

	stSSDT.FunctionAddrTable = (ULONG)ExAllocatePool(NonPagedPool, 0x1000);
	stSSDT.ArgumentSizeTable = (ULONG)ExAllocatePool(NonPagedPool, 0x1000);

	if (stSSDT.FunctionAddrTable == 0 || stSSDT.ArgumentSizeTable == 0)
	{
		return NULL;
	}

返回新SSDT表的地址

RtlFillMemory((PUCHAR)stSSDT.FunctionAddrTable, 0x1000, 0);
RtlFillMemory((PUCHAR)stSSDT.ArgumentSizeTable, 0x1000, 0);

stSSDT.Count = 0;

return &stSSDT;

再编写一个函数，当有新的内核函数创建时，存放FunctionAddrTable和ArgumentSizeTable，并把Count的值加1

ULONG AddFunctionToSSDT(pSSDT MySSDT, ULONG FunctionAddr, UCHAR ArgSize)
{
	ULONG Temp_Count = MySSDT->Count;
	*(PULONG)(MySSDT->FunctionAddrTable + Temp_Count * 4) = FunctionAddr;
	*(PUCHAR)(MySSDT->ArgumentSizeTable + Temp_Count) = ArgSize;
	MySSDT->Count = MySSDT->Count + 1;
	
	return Temp_Count;
}

再就是KiFastCallEntry函数的重写，这里需要通过IDA对堆栈结构进行分析，这里就不展开说了，直接贴代码和注释

这里注意必须使用裸函数，否则自动生成的汇编会将eax寄存器清0

void __declspec(naked) MyKiFastCallEntry()
{
	__asm
	{
		push 0
		push ebp
		push ebx
		push esi
		push edi
		push fs
		push eax
		mov eax,0x30
		mov fs,ax
		pop eax
		push dword ptr ds:0x0ffdff000			// 保存异常链表
		mov dword ptr ds:0x0ffdff00,0x0ffffffff	// 修改异常链表
		mov esi,ds:0x0ffdff124
		xor ecx,ecx
		mov cl,byte ptr [esi+0x140]
		push ecx						// 保存先前模式
		sub esp,0x48					// 指向_Tramp_Frame的首地址
		mov ecx,1
		mov [esi+0x140],cl			// 修改先前模式
		mov ebp,[esi+0x134]
		mov [esp+0x3c],ebp			// 保存当前线程的Trap_Frame
		mov [esi+0x134],esp			// 修改当前线程的Trap_Frame
		mov ebp,esp
		cld
		mov[esp+0xc],edx
		mov ebx,[esp+0x60]
		mov edi,[esp+0x68]
		mov [esp+0],ebx
		mov [esp+4],edi
		sti
		mov edi,MySSDT
		mov ebx,[edi+4]		// 函数大小
		mov edi,[edi]			// 函数地址表
		xor ecx,ecx
		mov cl,[ebx+eax]
		mov ebx,[edi+eax*4]
		sub esp,ecx
		shr ecx,2
		mov edi,esp
		mov esi,edx
		rep movsd
		call ebx
		mov esp,ebp
		mov ecx,ds:0x0ffdff124
		mov edx,[ebp+0x3c]	// 还原Trap_Frame
		mov [ecx+0x134],edx
		cli
		mov edx,[esp+0x4c]	// 还原异常链表
		mov fs:0,edx
		mov ecx,[esp+0x48]
		mov esi,fs:0x124
		mov [esi+0x140], cl	// 还原先前模式
		lea esp,[ebp+0x50]
		pop fs
		pop edi
		pop esi
		pop ebx
		pop ebp
		add esp, 4
		iretd
	}
}

然后这里我们再定义一个内核函数，调用成功则打印输出

VOID test(int a, int b)
{
	DbgPrint("API运行成功\n");
}

然后再进行加载驱动

void UnLoad(PDRIVER_OBJECT DriverObject)
{
	ExFreePool((PUCHAR)MySSDT->ArgumentSizeTable);
	ExFreePool((PUCHAR)MySSDT->FunctionAddrTable);
	DbgPrint("Driver unload successfully");
}

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
	IncreaseInterruptToIDT((ULONG)MyKiFastCallEntry);
	MySSDT = IncreaseSSDT();
	DbgPrint("MySSDT : %x\n", MySSDT);
	AddFunctionToSSDT(MySSDT, (ULONG)test, 8);

	DriverObject->DriverUnload = UnLoad;
	return STATUS_SUCCESS;
}