Logo

菜单

Hook-两种Inline Hook

selph
selph
发布于 2020-10-18 / 1341 阅读
0
0

Hook-两种Inline Hook

#Hook技术

前言

这个章节学习的主要内容是Inline Hook，在我正准备照着书敲代码的时候，我突然意识到了一个问题，这里的代码不是完整的，只是关键部分，作者也不是要读者照着源代码敲一遍，核心在于理解其中的技术原理，这里作者实现的功能是进程隐藏，这个功能我们再后面学习下一本书的时候再去实现，这里的重点是学习和实践两种Inline Hook：5字节和7字节

原理介绍：5字节的Inline Hook

Inline Hook 是 API Hook 的一种，目的是改变函数的执行结果，32位程序下，根据两种场景，分为5字节和7字节的Inline Hook，准确的来说，不一定是5字节或者7字节这么准确，前者指的是修改API前面的几个字节来进行跳转，然后再改回来进行执行，后者指的是，利用API前面的空间（Windows API很多都自带7字节的无用空间）一次修改，不再需要反复Hook和UnHook了

通常情况下，5字节的Inline Hook都适用：

  1. 通过修改目标API开头的5个字节为JMP XXXXXXXX，跳转到我们自己的函数上
  2. 跳转过去之后，再把API开头5字节改回来（UnHook）
  3. 然后调用这个API（这个时候栈帧还是原来的样子）
  4. API执行完毕后，返回到我们自己的函数上
  5. 根据需求修改API执行的结果
  6. 然后再进行Hook（将开头5字节改回来）
  7. 最后返回到最初函数调用的地方，等待下次调用

因为我们的函数需要在目标进程的内存空间中，所以用DLL注入的方式最方便

书上的例子是进程隐藏，但这里我们的主要目的是实践Inline Hook，所以选择一个简单的功能来实现

之前做过一次通过调试API在目标API调用的时候中断，修改栈中的参数来实现改变API的执行结果；那这次就通过Inline Hook来实现这个功能吧

没错，还是找notepad.exe下手哈哈哈

突然想到，010 editor 的验证过程中，只要能控制3个验证函数的返回值，那么就可以直接验证通过，挖个坑，下次单独拿出来实践写一篇笔记吧

代码分析：5字节的Inline Hook

由于都是通过dll注入来实现功能，这里也就只分析DLL的源代码，DLL注入写太多遍了，不多写了

MyWriteFile()

extern "C" __declspec(dllexport) 
BOOL WINAPI MyWriteFile(
    _In_ HANDLE hFile,
    _In_reads_bytes_opt_(nNumberOfBytesToWrite) LPCVOID lpBuffer,
    _In_ DWORD nNumberOfBytesToWrite,
    _Out_opt_ LPDWORD lpNumberOfBytesWritten,
    _Inout_opt_ LPOVERLAPPED lpOverlapped
) {
    //使用前先UnHook
    UnHook_By_Code("kernel32.dll", "WriteFile");

    BOOL bRet = 1;
    if(MessageBoxA(0, "是:保存\r\n否:清空", 0, MB_YESNO)==IDYES)
        bRet = WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);

    Hook_By_Code("kernel32.dll","WriteFile",(PROC)MyWriteFile);

    return bRet;
}

MyWriteFile就是在保存的时候弹框，点是则保存，点否则不保存任何东西，为了形式上保持完整，这里就把这个函数导出了

dllMain()

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH: {
        Hook_By_Code("kernel32.dll", "WriteFile", (PROC)MyWriteFile);
        MessageBoxA(0, "YesOK", 0, 0);
        break;
    }
    case DLL_PROCESS_DETACH:
        UnHook_By_Code("kernel32.dll", "WriteFile");
        break;
    }
    return TRUE;
}

DLL加载成功之后，进行Hook，修改API前面5个字节跳转到我们的函数里去，卸载之后就把API还原

接下来是我们这次的重点了，如何修改&还原API的代码

Hook_By_Code()

//保存原始5字节，全局变量
BYTE pOrgBytes[5] = {0};

