驅動開發：內核層InlineHook掛鉤函數

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

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

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

// 署名權
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com
#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.com \n");

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

	// 設置需要保護進程EProcess
	/*
	lyshark.com: 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進程時，則會提示拒絕訪問。

參考文獻

https://www.docin.com/p-1508418694.html