吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

 找回密码
 注册[Register]

QQ登录

只需一步,快速开始

查看: 5381|回复: 36
收起左侧

[系统底层] 系统调用(R3API调用过程详解)

[复制链接]
woshikele 发表于 2021-10-10 20:51
本帖最后由 woshikele 于 2021-10-20 18:48 编辑

WindowsAPI

  • API(Application Programming Interface),我们调用时只需提供正确的参数以及接收返回值就可以判断API执行是否成功或者通过GetLastError获得错误原因.
  • 大部分API在R3都是处理各种校验,真正执行功能都是在R0(并不是所有的API都是在R0处理).
  • 系统中几个核心DLL(Kernel32.dll,User32.dll,GDI32.dll,Ntdll.dll(大多数API通过此DLL进入内核)).
  • 通过API ReadProcessMemory / OpenProcess 分析函数从R3进入R0过程,进入R0如何处理原有寄存器数据,传递参数,找到对应内核函数并调用,以及从R0返回R3过程.
  • 前置知识点(汇编,C,Win32,段页机制,段描述符,中断门,).
  • 涉及知识点(_KUSER_SHARED_DATA,_KTRAP_FRAME,_KPCR,_KPRCB,_KTHREAD,KiFastSystemCall→KiFastCallEntry,KiIntSystemCall→KiSystemService,SSDT)下文详解.
  • 代码示例(重写R3API,SSDTHOOK,内核重载).

R3API调用分析

代码示例:

#include <stdio.h>
#include <Windows.h>

int main()
{
  //随便选择一个进程
  HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 2252);

  //0x400000大部分情况下为ImageBase
  DWORD dwData = 0;
  ReadProcessMemory(hProcess, (PVOID)0x400000, &dwData, 4, NULL);

  return 0;
}

1).将编译好的文件拖入DBG / OD 分析(定位MAIN函数找到API调用位置)

1.定位MAIN中API调用.png

2).OpenProcess执行流程分析

2.openprocess流程分析.png

OpenProcess执行流程:进程模块内CALLAPI(OpenProcess) -> kernel32.dll(OpenProcess) -> kernelBase.dll(OpenProcess) -> ntdll.dll(ZwOpenProcess) -> ntdll.dll中执行会进入R0后文详解.

3).ReadProcessMemory执行流程分析

3.readprocessmemory流程分析.png

ReadProcessMemory执行流程:进程模块内CALLAPI(ReadProcessMemory) -> kernel32.dll(ReadProcessMemory) -> kernelBase.dll(ReadProcessMemory) -> ntdll.dll(ZwReadVirtualMemory) -> ntdll.dll中执行会进入R0后文详解.

R3API功能实现分析

1).ReadProcessMemory分析(R3功能实现分析)

1).通过IDA导入KernelBase.dll,查询ReadProcessMemory函数,如下图:

4.readprocessmemory功能分析.png

分析得出ReadProcessMemory函数并未做任何处理而是调用ntdll.dll中NtReadVirtualMemory

2).通过IDA导入Ntdll.dll,查询NtReadVirtualMemory函数,如下图:

4.readprocessmemory功能分析2.png

后文详解此处...

2).OpenProcess分析(R3功能实现分析)

1).通过IDA导入KernelBase.dll,查询OpenProcess函数,如下图:

5.OpenProcess功能分析1.png

5.OpenProcess功能分析2.png

分析得出OpenProcess函数并未做任何功能实现,而是在原有参数基础上填充内核需要结构体信息后调用NtOpenProcess

2).通过IDA导入Ntdll.dll,查询NtOpenProcess函数,如下图:

5.OpenProcess功能分析3.png

这两个函数最终都执行到ntdll.dll中并且除了eax值不相同其余都一样.

edx = 7FFE0300h

call [edx]

这里只需要分析edx指向地址7FFE0300h中的值即可.

这里我们需要了解一个结构体_KUSER_SHARED_DATA

_KUSER_SHARED_DATA

1)._KUSER_SHARED_DATA

  • 用户层和内核层分别定义了一个_KUSER_SHARED_DATA结构体,用于在用户层和内核层共享数据,其大小为4KB(测试环境Win7 x86 这块结构系统默认用了0x5ff,意味着结构体 + 0x600 ~ 0xFFF可以构建自己的共享数据).
  • 页的知识可以知道共享数据是用户层和内核层_KUSER_SHARED_DATA结构体对应线性地址指向同一个物理页,但在用户层中这块内存是只读的,内核层中是可读可写的.
  • 用户层和内核层使用固定的地址映射_KUSER_SHARED_DATA结构体,地址如下表所示:
内核起始地址 内核结束地址 用户起始地址 用户结束地址
x86 0xFFDF0000 0xFFDF0FFF 0x7FFE0000 0x7FFE0FFF
x64 0xFFFFF780 - 00000000 0xFFFFF780 - 00000FFF 0x7FFE0000 0x7FFE0FFF
  • _KUSER_SHARED_DATA共享论证.

