驅動開發：核心層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: [email protected]
#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