python中的hook函数使用及应用场景

关注

原创 2024-01-08 17:43:39 2.3k 阅读 AI 写同款· GEO 优化 ›

Python钩子函数 hook，又称钩子，在C/C++中一般叫做回调函数。钩子是从功能角度描述这种编程模式，回调则是从函数调用时间角度描述的。通常理解的hook是在一个已有的方法上加入一些钩子，使得在该方法执行前或执行后另在做一些额外的处理。如我们熟知的windows系统消息响应事件，鼠标点击对程序产生的影响是有程序自己决定的，但是程序的执行是受制于框架（windows系统），框架提供了一些通用的流程执行，但是往往框架或流程在设计时无法完全预料到以后的使用会有什么新需求，或者有些行为只有在运行时才能确定的。... 阅读详情

文章目录

在这里插入图片描述

什么是hook？

经常会听到钩子函数(hook function)这个概念，最近在看目标检测开源框架mmdetection，里面也出现大量Hook的编程方式，那到底什么是hook？hook的作用是什么？

what is hook ？钩子hook，顾名思义，可以理解是一个挂钩，作用是有需要的时候挂一个东西上去。具体的解释是：钩子函数是把我们自己实现的hook函数在某一时刻挂接到目标挂载点上。
hook函数的作用举个例子，hook的概念在windows桌面软件开发很常见，特别是各种事件触发的机制; 比如C++的MFC程序中，要监听鼠标左键按下的时间，MFC提供了一个onLeftKeyDown的钩子函数。很显然，MFC框架并没有为我们实现onLeftKeyDown具体的操作，只是为我们提供一个钩子，当我们需要处理的时候，只要去重写这个函数，把我们需要操作挂载在这个钩子里，如果我们不挂载，MFC事件触发机制中执行的就是空的操作。

从上面可知

hook函数是程序中预定义好的函数，这个函数处于原有程序流程当中（暴露一个钩子出来）
我们需要再在有流程中钩子定义的函数块中实现某个具体的细节，需要把我们的实现，挂接或者注册（register）到钩子里，使得hook函数对目标可用
hook 是一种编程机制，和具体的语言没有直接的关系
如果从设计模式上看，hook模式是模板方法的扩展
钩子只有注册的时候，才会使用，所以原有程序的流程中，没有注册或挂载时，执行的是空（即没有执行任何操作）

本文用python来解释hook的实现方式，并展示在开源项目中hook的应用案例。hook函数和我们常听到另外一个名称：回调函数（callback function）功能是类似的，可以按照同种模式来理解。

hook应用场景（一）

相信你对钩子函数并不陌生。我在 requests 和 mitmproxy 都有看到类似的设计。

requests 使用hook

例如 requests 中需要打印状态码：

\# requests\_hooks.py
import requests
r = requests.get("https://httpbin.org/get")
print(f"status doce: {r.status\_code}")

打印状态码，这个动作，我们可以封装到一个函数里，然后作为钩子函数传给requests 使用。

\# requests\_hooks.py
import requests
def status\_code(response, \*args, \*\*kwargs):
    print(f"hook status doce: {response.status\_code}")
r = requests.get("https://httpbin.org/get", hooks={"response": status\_code})

代码说明：

把打印状态码封装到一个status_code() 函数中，在requests.get() 方法中通过hooks 参数接收钩子函数status_code()。

运行结果：

> python requests_hooks.py
hook status doce: 200

status_code() 作为一个函数，可以做的事情很多，比如，进一步判断状态码，打印响应的数据，甚至对相应的数据做加解密等处理。

mitmproxy 中的hook

mitmproxy是一个代理工具，我们这之前的文章也有做过介绍。在抓包的过程中，同样需要用到 hooks 去对request请求或response响应做一些额外的处理。

\# anatomy.py
"""
Basic skeleton of a mitmproxy addon.
Run as follows: mitmproxy -s anatomy.py
"""
import logging
class Counter:
    def \_\_init\_\_(self):
        self.num = 0
    def request(self, flow):
        self.num = self.num + 1
        logging.info("We've seen %d flows" % self.num)
addons = \[Counter()\]

运行mitmproxy

> mitmproxy -s anatomy.py

自己实现hook

什么情况下需要实现hook，就是一个功能（类/方法）自身无法满足所有需求，那么可以通过hook 就提供扩展自身能力的可能。

实现hook 并不难，看例子：

import time
class Programmer(object):
    """程序员"""
    def \_\_init\_\_(self, name, hook=None):
        self.name = name
        self.hooks\_func = hook
        self.now\_date = time.strftime("%Y-%m-%d")
    def get\_to\_eat(self):
        print(f"{self.name} - {self.now\_date}: eat.")
    def go\_to\_code(self):
        print(f"{self.name} - {self.now\_date}: code.")
    def go\_to\_sleep(self):
        print(f"{self.name} - {self.now\_date}: sleep.")
    def everyday(self):
        # 程序员日常三件事
        self.get\_to\_eat()
        self.go\_to\_code()
        self.go\_to\_sleep()
        # check the register\_hook(hooked or unhooked)
        # hooked
        if self.hooks\_func is not None:
            self.hooks\_func(self.name)