测试环境Win7 x86

1).Windbg输入指令 !process 0 0 找一个进程附加

6.KUSER共享论证1.png

2).Windbg输入指令 .process /i xxxxxxxx

6.KUSER共享论证2.png

此时Windbg处于Dbgview进程空间中.

3).Windbg输入指令 !pte 用户层以及内核层_KUSER_SHARED_DATA结构体对应线性地址

6.KUSER共享论证3.png

4).修改用户层结构数据查看内核层对应数据

6.KUSER共享论证4.png

2)._KUSER_SHARED_DATA.SystemCall

(Windbg输入指令 dt _KUSER_SHARED_DATA)
nt!_KUSER_SHARED_DATA
   +0x300 SystemCall       : Uint4B //系统调用
   +0x304 SystemCallReturn : Uint4B //调用返回

R3API如果通过 MOV EDX, 7FFE0300h; CALL DWORD PTR [edx];方式进R0,实际上相当于调用_KUSER_SHARED_DATA.SystemCall中的存储的值.

_KUSER_SHARED_DATA.SystemCall中存储的值决定了函数通过什么方式进R0.(操作系统通过检查当前CPU是否支持快速调用来填充这个值,支持函数地址为KiFastSystemCall快速调用,不支持函数地址为KiIntSystemCall中断调用).

CPU是否支持快速调用?

当EAX = 1 执行CPUID指令 如果EDX第11位(SEP) = 1 说明支持快速调用,否则为中断调用,即_KUSER_SHARED_DATA.SystemCall中存储的值.

至此已经了解到R3进入R0两种方式,接下来分析中断调用,快速调用如何进入R0.

代码示例:

#include <stdio.h>
#include <windows.h>

int main()
{
  DWORD dwEAX = 0;
  DWORD dwECX = 0;
  DWORD dwEDX = 0;

  __asm
  {
    xor eax, eax
    mov eax, 1
    CPUID

    mov dwEAX, eax
    mov dwECX, eax
    mov dwEDX, edx
  }

  printf("EAX 0x%08x \n",dwEAX);
  printf("ECX 0x%08x \n",dwECX);
  printf("EDX 0x%08x \n",dwEDX);

  printf("EDX 11(BIT) [%d] \n", (dwEDX & 0x800) >> 11);

  system("pause");
  return 0;
}

intel白皮书介绍如下:

7.CPUID1.png

7.CPUID2.png

系统调用

1).中断调用KiIntSystemCall

固定中断号为: 2Eh 通过解析如下图:

8.R3中断调用.png

2).快速调用KiFastSystemCall

如果CPU支持sysenter(快速调用)指令,操作系统会提前将CS/ESP/EIP的值存储在MSR寄存器中,sysenter指令执行时,CPU会将MSR寄存器中的值写入相关寄存器(没有查询内存过程速度更快).

MSR 地址
IA32_SYSENTER_CS 174H
IA32_SYSENTER_ESP 175H
IA32_SYSENTER_EIP 176H

9.R3快速调用.png

intel白皮书对SYSENTER介绍如下:

10.sysenter1.png

代码示例(特权指令需要在R0下运行)

#include <ntifs.h>

NTSTATUS DriverUnload(PDRIVER_OBJECT pDriver)
{
  DbgPrint("Driver Exit \r\n");
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg)
{
  DbgPrint("Driver Load \r\n");
  pDriver->DriverUnload = DriverUnload;

  DbgBreakPoint();

  ULONGLONG uData = 0;

  __asm
  {
    mov ecx, 0x174          //相当于msr寄存器index
    rdmsr
    mov dword ptr [uData], eax    //eax存储数据低32位
    mov dword ptr [uData + 4],edx  //edx存储数据高32位
  }

  DbgPrint("MSR[174] -> [0x%llx] \r\n", uData);

  return STATUS_SUCCESS;
}

3).中断调用快速调用区别如下

快速调用 中断调用
R3执行API KiFastSystemCall KiIntSystemCall
8bd4            mov     edx,esp //三环栈顶 系统调用号在EAX <br>0f34             sysenter 8d542408        lea     edx,[esp+8] //参数指针 系统调用号在EAX<br>cd2e                int     2Eh<br>c3                    ret
提权方式(段的机制R3进入R0相当于CPL发生改变 ) 如果CPU支持sysenter指令,操作系统会提前将CS/ESP/EIP的值存储在MSR寄存器中,sysenter指令执行时,CPU会将MSR寄存器中的值写入相关寄存器(没有查询内存过程速度更快).将特权级切换到R0,如果EFLAG.VM被置位,则清除该标志位. int     2Eh对应段描述符为83e4ee00-00083fee中断门描述符,其中加载代码段选择子为0x0008 对应段描述符为00cf9(1001)b00-0000ffff DPL = 0执行成功后CPL = 0.且因权限切换会向堆栈压入SS,ESP,EFLAG,CS,EIP.
提权方式(段的机制R3进入R0相当于CPL发生改变 ) 查询MSR寄存器.CS = rdmsr 174.SS = CS + 8(数值上).ESP = rdmsr 175.EIP = rdmsr 176. ESP,SS由TSS提供.CS由中断门描述符中低4字节高16位提供.EIP由中断门描述符中高4字节高16位与低4字节低16位组成.
进入R0执行API KiFastCallEntry(Windbg输入 rdmsr 176获取) KiSystemService(Windbg输入!IDT 2E获取)

