EasyHook 中部分函数的实现分析—-注入
写这篇文章之前发现了一篇文章,“easyhook库代码简要分析http://gslab.qq.com/article-245-1.html”这篇文章对EasyHook 整体的流程和使用有比较清晰的介绍,下面我主要是具体分析其中的一部分函数。最好在对EasyHook 有一定的了解之后再阅读本文,可以先阅读上链接的文章。
EasyHook 中的注入方法。
函数原型
// EasyHook 中的命名比较有意思,Rh 代表的就是Remote Hook,此函数就是远程钩子的一个子过程----注入,前面的宏代表它是导出函数。
EASYHOOK_NT_EXPORT RhInjectLibrary(
ULONG InTargetPID,
ULONG InWakeUpTID,//如果当前函数是通过RhCreateAndInject 调用过来的,这个指示主线程的ID。
//之后可以通过RhWakeUpProcess 唤醒进程。否则传0.
ULONG InInjectionOptions,
WCHAR* InLibraryPath_x86,
WCHAR* InLibraryPath_x64,
PVOID InPassThruBuffer,
ULONG InPassThruSize)
详细介绍
函数前面的部分就是一些参数检查以及针对X86 和 X64 的不同而准备的变量的不同初始化。之后检查是否进行跨WOW64 注入,是的话报错并退出。另外,代码需要使用PROCESS_ALL_ACCESS 权限调用OpenProcess 。经过上面的检查之后后面才是真正的的注入过程。要了解注入的过程就必须需要了解REMOTE_INFO 结构体以及其与注入代码在目标进程地址空间的位置关系。
- REMOTE_INFO 结构
#define WRAP_ULONG64(Decl)\
union\
{\
ULONG64 UNUSED;\
Decl;\
}\
typedef struct _REMOTE_INFO_
{
// will be the same for all processes
WRAP_ULONG64(wchar_t* UserLibrary); // fixed 0
WRAP_ULONG64(wchar_t* EasyHookPath); // fixed 8
WRAP_ULONG64(wchar_t* PATH); // fixed 16
WRAP_ULONG64(char* EasyHookEntry); // fixed 24
WRAP_ULONG64(void* RemoteEntryPoint); // fixed 32
WRAP_ULONG64(void* LoadLibraryW); // fixed; 40
WRAP_ULONG64(void* FreeLibrary); // fixed; 48
WRAP_ULONG64(void* GetProcAddress); // fixed; 56
WRAP_ULONG64(void* VirtualFree); // fixed; 64
WRAP_ULONG64(void* VirtualProtect); // fixed; 72
WRAP_ULONG64(void* ExitThread); // fixed; 80
WRAP_ULONG64(void* GetLastError); // fixed; 88
BOOL IsManaged; // 指示是否为托管代码
HANDLE hRemoteSignal; // 用于指示是否注入成功
DWORD HostProcess;
DWORD Size;
BYTE* UserData; // 自定义参数
DWORD UserDataSize; // 自定义参数的大小
ULONG WakeUpThreadID;
}REMOTE_INFO, *LPREMOTE_INFO;
该结构体中前面的值为函数指针,按照8 字节对齐。另外,这些函数指针都是通过GetRemoveFuncAddress 函数得到的。在填充完远程函数地址之后,代码通过GetInjectionSize 函数根据汇编代码中尾部的特征码判断汇编代码的大小,之后一次性在目标进程中申请“代码大小 + REMOTE_INFO 结构大小 + 字符串 ‘HookCompleteInjection’- X86或者’_HookCompleteInjection’-X64 长度+1 + 当前工作目录长度 + 当前模块位置长度 + 目标DLL 路径长度”。
- 目标进程的内存使用详情
我们可以看到,这段注入代码的原型及实现符合线程函数的规范,而且其参数就是REMOGE_INFO 结构的指针。在目标进程中申请内存并写入数据(包含代码)之后,我们应该想办法执行我们的代码,或者称为远程线程函数,这里有两种方式:
使用远程线程函数的方式注入
参考我之前介绍远程线程注入的文章http://blog.csdn.net/qq_18218335/article/details/75246816使用线程劫持的方法注入
X64
http://blog.csdn.net/qq_18218335/article/details/75308957
Win32–http://blog.csdn.net/qq_18218335/article/details/75268251
这里我们介绍的方法的思想与之前是相同的,不过EasyHook 中使用的方法更加的稳定,考虑的更加周到。
EasyHook 中线程劫持的实现
- 函数原型
EASYHOOK_NT_EXPORT RhCreateStealthRemoteThread(
ULONG InTargetPID,
LPTHREAD_START_ROUTINE InRemoteRoutine,
PVOID InRemoteParam,
HANDLE* OutRemoteThread)
- 使用到的数据结构
typedef struct _STEALTH_CONTEXT_
{
union
{
struct
{
/*00*/ WRAP_ULONG64(PVOID CreateThread);
/*08*/ WRAP_ULONG64(PVOID RemoteThreadStart);
/*16*/ WRAP_ULONG64(PVOID RemoteThreadParam);
/*24*/ WRAP_ULONG64(PVOID WaitForSingleObject);
/*32*/ WRAP_ULONG64(HANDLE hCompletionEvent);
/*40*/ WRAP_ULONG64(PVOID CloseHandle);
/*48*/ union
{
WRAP_ULONG64(HANDLE hRemoteThread);
WRAP_ULONG64(HANDLE hSyncEvent);
};
/*56*/ WRAP_ULONG64(PVOID SetEvent);
};
ULONGLONG __Unused__[8];
};
ULONGLONG Rax;
ULONGLONG Rcx;
ULONGLONG Rdx;
ULONGLONG Rbp;
ULONGLONG Rsp;
ULONGLONG Rsi;
ULONGLONG Rdi;
ULONGLONG Rbx;
ULONGLONG Rip;
ULONGLONG RFlags;
ULONGLONG R8;
ULONGLONG R9;
ULONGLONG R10;
ULONGLONG R11;
ULONGLONG R12;
ULONGLONG R13;
ULONGLONG R14;
ULONGLONG R15;
}STEALTH_CONTEXT, *PSTEALTH_CONTEXT;
劫持线程通用的做法,找到目标进程的一个活动的子线程,然后视图暂停其执行,成功后通过GetThreadContext 得到其ThreadContext,然后在目标进程中申请并写入代码,设置RIP或者EIP,然后恢复线程执行。EasyHook 的不同在于以下几点:
<1> 在恢复线程执行之前就保存了ThreadContext 中的寄存器的值,而不是在恢复了线程执行之后在通过代码将寄存器的值保存在栈中,这样做的好处就是靠谱、稳定。在介绍自己实现的线程劫持的实现的时候,我发现,在线程暂停后得到的ThreadContext 的值和之后恢复线程执行后执行第一个指令之前,部分寄存器的值会发生改变,虽然后来的运行结果正确,目标进程也没有发生崩溃的情况,但是我们应该按照EasyHook 的方式来进行ThreadContext 的保存与恢复。
<2> 劫持后执行的代码为创建新线程,在新线程中完成我们的任务,EasyHook 中的注入代码称为StealthRemoteThread 原因就在这里,我们通过目标进程已存在的线程创建新线程以执行注入的过程,以达到隐藏注入行为的目的。
<3> 在主线程中等待注入的完成,并判断注入是否成功,这是我当时没有注意到的一点。
- ebx/rbx 是 STEALTH_CONTEXT 结构体指针
- StealthStub_ASM_x86
public StealthStub_ASM_x86@0
StealthStub_ASM_x86@0 PROC
; Create thread...
push 0
push 0
push dword ptr [ebx + 16] ; save stealth context
push dword ptr [ebx + 8] ; RemoteThreadStart
push 0
push 0
call dword ptr [ebx + 0] ; CreateThread(0, NULL, RemoteThreadStart, RemoteThreadParam, 0, NULL);
; signal thread creation...
push dword ptr [ebx + 48]
mov dword ptr [ebx + 48], eax
call dword ptr [ebx + 56] ; SetEvent(hSyncEvent);
; wait for completion
push -1
push dword ptr [ebx + 32]
call dword ptr [ebx + 24] ; WaitForSingleObject(hCompletionEvent, INFINITE)
; close handle
push dword ptr [ebx + 32]
call dword ptr [ebx + 40] ; CloseHandle(hCompletionEvent);
; close handle
push dword ptr [ebx + 48]
call dword ptr [ebx + 40] ; CloseHandle(hSyncEvent);
; restore context
mov eax, [ebx + 64 + 8 * 0]
mov ecx, [ebx + 64 + 8 * 1]
mov edx, [ebx + 64 + 8 * 2]
mov ebp, [ebx + 64 + 8 * 3]
mov esp, [ebx + 64 + 8 * 4]
mov esi, [ebx + 64 + 8 * 5]
mov edi, [ebx + 64 + 8 * 6]
push dword ptr[ebx + 64 + 8 * 9] ; push EFlags
push dword ptr[ebx + 64 + 8 * 8] ; save old EIP
mov ebx, [ebx + 64 + 8 * 7]
add esp, 4
popfd
; continue execution...
jmp dword ptr [esp - 8]
; outro signature, to automatically determine code size
db 78h
db 56h
db 34h
db 12h
StealthStub_ASM_x86@0 ENDP
注释打的已经很清楚了,首先创建注入的线程,即之前介绍的远程注入线程,参数还是原来的参数。然后将线程句柄保存在结构体中,触发事件,之后等待主线程得到新创建线程的句柄之后关闭两个事件。返回原EIP 之前,恢复各类寄存器,之后直接跳转到原EIP 处继续运行。
- Injection_ASM_x86
public Injection_ASM_x86@0
Injection_ASM_x86@0 PROC
; no registers to save, because this is the thread main function
; save first param (address of hook injection information)
mov esi, dword ptr [esp + 4]
; call LoadLibraryW(Inject->EasyHookPath);
push dword ptr [esi + 8]
call dword ptr [esi + 40] ; LoadLibraryW@4
mov ebp, eax
test eax, eax
je HookInject_FAILURE_A
; call GetProcAddress(eax, Inject->EasyHookEntry);
push dword ptr [esi + 24]
push ebp
call dword ptr [esi + 56] ; GetProcAddress@8
test eax, eax
je HookInject_FAILURE_B
; call EasyHookEntry(Inject);
push esi
call eax
push eax ; save error code
; call FreeLibrary(ebp)
push ebp
call dword ptr [esi + 48] ; FreeLibrary@4
test eax, eax
je HookInject_FAILURE_C
jmp HookInject_EXIT
HookInject_FAILURE_A:
call dword ptr [esi + 88] ; GetLastError
or eax, 40000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_B:
call dword ptr [esi + 88] ; GetLastError
or eax, 10000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_C:
call dword ptr [esi + 88] ; GetLastError
or eax, 30000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_E:
push eax ; save error value
HookInject_EXIT:
push 0
push 0
push 0; // shadow space for executable stack part...
; call VirtualProtect(Outro, 4, PAGE_EXECUTE_READWRITE, &OldProtect)
lea ebx, dword ptr [esp + 8] ; we'll write to shadow space
push ebx
push 40h
push 12
push ebx
call dword ptr [esi + 72] ; VirtualProtect@16
test eax, eax
jne HookInject_EXECUTABLE
; failed to make stack executable
call dword ptr [esi + 88] ; GetLastError
or eax, 20000000h
add esp, 16
ret
HookInject_EXECUTABLE:
; save outro to executable stack
mov dword ptr [esp], 0448BD3FFh ; call ebx [VirtualFree()]
mov dword ptr [esp + 4], 05C8B0C24h ; mov eax, [esp + 12]
mov dword ptr [esp + 8], 0E3FF1024h ; mov ebx, [esp + 16]
; jmp ebx [exit thread]
; save params for VirtualFree(Inject->RemoteEntryPoint, 0, MEM_RELEASE);
mov ebx, [esi + 64] ; VirtualFree()
push 08000h
push 0
push dword ptr [esi + 16]
lea eax, dword ptr [esp + 12]
jmp eax
; outro signature, to automatically determine code size
db 78h
db 56h
db 34h
db 12h
Injection_ASM_x86@0 ENDP
远程线程首先调用LoadLibraryW 函数加载目标DLL,然后调用GetProcAddress函数得到规定必须实现的DLL 的导出函数,得到后调用该函数,并传入用户指定的参数及参数长度。调用完成后,函数调用FreeLibrary 函数释放目标DLL。之后的动作比较厉害了,开辟三个字节的栈区,修改该栈区的保护属性为可读写执行,然后拷贝指令,并执行,该指令功能为:释放注入所需要的内存,然后退出线程。这个代码写的就非常完善了,运行完了就将所申请的内存自己释放了。而且释放内存的代码在栈区,又不用担心在释放内存后执行执行会造成非法访问。棒!!!
X64 注入的代码及注释
public StealthStub_ASM_x64
int 3
StealthStub_ASM_x64 PROC
sub rsp, 8 * 4
mov qword ptr[rsp + 40], 0
mov qword ptr[rsp + 32], 0
mov r9, qword ptr [rbx + 16] ; RemoteThreadParam
mov r8, qword ptr [rbx + 8] ; RemoteThreadStart
mov rdx, 0
mov rcx, 0
call qword ptr[rbx] ; CreateThread
cmp rax, 0
; signal completion
mov rcx, qword ptr [rbx + 48]
mov qword ptr [rbx + 48], rax
call qword ptr [rbx + 56] ; SetEvent(hSyncEvent);
; wait for completion
mov rdx, -1
mov rcx, qword ptr [ebx + 32]
call qword ptr [ebx + 24] ; WaitForSingleObject(hCompletionEvent, INFINITE)
; close handle
mov rcx, qword ptr [rbx + 32]
call qword ptr [rbx + 40] ; CloseHandle(hCompletionEvent);
; close handle
mov rcx, qword ptr [rbx + 48]
call qword ptr [rbx + 40] ; CloseHandle(hSyncEvent);
; restore context
mov rax, [rbx + 64 + 8 * 0]
mov rcx, [rbx + 64 + 8 * 1]
mov rdx, [rbx + 64 + 8 * 2]
mov rbp, [rbx + 64 + 8 * 3]
mov rsp, [rbx + 64 + 8 * 4]
mov rsi, [rbx + 64 + 8 * 5]
mov rdi, [rbx + 64 + 8 * 6]
mov r8, [rbx + 64 + 8 * 10]
mov r9, [rbx + 64 + 8 * 11]
mov r10, [rbx + 64 + 8 * 12]
mov r11, [rbx + 64 + 8 * 13]
mov r12, [rbx + 64 + 8 * 14]
mov r13, [rbx + 64 + 8 * 15]
mov r14, [rbx + 64 + 8 * 16]
mov r15, [rbx + 64 + 8 * 17]
push qword ptr[rbx + 64 + 8 * 9] ; push EFlags
push qword ptr[rbx + 64 + 8 * 8] ; save old EIP
mov rbx, [rbx + 64 + 8 * 7]
add rsp, 8
popfq
; continue execution...
jmp qword ptr [rsp - 16]
; outro signature, to automatically determine code size
db 78h
db 56h
db 34h
db 12h
StealthStub_ASM_x64 ENDP
public Injection_ASM_x64
Injection_ASM_x64 PROC
; no registers to save, because this is the thread main function
mov r14, rcx ; r14 当前存储的为LPREMOTE_INFO
sub rsp, 40 ; space for register parameter stack, should be 32 bytes... no idea why it only works with 40
; call LoadLibraryW(Inject->EasyHookPath);
mov rcx, qword ptr [r14 + 8]
call qword ptr [r14 + 40] ; LoadLibraryW
mov r13, rax
test rax, rax
je HookInject_FAILURE_A
; call GetProcAddress(hModule, Inject->EntryPoint)
mov rdx, qword ptr [r14 + 24]
mov rcx, rax
call qword ptr [r14 + 56] ; GetProcAddress
test rax, rax
je HookInject_FAILURE_B
; call EasyHookEntry(Inject);
mov rcx, r14
call rax
mov r15, rax ; save error code to non-volatile register
; call FreeLibrary(hEasyHookLib)
mov rcx, r13
call qword ptr [r14 + 48] ; FreeLibrary
test rax, rax
je HookInject_FAILURE_C
jmp HookInject_EXIT
HookInject_FAILURE_A:
call qword ptr [r14 + 88] ; GetLastError
or rax, 40000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_B:
call qword ptr [r14 + 88] ; GetLastError
or rax, 10000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_C:
call qword ptr [r14 + 88] ; GetLastError
or rax, 30000000h
jmp HookInject_FAILURE_E
HookInject_FAILURE_E:
mov r15, rax ; save error value
HookInject_EXIT:
; call VirtualProtect(Outro, 8, PAGE_EXECUTE_READWRITE, &OldProtect)
; 这里的Outro 也就是 &OldProtect,即此线程函数开始时申请的一个局部变量
lea rbx, qword ptr [rsp + 8] ; writes into register parameter stack
mov r9, rbx
mov r8, 40h
mov rdx, 8
mov rcx, rbx
call qword ptr [r14 + 72] ; VirtualProtect
test rax, rax
jne HookInject_EXECUTABLE
; failed to make stack executable
call qword ptr [r14 + 88] ; GetLastError
or rax, 01000000h
mov rcx, rax
call qword ptr [r14 + 80] ; ExitThread
HookInject_EXECUTABLE:
; save outro to executable stack
mov rbx, [r14 + 64] ; VirtualFree()
mov rbp, [r14 + 80] ; ExitThread()
mov rax, 000D5FFCF8B49D3FFh
; 类似于shellcode,后面会跳转到&OldProtect 处执行这三个指令
; r15 为 EsayHookEntry 的返回值代码
; call rbx
; mov rcx, r15
; call rbp
mov qword ptr [rsp + 8], rax
; save params for VirtualFree(Inject->RemoteEntryPoint, 0, MEM_RELEASE);
; 这里直接把RemoteEntryPoint 参数删除了.....
mov r8, 8000h
mov rdx, 0h
mov rcx, qword ptr [r14 + 32]
lea rax, qword ptr [rsp + 8]
sub rsp, 48
jmp rax
; outro signature, to automatically determine code size
db 78h
db 56h
db 34h
db 12h
Injection_ASM_x64 ENDP