《逆向工程核心原理》--注入学习

Windows消息钩取

一、钩子和消息钩子

钩子，英文Hook，泛指偷看或截取信息时所用的手段或工具。

Windows操作系统向用户提供GUI，它是以事件驱动（Event Driven）方式工作。事件发生后，OS将事先定义好的消息发送给相应的应用程序，应用程序分析收到的消息后执行相应动作。以敲击键盘为例，

常规Windows消息流：

1. 发生键盘输入事件，WM_KEYDOWN消息被添加到OS消息队列；
2. OS判断哪个应用程序发生了事件，从OS消息队列中取出消息，添加到相应应用程序的app消息队列；
3. 应用程序监视自身的消息队列，发现新添加的WM_KEYDOWN消息，调用相应的事件处理程序进行处理。

附带钩子的信息流：

1. 发生键盘输入事件，WM_KEYDOWN消息被添加到OS消息队列；
2. OS判断哪个应用程序发生了事件，从OS消息队列中取出消息，发送给应用程序；
3. 钩子程序截取信息，对消息采取一定的动作（因钩子目的而定）；
4. 如钩子程序不拦截消息，消息最终传输给应用程序，此时的消息可能经过了钩子程序的修改。

 

DLL注入

DLL注入：向运行中的其他进程强制插入特定的DLL文件，主要是命令其他进程自行调用LoadLibrary() API，加载用户指定的DLL文件。

DLL注入与一般DLL加载的主要区别是加载的目标进程是其自身或其他进程。

DLL

DLL（Dynamic Linked Library，动态链接库），DLL被加载到进程后会自动运行DllMain函数，用户可以把想要执行的额代码放到DllMain函数，每当加载DLL时，添加的代码就会自动得到执行。利用该特性可以修复程序BUG，或向程序添加新功能

// CodeInject.cpp : 定义控制台应用程序的入口点。
//
 
//#include "stdafx.h"
#include "windows.h"
#include "stdio.h"
#include <iostream>
#include <cstring> 
#include "string.h" 
using namespace std; 
//该结构体用于接收API和4个字符串
typedef struct _THREAD_PARAM {
    FARPROC pFunc[2];
    char szBuf[4][128];
} THREAD_PARAM, *PTHREAD_PARAM;
 
typedef HMODULE (WINAPI *PFLOADLIBRARYA)
(
    LPCSTR lpLibFileName
);
 
typedef FARPROC (WINAPI *PFGETPROCADDRESS)
(
    HMODULE hModule,
    LPCSTR lpProcName
);
 
typedef int (WINAPI *PFMESSAGEBOXA)
(
    HWND hWnd,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType
);
 
DWORD WINAPI ThreadProc(LPVOID lParam){
    PTHREAD_PARAM pParam = (PTHREAD_PARAM)lParam;
    HMODULE hMod = NULL;
    FARPROC pFunc = NULL;
 
    //未直接调用相关API和未直接定义使用字符串，而通过THREAD_PARAM结构体以线程参数的形式传递使用
    // LoadLibrary()
    hMod = ((PFLOADLIBRARYA)pParam->pFunc[0])(pParam->szBuf[0]);    // "user32.dll"
    if( !hMod ){
        return 1;
    }
        
 
    // GetProcAddress()
    pFunc = (FARPROC)((PFGETPROCADDRESS)pParam->pFunc[1])(hMod, pParam->szBuf[1]);  // "MessageBoxA"
    if( !pFunc ){
        return 1;
    }
 
    // MessageBoxA()
    ((PFMESSAGEBOXA)pFunc)(NULL, pParam->szBuf[2], pParam->szBuf[3], MB_OK);
 
    return 0;
}
 