至此已经知道R3API在ntdll.dll中进入R0的两种方法.

在分析对应内核函数前需要了解两个结构体_KTRAP_FRAME,_KPCR.

_KTRAP_FRAME

Windbg输入dt _KTRAP_FRAME指令:

_KTRAP_FRAME结构如下:

nt!_KTRAP_FRAME //类似于R3 -> CONTEXT
   +0x000 DbgEbp           : Uint4B
   +0x004 DbgEip           : Uint4B
   +0x008 DbgArgMark       : Uint4B
   +0x00c DbgArgPointer    : Uint4B
   +0x010 TempSegCs        : Uint2B
   +0x012 Logging          : UChar
   +0x013 Reserved         : UChar
   +0x014 TempEsp          : Uint4B
   +0x018 Dr0              : Uint4B
   +0x01c Dr1              : Uint4B
   +0x020 Dr2              : Uint4B
   +0x024 Dr3              : Uint4B
   +0x028 Dr6              : Uint4B
   +0x02c Dr7              : Uint4B
   +0x030 SegGs            : Uint4B
   +0x034 SegEs            : Uint4B
   +0x038 SegDs            : Uint4B
   +0x03c Edx              : Uint4B
   +0x040 Ecx              : Uint4B
   +0x044 Eax              : Uint4B
   +0x048 PreviousPreviousMode : Uint4B
   +0x04c ExceptionList    : Ptr32 _EXCEPTION_REGISTRATION_RECORD
   +0x050 SegFs            : Uint4B
   +0x054 Edi              : Uint4B
   +0x058 Esi              : Uint4B
   +0x05c Ebx              : Uint4B
   +0x060 Ebp              : Uint4B
   +0x064 ErrCode          : Uint4B //如果是发生错误导致其他中断触发时,这里会有ErrCode,中断调用进内核函数KiSystemService这里push 0.
   +0x068 Eip              : Uint4B
   +0x06c SegCs            : Uint4B
   +0x070 EFlags           : Uint4B
   +0x074 HardwareEsp      : Uint4B
   +0x078 HardwareSegSs    : Uint4B
   +0x07c V86Es            : Uint4B //0x07c ~ 0x088位置为虚拟8086模式下使用,函数进入R0时栈顶默认指向_KTRAP_FRAME.V86Es
   +0x080 V86Ds            : Uint4B
   +0x084 V86Fs            : Uint4B
   +0x088 V86Gs            : Uint4B

0x07c ~ 0x088位置为虚拟8086模式下使用.

中断调用进入R0时栈顶(ESP由TSS提供(每个线程进入R0时ESP都由TSS.ESP0提供,以及TSS里存储的ESP0一直是当前线程进入R0时对应ESP0,线程切换时会更新TSS里存储的ESP0))默认指向_KTRAP_FRAME.V86Es,中断门执行权限发生切换时会向堆栈压入SS,ESP,EFLAG,CS,RETADDR(EIP),由此得知当执行函数KiIntSystemCall进入R0函数KiSystemService时此时ESP指向_KTRAP_FRAME.Eip.(下文分析).

快速调用进入R0时堆栈是由MSR[175]提供的,KiFastCallEntry函数执行时首先会修改FS指向_KPCR结构,通过_KPCR -> _TSS定位到当前线程ESP0,并切换新的堆栈.此时ESP指向_KTRAP_FRAME.V86Ds.(下文分析).

_KPCR

一个核一个_KPCR(Processor Control Region CPU控制块)记录当前CPU核对应各种状态以及上下文环境.

查看CPU数量

kd> dd KeNumberProcessors               
83fb796c  00000001                 //一个核心           

查看KPCR 

kd> dd KiProcessorBlock          //几个核对应几个KPCR 
83fb78c0  83f78d20 00000000      //减去120(kpcr的大小)                

