Linux 内核: 系统调用挂钩示例

我正在尝试编写一些简单的测试代码，作为挂钩系统调用表的演示。

“ sys _ call _ table”在2.6中不再导出，所以我只是从 System.map 文件中获取地址，我可以看到它是正确的(查看我找到的地址的内存，我可以看到指向系统调用的指针)。

但是，当我试图修改这个表时，内核会发出一个“ Oops”，表示“无法在虚拟地址 c061e4f4处理内核分页请求”，然后机器重新启动。

这是 CentOS 5.4，运行2.6.18-164.10.1。El5.有什么保护措施吗，还是我只是被窃听了？我知道它是 SELinux 自带的，我也试过把它设置为允许模式，但是没有什么区别

这是我的密码:

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>


void **sys_call_table;


asmlinkage int (*original_call) (const char*, int, int);


asmlinkage int our_sys_open(const char* file, int flags, int mode)
{
printk("A file was opened\n");
return original_call(file, flags, mode);
}


int init_module()
{
// sys_call_table address in System.map
sys_call_table = (void*)0xc061e4e0;
original_call = sys_call_table[__NR_open];


// Hook: Crashes here
sys_call_table[__NR_open] = our_sys_open;
}


void cleanup_module()
{
// Restore the original call
sys_call_table[__NR_open] = original_call;
}
77960 次浏览
小开
最佳答案

我终于自己找到了答案。

Http://www.linuxforums.org/forum/linux-kernel/133982-cannot-modify-sys_call_table.html

内核在某个时候发生了变化，因此系统调用表是只读的。

密码朋克:

即使为时已晚，但解决之道 可能也会引起其他人的兴趣 你会发现 entry.S 文件: 代码:

.section .rodata,"a"
#include "syscall_table_32.S"

Sys _ call _ table-> ReadOnly 你必须 如果需要，可以编译新的内核 使用 sys _ call _ table 进行“黑客攻击”..。

该链接还有一个将内存更改为可写的示例。

Nasekomoe:

大家好，谢谢你们的回复 很久以前就解决了这个问题 修改对内存页的访问 实现了两个功能 这是我的上层代码:

#include <asm/cacheflush.h>
#ifdef KERN_2_6_24
#include <asm/semaphore.h>
int set_page_rw(long unsigned int _addr)
{
struct page *pg;
pgprot_t prot;
pg = virt_to_page(_addr);
prot.pgprot = VM_READ | VM_WRITE;
return change_page_attr(pg, 1, prot);
}


int set_page_ro(long unsigned int _addr)
{
struct page *pg;
pgprot_t prot;
pg = virt_to_page(_addr);
prot.pgprot = VM_READ;
return change_page_attr(pg, 1, prot);
}


#else
#include <linux/semaphore.h>
int set_page_rw(long unsigned int _addr)
{
return set_memory_rw(_addr, 1);
}


int set_page_ro(long unsigned int _addr)
{
return set_memory_ro(_addr, 1);
}


#endif // KERN_2_6_24

这里有一个修改过的原始代码版本，对我很有用。

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>
#include <asm/semaphore.h>
#include <asm/cacheflush.h>


void **sys_call_table;


asmlinkage int (*original_call) (const char*, int, int);


asmlinkage int our_sys_open(const char* file, int flags, int mode)
{
printk("A file was opened\n");
return original_call(file, flags, mode);
}


int set_page_rw(long unsigned int _addr)
{
struct page *pg;
pgprot_t prot;
pg = virt_to_page(_addr);
prot.pgprot = VM_READ | VM_WRITE;
return change_page_attr(pg, 1, prot);
}


int init_module()
{
// sys_call_table address in System.map
sys_call_table = (void*)0xc061e4e0;
original_call = sys_call_table[__NR_open];


set_page_rw(sys_call_table);
sys_call_table[__NR_open] = our_sys_open;
}


void cleanup_module()
{
// Restore the original call
sys_call_table[__NR_open] = original_call;
}
小开

