linux内核hook技术之指令覆盖与注入

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了linux内核hook技术之指令覆盖与注入，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5603字，纯文字阅读大概需要9分钟。

内容图文

前言

    说到hook，传统意义上，大家都会觉得跟注入和劫持挂钩。在linux内核中，也可以通过指令覆盖和注入的方式进行hook，来完成自己的业务逻辑，实现自己的功能需求。

    一部分人喜欢称这种hook技术为inline hook。

如何hook

    具体hook细节在以下编写的驱动例子程序中给出了，例子中标注了详细的注释，大家可对照着代码查看。

    例子程序在centos 6系统上编译并测试通过了，如果换成其他系统，部分代码可能需要进行微调，想要尝试的朋友，自己写个简单的makefile文件编译即可。

    例子程序中以check_kill_permission内核函数为例进行了hook，装载时需要给驱动传递kallsyms_lookup_name函数地址作为参数。

    eg： insmod **.ko kallsyms_lookup_name=0x*******，具体地址0x*****可通过指令 cat /proc/kallsyms | grep kallsyms_lookup_name获取。

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kallsyms.h>
#include <linux/types.h>
#include <linux/cpu.h>
#include <asm/siginfo.h>
#include <asm/insn.h>
#include <linux/stop_machine.h>

/*使用check_kill_permission函数来进行hook测试*/
#define HOOK0_SYS_OPEN_NAME  "check_kill_permission"

#define HOOK0_INSN_INIT_NAME    "insn_init"
#define HOOK0_INSN_GET_LENGTH_NAME  "insn_get_length"

typedef unsigned long (* kallsyms_lookup_name_t)(const char *name);
typedef void (* insn_get_length_t)(struct insn *insn);
typedef void (* insn_init_t)(struct insn *insn,
                const void *kaddr,
                int x86_64);
typedef int (* hook0_stub_t) (int sig,
                struct siginfo *info,
                struct task_struct *t);

static ulong kallsyms_lookup_name_address;
static void *origin_function_head;
static void *origin_function_next;

static kallsyms_lookup_name_t hook0_lookup_name;
static insn_init_t hook0_insn_init;
static insn_get_length_t hook0_insn_get_length;
static hook0_stub_t p_hook0_stub;

static uint hook0_insn_len = 0;
static ulong g_wpbit_val = 0;

/*
 *占位函数
 *函数体里面的代码用来占位,无其他意义
 *do_stub稍后会被其他指令覆盖,用来跳转会原函数
 * */
static int do_stub(int sig,
                struct siginfo *info,
                struct task_struct *t)
{
    int c0, c1, c2;

    c0 = 10;
    c1 = 10;
    c2 = c0 + c1;
    return c2;
}

/*
 *钩子函数
 * 通俗点说就是想为所欲为的地方
 * */
static int hook0_new_function(int sig,
                struct siginfo *info,
                struct task_struct *t)
{
    printk("this is hook body\n");

    /*p_hook0_stub其实指向的是do_stub
     *当为所欲为完成之后,可以再将原函数重新执行一遍
     * */
    return p_hook0_stub(sig, info, t);
}

/*
 *写保护关闭函数
 * */
static void hook0_clear_wpbit(void)
{
    ulong val = read_cr0();
    g_wpbit_val = val;
    val &= 0xfffffffffffeffff;
    write_cr0(val);
}

/*
 * 写保护位恢复函数
 * */
static void hook0_recover_wpbit(void)
{
    write_cr0(g_wpbit_val);
}

/*
 *获取指令长度
 * */
static int hook0_get_length(char *pc_addr)
{
    struct insn insn;
    int x86_64 = 1;
    char *p = pc_addr;

    hook0_insn_init(&insn, p, x86_64);
    hook0_insn_get_length(&insn);

    return insn.length;
}

/*
 *钩子函数注入的地方
 *此处主要通过注入jmp命令来实现的
 * */
