函数的打桩和hook

最新推荐文章于 2024-09-12 09:47:34 发布
最新推荐文章于 2024-09-12 09:47:34 发布
阅读量6.1k 收藏 9
点赞数
分类专栏： C语言 文章标签： hook windows null 数据结构 struct 算法

 

刚参加工作，总是听到PM分配任务的时候提到打桩的概念。查看项目代码的时候又碰到打桩函数中的HOOK技术。对于这两种技术我以前都没有接触过，在网上查了下资料，备份如下，希望对自己和他人都能有所帮助。

 

在软件测试的时候经常需要动态的替换被测函数调用的其它函数，而这个替换就叫做打桩。比如现在要测试函数A，但是函数A调用了还没有实现的函数B，那么我们给函数B创造打桩函数STUB_B，STUB_B可以直接返回一个值，由此便可以测试函数A的功能。这便是打桩。

以下为函数HOOK技术的两篇文章：

多任务下的数据结构与算法：函数的HOOK

HOOK功能的应用简介

    HOOK功能是一项非常重要的功能，是软件工程师必须掌握的技术。HOOK功能在实际中应用非常广泛，如词典软件、安全软件及各种系统软件中均会用到；还有一些C语言语法不能实现的功能也可以用HOOK来实现，如C++标准模板库中就用到了内存配置器的概念，即用户可以自己指定内存分配方法，可以使用自己的内存分配函数来进行内存管理。在C语言中，这个功能从语法上要求用函数指针作为回调函数等来实现，但是有很多已经写好的模块是不能随便修改接口的，如果要让这些模块在不修改的基础上使用自定义内存管理算法，就必须使用 HOOK功能。可以对malloc()，free()等内存管理函数设置 HOOK，使它们跳转到自定义的内存管理函数即可。

    HOOK功能还有一项非常重要的用途就是在白盒测试方面，像单元测试需要打桩，传统的打桩方法是将源文件中需要打桩的函数用桩函数替代，这个工作虽然可以通过工具来实现，但还是比较麻烦；如果使用HOOK来打桩则可以避免修改源文件，只要将桩函数设置成钩子函数，比传统的方法简洁多了。

    单个函数的HOOK实现

    很多读者可能用过金山词霸之类的软件，鼠标只要往单词上一指，就可以弹出对应单词的解释，这种屏幕取词便是使用了HOOK功能拦截Windows API的调用来实现的。本节要用数组来实现对函数HOOK的管理功能，首先讨论如何实现对单个函数的HOOK功能。



    对某个函数的HOOK就是通过某种方法使得调用这个函数时调用到指定的钩子函数。实现HOOK的方法很多，最简单的一种方法便是将调用函数的开头位置的代码改成一条跳转到钩子函数的指令即可。

    譬如我们自己写了一个MyMalloc()函数，以实现所有对malloc()函数的调用都调用MyMalloc()函数，假设 malloc函数的起始地址是0x00421540，那么只要将0x00421540开始的几个字节改成jmp DWORD PTR MyMalloc指令即可，假设MyMalloc()函数执行代码的起始地址为00401830，在INTEL32位芯片系列的机器中，jmp DWORD PTR MyMalloc这条指令的机器码为0xff2500401830，共6个字节，只要将这6个字节写入malloc()函数的开头6个字节中，即可实现调用malloc()函数时跳转到MyMalloc()函数。

    以下代码便能实现将跳转到MyMalloc()函数的指令写入malloc函数起始位置。
    DWORD lpSrcFunc = (DWORD)malloc；
    DWORD dwNewFunc = (DWROD)MyMalloc；
    DWORD lppNewFunc = &dwNewFunc；
    *(unsigned char *)lpSrcFunc = (unsigned char)0xff；
    *(((unsigned char *)lpSrcFunc)+1) = (unsigned char)0x25；


    memcpy( (void *)(lpSrcFunc+2)，(const void *)&lppNewFunc，sizeof(DWORD) )；
    如果是像Windows NT系列的操作系统，对执行代码的内存做了保护，是不能直接调用以上代码的，还需要使用VirtualProtect()函数将lpSrcFunc指向的地址处的内存属性改成可以写的，才可以调用以上代码。

    还要考虑将malloc()的调用改掉后再如何恢复的问题，否则程序运行很容易出现问题。恢复的做法便是将malloc()起始处的6个字节先保存起来，当要恢复时，将保存的6个字节写回原来位置即可。

    还需说明的是，以上介绍的是同一进程内的HOOK实现方法，如果要HOOK其他进程中的函数调用，还需要将上述代码注入到目标进程中去执行才可以实现HOOK功能，将代码注入到其他进程中的方法有很多种，Windows系统下常用的方法有以下几种。
    ① 使用Windows API函数 SetWindowsHookEx()将程序注入到其他进程中执行；
    ② 使用修改DLL IMPORT表的方法来实现对DLL中函数的HOOK；
    ③ 使用CreateRemoteThread()函数将代码注入到其他进程中执行；
    ④ 对于Windows NT系列操作系统，还可以使用注册表设置来实现将代码注入到其他进程中执行。



    以上几种方法在很多书籍中都有详细介绍，这里就不作进一步介绍。

    HOOK使用的注意事项

    使用HOOK时要特别小心，使用不当很容易导致程序崩溃。比如要HOOK malloc()和free()函数，如果HOOK的时机不当，会导致HOOK了的free()函数去释放未被HOOK的malloc()的内存，引起程序崩溃。