kd> dt _KPCR 83f78d20-120        //就是kpcr的地址   
nt!_KPCR
   +0x000 NtTib            : _NT_TIB

       nt!_NT_TIB
       +0x000 ExceptionList    : Ptr32 _EXCEPTION_REGISTRATION_RECORD
       +0x004 StackBase        : Ptr32 Void
       +0x008 StackLimit       : Ptr32 Void
       +0x00c SubSystemTib     : Ptr32 Void
       +0x010 FiberData        : Ptr32 Void
       +0x010 Version          : Uint4B
       +0x014 ArbitraryUserPointer : Ptr32 Void
       +0x018 Self             : Ptr32 _NT_TIB   //结构体指针 指向自己

   +0x000 Used_ExceptionList : Ptr32 _EXCEPTION_REGISTRATION_RECORD
   +0x004 Used_StackBase   : Ptr32 Void
   +0x008 Spare2           : Ptr32 Void
   +0x00c TssCopy          : Ptr32 Void
   +0x010 ContextSwitches  : Uint4B
   +0x014 SetMemberCopy    : Uint4B
   +0x018 Used_Self        : Ptr32 Void
   +0x01c SelfPcr          : Ptr32 _KPCR
   +0x020 Prcb             : Ptr32 _KPRCB
   +0x024 Irql             : UChar
   +0x028 IRR              : Uint4B
   +0x02c IrrActive        : Uint4B
   +0x030 IDR              : Uint4B
   +0x034 KdVersionBlock   : Ptr32 Void   
   +0x038 IDT              : Ptr32 _KIDTENTRY
   +0x03c GDT              : Ptr32 _KGDTENTRY
   +0x040 TSS              : Ptr32 _KTSS
   +0x044 MajorVersion     : Uint2B
   +0x046 MinorVersion     : Uint2B
   +0x048 SetMember        : Uint4B
   +0x04c StallScaleFactor : Uint4B
   +0x050 SpareUnused      : UChar
   +0x051 Number           : UChar
   +0x052 Spare0           : UChar
   +0x053 SecondLevelCacheAssociativity : UChar
   +0x054 VdmAlert         : Uint4B
   +0x058 KernelReserved   : [14] Uint4B
   +0x090 SecondLevelCacheSize : Uint4B
   +0x094 HalReserved      : [16] Uint4B
   +0x0d4 InterruptMode    : Uint4B
   +0x0d8 Spare1           : UChar
   +0x0dc KernelReserved2  : [17] Uint4B
   +0x120 PrcbData         : _KPRCB

KiSystemService(函数分析)

KiIntSystemCall(R3) -> KiSystemService(R0)

设置环境

11.Kisystemservice1.png

11.Kisystemservice2.png

KiSystemService设置环境后跳转KiFastCallEntry(详情见下文)

KiFastCallEntry(函数分析)

KiFastSystemCall(R3) -> KiFastCallEntry(R0)

设置环境

12.KiFastCallEntry1.png

12.KiFastCallEntry2.png

寻找内核函数地址,拷贝参数

此时需要了解一个结构SystemServiceTable
结构如下:

13SSDT.png

定位SystemServiceTable
_KTHREAD -> ServiceTable 

系统服务表有两张:
1.ntoskrnl.exe导出的常用系统服务.
2.Win32k.sys导出的与图形显示和用户界面相关的系统服务(只有GDI相关线程访问对应系统服务表才会有值).

系统服务表结构如下:

typedef struct _KSERVICE_TABLE_DESCRIPTOR
{
  KSYSTEM_SERVICE_TABLE ntoskrnl;    // 内核函数
  KSYSTEM_SERVICE_TABLE win32k;      // win32k.sys 函数
  KSYSTEM_SERVICE_TABLE unUsed1;     // 未使用
  KSYSTEM_SERVICE_TABLE unUsed2;     // 未使用
} KSERVICE_TABLE_DESCRIPTOR, * PKSERVICE_TABLE_DESCRIPTOR;

typedef struct _KSYSTEM_SERVICE_TABLE
{
  PULONG ServiceTableBase;       // 函数地址表基址
  PULONG ServiceCounterTableBase;// 函数被调用的次数
  ULONG NumberOfService;         // 函数个数
  PULONG ParamTableBase;         // 函数参数表基址
} KSYSTEM_SERVICE_TABLE, * PKSYSTEM_SERVICE_TABLE;

ServiceTable指向函数地址表每个成员大小为4字节,存储函数地址.
ServiceLimit存储函数地址表的成员个数.
ArgumentTable 函数参数表每个成员大小为1字节,存储函数参数个数(存储值 / 4 = 参数个数).

在快速调用和中断调用R3函数执行时,EAX存储了系统服务号.

通过第12位确定是哪张表.
通过低12位确定在函数地址表中的索引值以及函数参数表的索引值.

System Services Descriptor Table系统服务描述符表,为导出结构KeServiceDescriptorTable(代码中只需声明即可直接使用).

13SSDT2.png

查找ReadProcessMemory(测试环境系统服务号为115h)对应内核函数地址以及参数

Windbg查看SSDT

dd KeServiceDescriptorTable

13SSDT3.png

继续函数分析