BOOL InjectCode(DWORD dwPID){
    HMODULE hMod = NULL;
    THREAD_PARAM param = {0,};
    HANDLE hProcess = NULL;
    HANDLE hThread = NULL;
    LPVOID pRemoteBuf[2] = {0,};
    DWORD dwSize = 0;
 
    hMod = GetModuleHandleA("kernel32.dll");
 
    //设置THREAD_PARAM结构体
    //加载到所有进程的kernel32.dll的地址都相同，因此从本进程获取的API与在notepad进程中获取的API地址是一样的
    param.pFunc[0] = GetProcAddress(hMod, "LoadLibraryA");
    param.pFunc[1] = GetProcAddress(hMod, "GetProcAddress");
    strcpy(param.szBuf[0], "user32.dll");
    strcpy(param.szBuf[1], "MessageBoxA");
    strcpy(param.szBuf[2], "代码注入 By SKI12");
    strcpy(param.szBuf[3], "blog.csdn.net/ski_12");
 
    // Open Process
    if ( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS,   // dwDesiredAccess
                                  FALSE,                // bInheritHandle
                                  dwPID)) )             // dwProcessId
    {
        printf("OpenProcess() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
 
    // Allocation for THREAD_PARAM
    //注入数据部分到进程
    dwSize = sizeof(THREAD_PARAM);
    if( !(pRemoteBuf[0] = VirtualAllocEx(hProcess,          // hProcess
                                      NULL,                 // lpAddress
                                      dwSize,               // dwSize
                                      MEM_COMMIT,           // flAllocationType
                                      PAGE_READWRITE)) )    // flProtect
    {
        printf("VirtualAllocEx() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
    //param参数值为数据
    if( !WriteProcessMemory(hProcess,                       // hProcess
                            pRemoteBuf[0],                  // lpBaseAddress
                            (LPVOID)&param,                 // lpBuffer
                            dwSize,                         // nSize
                            NULL) )                         // [out] lpNumberOfBytesWritten
    {
        printf("WriteProcessMemory() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
 
    // Allocation for ThreadProc()
    //注入代码部分到进程
    dwSize = (DWORD)InjectCode - (DWORD)ThreadProc;
    if( !(pRemoteBuf[1] = VirtualAllocEx(hProcess,          // hProcess
                                      NULL,                 // lpAddress
                                      dwSize,               // dwSize
                                      MEM_COMMIT,           // flAllocationType
                                      PAGE_EXECUTE_READWRITE)) )    // flProtect
    {
        printf("VirtualAllocEx() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
    //ThreadProc()函数为操作代码
    if( !WriteProcessMemory(hProcess,                       // hProcess
                            pRemoteBuf[1],                  // lpBaseAddress
                            (LPVOID)ThreadProc,             // lpBuffer
                            dwSize,                         // nSize
                            NULL) )                         // [out] lpNumberOfBytesWritten
    {
        printf("WriteProcessMemory() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
 
    //将数据与代码注入到进程内存后，调用CreateRemoteThread()执行远程线程
    if( !(hThread = CreateRemoteThread(hProcess,            // hProcess
                                       NULL,                // lpThreadAttributes
                                       0,                   // dwStackSize
                                       (LPTHREAD_START_ROUTINE)pRemoteBuf[1],     // dwStackSize
                                       pRemoteBuf[0],       // lpParameter
                                       0,                   // dwCreationFlags
                                       NULL)) )             // lpThreadId
    {
        printf("CreateRemoteThread() fail : err_code = %d
", GetLastError());
        return FALSE;
    }
 
    WaitForSingleObject(hThread, INFINITE);    
 
    CloseHandle(hThread);
    CloseHandle(hProcess);
 
    return TRUE;
}
 
BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege) {
    TOKEN_PRIVILEGES tp;
    HANDLE hToken;
    LUID luid;
 
    if( !OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken) ){
        printf("OpenProcessToken error: %u
", GetLastError());
        return FALSE;
    }
 
    if( !LookupPrivilegeValue(NULL,           // lookup privilege on local system
                              lpszPrivilege,  // privilege to lookup 
                              &luid) )        // receives LUID of privilege
    {
        printf("LookupPrivilegeValue error: %u
", GetLastError() ); 
        return FALSE; 
    }
 
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    if( bEnablePrivilege )
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    else
        tp.Privileges[0].Attributes = 0;
 
    // Enable the privilege or disable all privileges.
    if( !AdjustTokenPrivileges(hToken, 
                               FALSE, 
                               &tp, 
                               sizeof(TOKEN_PRIVILEGES), 
                               (PTOKEN_PRIVILEGES) NULL, 
                               (PDWORD) NULL) )
    { 
        printf("AdjustTokenPrivileges error: %u
", GetLastError() ); 
        return FALSE; 
    } 
 
    if( GetLastError() == ERROR_NOT_ALL_ASSIGNED ){
        printf("The token does not have the specified privilege. 
");
        return FALSE;
    } 
 
    return TRUE;
}
 
int main(int argc, char* argv[]){
    DWORD dwPID = 0;
    if( argc != 2 ){
        printf("
 USAGE  : %s <pid>
", argv[0]);
        return 1;
    }
 
    // change privilege
    if( !SetPrivilege(SE_DEBUG_NAME, TRUE) ){
        return 1;
    }
 
    // code injection
    //将字符串转换为长整型
    dwPID = (DWORD)atol(argv[1]);
    InjectCode(dwPID);
 
    return 0;
}
 

待续。。。