BOOL Hook_By_Code(LPCSTR szDllName,LPCSTR szAPIName,PROC pfnNew) {
    BYTE pBuf[5] = {0xE9,0,};//E9在IA-32是JMP，EB是64位的

    //获取目标函数地址
    HMODULE hMod = GetModuleHandleA(szDllName);
    PROC pFunAddr = GetProcAddress(hMod, szAPIName);
    
    //如果已经修改过了,则直接返回
    if (((PBYTE)pFunAddr)[0] == 0xE9) {
        return FALSE;
    }

    //向目标添加写属性
    HANDLE hProcess = GetCurrentProcess();//获取当前进程伪句柄
    DWORD dwOldProtect = 0;
    VirtualProtectEx(hProcess,pFunAddr, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);

    //读出来原本的5字节
    memcpy(pOrgBytes, pFunAddr, 5);

    //写入新的字节
    DWORD dwAddress = (DWORD)pfnNew - (DWORD)pFunAddr -  5;
    memcpy(&pBuf[1], &dwAddress, 4);
    memcpy(pFunAddr, pBuf, 5);

    //恢复内存属性
    VirtualProtectEx(hProcess,pFunAddr, 5, dwOldProtect, &dwOldProtect);

    return TRUE;
}

这个注释还是蛮清楚的，这个流程就是获取API的地址，改一下这个内存的读写权限，然后读取代码出来存起来，把我们的构造的代码写入进去，然后恢复读写权限

UnHook_By_Code()

BOOL UnHook_By_Code(LPCSTR szDllName, LPCSTR szAPIName) {
    //获取目标函数地址
    HMODULE hMod = GetModuleHandleA(szDllName);
    if (hMod == NULL) {
        return FALSE;
    }
    PROC pFunAddr = GetProcAddress(hMod, szAPIName);
    if (((PBYTE)pFunAddr)[0] != 0xE9) {
        return FALSE;
    }

    //向目标添加写属性
    HANDLE hProcess = GetCurrentProcess();//获取当前进程伪句柄
    DWORD dwOldProtect = 0;
    VirtualProtectEx(hProcess, pFunAddr, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);

    //还原原本的5字节
    memcpy(pFunAddr,pOrgBytes, 5);

    //恢复内存属性
    VirtualProtectEx(hProcess, pFunAddr, 5, dwOldProtect, &dwOldProtect);
    return TRUE;
}

取消修改的函数更简单了，还是获取目标API的地址，然后修改内存属性，还原刚刚保存出来的原本的代码就行

效果展示：5字节的Inline Hook

Hook之前：

image-20201017204259447

Hook之后：

image-20201017204358363

notepad点击保存的时候弹框：

image-20201017204422564

原理介绍：7字节的Inline Hook

所谓7字节Inline Hook，其实就是热补丁（相比5字节Inline Hook就是一次修改，一直使用），微软给一些库的API前面设置了7个字节的无用空间，可通过热补丁实现二次跳转来实现对特定API的Hook：

比如WriteFile API：

image-20201017185929619

API正式运行前有7个字节的空间

我们假设我们要跳转到0x10001000这个位置，进行远距离跳转，那么就可以这么修改这7字节无用空间：

image-20201017190207687

E9是远距离跳转，EB是短距离跳转，虽然都是JMP，但解析出来是不一样的，以后学习到相关部分会好好进行分析

这种Inline Hook的特点就是二次跳转，且无需再API内部进行反复的Hook和UnHook操作

具体操作步骤同5字节Inline Hook

代码分析：7字节的Inline Hook

MyWriteFile()

typedef  BOOL(WINAPI* OrgWriteFile)(
    _In_ HANDLE hFile,
    _In_reads_bytes_opt_(nNumberOfBytesToWrite) LPCVOID lpBuffer,
    _In_ DWORD nNumberOfBytesToWrite,
    _Out_opt_ LPDWORD lpNumberOfBytesWritten,
    _Inout_opt_ LPOVERLAPPED lpOverlapped
    );

....
    
