手把手教你拦截系统调用

开发 前端
系统调用 是内核提供给应用程序使用的功能函数,由于应用程序一般运行在 用户态,处于用户态的进程有诸多限制(如不能进行 I/O 操作),所以有些功能必须由内核代劳完成。

一、什么是系统调用

系统调用 是内核提供给应用程序使用的功能函数,由于应用程序一般运行在 用户态,处于用户态的进程有诸多限制(如不能进行 I/O 操作),所以有些功能必须由内核代劳完成。而内核就是通过向应用层提供 系统调用,来完成一些在用户态不能完成的工作。

说白了,系统调用其实就是函数调用,只不过调用的是内核态的函数。但与普通的函数调用不同,系统调用不能使用 call 指令来调用,而是需要使用 软中断 来调用。在 Linux 系统中,系统调用一般使用 int 0x80 指令(x86)或者 syscall 指令(x64)来调用。

下面我们以 int 0x80 指令(x86)调用方式为例,来说明系统调用的原理。

二、系统调用原理

在 Linux 内核中,使用 sys_call_table 数组来保存所有系统调用,sys_call_table 数组每一个元素代表着一个系统调用的入口,其定义如下:

typedef void (*sys_call_ptr_t)(void); 
 
const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = { 
    ... 
}; 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

当应用程序需要调用一个系统调用时,首先需要将要调用的系统调用号(也就是系统调用所在 sys_call_table 数组的索引)放置到 eax 寄存器中,然后通过使用 int 0x80 指令触发调用 0x80 号软中断服务。

0x80 号软中断服务,会通过以下代码来调用系统调用,如下所示:

... 
call *sys_call_table(,%eax,8) 
... 
  • 1.
  • 2.
  • 3.

上面的代码会根据 eax 寄存器中的值来调用正确的系统调用,其过程如下图所示:

三、系统调用拦截

了解了系统调用的原理后,要拦截系统调用就很简单了。那么如何拦截呢?

做法就是:我们只需要把 sys_call_table 数组的系统调用换成我们自己编写的函数入口即可。比如,我们想要拦截 write() 系统调用,那么只需要将 sys_call_table 数组的第一个元素换成我们编写好的函数(因为 write() 系统调用在 sys_call_table 数组的索引为1)。

要修改 sys_call_table 数组元素的值,步骤如下:

1. 获取 sys_call_table 数组的地址

要修改 sys_call_table 数组元素的值,一般需要通过内核模块来完成。因为用户态程序由于内存保护机制,不能改写内核态的数据。而内核模块运行在内核态,所以能够跳过这个限制。

要修改 sys_call_table 数组元素的值,首先要获取 sys_call_table 数组的虚拟内存地址(由于 sys_call_table 变量不是一个导出符号,所以内核模块不能直接使用)。

要获取 sys_call_table 数组的虚拟内存地址有两种方法:

第一种方法:从 System.map 文件中读取

System.map 是一份内核符号表,包含了内核中的变量名和函数名地址,在每次编译内核时,自动生成。获取 sys_call_table 数组的虚拟地址使用如下命令:

sudo cat /boot/System.map-`uname -r` | grep sys_call_table 
  • 1.

结果如下图所示:

从上图可知,sys_call_table 数组的虚拟地址为:ffffffff818001c0。

第二种方法:通过 kallsyms_lookup_name() 函数来获取

从 System.map 文件中读取的方法不是很优雅,所以内核提供了一个名为 kallsyms_lookup_name() 的函数来获取内核变量和内核函数的虚拟内存地址。

#include <linux/kallsyms.h> 
 