请注意，以下内容也可以替代 change _ page _ attr，并且不能折旧:

static void disable_page_protection(void) {


unsigned long value;
asm volatile("mov %%cr0,%0" : "=r" (value));
if (value & 0x00010000) {
value &= ~0x00010000;
asm volatile("mov %0,%%cr0": : "r" (value));
}
}


static void enable_page_protection(void) {


unsigned long value;
asm volatile("mov %%cr0,%0" : "=r" (value));
if (!(value & 0x00010000)) {
value |= 0x00010000;
asm volatile("mov %0,%%cr0": : "r" (value));
}
}
小开

谢谢你，斯蒂芬，你的研究对我很有帮助。但是，我遇到了一些问题，因为我在2.6.32内核上尝试了这种方法，然后得到了 WARNING: at arch/x86/mm/pageattr.c:877 change_page_attr_set_clr+0x343/0x530() (Not tainted)和一个内核 OOPS，后者表示无法写入内存地址。

上述一行的评论说:

// People should not be passing in unaligned addresses

下列修订守则的作用:

int set_page_rw(long unsigned int _addr)
{
return set_memory_rw(PAGE_ALIGN(_addr) - PAGE_SIZE, 1);
}


int set_page_ro(long unsigned int _addr)
{
return set_memory_ro(PAGE_ALIGN(_addr) - PAGE_SIZE, 1);
}

注意，在某些情况下，这实际上仍然没有将页面设置为读/写。在 set_memory_rw()内部调用的 static_protections()函数在以下情况下移除 _PAGE_RW标志:

  • 在 BIOS 区域
  • 地址在里面
  • 设置 CONFIG _ DEBUG _ RODATA，并将内核设置为只读

在调试之后，我发现了为什么在修改内核函数的地址时仍然“无法处理内核分页请求”。我最终能够通过自己找到地址的页表条目并手动将其设置为可写来解决这个问题。值得庆幸的是，lookup_address()函数是在2.6.26 + 版本中导出的。下面是我为此编写的代码:

void set_addr_rw(unsigned long addr) {


unsigned int level;
pte_t *pte = lookup_address(addr, &level);


if (pte->pte &~ _PAGE_RW) pte->pte |= _PAGE_RW;


}


void set_addr_ro(unsigned long addr) {


unsigned int level;
pte_t *pte = lookup_address(addr, &level);


pte->pte = pte->pte &~_PAGE_RW;


}

最后，虽然 Mark 的答案在技术上是正确的，但是在 Xen 中运行时会出现问题。如果要禁用写保护，请使用读/写 cr0函数。我把它们宏观化如下:

#define GPF_DISABLE write_cr0(read_cr0() & (~ 0x10000))
#define GPF_ENABLE write_cr0(read_cr0() | 0x10000)

希望这对其他碰到这个问题的人有所帮助。

小开

如果您正在处理内核3.4或更高版本(它也可以处理早期的内核，我没有测试它) ，我会推荐一种更聪明的方法来获取系统调用表的位置。

比如说

#include <linux/module.h>
#include <linux/kallsyms.h>


static unsigned long **p_sys_call_table;
/* Aquire system calls table address */
p_sys_call_table = (void *) kallsyms_lookup_name("sys_call_table");

就这样，没有地址，我测试过的所有内核都能正常工作。

与使用模块中未导出的 Kernel 函数的方法相同:

static int (*ref_access_remote_vm)(struct mm_struct *mm, unsigned long addr,
void *buf, int len, int write);
ref_access_remote_vm = (void *)kallsyms_lookup_name("access_remote_vm");

好好享受吧！

小开

正如其他人所暗示的那样，现代内核的整体情况有所不同。我将在这里报道 x86-64，现代武器上的系统呼叫劫持请参阅 我的另一个答案。还有 注意: 这是简单明了的系统调用 劫机。使用 火箭筒可以更好地完成非侵入性挂钩。