extern "C" __declspec(dllexport) 
BOOL WINAPI MyWriteFile(
    _In_ HANDLE hFile,
    _In_reads_bytes_opt_(nNumberOfBytesToWrite) LPCVOID lpBuffer,
    _In_ DWORD nNumberOfBytesToWrite,
    _Out_opt_ LPDWORD lpNumberOfBytesWritten,
    _Inout_opt_ LPOVERLAPPED lpOverlapped
) {
    MessageBoxA(NULL,"今天也是充满希望的一天!","保佑一次成功",MB_OK);

    PBYTE pByte = (PBYTE)GetProcAddress(GetModuleHandleA("kernel32.dll"), "WriteFile");
    OrgWriteFile pOrgWriteFile = (OrgWriteFile)(pByte + 2);
    return pOrgWriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
}

7字节的Inline Hook，也就是热补丁，再次调用函数的时候，需要跳过我们修改的API开头的两个字节，从两个字节之后开始调用，所以这里要定义这个函数，然后把地址+2进行调用

dllmain()

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        Hook_By_Code("kernel32.dll", "WriteFile", (PROC)MyWriteFile);
        break;
    case DLL_PROCESS_DETACH:
        UnHook_By_Code("kernel32.dll", "WriteFile");
        break;
    }
    return TRUE;
}

老样子

Hook_By_Code()

BYTE g_OrgBytes[7] = { 0 };//全局变量
BOOL Hook_By_Code(LPCSTR szDllName,LPCSTR szAPIName,PROC pNewFunAddr) {

    //获取目标API
    HMODULE hMod = GetModuleHandleA("kernel32.dll");
    if (hMod == NULL) {
        return FALSE;
    }
    PROC pOrgFunAddr = GetProcAddress(hMod, "WriteFile");
    PBYTE pByte = (PBYTE)pOrgFunAddr;

    //读取前7个字节
    HANDLE hProcess = GetCurrentProcess();
    DWORD dwOldProtect = 0;
    VirtualProtectEx(hProcess, pByte - 5, 7, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    ReadProcessMemory(hProcess, pByte - 5, g_OrgBytes, 7, NULL);

    //构造新的7字节
    BYTE pBuffer[7] = { 0xE9,0,0,0,0,0xEB,0xF9 };
    DWORD dwAddr = (DWORD)pNewFunAddr - (DWORD)pOrgFunAddr;
    memcpy(&pBuffer[1], &dwAddr,4);

    //修改为新的7字节
    WriteProcessMemory(hProcess,pByte-5,pBuffer,7,NULL);
    VirtualProtectEx(hProcess, pByte - 5, 7, dwOldProtect, &dwOldProtect);

    return TRUE;
}

写法上同5字节，这里要注意的是，7字节是API开头的两个字节加上之前的5个字节，要注意函数指针的位置！

UnHook_By_Code()

BOOL UnHook_By_Code(LPCSTR szDllName, LPCSTR szAPIName) {
   //获取目标API
   HMODULE hMod = GetModuleHandleA("kernel32.dll");
   if (hMod == NULL) {
       return FALSE;
   }
   PROC pOrgFunAddr = GetProcAddress(hMod, "WriteFile");
   PBYTE pByte = (PBYTE)pOrgFunAddr;

   //修改访问权限
   HANDLE hProcess = GetCurrentProcess();
   DWORD dwOldProtect = 0;
   VirtualProtectEx(hProcess, pByte - 5, 7, PAGE_EXECUTE_READWRITE, &dwOldProtect);

   //还原7字节
   WriteProcessMemory(hProcess, pByte - 5, g_OrgBytes, 7, NULL);
   
   //还原访问权限
   VirtualProtectEx(hProcess, pByte - 5, 7, dwOldProtect, &dwOldProtect);

   return TRUE;
}

同理

效果展示：7字节的Inline Hook

Hook之前：

image-20201017205148773

Hook之后：

image-20201017205225703

函数调用跳转回来的地方：

image-20201017205316848

notepad的弹框：

image-20201017205340998

总结

绝了，同样的代码，怎么运行都不成功，调试了半天之后，最后还是原来的代码，一运行居然成功了，唉，不管了

这一章节主要学习的内容是两种Inline Hook，一种是通过反复Hook和UnHook来修改API代码实现对API的Hook，另一种是通过热补丁的方式进行API Hook

抱怨一句，照这样折腾下去，下次再写这个代码基本都不用查书了。。。

编写 Windows 服务程序
160个CrackMe系列-004...

评论