5.9 Windows驅動開發：內核InlineHook掛鉤技術

在上一章《內核LDE64引擎計算彙編長度》中，LyShark教大家如何通過LDE64引擎實現計算反彙編指令長度，本章將在此基礎之上實現內聯函數掛鉤，內核中的InlineHook函數掛鉤其實與應用層一致，都是使用劫持執行流並跳轉到我們自己的函數上來做處理，唯一的不同的是內核Hook只針對內核API函數，但由於其身處在最底層所以一旦被掛鉤其整個應用層都將會受到影響，這就直接決定了在內核層掛鉤的效果是應用層無法比擬的，對於安全從業者來說學會使用內核掛鉤也是很重要。

內核掛鉤的原理是一種劫持系統函數調用的技術，用於在運行時對系統函數進行修改或者監控。其基本思想是先獲取要被劫持的函數的地址，然後將該函數的前15個字節的指令保存下來，接着將自己的代理函數地址寫入到原始函數上，這樣當API被調用時，就會默認轉向到自己的代理函數上執行，從而實現函數的劫持。

掛鉤的具體步驟如下：

• 1.使用MmGetSystemRoutineAddress函數獲取要被劫持的函數地址。
• 2.使用自己的代理函數取代原始函數，代理函數和原始函數具有相同的參數和返回值類型，並且在代理函數中調用原始函數。
• 3.保存原始函數的前15個字節的指令，因爲這些指令通常被認爲是函數的前導碼或是修飾碼。
• 4.在原始函數的前15個字節位置寫入jmp MyPsLookupProcessByProcessId的指令，使得API調用會跳轉到我們的代理函數。
• 5.當代理函數被調用時，執行我們自己的邏輯，然後在適當的時候再調用原始函數，最後將其返回值返回給調用者。
• 6.如果需要恢復原始函數的調用，將保存的前15個字節的指令寫回原始函數即可。

掛鉤的原理可以總結爲，通過MmGetSystemRoutineAddress得到原函數地址，然後保存該函數的前15個字節的指令，將自己的MyPsLookupProcessByProcessId代理函數地址寫出到原始函數上，此時如果有API被調用則默認會轉向到我們自己的函數上面執行，恢復原理則是將提前保存好的前15個原始字節寫回則恢復原函數的調用。

而如果需要恢復掛鉤狀態，則只需要還原提前保存的機器碼即可，恢復內核掛鉤的原理是將先前保存的原始函數前15個字節的指令寫回到原始函數地址上，從而還原原始函數的調用。具體步驟如下：

• 1.獲取原函數地址，可以通過MmGetSystemRoutineAddress函數獲取。
• 2.將保存的原始函數前15個字節的指令寫回到原始函數地址上，可以使用memcpy等函數實現。
• 3.將代理函數的地址清除，可以將地址設置爲NULL。

原理很簡單，基本上InlineHook類的代碼都是一個樣子，如下是一段完整的掛鉤PsLookupProcessByProcessId的驅動程序，當程序被加載時則默認會保護lyshark.exe進程，使其無法被用戶使用任務管理器結束掉。

#include "lyshark_lde64.h"
#include <ntifs.h>
#include <windef.h>
#include <intrin.h>

#pragma  intrinsic(_disable)
#pragma  intrinsic(_enable)

// --------------------------------------------------------------
// 彙編計算方法
// --------------------------------------------------------------
// 計算地址處指令有多少字節
// address = 地址
// bits 32位驅動傳入0 64傳入64
typedef INT(*LDE_DISASM)(PVOID address, INT bits);

LDE_DISASM lde_disasm;

// 初始化引擎
VOID lde_init()
{
    lde_disasm = ExAllocatePool(NonPagedPool, 12800);
    memcpy(lde_disasm, szShellCode, 12800);
}

// 得到完整指令長度,避免截斷
ULONG GetFullPatchSize(PUCHAR Address)
{
    ULONG LenCount = 0, Len = 0;

    // 至少需要14字節
    while (LenCount <= 14)
    {
        Len = lde_disasm(Address, 64);
        Address = Address + Len;
        LenCount = LenCount + Len;
    }
    return LenCount;
}

// --------------------------------------------------------------
// Hook函數封裝
// --------------------------------------------------------------

// 定義指針方便調用
typedef NTSTATUS(__fastcall *PSLOOKUPPROCESSBYPROCESSID)(HANDLE ProcessId, PEPROCESS *Process);

ULONG64 protect_eprocess = 0;           // 需要保護進程的eprocess
ULONG patch_size = 0;                   // 被修改了幾個字節
PUCHAR head_n_byte = NULL;              // 前幾個字節數組
PVOID original_address = NULL;          // 原函數地址

KIRQL WPOFFx64()
{
    KIRQL irql = KeRaiseIrqlToDpcLevel();
    UINT64 cr0 = __readcr0();
    cr0 &= 0xfffffffffffeffff;
    __writecr0(cr0);
    _disable();
    return irql;
}

VOID WPONx64(KIRQL irql)
{
    UINT64 cr0 = __readcr0();
    cr0 |= 0x10000;
    _enable();
    __writecr0(cr0);
    KeLowerIrql(irql);
}

// 動態獲取內存地址
PVOID GetProcessAddress(PCWSTR FunctionName)
{
    UNICODE_STRING UniCodeFunctionName;
    RtlInitUnicodeString(&UniCodeFunctionName, FunctionName);
    return MmGetSystemRoutineAddress(&UniCodeFunctionName);
}