原文地址：http://www.mscto.com/shujujiegou/25533203.html

数据结构与算法：多个函数的HOOK实现

 采用前面的方法对多个函数实现HOOK，当设置HOOK时，如何保存那些函数的起始6 个字节？当取消HOOK时，如何从保存的数据中找到某个函数的起始6个字节？解决这个问题，可以用一个结构体数组来实现，结构体中包含源函数地址、源函数起始位置的6个字节数据等内容。HOOK管理结构体设计如下。
    typedef struct APIHOOKDATA_st {
    DWORD dwSrcFuncAddr； /* 源函数的地址 */
    DWORD dwNewFuncAddr； /* 钩子函数的地址 */
    BYTE byHeaderCode[6]； /* 源函数起始6字节 */
    WORD wFlag； /* 用来表示是否设置了HOOK的标志 */
    } APIHOOKDATA；
    typedef struct APIHOOK_st {
    APIHOOKDATA *pHookData；
    UINT uMaxFunctions；
    } APIHOOK；

    APIHOOKDATA结构体用来记录单个函数的HOOK数据，APIHOOK结构体用来管理多个函数的HOOK，里面包含一个APIHOOKDATA结构体数组，uMaxFunctions是数组的长度，表示最多可以HOOK的函数个数。

    1. 多个函数的HOOK管理 软件开发网 www.mscto.com

    对多个函数的HOOK管理可以分为以下四个操作步骤。
    ① 初始化；
    ② 设置某个函数的HOOK；
    ③ 取消某个函数的HOOK；
    ④ 关闭。

    下面以Windows NT系列操作系统为例来实现以上四个操作的代码。初始化操作主要是为结构体分配内存，将整个数组清零。编码如下。
    /** ApiHook 模块初始化函数
    @param INT nMaxHookFuncCounts——最大可设置的钩子数量
    @return INT (by default) ——返回NULL 表示失败
    */
    HANDLE ApiHook_Init(UINT uMaxFunctions)
    {
        APIHOOK * pApiHook = (APIHOOK *)malloc(sizeof(APIHOOK))；
        if ( pApiHook )
        {
            pApiHook->uMaxFunctions = uMaxFunctions；


            pApiHook->pHookData =
            (APIHOOKDATA *)malloc(sizeof(APIHOOKDATA) *uMaxFunctions)；
            if ( NULL != pApiHook->pHookData)
            {
                memset(pApiHook->pHookData，0，sizeof(APIHOOKDATA) *uMaxFunctions )；
                return (HANDLE)pApiHook；
            }
            free(pApiHook)；
        }
    return NULL；
    }

    2. 设置HOOK操作

    设置某个函数的HOOK操作主要是在数组中查找未使用的节点，将源函数相关信息保存到节点中，修改源函数起始位置的几个字节为一条跳转到钩子函数的指令。
    /** 通过地址来设置某个函数的钩子函数
    @param HANDLE hApiHook——由ApiHook_Init()函数生成的句柄
    @param DWORD dwSrcFuncAddr——源函数地址
    @param DWORD dwNewFuncAddr——钩子函数地址
    @return INT (by default) ——返回－1表示失败；返回0表示在HOOK数组中的序号
    */
  INT ApiHook_SetByAddr(HANDLE hApiHook，DWORD dwSrcFuncAddr，DWORD dwNewFuncAddr)
    {
        DWORD dwOldProtect；
        DWORD dwNewProtect；
        DWORD lpSrcFunc；
        DWORD lppNewFunc；
        UINT i；


        INT nAlreadyFlag = 0；
        if ( NULL == hApiHook )
        {
            return－1；
        }
        APIHOOK *pApiHook = (APIHOOK *)hApiHook；
        lpSrcFunc = dwSrcFuncAddr；
        /* 查找是否已设置了钩子 */
        for ( i = 0； i < pApiHook->uMaxFunctions； i++ )
        {
            if ( pApiHook->pHookData[i].dwSrcFuncAddr == lpSrcFunc )
            {
                /* 如果已经设置了钩子，仅仅改变 */


                nAlreadyFlag = 1；
                break；
            }
        }
        /* 如果没有设置源函数的钩子函数，在表中找出一个可供记录的位置 */
        if ( i == pApiHook->uMaxFunctions )
        {
            for ( i = 0； i < pApiHook->uMaxFunctions； i++ )
            {
                if (pApiHook->pHookData[i].wFlag == 0 )
                {


                    break；
                }
            }
        if ( i == pApiHook->uMaxFunctions )
        {
            return－1；
        }
    }
    /* 将新的钩子函数地址记录到表中 */
    pApiHook->pHookData[i].dwNewFuncAddr = dwNewFuncAddr；
    /* 以下这段代码将源函数头部6个字节保存到表中 */
    lppNewFunc = (DWORD)(&(pApiHook->pHookData[i].dwNewFuncAddr) )；
    if ( !nAlreadyFlag )
    {
        /* 将源函数起始处6个字节保存到 byHeaderCode.中 */


        memcpy( pApiHook->pHookData[i].byHeaderCode，(const void *)lpSrcFunc，6)；
    }
    /* 以下这段代码将源函数首部6个字节改成为一条跳转到新函数地址的指令 */
    if ( VirtualProtect( (LPVOID)lpSrcFunc，6， PAGE_EXECUTE_READWRITE，&dwOldProtect ) == 0 )
    {
        return－1；
    }
    *(unsigned char *)lpSrcFunc = (unsigned char)0xff；
    *(((unsigned char *)lpSrcFunc)+1) = (unsigned char)0x25；
    memcpy( (void *)(lpSrcFunc+2)，(const void *)&lppNewFunc，4 )；
    if ( VirtualProtect( (LPVOID)lpSrcFunc，6，dwOldProtect， &dwNewProtect) == 0 )
    {
        return－1；
    }；
    pApiHook->pHookData[i].wFlag = 1；
    pApiHook->pHookData[i].dwSrcFuncAddr = lpSrcFunc；


    return (INT)i；
    }
 3. 取消HOOK操作

    取消某个函数的HOOK操作和设置操作相反，主要是在数组中查到要操作的函数的相关记录信息，将源函数起始位置处的6个字节恢复，清除数组中的对应记录信息。编码如下。

    /** 取消某个函数的钩子函数设置
    @param HANDLE hApiHook——由ApiHook_Init()函数生成的句柄
    @param DWORD dwSrcFuncAddr——源函数地址
    @return INT (by default) ——返回－1表示失败；返回0表示在HOOK数组中的序号
    */
    INT ApiHook_UnSetByAddr(HANDLE hApiHook，DWORD dwSrcFuncAddr)
    {
        UINT i；
        DWORD dwOldProtect；
        DWORD dwNewProtect；
        DWORD lpSrcFunc；
        APIHOOK *pApiHook = (APIHOOK *)hApiHook； 软件开发网 www.mscto.com
        if ( NULL == hApiHook )
        {
            return－1；
        }
        for ( i = 0； i < pApiHook->uMaxFunctions； i++ )
        {
            if ( pApiHook->pHookData[i].dwSrcFuncAddr == dwSrcFuncAddr )
            {
                break；
            }
        }
        if ( i == pApiHook->uMaxFunctions )
        {
            return－1；
        }
        lpSrcFunc = pApiHook->pHookData[i].dwSrcFuncAddr；
        /* 将lpSrcFunc指向的内存属性修改为可以读写的 */
        if ( VirtualProtect( ( LPVOID)lpSrcFunc，6，PAGE_EXECUTE_READWRITE，&dwOldProtect ) == 0 )
        {
            return－1；
        }
        memcpy( (void *)lpSrcFunc，pApiHook->pHookData[i].byHeaderCode，6 )；
        /* 恢复lpSrcFunc指向的内存属性 */
        if ( VirtualProtect( (LPVOID)lpSrcFunc，6，dwOldProtect，&dwNewProtect ) == 0 )
        {
            return－1；


        }
        pApiHook->pHookData[i].wFlag = 0；
        if ( pApiHook->pHookData[i].pszDllName )
        {
            free(pApiHook->pHookData[i].pszDllName)；
            pApiHook->pHookData[i].pszDllName = NULL；
        }
        if ( pApiHook->pHookData[i].pszFuncName )
        {
            free( pApiHook->pHookData[i].pszFuncName )；
            pApiHook->pHookData[i].pszFuncName = NULL；
        }
        return (INT)i；


    }