12.KiFastCallEntry3.png

12.KiFastCallEntry4.png

至此完成了初始化内核环境以及参数拷贝,函数调用.

函数返回

涉及到APC,此部分会更新到APC处,大致流程为执行完毕后首先判断当前IRQL等级(不为0跳转处理蓝屏),然后判断是否为虚拟8086模式,接着判断有没有APC需要处理等.最后通过iretd返回.

涉及到的结构体如下图:

14总汇.png

Win7 x86系统调用全过程...

重写R3API

  • WindowsAPI分析中可以判断出大部分API在R3都未做真正功能实现,只是完成一些内核所需结构数据填充,数据校验等等.
  • 重写R3API,需对接快速调用/中短调用堆栈要求,以及对应内核函数所需数据就可以实现(可避免恶意挂钩,R3层的API监控等).

1).快速调用方式重写

通过WindowsAPI分析,可以得知除了R3API业务实现内还需要注意EDX进入内核前指向栈顶,EAX存储系统服务号.

#include <stdio.h>
#include <windows.h>

BOOL MyReadMemory(
    HANDLE  hProcess,
    LPCVOID lpBaseAddress,
    LPVOID  lpBuffer,
    SIZE_T  nSize,
    SIZE_T* lpNumberOfBytesRead
)
{
    BOOL bRet = 0;

    __asm
    {
        //Kernelbase.dll -> ReadProcessMemory 
        lea eax, nSize
        push eax
        push nSize
        push lpBuffer
        push lpBaseAddress
        push hProcess

        //ntdll.dll -> NtReadVirtualMemory 
        //模拟call 栈顶-4
        sub esp, 4

        //系统服务号
        mov eax, 0x115

        //KiFastSystemCall 
        //模拟call 堆栈保存返回地址
        PUSH RETADDR 

        //快速调用
        mov edx, esp

        //sysenter对应硬编码
        _emit 0x0F;
        _emit 0x34;

    RETADDR:

        add esp, 0x18

        mov bRet, eax
    }

    return bRet;
}

int main()
{

    DWORD dwData = 0;
    HANDLE handle = 0;

    handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 2252);
    MyReadMemory(handle, (LPVOID)0x400000, &dwData, 4, NULL);
    printf("dwData [0x%08x] \n", dwData);

    system("pause");
    return 0;
}

2).中断调用方式重写

#include <stdio.h>
#include <windows.h>

BOOL MyReadMemory(
    HANDLE  hProcess,
    LPCVOID lpBaseAddress,
    LPVOID  lpBuffer,
    SIZE_T  nSize,
    SIZE_T* lpNumberOfBytesRead
)
{
    BOOL bRet = 0;

    __asm
    {
        //系统服务号
        mov eax, 0x115

        //首参数指针
        lea edx, hProcess

        //中断调用固定号
        int 0x2E
    }

    return bRet;
}

int main()
{
    DWORD dwData = 0;
    HANDLE handle = 0;

    handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 2252);
    MyReadMemory(handle, (LPVOID)0x400000, &dwData, 4, NULL);
    printf("dwData [0x%08x] \n", dwData);

    system("pause");
    return 0;
}

3).动态重写

  • 上述两种方式中系统服务号都是写死的不方便项目中使用,下述代码演示动态获取系统服务号并调用函数.
#include <stdio.h>
#include <Windows.h>
#include <winternl.h> 

typedef NTSTATUS(WINAPI* ZwOpenProcessProc)(PHANDLE ProcessHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes, CLIENT_ID* ClientId);