def play\_game(name):
    now\_date = time.strftime("%Y-%m-%d")
    print(f"{name} - {now\_date}: play game.")
def shopping(name):
    now\_date = time.strftime("%Y-%m-%d")
    print(f"{name} - {now\_date}: shopping.")
if \_\_name\_\_ == "\_\_main\_\_":
    # hook 作为参数传入
    tom = Programmer("Tom", hook=play\_game)
    jerry = Programmer("Jerry", hook=shopping)
    spike = Programmer("Spike")
    # 今日事情
    tom.everyday()
    jerry.everyday()
    spike.everyday()

代码说明:

在上面的例子中Programmer类实现三个功能：eat、code、sleep，但程序员也是普通人，不能每天都只吃饭、编码、睡觉，于是通过register_hook() 提供了做别的事情的能力。

那么，看看Tom、Jerry、Spike三位主角，今天都干了什么吧！

运行结果：

Tom - 2022-12-01: eat.
Tom - 2022-12-01: code.
Tom - 2022-12-01: sleep.
Tom - 2022-12-01: play game.
Jerry - 2022-12-01: eat.
Jerry - 2022-12-01: code.
Jerry - 2022-12-01: sleep.
Jerry - 2022-12-01: shopping.
Spike - 2022-12-01: eat.
Spike - 2022-12-01: code.
Spike - 2022-12-01: sleep.

hook应用场景(二)

如果把hook理解为：定义一个函数，然后作为参数塞到另一个类/方法里。显然，这只是一种用法。我重新想了一下。httpRunner 的 debugtalk.py 文件； pytest 的 conftest.py 文件，他们本身也是拥有特殊名字的 hook文件。程序在执行的过程中，调用这些文件中的钩子函数完成一些特殊的任务。

以pytest为例子

└───project
    ├───conftest.py
    └───test\_sample.py

conftest.py

import pytest
@pytest.fixture()
def baidu\_url():
    """定义钩子函数"""
    return "https://www.baidu.com"

test_sample.py

import webbrowser
def test\_open\_url(baidu\_url):
    # 调用 baidu\_url 钩子函数
    # 调用 浏览器 访问 baidu\_url
    webbrowser.open\_new(baidu\_url)

两个文件看似没有直接的调用关系，在执行 test_sample.py 文件时，可以间接的调用 conftest.py 文件中的baidu_url()钩子函数。

执行测试

> pytest -q test_sample.py

实现动态调用hook

接下来，我们来试试做个类似的功能出来。

└───project
    ├───run\_conf.py
    ├───loader.py
    └───run.py

run_conf.py

def baidu\_url():
    """定义钩子函数"""
    name = "https://www.baidu.com"
    return name

与 conftest.py 文件类似，在这个文件中实现钩子函数。

loader.py

import os
import inspect
import importlib
def loader(name):
    """
    动态执行 hook 函数
    """
    # 被调用文件的目录
    stack\_t = inspect.stack()
    ins = inspect.getframeinfo(stack\_t\[1\]\[0\])
    file\_dir = os.path.dirname(os.path.abspath(ins.filename))
    # 被调用文件目录下面 \*\_conf.py 文件
    all\_hook\_files = list(filter(lambda x: x.endswith("\_conf.py"), os.listdir(file\_dir)))
    all\_hook\_module = list(map(lambda x: x.replace(".py", ""), all\_hook\_files))
    # 动态加载 \*\_config.py
    hooks = \[\]
    for module\_name in all\_hook\_module:
        hooks.append(importlib.import\_module(module\_name))
    # 根据传过来的 name 函数名，从 \*\_conf.py 文件查找并执行。
    for per\_hook in hooks:
        # 动态执行 process 函数
        func = getattr(per\_hook, name)
        return func()

这个东西就比较复杂了，他的作用就是丢给他一个的函数名，他能通过*_conf.py文件中查找对应的函数名，并将函数执行结果返回。

loader() 函数是一个通用的东西，你可以把他放到任何位置使用。

run.py

import webbrowser
from loader import loader
def test\_open\_url():
    # 调用 baidu\_url 钩子函数
    # 调用 浏览器 访问 baidu\_url
    url = loader("baidu\_url")
    webbrowser.open\_new(url)
if \_\_name\_\_ == '\_\_main\_\_':
    test\_open\_url()

通过loader() 函数执行baidu_url 钩子函数，并拿到 url。

注意，我们不需要像传统的方式一样from run_conf import baidu_url 导入模块，只要知道钩子函数的名字即可。

这里的实现并没有 pytest 那么优雅，但也比较接近了。