void func() { 
    ... 
    unsigned long *sys_call_table; 
 
    // 获取 sys_call_table 的虚拟内存地址 
    sys_call_table = (unsigned long *)kallsyms_lookup_name("sys_call_table"); 
    ... 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

2. 设置 sys_call_table 数组为可写状态

是不是获取到 sys_call_table 数组的虚拟地址就可以修改其元素的值呢?没那么简单。

由于 sys_call_table 数组处于写保护区域,并不能直接修改其内容。但有两种方法可以将写保护暂时关闭,如下:

第一种方法:将 cr0 寄存器的第 16 位设置为零

cr0 控制寄存器的第 16 位是写保护位,若设置为零,则允许超级权限往内核中写入数据。这样我们可以在修改 sys_call_table 数组的值前,将 cr0 寄存器的第 16 位清零,使其可以修改 sys_call_table 数组的内容。当修改完后,又将那一位复原即可。

代码如下:

/* 
 * 设置cr0寄存器的第16位为0 
 */ 
unsigned int clear_and_return_cr0(void) 

    unsigned int cr0 = 0; 
    unsigned int ret; 
 
    /* 将cr0寄存器的值移动到rax寄存器中,同时输出到cr0变量中 */ 
    asm volatile ("movq %%cr0, %%rax" : "=a"(cr0)); 
 
    ret = cr0; 
    cr0 &= 0xfffeffff;  /* 将cr0变量值中的第16位清0,将修改后的值写入cr0寄存器 */ 
 
    /* 读取cr0的值到rax寄存器,再将rax寄存器的值放入cr0中 */ 
    asm volatile ("movq %%rax, %%cr0" :: "a"(cr0)); 
 
    return ret; 

 
/* 
 * 还原cr0寄存器的值为val 
 */ 
void setback_cr0(unsigned int val) 

    asm volatile ("movq %%rax, %%cr0" :: "a"(val)); 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

第二种方法:设置虚拟地址对应页表项的读写属性

由于 x86 CPU 的内存保护机制是通过虚拟内存页表来实现的(可以参考这篇文章:漫谈内存映射),所以我们只需要把 sys_call_table 数组的虚拟内存页表项中的保护标志位清空即可,代码如下:

/* 
 * 把虚拟内存地址设置为可写 
 */ 
int make_rw(unsigned long address) 

    unsigned int level
 
    //查找虚拟地址所在的页表地址 
    pte_t *pte = lookup_address(address, &level); 
 
    if (pte->pte & ~_PAGE_RW)  //设置页表读写属性 
        pte->pte |=  _PAGE_RW; 
 
    return 0; 

 
/* 
 * 把虚拟内存地址设置为只读 
 */ 
int make_ro(unsigned long address) 

    unsigned int level
 
    pte_t *pte = lookup_address(address, &level); 
    pte->pte &= ~_PAGE_RW;  //设置只读属性 
 
    return 0; 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.

3. 修改 sys_call_table 数组的内容

万事俱备,只欠东风。前面我们把准备工作都做完了,现在只需要把 sys_call_table 数组中的系统调用入口替换成我们编写的函数入口即可。

我们可以在内核模块初始化函数修改 sys_call_table 数组的值,然后在内核模块退出函数改回成原来的值即可,完整代码如下:

/* 
 * File: syscall.c 
 */ 
 
#include <linux/module.h> 
#include <linux/kernel.h> 
#include <linux/init.h> 
#include <linux/unistd.h> 
#include <linux/time.h> 
#include <asm/uaccess.h> 
#include <linux/sched.h> 
#include <linux/kallsyms.h> 
 
unsigned long *sys_call_table; 
 
unsigned int clear_and_return_cr0(void); 
void setback_cr0(unsigned int val); 
static int sys_hackcall(void); 
 
unsigned long *sys_call_table = 0; 
 
/* 定义一个函数指针,用来保存原来的系统调用*/ 
static int (*orig_syscall_saved)(void); 
 
/* 
 * 设置cr0寄存器的第16位为0 
 */ 
unsigned int clear_and_return_cr0(void) 

    unsigned int cr0 = 0; 
    unsigned int ret; 
 
    /* 将cr0寄存器的值移动到rax寄存器中,同时输出到cr0变量中 */ 
    asm volatile ("movq %%cr0, %%rax" : "=a"(cr0)); 
 
    ret = cr0; 
    cr0 &= 0xfffeffff;  /* 将cr0变量值中的第16位清0,将修改后的值写入cr0寄存器 */ 
 
    /* 读取cr0的值到rax寄存器,再将rax寄存器的值放入cr0中 */ 
    asm volatile ("movq %%rax, %%cr0" :: "a"(cr0)); 
 
    return ret; 

 
/* 
 * 还原cr0寄存器的值为val 
 */ 
void setback_cr0(unsigned int val) 

    asm volatile ("movq %%rax, %%cr0" :: "a"(val)); 

 
/* 
 * 自己编写的系统调用函数 
 */ 
static int sys_hackcall(void) 

    printk("Hack syscall is successful!!!\n"); 
    return 0; 

 
/* 
 * 模块的初始化函数,模块的入口函数,加载模块时调用 
 */ 
static int __init init_hack_module(void) 

    int orig_cr0; 
 
    printk("Hack syscall is starting...\n"); 
 
    /* 获取 sys_call_table 虚拟内存地址 */ 
    sys_call_table = (unsigned long *)kallsyms_lookup_name("sys_call_table"); 
 
    /* 保存原始系统调用 */ 
    orig_syscall_saved = (int(*)(void))(sys_call_table[__NR_perf_event_open]); 
 
    orig_cr0 = clear_and_return_cr0(); /* 设置cr0寄存器的第16位为0 */ 
    sys_call_table[__NR_perf_event_open] = (unsigned long)&sys_hackcall; /* 替换成我们编写的函数 */ 
    setback_cr0(orig_cr0); /* 还原cr0寄存器的值 */ 
 
    return 0; 

 
/* 
 * 模块退出函数,卸载模块时调用 
 */ 
static void __exit exit_hack_module(void) 

    int orig_cr0; 
 
    orig_cr0 = clear_and_return_cr0(); 
    sys_call_table[__NR_perf_event_open] = (unsigned long)orig_syscall_saved; /* 设置为原来的系统调用 */ 
    setback_cr0(orig_cr0); 
 
    printk("Hack syscall is exited....\n"); 

 
module_init(init_hack_module); 
module_exit(exit_hack_module); 
MODULE_LICENSE("GPL"); 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.

在上面代码中,我们将 perf_event_open() 系统调用替换成了我们自己实现的函数。

注意:测试时最好使用冷门的系统调用,否则可能会导致系统崩溃。

4. 编写 Makefile 文件

为了编译方便,我们编写一个 Makefile 文件来进行编译,如下所示:

obj-m:=syscall.o 
PWD:= $(shell pwd) 
KERNELDIR:= /lib/modules/$(shell uname -r)/build 
EXTRA_CFLAGS= -O0 
 
all
    make -C $(KERNELDIR)  M=$(PWD) modules 
clean: 
    make -C $(KERNELDIR) M=$(PWD) clean 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

要注意添加 EXTRA_CFLAGS= -O0 关闭 gcc 优化选项,避免插入模块出错。

5. 测试程序

现在,我们编写一个测试程序来测试一下系统调用拦截是否成功,代码如下:

#include <syscall.h> 
#include <stdio.h> 
#include <unistd.h> 
 
int main(void) 

    unsigned long ret = syscall(__NR_perf_event_open, NULL, 0, 0, 0, 0); 
    printf("%d\n", (int)ret); 
    return 0; 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

6. 运行结果

第一步:安装拦截内核模块

使用以下命令安装内核模块:

root# insmod syscall.ko 
  • 1.

然后通过 dmesg 命令来观察系统日志,可以看到以下输出:

... 
 
[ 133.564652] Hack syscall is starting... 
  • 1.
  • 2.
  • 3.

这说明我们的内核模块安装成功。

第二步:运行测试程序

接着,我们运行刚才编写的测试程序,然后观察系统日志,输出如下:

... 
[  532.243714] Hack syscall is successful!!! 
  • 1.
  • 2.

 

这说明拦截系统调用成功了。

 

责任编辑:武晓燕 来源: Linux内核那些事
相关推荐

2021-12-28 08:38:26

Linux 中断唤醒系统Linux 系统

2021-07-14 09:00:00

JavaFX开发应用

2011-05-03 15:59:00

黑盒打印机

2011-01-10 14:41:26

2011-02-22 14:36:40

ASP.NETmsdnC#

2025-02-19 08:00:00

SpringBootOllamaDeepSeek

2022-07-27 08:16:22

搜索引擎Lucene

2023-04-26 12:46:43

DockerSpringKubernetes

2022-12-07 08:42:35

2022-03-14 14:47:21

HarmonyOS操作系统鸿蒙

2021-12-15 08:49:21

gpio 子系统pinctrl 子系统API

2021-02-26 11:54:38

MyBatis 插件接口

2011-02-22 13:46:27

微软SQL.NET

2021-09-22 08:51:34

Android

2009-07-19 15:02:56

2011-04-28 15:09:15

jQueryjqPlot

2017-07-07 11:01:04

Spark性能调优

2010-09-16 14:08:13

无线双网

2023-03-27 08:28:57

spring代码,starter

2021-07-01 09:31:50

MySQL SQL 语句数据库
点赞
收藏

51CTO技术栈公众号