int main()
{
    //获取ZwOpenProcess函数地址
    HMODULE hModule = LoadLibraryA("ntdll.dll");
    PUCHAR pFunAddr = (PUCHAR)GetProcAddress(hModule, "ZwOpenProcess");
    printf("Funaddr -> [0x%08x] \r\n", pFunAddr);

    //获取ZwOpenProcess函数长度
    ULONG uSize = 0;
    for (int i = 0; i < 100; i++)
    {
        //C2 == ret 
        if (pFunAddr[i] == 0xc2)
        {
            uSize = i + 2;
            break;
        }
    }
    printf("FunLength -> [0x%08x] \r\n", uSize);

    //函数指针申请内存
    ZwOpenProcessProc func = (ZwOpenProcessProc)VirtualAlloc(NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    //拷贝默认函数数据
    memcpy(func, pFunAddr, uSize);

    //分析得知需要打开进程需要填充CLIENT_ID.UniqueProcess
    CLIENT_ID Client = { 0 };
    Client.UniqueProcess = (HANDLE)2252;

    //分析得知需要填充POBJECT_ATTRIBUTES.Length
    OBJECT_ATTRIBUTES Obj_Attr = { 0 };
    Obj_Attr.Length = sizeof(OBJECT_ATTRIBUTES);

    HANDLE hProcess = NULL;
    NTSTATUS ntstatus = func(&hProcess, PROCESS_ALL_ACCESS, &Obj_Attr, &Client);

    printf("Ret -> [%x]  hProcess -> [%x] \r\n", ntstatus, hProcess);
    system("Pause");

    return 0;
}

SSDT_HOOK

测试环境Win7 x86

  • 重新加载一份按照PE格式拉伸后的内核文件到内存(避免当前内核已经被挂钩).
  • 通过导出表获取HOOK函数系统服务号.
  • 利用导出KeServiceDescriptorTable结构定位系统服务表实现替换函数(类似IAT_HOOK).
#include <ntifs.h>
#include <ntimage.h>
#include <ntstrsafe.h>

//获取系统目录
PWCHAR GetSystemFullPath();

//内核文件按照PE拉伸后格式映射到内存
PUCHAR FileMaping(PWCHAR SystemPath);

//释放文件映射
VOID UnFileMaping(PVOID mapBase);

//通过函数名查找导出函数
ULONG64 GetFuntionAddressByExportTableName(PUCHAR ImageBuffer, PUCHAR FunctionName);

//导出未文档化函数
NTSTATUS MmCreateSection(
        __deref_out PVOID* SectionObject,
        __in ACCESS_MASK DesiredAccess,
        __in_opt POBJECT_ATTRIBUTES ObjectAttributes,
        __in PLARGE_INTEGER InputMaximumSize,
        __in ULONG SectionPageProtection,
        __in ULONG AllocationAttributes,
        __in_opt HANDLE FileHandle,
        __in_opt PFILE_OBJECT FileObject
);

// 系统服务表
typedef struct _KSYSTEM_SERVICE_TABLE
{
        PULONG ServiceTableBase;                        // 函数地址表(SSDT)
        PULONG ServiceCounterTableBase;                // SSDT 函数被调用的次数
        ULONG NumberOfService;                                // 函数个数
        PULONG ParamTableBase;                                // 函数参数表(SSPT)
} KSYSTEM_SERVICE_TABLE, * PKSYSTEM_SERVICE_TABLE;

typedef struct _KSERVICE_TABLE_DESCRIPTOR
{
        KSYSTEM_SERVICE_TABLE ntoskrnl;                // 内核函数
        KSYSTEM_SERVICE_TABLE win32k;                // win32k.sys 函数
        KSYSTEM_SERVICE_TABLE unUsed1;
        KSYSTEM_SERVICE_TABLE unUsed2;
} KSERVICE_TABLE_DESCRIPTOR, * PKSERVICE_TABLE_DESCRIPTOR;

extern PKSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable;

PUCHAR G_MapNtdll = NULL;

//拷贝SSDT表
BOOLEAN SSDT_Init();

//释放SSDT表
VOID SSDT_Destroy();

//获取函数系统服务号
ULONG SSDT_GetFunIndex(PUCHAR szFunctionName);

//SSDTHOOK
ULONG_PTR SSDT_Hook(PUCHAR szFunctionName, ULONG_PTR FunctionAddr);

//关闭写保护以及中断
ULONG wpOff()
{
        ULONG cr0 = __readcr0();
        _disable();
        __writecr0(cr0 & (~0x10000));
        return cr0;
}

//恢复CR0默认数据
VOID wpOn(ULONG value)
{
        __writecr0(value);
        _enable();
}

//恢复HOOK时用到
ULONG G_OldFunAddr = NULL;

//函数指针
typedef NTSTATUS(NTAPI* OpenProcessProc)(_Out_ PHANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PCLIENT_ID ClientId);

//替换函数
NTSTATUS NTAPI MyOpenProcess(_Out_ PHANDLE ProcessHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_opt_ PCLIENT_ID ClientId)
{
        PUCHAR pEprocess = (PUCHAR)IoGetCurrentProcess();
        DbgPrint("进程ID: [%d] 调用OpenProcess \r\n", *(PULONG)(pEprocess + 0xb4));

        //TODO:
        //获取参数,监控,修改返回值....

        return ((OpenProcessProc)G_OldFunAddr)(ProcessHandle, DesiredAccess, ObjectAttributes, ClientId);
}

NTSTATUS DriverUnload(PDRIVER_OBJECT pDriver)
{
        DbgPrint("Driver Exit \r\n");

        //恢复钩子
        if (G_OldFunAddr)
        {
                SSDT_Hook("ZwOpenProcess", G_OldFunAddr);
        }

        //释放后延迟避免有进程还在执行我们函数释放导致蓝屏
        SSDT_Destroy();

        //延时
        LARGE_INTEGER inTime = { 0 };
        inTime.QuadPart = -10000 * 3000;
        KeDelayExecutionThread(KernelMode, FALSE, &inTime);

}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg)
{
        DbgPrint("Driver Load \r\n");
        pDriver->DriverUnload = DriverUnload;

        if (SSDT_Init())
        {
                G_OldFunAddr = SSDT_Hook("ZwOpenProcess", MyOpenProcess);
        }

        return STATUS_SUCCESS;
}

