手把手教你攔截系統調用
一、什麼是系統調用
系統調用 是內核提供給應用程序使用的功能函數，由於應用程序一般運行在 用戶態，處於用戶態的進程有諸多限制（如不能進行 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] = {
...
};當應用程序需要調用一個系統調用時，首先需要將要調用的系統調用號（也就是系統調用所在 sys_call_table 數組的索引）放置到 eax 寄存器中，然後通過使用 int 0x80 指令觸發調用 0x80 號軟中斷服務。
0x80 號軟中斷服務，會通過以下代碼來調用系統調用，如下所示：
...
call *sys_call_table(,%eax,8)
...上面的代碼會根據 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結果如下圖所示：
從上圖可知，sys_call_table 數組的虛擬地址爲：ffffffff818001c0。
第二種方法：通過 kallsyms_lookup_name() 函數來獲取
從 System.map 文件中讀取的方法不是很優雅，所以內核提供了一個名爲 kallsyms_lookup_name() 的函數來獲取內核變量和內核函數的虛擬內存地址。
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");
...
}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));
}第二種方法：設置虛擬地址對應頁表項的讀寫屬性
由於 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;
}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");在上面代碼中，我們將 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要注意添加 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;
}6. 運行結果
第一步：安裝攔截內核模塊
使用以下命令安裝內核模塊：
root# insmod syscall.ko然後通過 dmesg 命令來觀察系統日誌，可以看到以下輸出：
...
[ 133.564652] Hack syscall is starting...這說明我們的內核模塊安裝成功。
第二步：運行測試程序
接着，我們運行剛纔編寫的測試程序，然後觀察系統日誌，輸出如下：
...
[ 532.243714] Hack syscall is successful!!!這說明攔截系統調用成功了。
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/9Q22avY-P7cglTk0gScEGw