从 Linux v4.17开始，x86(64位和32位)现在使用以 struct pt_regs *作为唯一参数的 syscall 包装器(参见 第一次犯罪，第二项)。您可以看到 arch/x86/include/asm/syscall.h的定义。

此外，正如其他人已经在不同的答案中描述的那样，修改 sys_call_table的最简单方法是暂时禁用 CR0 WP (写保护)位，这可以使用 read_cr0()和 write_cr0()来完成。但是，自从 Linux v5.3以来，[native_]write_cr0将检查永远不应该更改的敏感位(如 WP) ，并拒绝更改它们(承诺)。为了解决这个问题，我们需要使用内联汇编手动编写 CR0。

下面是一个工作的内核模块(在 Linux 5.10和5.18上测试过) ，它在现代 Linux x86-64上进行系统调用劫持，考虑到上面的警告，并假设您已经知道 sys_call_table的地址(如果您也想在模块中找到它，请参阅 Linux 内核模块中获取非导出内核符号地址的正确方法) :

// SPDX-License-Identifier: (GPL-2.0 OR MIT)
/**
* Test syscall table hijacking on x86-64. This module will replace the `read`
* syscall with a simple wrapper which logs every invocation of `read` using
* printk().
*
* Tested on Linux x86-64 v5.10, v5.18.
*
* Usage:
*
*     sudo cat /proc/kallsyms | grep sys_call_table # grab address
*     sudo insmod syscall_hijack.ko sys_call_table_addr=0x<address_here>
*/


#include <linux/init.h>          // module_{init,exit}()
#include <linux/module.h>        // THIS_MODULE, MODULE_VERSION, ...
#include <linux/kernel.h>        // printk(), pr_*()
#include <asm/special_insns.h>   // {read,write}_cr0()
#include <asm/processor-flags.h> // X86_CR0_WP
#include <asm/unistd.h>          // __NR_*


#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt


typedef long (*sys_call_ptr_t)(const struct pt_regs *);


static sys_call_ptr_t *real_sys_call_table;
static sys_call_ptr_t original_read;


static unsigned long sys_call_table_addr;
module_param(sys_call_table_addr, ulong, 0);
MODULE_PARM_DESC(sys_call_table_addr, "Address of sys_call_table");


// Since Linux v5.3 [native_]write_cr0 won't change "sensitive" CR0 bits, need
// to re-implement this ourselves.
static void write_cr0_unsafe(unsigned long val)
{
asm volatile("mov %0,%%cr0": "+r" (val) : : "memory");
}


static long myread(const struct pt_regs *regs)
{
pr_info("read(%ld, 0x%lx, %lx)\n", regs->di, regs->si, regs->dx);
return original_read(regs);
}


static int __init modinit(void)
{
unsigned long old_cr0;


real_sys_call_table = (typeof(real_sys_call_table))sys_call_table_addr;


pr_info("init\n");


// Temporarily disable CR0 WP to be able to write to read-only pages
old_cr0 = read_cr0();
write_cr0_unsafe(old_cr0 & ~(X86_CR0_WP));


// Overwrite syscall and save original to be restored later
original_read = real_sys_call_table[__NR_read];
real_sys_call_table[__NR_read] = myread;


// Restore CR0 WP
write_cr0_unsafe(old_cr0);
pr_info("init done\n");


return 0;
}


static void __exit modexit(void)
{
unsigned long old_cr0;


pr_info("exit\n");


old_cr0 = read_cr0();
write_cr0_unsafe(old_cr0 & ~(X86_CR0_WP));


// Restore original syscall
real_sys_call_table[__NR_read] = original_read;


write_cr0_unsafe(old_cr0);


pr_info("goodbye\n");
}


module_init(modinit);
module_exit(modexit);
MODULE_VERSION("0.1");
MODULE_DESCRIPTION("Test syscall table hijacking on x86-64.");
MODULE_AUTHOR("Marco Bonelli");
MODULE_LICENSE("Dual MIT/GPL");

提交答案