原文地址：http://www.mscto.com/shujujiegou/25533303.html

mr_gongcheng
关注
专栏目录
劫持linux系统函数 malloc free linux打桩hooking
万有文的博客
04-24 1531
在Linux中，“打桩”（stubbing）或"钩子"（hooking）是一种修改程序行为的技术，通常用于测试、调试或功能增强。对于malloc和free这样的函数，打桩通常用于追踪内存分配和释放情况，或用于在内存管理中加入额外的逻辑。
windows 下实现函数打桩：拦截API方式
liaoyoujinb的专栏
07-19 2645
1. 函数调用的原理：通过函数名（函数的入口地址）对函数进行访问，假设我们能够改变函数首地址指向的内存的话，使其跳转到另一个函数去执行的话，那么就可以实现函数打桩了。 2. 方法：对函数首地址出写入一条汇编语言 jmp xxx (其中xxx是要跳转的相对地址）。 3. 令原函数为oldFun,新函数为newFun,那么打桩时函数跳转的相对地址 offset = newFun - oldFun - (我们制定的这条指令的大小)，此处为绝对跳转指令的长度=5。 jmp xxx一共6字节。
函数打桩原理
LouisYu的博客
04-14 7120
桩函数(Stub)是模拟被测试模块所调用的模块。 =================================================================== 什么是桩 桩,或称桩代码,是指用来代替关联代码或者未实现代码的代码。如果函数B用B1来代替,那么,B称为原函数,B1称为桩函数。打桩就是编写或生成桩代码。 =================================================================== 打桩的目的 打桩的目的主要有:隔离
C语言之简单的函数打桩
yiweij的博客
02-13 4164
何为打桩？ 打桩我的理解就是，定义好函数头文件，函数实现块暂时不加功能。 废话不必多说，代码实现： 定义头文件demo.h #pragma once //防止头文件重复 #ifdef __cplusplus //按照C标准，兼容C++编译器。 extern"C" { #endif //初始化环境 int socketclient_init(void **handle); //...
学懂C++（五十九）：C++ 系统HOOK编程开发技术详解
最新发布
martian665的专栏
09-12 1354
C++ 系统HOOK编程开发技术详解
用hook代码实现桩函数设置功能
01-04
这是一段hook代码，可在linux（cygwin）以及windows下使用，可用于软件单元测试时函数打桩设置。
基于Hook的动态打桩工具（Linux）
12-30
linux下方便单元测试使用的动态打桩工具、可以对全局函数、静态函数、类成员函数、类虚徐成员函数进行打桩。
打桩代码函数
08-24
打桩代码函数，c++版本的，希望对大家有帮助。
打桩
qq_27349197的博客
10-10 1397
打桩@[TOC](这里写自定义目 /* linux_stub.c Created on: 2020-5-28 Author: xxxx */ #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <memory.h> #include <errno.h> #include <limits.h> #include <sys/mman.h>
mprotect/mlock使用demo
tugouxp的专栏
10-14 228
mlock起作用的过程分为两步，第一步，对于已经存在的VMA，将会调用mm_populate将其手动建立物理页面的映射。而对于未来分配的物理页面，则将会调用apply_mlockall_flags设置VM_LOCKED标志，设置此标志后，将来的MMAP函数将会调用__mm_populate分配页面。这样，在加入LRU的逻辑中，判断PageMlocked为真，将会把页面加入LRU_UNEVICTABLE list.所以，最终MLOCKD的效果显示在/proc/meminfo的unenvicible字段。
Hook HeapAlloc遇到的问题
duhaomin的专栏
06-11 1977
描述一下问题： 想在程序申请内存时获得当前进程占用内存大小，以便找到内存占用瞬间增大的点 实现方式是在hook heapalloc时，调用GetProcessMemoryInfo获取内存大小并记录，结果导致GetProcessMemoryInfo后边的所有代码都没法进入 问题找了很久，之后求助开发宋大侠找到了原因，原来，GetProcessMemoryInfo内部实现的时候也会调用h
C/C++/Linux函数函数插桩(打桩)指南
08-12
在具有一定规模的代码中(C 语言)，调用第三方动态库中的函数来完成一些功能，是很常见的工作场景。 假设现在有一项任务：需要在调用某个动态库中的某个函数的之前和之后，做一些额外的处理工作。 这样的需求一般称作：插桩，也就是对于一个指定的目标函数，新建一个包装函数，来完成一些额外的功能，如动态调试等。 本文主要讲解什么是打桩，以及编译阶段打桩、链接阶段打桩、执行阶段打桩三种方式。
打桩 转
wangqing008的专栏
11-01 1907
打桩是一种用定制的函数替换链接库函数且不需重新编译的技术。甚至可用此技术替换系统调用（更确切地说，库函数包装系统调用）。可能的应用是沙盒、调试或性能优化库。为演示过程，此处给出一个简单库，以记录GNU/Linux中 malloc 调用次数。 1 2 3 4 5 6 7 8 9 10 11 12 1
如何实现函数打桩
sydyh43的博客
01-19 2280
1、打桩是干什么的？ 在对打桩函数本身执行完整的基础上，添加一些额外的代码，完成必要的信息采集，用于具体的问题定位。 2、打桩的时机 程序从诞生到生存分三个阶段，编译，链接和运行 函数分别可以在这三个阶段实现打桩操作 3、打桩的实现 3.1、代码框架 main.c函数调用libmalloc0.so动态库函数，libmalloc1.so调用libmalloc0.so动态库函数 3.2、代码路径 GitHub - dyh-git/func_stub: 函数打桩，重载函数 3.3、具体情况 3.
c语言自动插桩,静态插桩的方式来实现Hook Method
weixin_35851508的博客
05-24 938
通过fishhook拦截方法的局限性我之前写了一个开源库TimeProfiler，监控所有的OC方法耗时。可以在开发App阶段，很方便的看到主线程所有OC方法的耗时。但是由于TimeProfiler是通过fishhook基于运行时hook，所以从原理上，它就有局限性：不能选择hook部分类的OC方法。这造成2个很难解决的问题：不能选择hook一部分类的OC方法，全部hook会有性能问题，所以也不能...
单元测试中的打桩技术
热门推荐
鹏鹏的博客
07-01 2万+
一、桩是什么桩，或称桩代码，是指用来代替关联代码或者未实现代码的代码。如果用函数B1来代替B，那么，B称为原函数，B1称为桩函数。打桩就是编写或生成桩代码。二、打桩的用途打桩的目的主要有：隔离、补齐、控制。①隔离是指将测试任务从产品项目中分离出来，使之能够独立编译、链接，并独立运行。隔离的基本方法就是打桩，将测试任务之外的，并且与测试任务相关的代码，用桩来代替，从而实现分离测试任务。例如函数A调用...
Linux 程序开发 之 库打桩机制
小嵌同学的博客
12-12 1824
Linux 链接器支持一个很强大的技术，称为库打桩(library interpositioning)，它允许你截获对共享库函数的调用，取而代之执行自己的代码。使用打桩机制，你可以追踪对某个特殊库函数的调用次数，验证和追踪它的输入和输出值，或者甚至把它替换成一个完全不同的实现。基本思想：给定一个需要打桩的目标函数，创建一个包装函数，它的原型与目标函数完全一样。使用某种特殊的打桩机制，你就可以欺骗系统调用包装函数而不是目标函数了。
啥是钩子？啥又是钩子函数啊？
default_coder的博客
12-08 1028
在插件的API中，我们常常将暴露的方法或者属性统称为钩子(Hook)，方法则直接叫钩子函数。这是一种形象生动的说法，就好像我们在一条绳子上放很多挂钩，我们可以按需要在上面挂东西。 实际上，我们即知道插件可以像一条绳子上挂东西，也可以拿掉挂的东西。那么一个插件，实际上就是个形象上的链。不过我们上面的所有钩子都是挂在对象上的，用于实现链并不是很理想。 作者：匪号陆拾柒 链接：http://www.
C++ 之 Hook编程
HeroIsUseless的博客
10-23 3297
当我们使用特定函数来安装一个钩子时，操作系统会给这个钩子分配一个钩子链表，信息先经过钩子函数洗一遍，才行。 这段程序会根据钩子类型的不同，来实现不同程度的消息截获，并且这个钩子链表里包含了这个钩子程序的地址，类型，回调函数的地址！ 并且钩子子程序的优先级会高于应用程序，在接受消息时会被钩子子程序先行截获，操作系统会先把消息发送给钩子，由钩子决定这些消息是否发送下去，钩子可以拦截这些消息，可以决定这些消息的作用，甚至可以屏蔽这些消息不让传递到指定应用程序当中！ 在安装钩子的时候是由顺序之分的，链表遵循的是先进
函数组件和hook函数使用举例
06-01
函数组件和hook函数是React中的两个重要概念，它们可以让我们更方便地编写可复用的组件和处理组件的状态和生命周期。 下面以一个简单的计数器组件为例，演示如何使用函数组件和hook函数： ```jsx import React, { useState } from 'react'; function Counter() { const [count, setCount] = useState(0); // 使用useState hook函数来定义计数器的状态 function handleButtonClick() { setCount(count + 1); // 更新计数器状态 } return ( <div> <p>Count: {count}</p> <button onClick={handleButtonClick}>Click me</button> </div> ); } ``` 上述代码中，我们使用函数组件定义了一个计数器组件，使用useState hook函数来定义计数器的状态。useState函数返回一个数组，其中第一个元素为当前状态的值，第二个元素为更新状态值的函数。在handleButtonClick函数中，我们使用setCount函数来更新计数器状态。最后，将计数器状态和更新函数作为变量渲染到组件上。 需要注意的是，useState hook函数的参数为状态的初始值，useState函数只会在组件初次渲染时被调用，后续的更新操作都会通过setCount函数来实现。 总的来说，使用函数组件和hook函数可以让我们更方便地编写可复用的组件和处理组件的状态和生命周期，提高开发效率和代码可维护性。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值