PWCHAR GetSystemFullPath()
{
        //申请路径缓冲区
        PWCHAR SystemPath = ExAllocatePool(PagedPool, PAGE_SIZE);
        if (!SystemPath)
        {
                return NULL;
        }
        memset(SystemPath, 0, PAGE_SIZE);

        //初始化路径
        RtlStringCbPrintfW(SystemPath, PAGE_SIZE, L"\\??\\%s\\System32\\ntdll.dll", SharedUserData->NtSystemRoot);
        DbgPrint("SystemPath -> [%ws] \r\n", SystemPath);

        return SystemPath;
}

PUCHAR FileMaping(PWCHAR SystemPath)
{
        //Initialize UnicodeString
        UNICODE_STRING FileName = { 0 };
        RtlInitUnicodeString(&FileName, SystemPath);

        //Initialize ObjectAttribute
        OBJECT_ATTRIBUTES objectFile = { 0 };
        InitializeObjectAttributes(&objectFile, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL);

        //CreateFile
        HANDLE hFile = NULL;
        IO_STACK_LOCATION iostacklocation = { 0 };
        NTSTATUS ntstatus = ZwCreateFile(&hFile, GENERIC_READ, &objectFile, &iostacklocation, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, NULL);
        if (!NT_SUCCESS(ntstatus))
        {
                DbgPrint("FileMaping ZwCreateFile Filed \r\n");
                return NULL;
        }

        //Create Section
        OBJECT_ATTRIBUTES objectSection = { 0 };
        InitializeObjectAttributes(&objectSection, NULL, OBJ_CASE_INSENSITIVE, NULL, NULL);

        PVOID pSection = NULL;
        LARGE_INTEGER InputMaximumSize = { 0 };
        ntstatus = MmCreateSection(&pSection, SECTION_ALL_ACCESS, &objectSection, &InputMaximumSize, PAGE_EXECUTE_READWRITE, 0x1000000, hFile, NULL);
        if (!NT_SUCCESS(ntstatus))
        {
                DbgPrint("FileMaping MmCreateSection Filed \r\n");
                ZwClose(hFile);
                return NULL;
        }

        PVOID pMapBase = NULL;
        SIZE_T ViewSize = 0;
        ntstatus = MmMapViewInSystemSpace(pSection, &pMapBase, &ViewSize);
        ObDereferenceObject(pSection);
        ZwClose(hFile);

        if (NT_SUCCESS(ntstatus))
        {
                return pMapBase;
        }

        return NULL;
}

VOID UnFileMaping(PVOID pImage)
{
        if (pImage)
        {
                MmUnmapViewInSystemSpace(pImage);
        }
}