static int hook0_do_hijack(void *arg)
{
    char *p, *p_stub;
    int insn_len, offset0, offset1;

    p = origin_function_head;
    p_stub = (char *)do_stub;

    insn_len = 0;
    /*
     *计算原地址入口出,
     * */
    while (insn_len < 5)
        insn_len += hook0_get_length(p + insn_len);
    hook0_insn_len = insn_len;

    /*计算hook0_new_function的跳转偏移*/
    origin_function_next = p + insn_len;
    offset0 = (long)hook0_new_function - (long)origin_function_head - 5;

    /*保存原函数指令的前几个字节,稍后在原函数的开始位置植入jmp调转*/
    memcpy(p_stub, origin_function_head, hook0_insn_len);
    p_stub += hook0_insn_len;
    /*计算占位函数的偏移,占位函数前几个字字节存放的原函数的前几个字节,
     *稍后存入jmp指令,跳转到origin_function_next
     *origin_function_next指向原函数保存字节之后的剩余部分指令
     * */
    offset1 = (long)origin_function_next - (long)p_stub  - 5;

    /*关闭写保护位 [16bit]*/
    hook0_clear_wpbit();
    /*
     *hijack do_stub 
     *e9(后面的4字节表示偏移值) eb(后面的2字节表示偏移值) => jmp 
     *e8 => call
     */
    *p_stub++ = 0xe9;
    *((int *)p_stub) = offset1;
    p_hook0_stub = do_stub;
    /*内存屏障,保障do_stub先跳转先植入*/
    barrier();
    /*
     *hijack origin check_kill_permission 
     *e9(后面的4字节表示偏移值) eb(后面的2字节表示偏移值) => jmp 
     *e8 => call
     */
    *p++ = 0xe9;
    *((int *)p) = offset0;
    /*写保护复原*/
    hook0_recover_wpbit();

    return 0;
}

static int hook0_recover_hijack(void *arg)
{
    hook0_clear_wpbit();
    /*将原函数开头被植入的jmp指令复原*/
    memcpy(origin_function_head, do_stub, hook0_insn_len);
    hook0_recover_wpbit();
    return 0;
}

static int hook0_init(void)
{
    /*
     * kallsyms_lookup_name函数的地址,
     *在insmod装载时由参数kallsyms_lookup_name_address传递
     */
    hook0_lookup_name = (kallsyms_lookup_name_t)kallsyms_lookup_name_address;
    /*
     * 查找将要劫持的函数地址,此处使用内核提供的kallsyms_lookup_name函数
     */
    origin_function_head = hook0_lookup_name(HOOK0_SYS_OPEN_NAME);
    /*
     *查找insn_init和insn_get_length函数地址
     *函数用来计算某指令地址的长度 
     */
    hook0_insn_init = (insn_init_t)hook0_lookup_name(HOOK0_INSN_INIT_NAME);
    hook0_insn_get_length = (insn_get_length_t)hook0_lookup_name(HOOK0_INSN_GET_LENGTH_NAME);

    stop_machine(hook0_do_hijack, NULL, 0);

    return 0;
}

static void hook0_exit(void)
{
    stop_machine(hook0_recover_hijack, NULL, 0);
    return;
}

module_init(hook0_init);
module_exit(hook0_exit);
module_param(kallsyms_lookup_name_address, ulong, 0644);
MODULE_LICENSE("GPL");

一些感想

使用指令注入等hook技术时候，有几点可能需要注意下：

• 写保护的问题，代码区的内存空间是只读的，想进行指令注入需要放开写保护位。
• 执行权限问题，以上演示的hook技术中使用了do_stub占位函数，本身已经具有了执行权限，如果选择自己开辟内存空间，放入跳转等指令的话，是需要给该内存空间加上执行权限的，例如set_memory_x。
• 指令长度问题，将jmp植入check_kill_permission原函数的开头时，需要将开头的指令进行备份，以上演示例子中备份到了do_stub函数空间。而我们需要注意的是备份长度问题，所以我们可以借助insn的api来计算指令长度，而拷贝的指令长度需要大于等于要注入的jmp指令长度（jmp指令长度为5）。
• 堆栈平衡问题，不能随意注入指令，要考虑注入指令之后对内核堆栈的影响。

 

 

 

 

 

 

 

内容总结

以上是互联网集市为您收集整理的linux内核hook技术之指令覆盖与注入全部内容，希望文章能够帮你解决linux内核hook技术之指令覆盖与注入所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---