Linux内核二进制hook的手艺-一个简单的demo

冷不防 2023-07-19 11:00 12阅读 0赞

有时候，我们希望修改Linux的内核某些行为，或者更一般的，我们需要进行一些统计，比如说我们希望实时统计出当前系统的TCP半连接数量。

但问题是，可能没有现成的工具可以使用，也不能重新编译内核，那么怎么办呢？

kpatch机制就是干这个的。

你可能认为我接下来要开始介绍kpatch的原理和用法了。但并不是，我不善于为工具写文档介绍用法，我更擅长手艺人的做法。下面的篇幅，正式开始展示一个不使用kpatch技术来实现等效功能的方法。

我以一个demo开始介绍其原理，下一篇文章我将介绍一个正式的可以使用的例子。如果有一些细节上的疑问，建议在我前两天写的文章中试着找找答案，如果还有问题需要解决，直接email我或者wechat我都可以。

我前面的文章链接如下：  
[https://blog.csdn.net/dog250/article/details/105135219][https_blog.csdn.net_dog250_article_details_105135219]  
[https://blog.csdn.net/dog250/article/details/105129254][https_blog.csdn.net_dog250_article_details_105129254]  
[https://blog.csdn.net/dog250/article/details/105093969][https_blog.csdn.net_dog250_article_details_105093969]

好了，让我们直接上demo模块代码：

#include <linux/module.h>
    #include <linux/proc_fs.h>
    
    static ssize_t sample_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos)
    { 
    	int n = 0;
    	char kb[16];
    
    	if (*ppos != 0) { 
    		return 0;
    	}
    
    	n = sprintf(kb, "%d\n", 1234);
    	memcpy(ubuf, kb, n);
    	*ppos += n;
    	return n;
    }
    
    static struct file_operations sample_ops = { 
    	.owner = THIS_MODULE,
    	.read = sample_read,
    };
    
    static struct proc_dir_entry *ent;
    static int __init sample_init(void)
    { 
    	ent = proc_create("test", 0660, NULL, &sample_ops);
    	if (!ent)
    		return -1;
    
    	return 0;
    }
    
    static void __exit sample_exit(void)
    { 
    	proc_remove(ent);
    }
    
    module_init(sample_init);
    module_exit(sample_exit);
    MODULE_LICENSE("GPL");

该模块会在procfs文件系统中创建/proc/test这个文件，我的目标是，每次读取这个文件的时候，另一个内核模块中的一个计数器counter这个值递增1.

由于模块已经写好了，我们不可能去修改它，这就是展示手艺的点了，我们从外部在另一个模块里来增加计数器递增的操作。

为了hook住sample\_read这个函数，我们先看它的反汇编：

crash> dis sample_read
    0xffffffffa00e1000 <sample_read>:       nopl   0x0(%rax,%rax,1) [FTRACE NOP]
    0xffffffffa00e1005 <sample_read+5>:     push   %rbp
    0xffffffffa00e1006 <sample_read+6>:     mov    %rsp,%rbp
    0xffffffffa00e1009 <sample_read+9>:     push   %r13
    0xffffffffa00e100b <sample_read+11>:    push   %r12
    0xffffffffa00e100d <sample_read+13>:    push   %rbx
    0xffffffffa00e100e <sample_read+14>:    mov    %rcx,%rbx
    0xffffffffa00e1011 <sample_read+17>:    sub    $0x18,%rsp
    0xffffffffa00e1015 <sample_read+21>:    mov    %gs:0x28,%rax
    0xffffffffa00e101e <sample_read+30>:    mov    %rax,-0x20(%rbp)
    0xffffffffa00e1022 <sample_read+34>:    xor    %eax,%eax
    // 下面是if (*ppos != 0) 判断语句
    0xffffffffa00e1024 <sample_read+36>:    cmpq   $0x0,(%rcx)
    0xffffffffa00e1028 <sample_read+40>:    jne    0xffffffffa00e105a <sample_read+90>
    // 下面的两行就是HOOK点！！！
    0xffffffffa00e102a <sample_read+42>:    lea    -0x30(%rbp),%rdi
    0xffffffffa00e102e <sample_read+46>:    mov    %rsi,%r13
    0xffffffffa00e1031 <sample_read+49>:    mov    $0x4d2,%edx
    0xffffffffa00e1036 <sample_read+54>:    mov    $0xffffffffa00e2024,%rsi
    0xffffffffa00e103d <sample_read+61>:    callq  0xffffffff812fd960 <sprintf>

我们只需要将lea和后面mov两行替换成一个jmp/call到自己定义的地址就可以了，同时把lea/mov移到自定义的逻辑里面去执行，执行完成后，在jmp/ret回来。

本例中，为了避免jmp过去后再jmp回来，所以使用call，因为ret可以自动jmp回来。

非常简单的逻辑，直接上代码吧：

#include <linux/module.h>
    #include <linux/slab.h>
    #include <linux/cpu.h>
    
    char *stub;
    char *addr = NULL;
    
    // laddr 参数保存sample_read的地址，通过/proc/kallsyms查询后传入
    static unsigned long laddr = 0xffffffffa0267000;
    module_param(laddr, ulong, 0644);
    
    // 独立的计数器，每次读取/proc/test时，该计数器加1
    static unsigned int counter = 0;
    module_param(counter, int, 0444);
    
    void test_stub1(void) __attribute__ ((aligned (1024)));
    void test_stub2(void) __attribute__ ((aligned (1024)));
    void test_stub1(void)
    { 
    	printk("yes\n");
    }
    void test_stub2(void)
    { 
    	printk("yes yes\n");
    }
    
    #define POKE_OFFSET 42 // sample_read的42偏移处需要被poke成jmp
    #define POKE_LENGTH 7 // 被poke的必须是完整的指令行，如果有空余的，用nop填充
    
    // text_poke和text_mutex通过/proc/kallsyms查询地址
    static void *(*_text_poke_smp)(void *addr, const void *opcode, size_t len);
    static struct mutex *_text_mutex;
    
    static int __init hotfix_init(void)
    { 
    	unsigned char e8_call[POKE_LENGTH];
    	unsigned char incl[8];
    	s32 offset;
    	u32 low32 = (unsigned int)(((unsigned long)&counter) & 0xffffffff);
    
    	addr = (void *)laddr;
    
    	_text_poke_smp = (void *)0xffffffff8163e1f0;
    	_text_mutex = (void *)0xffffffff81984920;
    
    	stub = (void *)test_stub1;
    
    
    	offset = (s32)((long)stub - (long)addr - 5);
    
    	// 插入的指令中需要save/restore寄存器，但这里简单，略过
    	incl[0] = 0xff;
    	incl[1] = 0x04;
    	incl[2] = 0x25;
    	(*(u32 *)(&incl[3])) = low32; // 写入需要递增的counter变量地址
    	incl[7] = 0xc3; // retq 指令
    
    	// 执行poke：1. 首先拷贝原始函数中的指令； 2. 其次写入新增的计数器递增指令 
    	_text_poke_smp(&stub[0], &addr[POKE_OFFSET], POKE_LENGTH);
    	_text_poke_smp(&stub[POKE_LENGTH], &incl, 8);
    
    	// call比jmp方便，可以自动帮忙return，不然还要自己jmp回来，但是代价是push/pop
    	e8_call[0] = 0xe8;
    	(*(s32 *)(&e8_call[1])) = offset - POKE_OFFSET;
    	e8_call[5] = 0x90; e8_call[6] = 0x90; // nop 占位符
    	get_online_cpus();
    	mutex_lock(_text_mutex);
    	// 执行call指令替换
    	_text_poke_smp(&addr[POKE_OFFSET], e8_call, POKE_LENGTH);
    	mutex_unlock(_text_mutex);
    	put_online_cpus();
    
    	return 0;
    }
    
    static void __exit hotfix_exit(void)
    { 
    	get_online_cpus();
    	mutex_lock(_text_mutex);
    	_text_poke_smp(&addr[POKE_OFFSET], &stub[0], POKE_LENGTH);
    	mutex_unlock(_text_mutex);
    	put_online_cpus();
    }
    
    module_init(hotfix_init);
    module_exit(hotfix_exit);
    MODULE_LICENSE("GPL");

我们看下效果：

[root@localhost ~]# cat /proc/test
    1234
    [root@localhost ~]# cat /sys/module/nowa/parameters/counter
    1
    [root@localhost ~]# cat /proc/test
    1234
    [root@localhost ~]# cat /sys/module/nowa/parameters/counter
    2
    [root@localhost ~]# cat /proc/test
    1234
    [root@localhost ~]# cat /sys/module/nowa/parameters/counter
    3

已经实现效果了。我们看一下原始的sample\_read和test\_stub1变成了什么样子：

crash> dis sample_read
    ...
    0xffffffffa00e1024 <sample_read+36>:    cmpq   $0x0,(%rcx)
    0xffffffffa00e1028 <sample_read+40>:    jne    0xffffffffa00e105a <sample_read+90>
    // 注意下面的7个字节的指令，已经被替换了
    0xffffffffa00e102a <sample_read+42>:    callq  0xffffffffa0264000 <test_stub1>
    0xffffffffa00e102f <sample_read+47>:    nop
    0xffffffffa00e1030 <sample_read+48>:    nop
    0xffffffffa00e1031 <sample_read+49>:    mov    $0x4d2,%edx
    ...
    crash> dis test_stub1
    // 下面的7字节指令拷贝自原始函数
    0xffffffffa0264000 <test_stub1>:        lea    -0x30(%rbp),%rdi
    0xffffffffa0264004 <test_stub1+4>:      mov    %rsi,%r13
    // 计数器递增指令
    0xffffffffa0264007 <test_stub1+7>:      incl   0xffffffffa0266278
    0xffffffffa026400e <test_stub1+14>:     retq
    ...

--------------------

浙江温州皮鞋湿，下雨进水不会胖。

[https_blog.csdn.net_dog250_article_details_105135219]: https://blog.csdn.net/dog250/article/details/105135219
[https_blog.csdn.net_dog250_article_details_105129254]: https://blog.csdn.net/dog250/article/details/105129254
[https_blog.csdn.net_dog250_article_details_105093969]: https://blog.csdn.net/dog250/article/details/105093969