ULONG64 GetFuntionAddressByExportTableName(PUCHAR ImageBuffer, PUCHAR FunctionName)
{
        //Headers
        PIMAGE_DOS_HEADER    pDos = (PIMAGE_DOS_HEADER)ImageBuffer;
        if (*(PUSHORT)pDos != IMAGE_DOS_SIGNATURE)
        {
                DbgPrint("Not PeFile \r\n");
                return NULL;
        }

        PIMAGE_NT_HEADERS    pNts = (PIMAGE_NT_HEADERS)(ImageBuffer + pDos->e_lfanew);
        if (*(PULONG)pNts != IMAGE_NT_SIGNATURE)
        {
                DbgPrint("Not PeFile \r\n");
                return NULL;
        }

        PIMAGE_FILE_HEADER      pFil = (PIMAGE_FILE_HEADER)((ULONG)pNts + 0x4);
        PIMAGE_OPTIONAL_HEADER  pOpt = (PIMAGE_OPTIONAL_HEADER)((ULONG)pFil + IMAGE_SIZEOF_FILE_HEADER);
        PIMAGE_EXPORT_DIRECTORY pExp = (PIMAGE_EXPORT_DIRECTORY)(ImageBuffer + pOpt->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

        //遍历导出表
        ULONG64 FunctionAddr = NULL;
        for (int i = 0; i < pExp->NumberOfNames; i++)
        {
                PULONG  pAddressOfFuntion        = ImageBuffer + pExp->AddressOfFunctions;
                PULONG  pAddressOfNames                = ImageBuffer + pExp->AddressOfNames;
                PUSHORT pAddressOfOrd                = ImageBuffer + pExp->AddressOfNameOrdinals;
                PUCHAR  CurrentFunctionName = ImageBuffer + pAddressOfNames[i];

                ULONG uIndex = -1;

                if (strcmp(CurrentFunctionName, FunctionName) == 0)
                {
                        uIndex = pAddressOfOrd[i];
                }

                if (uIndex != -1)
                {
                        FunctionAddr = ImageBuffer + pAddressOfFuntion[uIndex];
                        break;
                }

        }

        if (FunctionAddr)
        {
                DbgPrint("FindFunctionAddress FunName[%s] Addr[%p] \r\n", FunctionName, FunctionAddr);
        }
        else
        {
                DbgPrint("FindFunctionAddress Error FunName[%s] \r\n", FunctionName);
        }

        return FunctionAddr;
}

BOOLEAN SSDT_Init()
{
        if (G_MapNtdll)
        {
                return TRUE;
        }

        PWCHAR szPath = GetSystemFullPath();
        if (szPath == NULL)
        {
                return FALSE;
        }

        G_MapNtdll = FileMaping(szPath);
        if (G_MapNtdll == NULL)
        {
                ExFreePool(szPath);
                return FALSE;
        }

        ExFreePool(szPath);
        return TRUE;
}

VOID SSDT_Destroy()
{
        if (G_MapNtdll)
        {
                UnFileMaping(G_MapNtdll);
                G_MapNtdll = NULL;
        }
}

ULONG SSDT_GetFunIndex(PUCHAR szFunctionName)
{
        //获取函数地址
        PUCHAR pFunAddr = (PUCHAR)GetFuntionAddressByExportTableName(G_MapNtdll, szFunctionName);
        if (pFunAddr == NULL)
        {
                return -1;
        }

        //获取函数系统服务号
        return *(PULONG)(pFunAddr + 1);
}

ULONG_PTR SSDT_Hook(PUCHAR szFunctionName, ULONG_PTR FunctionAddr)
{
        ULONG uIndex = SSDT_GetFunIndex(szFunctionName);
        if (uIndex == -1)
        {
                return NULL;
        }

        //备份旧的地址
        ULONG OldFuncAddr = KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[uIndex];

        //替换SSDT表中函数
        ULONG cr0 = wpOff();
        KeServiceDescriptorTable->ntoskrnl.ServiceTableBase[uIndex] = FunctionAddr;
        wpOn(cr0);

        return OldFuncAddr;
}

免费评分

参与人数 16吾爱币 +19 热心值 +15 收起 理由
Y1zh1ma0 + 1 + 1 很好,接下来的两天又有东西看了,这量不小,只能说博主太厉害了
q739806133 + 1 + 1 热心回复!
92013 + 3 + 1 我很赞同!
非洲小白脸. + 1 + 1 热心回复!
Stoneone + 1 + 1 谢谢@Thanks!
KylinYang + 1 + 1 我很赞同!
gaosld + 1 + 1 谢谢@Thanks!
topzhp + 1 + 1 热心回复!
qaz003 + 1 + 1 谢谢分享。。收藏有空再爬文
fangchang819 + 1 用心讨论,共获提升!
021012 + 1 + 1 感谢发布原创作品,吾爱破解论坛因你更精彩!
mayl8822 + 1 + 1 我很赞同!
smny + 1 + 1 真技术贴
signed + 1 + 1 我很赞同!
lyl610abc + 3 + 1 我很赞同!
sam喵喵 + 1 谢谢@Thanks!写的太棒了!

查看全部评分

发帖前要善用论坛搜索功能,那里可能会有你要找的答案或者已经有人发布过相同内容了,请勿重复发帖。

 楼主| woshikele 发表于 2021-10-11 12:36

有时间我整理下,内核重载有些地方有bug,但大部分函数我记得还是适用的
 楼主| woshikele 发表于 2021-10-10 21:45
lyl610abc 发表于 2021-10-10 21:37
写得很棒,但可能对新人不是很友好

是的我还是偏向笔记型的...文化水平有限有时表达不清- -!
lyl610abc 发表于 2021-10-10 21:37
smny 发表于 2021-10-10 21:46
很细腻的研究又很细致的整理出来,很有恒心有毅力,赞一个
 楼主| woshikele 发表于 2021-10-10 21:47
smny 发表于 2021-10-10 21:46
很细腻的研究又很细致的整理出来,很有恒心有毅力,赞一个

三克油!
梦幻之神 发表于 2021-10-10 23:10
学习到了
稻海香 发表于 2021-10-11 01:21
非常棒。
54mj 发表于 2021-10-11 07:21
有技术文章必须支持一下
aswcy815174418 发表于 2021-10-11 07:52
期待你的内核重载
fangchang819 发表于 2021-10-11 10:15
进来学习的!
您需要登录后才可以回帖 登录 | 注册[Register]

本版积分规则 警告:本版块禁止灌水或回复与主题无关内容,违者重罚!

快速回复 收藏帖子 返回列表 搜索

RSS订阅|小黑屋|处罚记录|联系我们|吾爱破解 - LCG - LSG ( 京ICP备16042023号 | 京公网安备 11010502030087号 )

GMT+8, 2022-9-26 11:09

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表