/*
    InlineHookAPI 掛鉤地址

    參數1：待HOOK函數地址
    參數2：代理函數地址
    參數3：接收原始函數地址的指針
    參數4：接收補丁長度的指針
    返回：原來頭N字節的數據
*/
PVOID KernelHook(IN PVOID ApiAddress, IN PVOID Proxy_ApiAddress, OUT PVOID *Original_ApiAddress, OUT ULONG *PatchSize)
{
    KIRQL irql;
    UINT64 tmpv;
    PVOID head_n_byte, ori_func;

    // 保存跳轉指令 JMP QWORD PTR [本條指令結束後的地址]
    UCHAR jmp_code[] = "\xFF\x25\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF";

    // 保存原始指令
    UCHAR jmp_code_orifunc[] = "\xFF\x25\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF";

    // 獲取函數地址處指令長度
    *PatchSize = GetFullPatchSize((PUCHAR)ApiAddress);
    
    // 分配空間
    head_n_byte = ExAllocatePoolWithTag(NonPagedPool, *PatchSize, "LyShark");

    irql = WPOFFx64();

    // 跳轉地址拷貝到原函數上
    RtlCopyMemory(head_n_byte, ApiAddress, *PatchSize);
    WPONx64(irql);

    // 構建跳轉

    // 1.原始機器碼+跳轉機器碼
    ori_func = ExAllocatePoolWithTag(NonPagedPool, *PatchSize + 14, "LyShark");
    RtlFillMemory(ori_func, *PatchSize + 14, 0x90);

    // 2.跳轉到沒被打補丁的那個字節
    tmpv = (ULONG64)ApiAddress + *PatchSize;
    RtlCopyMemory(jmp_code_orifunc + 6, &tmpv, 8);
    RtlCopyMemory((PUCHAR)ori_func, head_n_byte, *PatchSize);
    RtlCopyMemory((PUCHAR)ori_func + *PatchSize, jmp_code_orifunc, 14);
    *Original_ApiAddress = ori_func;
    
    // 3.得到代理地址
    tmpv = (UINT64)Proxy_ApiAddress;
    RtlCopyMemory(jmp_code + 6, &tmpv, 8);

    //4.打補丁
    irql = WPOFFx64();
    RtlFillMemory(ApiAddress, *PatchSize, 0x90);
    RtlCopyMemory(ApiAddress, jmp_code, 14);
    WPONx64(irql);

    return head_n_byte;
}

/*
    InlineHookAPI 恢復掛鉤地址

    參數1：被HOOK函數地址
    參數2：原始數據
    參數3：補丁長度
*/
VOID KernelUnHook(IN PVOID ApiAddress, IN PVOID OriCode, IN ULONG PatchSize)
{
    KIRQL irql;
    irql = WPOFFx64();
    RtlCopyMemory(ApiAddress, OriCode, PatchSize);
    WPONx64(irql);
}

// 實現我們自己的代理函數
NTSTATUS MyPsLookupProcessByProcessId(HANDLE ProcessId, PEPROCESS *Process)
{
    NTSTATUS st;
    st = ((PSLOOKUPPROCESSBYPROCESSID)original_address)(ProcessId, Process);
    if (NT_SUCCESS(st))
    {
        // 判斷是否是需要保護的進程
        if (*Process == (PEPROCESS)protect_eprocess)
        {
            *Process = 0;
            DbgPrint("[lyshark] 攔截結束進程 \n");
            st = STATUS_ACCESS_DENIED;
        }
    }
    return st;
}

VOID UnDriver(PDRIVER_OBJECT driver)
{
    DbgPrint("驅動已卸載 \n");

    // 恢復Hook
    KernelUnHook(GetProcessAddress(L"PsLookupProcessByProcessId"), head_n_byte, patch_size);
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
{
    DbgPrint("hello lyshark \n");

    // 初始化反彙編引擎
    lde_init();

    // 設置需要保護進程EProcess
    /*
    lyshark: kd> !process 0 0 lyshark.exe
        PROCESS ffff9a0a44ec4080
            SessionId: 1  Cid: 05b8    Peb: 0034d000  ParentCid: 13f0
            DirBase: 12a7d2002  ObjectTable: ffffd60bc036f080  HandleCount: 159.
            Image: lyshark.exe
    */
    protect_eprocess = 0xffff9a0a44ec4080;

    // Hook掛鉤函數
    head_n_byte = KernelHook(GetProcessAddress(L"PsLookupProcessByProcessId"), (PVOID)MyPsLookupProcessByProcessId, &original_address, &patch_size);

    DbgPrint("[lyshark] 掛鉤保護完成 --> 修改字節: %d | 原函數地址: 0x%p \n", patch_size, original_address);

    for (size_t i = 0; i < patch_size; i++)
    {
        DbgPrint("[byte] = %x", head_n_byte[i]);
    }

    Driver->DriverUnload = UnDriver;
    return STATUS_SUCCESS;
}

運行這段驅動程序，會輸出掛鉤保護的具體地址信息；

使用WinDBG觀察，會發現掛鉤後原函數已經被替換掉了，而被替換的地址就是我們自己的MyPsLookupProcessByProcessId函數。

當你嘗試使用任務管理器結束掉lyshark.exe進程時，則會提示拒絕訪問。