AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Linux Kernel sys_call_table、Kernel Symbols Export Table Generation Principle、Difference Between System Calls Entrance In 32bit、64bit Linux【转】

2017-11-08 1532
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
复制代码

转自：http://www.cnblogs.com/LittleHann/p/4127096.html

目录

1. sys_call_table：系统调用表
2. 内核符号导出表：Kernel-Symbol-Table
3. Linux 32bit、64bit环境下系统调用入口的异同
4. Linux 32bit、64bit环境下sys_call_table replace hook

 

1. sys_call_table：系统调用表

0x1: sys_call_table简介

sys_call_table在Linux内核中是在Linux内核中的一段连续内存的数组，数组中的每个元素保存着对应的系统调用处理函数的内存地址

复制代码
复制代码 
1. 32bit：
cat /boot/System.map-3.13.0-32-generic | grep sys_call_table
c1663140 R sys_call_table

2. 64bit
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_call_table
ffffffff81600460 R sys_call_table

3. 64bit 兼容 32bit
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep ia32sys_call_table
ffffffff8160a1f8 r ia32_sys_call_table
复制代码
复制代码

sys_call_table由Linux内核在初始化的时候填充，从内核源代码中可以得到它的声明和定义

复制代码
复制代码 
1. 32bit：
/source/arch/x86/kernel/syscall_32.c
__visible const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = 
{
/*
* Smells like a compiler bug -- it doesn't work
* when the & below is removed.
*/
    [0 ... __NR_syscall_max] = &sys_ni_syscall, 
    #include <asm/syscalls_32.h>
};

2. 64bit
/source/arch/x86/kernel/syscall_64.c
asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = 
{
/*
* Smells like a compiler bug -- it doesn't work
* when the & below is removed.
*/
    [0 ... __NR_syscall_max] = &sys_ni_syscall,
    #include <asm/syscalls_64.h>
};

3. 64bit 兼容 32bit
/source/arch/x86/ia32/syscall_ia32.c
const sys_call_ptr_t ia32_sys_call_table[__NR_ia32_syscall_max+1] = 
{
/*
* Smells like a compiler bug -- it doesn't work
* when the & below is removed.
*/
    [0 ... __NR_ia32_syscall_max] = &compat_ni_syscall,
    #include <asm/syscalls_32.h>
};
复制代码
复制代码

Relevant Link:

深入linux内核架构(中文版).pdf
http://www.cnblogs.com/LittleHann/p/3850653.html
http://www.cnblogs.com/LittleHann/p/3854977.html

0x2: Linux下获取sys_call_table内核地址的方式

http://www.cnblogs.com/LittleHann/p/3854977.html
//搜索：0x3: 获取sys_call_table的常用方法

 

2. 内核符号导出表：Kernel-Symbol-Table
驱动LKM也是存在于内核空间的，函数中的函数、变量都会有对应的符号，这部分符号也可以称作内核符号，这些内核符号有两种状态

1. 导出(EXPORT_SYMBOL)
在内核代码中明确声明EXPORT_SYMBOL(xxxx_FUNCTION)之后，这个函数就可以作为内核对外的接口，供外部使用了。对于这部分导出的内核符号表我们称之为"内核导出符号表"

2. 不导出
对于不导出的内核函数，只能在内核中使用

insmod的时候并不是所有的函数都得到内核符号表去寻找对应的符号，每一个驱动在自已的分配的空间里也会存在一份符号表，里面有关于这个驱动里使用到的变量以及函数的一些符号，首先驱动会在这里面找，如果发现找不到就会去公共内核符号表中搜索，搜索到了则该模块加载成功，搜索不到则该模块加载失败

可以通过nm -l xx.ko来查看一个模块里的符号情况

复制代码
复制代码 
nm -l find_sys_call_table.ko
/*
00000000 T cleanup_module
00000030 T find_sys_call_table
000000b6 T init_module
         U loops_per_jiffy
         U mcount
00000ef8 r __module_depends
         U printk    find_sys_call_table.c:0
000000b6 t syscall_init
000001c1 t syscall_release
00000000 B syscall_table
         U sys_close
00007980 D __this_module
00000ec9 r __UNIQUE_ID_license0
00000ed5 r __UNIQUE_ID_srcversion1
00000f01 r __UNIQUE_ID_vermagic0
00003c20 r ____versions
*/
复制代码
复制代码

在Linux内核中，大部分的函数、变量都是导出的，我们可以通过对内核符号表的遍历搜索得到我们想要获得的内核函数、内核变量的地址
 

3. Linux 32bit、64bit下系统调用入口的异同

以sys_execve、sys_socketcall、sys_init_module这三个系统调用作为研究对象，为了更好的说明问题，我们打印一下Linux 64bit的sys_call_table的函数指针地址

find_sys_call_table.c

复制代码
复制代码 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <asm/uaccess.h>
#include <asm/cacheflush.h>
#include <linux/syscalls.h>
#include <linux/delay.h>    // loops_per_jiffy

/* Just so we do not taint the kernel */
MODULE_LICENSE("GPL");

void **syscall_table;
unsigned long **find_sys_call_table(void);

unsigned long **find_sys_call_table() {
    
    unsigned long ptr;
    unsigned long *p;

    for (ptr = (unsigned long)sys_close;
         ptr < (unsigned long)&loops_per_jiffy;
         ptr += sizeof(void *)) {
             
        p = (unsigned long *)ptr;

        if (p[__NR_close] == (unsigned long)sys_close) {
            printk(KERN_DEBUG "Found the sys_call_table!!!\n");
            return (unsigned long **)p;
        }
    }
    
    return NULL;
} 

static int __init syscall_init(void)
{
    int ret;
    unsigned long addr;
    unsigned long cr0;
    int num = 0;
  
    syscall_table = (void **)find_sys_call_table();

    if (!syscall_table) 
    {
        printk(KERN_DEBUG "Cannot find the system call address\n"); 
        return -1;
    }

    do
        {
            printk("%d:  the address is: %16x\n", num, syscall_table[num]);
            num++;
        } while (num < 400);
  
    return 0;
}

static void __exit syscall_release(void)
{ 
}

module_init(syscall_init);
module_exit(syscall_release);
复制代码
复制代码

Makefile

复制代码
复制代码 
obj-m := find_sys_call_table.o 
PWD       := $(shell pwd)

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    rm -rf *.o *~ core .*.cmd *.mod.c ./tmp_version *.ko modules.order  Module.symvers

clean_omit:
    rm -rf *.o *~ core .*.cmd *.mod.c ./tmp_version modules.order  Module.symvers
复制代码
复制代码

0x1: Linux 32bit

1. sys_execve

对于Linux 32bit操作系统来说，sys_execve的系统调用号、以及在它在sys_call_table中的索引位置

复制代码
复制代码 
\linux-3.15.5\arch\sh\include\uapi\asm\unistd_32.h
#define __NR_execve         11

//系统调用处理函数在内核内存中的地址可以通过以下方式得到
cat /boot/System.map-3.13.0-32-generic | grep sys_execve
c117fc00 T sys_execve

//和sys_call_table中的函数地址进行逐行对比
cat info | grep c117fc00
[16595.247404] 11:  the address is:         c117fc00
复制代码
复制代码

在正常情况下(当前linux没有被rootkit、sys_call_table没有被hooked)，sys_call_table(系统调用表)中的函数地址和内核导出符号表中的函数地址应该是相同的，即

sys_call_table[__NR_sys_execve] = cat /boot/System.map-3.13.0-32-generic | grep sys_execve

系统调用函数的入口点跟踪如下

linux-3.15.5\fs\exec.c

复制代码
复制代码 
SYSCALL_DEFINE3(execve,
        const char __user *, filename,
        const char __user *const __user *, argv,
        const char __user *const __user *, envp)
{
    return do_execve(getname(filename), argv, envp);
}
复制代码
复制代码

这是个宏定义，等价于对sys_execve的声明

复制代码
复制代码 
int do_execve(struct filename *filename,
    const char __user *const __user *__argv,
    const char __user *const __user *__envp)
{
    struct user_arg_ptr argv = { .ptr.native = __argv };
    struct user_arg_ptr envp = { .ptr.native = __envp };
    return do_execve_common(filename, argv, envp);
}
复制代码
复制代码

2. sys_socketcall

复制代码
复制代码 
\linux-3.15.5\arch\sh\include\uapi\asm\unistd_32.h
#define __NR_socketcall        102

//系统调用处理函数在内核内存中的地址可以通过以下方式得到
cat /boot/System.map-3.13.0-32-generic | grep sys_socketcall
c1560100 T sys_socketcall

//和sys_call_table中的函数地址进行逐行对比
cat info | grep c1560100
[16595.247515] 102:  the address is:         c1560100
复制代码
复制代码

\linux-3.15.5\net\socket.c

复制代码
复制代码 
/*
进行socket调用派发
*/
SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
{
    unsigned long a[AUDITSC_ARGS];
    unsigned long a0, a1;
    int err;
    unsigned int len;

    if (call < 1 || call > SYS_SENDMMSG)
        return -EINVAL;

    len = nargs[call];
    if (len > sizeof(a))
        return -EINVAL;

    /* copy_from_user should be SMP safe. */
    if (copy_from_user(a, args, len))
        return -EFAULT;

    err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
    if (err)
        return err;

    a0 = a[0];
    a1 = a[1];

    switch (call) {
    case SYS_SOCKET:
        err = sys_socket(a0, a1, a[2]);
        break;
    case SYS_BIND:
        err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
        break;
    case SYS_CONNECT:
        err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
        break;
    case SYS_LISTEN:
        err = sys_listen(a0, a1);
        break;
    case SYS_ACCEPT:
        err = sys_accept4(a0, (struct sockaddr __user *)a1,
                  (int __user *)a[2], 0);
        break;
    case SYS_GETSOCKNAME:
        err =
            sys_getsockname(a0, (struct sockaddr __user *)a1,
                    (int __user *)a[2]);
        break;
    case SYS_GETPEERNAME:
        err =
            sys_getpeername(a0, (struct sockaddr __user *)a1,
                    (int __user *)a[2]);
        break;
    case SYS_SOCKETPAIR:
        err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
        break;
    case SYS_SEND:
        err = sys_send(a0, (void __user *)a1, a[2], a[3]);
        break;
    case SYS_SENDTO:
        err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
                 (struct sockaddr __user *)a[4], a[5]);
        break;
    case SYS_RECV:
        err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
        break;
    case SYS_RECVFROM:
        err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
                   (struct sockaddr __user *)a[4],
                   (int __user *)a[5]);
        break;
    case SYS_SHUTDOWN:
        err = sys_shutdown(a0, a1);
        break;
    case SYS_SETSOCKOPT:
        err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
        break;
    case SYS_GETSOCKOPT:
        err =
            sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
                   (int __user *)a[4]);
        break;
    case SYS_SENDMSG:
        err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
        break;
    case SYS_SENDMMSG:
        err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
        break;
    case SYS_RECVMSG:
        err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
        break;
    case SYS_RECVMMSG:
        err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
                   (struct timespec __user *)a[4]);
        break;
    case SYS_ACCEPT4:
        err = sys_accept4(a0, (struct sockaddr __user *)a1,
                  (int __user *)a[2], a[3]);
        break;
    default:
        err = -EINVAL;
        break;
    }
    return err;
}
复制代码
复制代码

3. sys_init_module

复制代码
复制代码 
\linux-3.15.5\arch\sh\include\uapi\asm\unistd_32.h
#define __NR_init_module    128

//系统调用处理函数在内核内存中的地址可以通过以下方式得到
cat /boot/System.map-3.13.0-32-generic | grep sys_init_module
c10c4820 T sys_init_module

//和sys_call_table中的函数地址进行逐行对比
cat info | grep c10c4820
[16595.247540] 128:  the address is:         c10c4820
复制代码
复制代码

\linux-3.15.5\kernel\module.c

复制代码
复制代码 
SYSCALL_DEFINE3(init_module, void __user *, umod,
        unsigned long, len, const char __user *, uargs)
{
    int err;
    struct load_info info = { };

    err = may_init_module();
    if (err)
        return err;

    pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n", umod, len, uargs);

    err = copy_module_from_user(umod, len, &info);
    if (err)
        return err;

    return load_module(&info, uargs, 0);
}
复制代码
复制代码

0x2: Linux 64bit

在Linux 64bit下，系统调用的入口点和32bit下有一点区别

1. sys_execve

复制代码
复制代码 
/source/arch/x86/syscalls/syscall_64.tbl
#
# 64-bit system call numbers and entry vectors
#
# The format is:
# <number> <abi> <name> <entry point>
#
# The abi is "common", "64" or "x32" for this file.
59      64      execve                  stub_execve

//在内核符号导出表中得到的内核内存地址
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep stub_execve
ffffffff8100b4e0 T stub_execve
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_execve
ffffffff810095b0 T sys_execve

//在sys_call_table中搜索系统调用函数地址
cat info | grep 8100b4e0: [10298.905575] 59:  the address is:         8100b4e0
cat info | grep 810095b0: no result

//对于64bit的Linux系统来说，在系统调用外层使用了stub(wrapper functions)
\linux-3.15.5\arch\x86\kernel\entry_64.S
ENTRY(stub_execve)
    CFI_STARTPROC
    addq $8, %rsp
    PARTIAL_FRAME 0
    SAVE_REST
    FIXUP_TOP_OF_STACK %r11
    call sys_execve
    movq %rax,RAX(%rsp)
    RESTORE_REST
    jmp int_ret_from_sys_call
    CFI_ENDPROC
END(stub_execve)
复制代码
复制代码

在Linux 64bit下，stub_execve就是sys_execve的wrapper函数

/source/arch/x86/um/sys_call_table_64.c

#define stub_execve sys_execve

这也意味着在Linux 64bit下，sys_execeve在sys_call_table里不存在了，而是用stub_execve取代了，我们的hook对象也就是stub_execve

2. sys_socketcall

sys_socketcall 只适用于x86-32平台下适用，在非x86-32平台下，sys_socketcall是不存在的，Linux 64bit将sys_socketcall的"系统调用派发机制"拆分成了分别独立的系统调用，例如sys_socket、sys_bind、 sys_connect

复制代码
复制代码 
//找到Linux 64bit对应的unistd_64.h文件
find /usr/src/kernels/`uname -r` -name unistd_64.h
vim /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h

1. sys_socket
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_socket
ffffffff8140a210 T sys_socket
cat info | grep 8140a210
[924227.139549] 41:  the address is:         8140a210
cat /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h | grep __NR_socket
#define __NR_socket                             41
__SYSCALL(__NR_socket, sys_socket)


2. sys_connect
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_connect
ffffffff8140bfb0 T sys_connect
[924227.139550] 42:  the address is:         8140bfb0
cat /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h | grep __NR_connect
#define __NR_connect                42
__SYSCALL(__NR_connect, sys_connect)


3. sys_bind
cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_bind
ffffffff8140c0a0 T sys_bind
[924227.139558] 49:  the address is:         8140c0a0
cat /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h | grep __NR_bind
#define __NR_bind                49
__SYSCALL(__NR_bind, sys_bind)
复制代码
复制代码

在Linux 64bit环境下，可以直接针对sys_connect(即TCP_CONNECT动作进行监控)

3. sys_init_module

复制代码
复制代码 
//找到Linux 64bit对应的unistd_64.h文件
find /usr/src/kernels/`uname -r` -name unistd_64.h
vim /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h

cat /boot/System.map-2.6.32-220.23.2.ali878.el6.x86_64 | grep sys_init_module
ffffffff810afe50 T sys_init_module
cat info | grep 810afe50
[924227.139712] 175:  the address is:         810afe50

cat /usr/src/kernels/2.6.32-220.23.2.ali878.el6.x86_64/arch/x86/include/asm/unistd_64.h | grep __NR_init_module
#define __NR_init_module                        175
__SYSCALL(__NR_init_module, sys_init_module)
复制代码
复制代码

Relevant Link:

http://stackoverflow.com/questions/9940391/looking-for-a-detailed-document-on-linux-system-calls

 

4. Linux 32bit、64bit环境下sys_call_table replace hook：建立通用兼容性的sys_call_table Replace Hook Engine

0x1: Linux 32/64bit Hook Point

复制代码
复制代码 
1. 32bit
    1) sys_execve
    2) sys_socketcall
    3) sys_init_module
2. 64bit
    1) stub_execve
    2) sys_connect
    3) sys_init_module
复制代码
复制代码

0x2: Linux 32/64bit __NR_XX定义的异同

在进行sys_call_table replace hook的时候，我们往往需要借助系统头文件<asm/unistd.h>的__NR_XX宏定义来定位寻址到我们要hook的目标系统调用处理函数，需要注意的是，这个宏定义在32/64bit的Linux上存在着一些差异，我们在编写sys_call_table hook engine的时候需要特别注意这块的兼容性

print_NR.c

复制代码
复制代码 
#include <asm/unistd.h>
#include <linux/module.h>    // included for all kernel modules
#include <linux/kernel.h>    // included for KERN_INFO
#include <linux/init.h>        // included for __init and __exit macros
 
static int __init hello_init(void)
{ 
    //在32bit Linux下编译(未做跨平台兼容)
    /*
    printk("__NR_execve: %d\n", __NR_execve);
    printk("__NR_socketcall: %d\n", __NR_socketcall);
    printk("__NR_init_module: %d\n", __NR_init_module);
    */

    //在64bit Linux下编译(未做跨平台兼容)
    printk("__NR_execve: %d\n", __NR_execve); 
    printk("__NR_connect: %d\n", __NR_connect);
    printk("__NR_init_module: %d\n", __NR_init_module);
 
    printk(KERN_INFO "Hello world!\n"); 
    return 0;    // Non-zero return means that the module couldn't be loaded.
}
 
static void __exit hello_cleanup(void)
{
    printk(KERN_INFO "Cleaning up module.\n");
}
 
module_init(hello_init);
module_exit(hello_cleanup);
复制代码
复制代码

在Linux 32bit、Linux 64bit环境下分别作编译，结果如下

复制代码
复制代码 
1. 32 bit
[22726.762562] __NR_execve: 11: sys_execve
[22726.762570] __NR_socketcall: 102: sys_socketcall
[22726.762573] __NR_init_module: 128: sys_init_module

2. 64 bit
[ 2295.036784] __NR_execve: 59: stub_execve
[ 2295.036785] __NR_connect: 42: sys_connect
[ 2295.036786] __NR_init_module: 175: sys_init_module
复制代码
复制代码

从结果上来看，_NR_XX宏定义的打印结果和我们的调研结果是一致的，所不同的是在32、64环境下系统调用对应的__NR_XX宏定义名字不同了

0x3: Linux 64bit 环境下 sys_execve hook特殊处理

为了充分利用Linux 64bit下的寄存器资源、以及提高Linux 64bit针对进程执行系统调用的执行效率，Linux 64bit内核针对sys_execve进行了特殊处理，使用了"wrapper function"：stub_execve，对sys_execve进行了包装

复制代码
复制代码 
\linux-3.15.5\arch\x86\kernel\entry_64.S
ENTRY(stub_execve)
    /*
    汇编代码对rsp，堆栈参数寻址寄存器进行了修正
    说明内核在进入stub_execve之前，rsp本身就是"不准确"的，需要进行修正，而rsp不准确也意味着栈上参数寻址是不准确的，这直接带来一个问题就是我们进行replace hook的fake_xxx_function不能简单的直接使用函数声明中传递进来的参数
    */
    CFI_STARTPROC
    addq $8, %rsp 
    PARTIAL_FRAME 0
    SAVE_REST
    FIXUP_TOP_OF_STACK %r11

    //修复栈、寄存器状态之后，进入真正的sys_execve系统调用
    call sys_execve

    movq %rax,RAX(%rsp)
    RESTORE_REST
    jmp int_ret_from_sys_call
    CFI_ENDPROC
END(stub_execve)
复制代码
复制代码

在Linux 64bit环境下，我们对sys_call_table[__NR_execve]进行replace hook之后，我们在fake_sys_execve中得到的参数不是准确的，因为这个时候rsp是不准确的，解决这个问题的思路有两个

复制代码
复制代码 
1. 在fake_sys_execve中使用"inline asm 内联汇编"的方式，模仿stub_execve在进入sys_execve之前所做的事情
/*
这种方式需要在内核代码中插入大量的汇编
并且承当更大的兼容性风险
*/

2. 直接对sys_execve进行"inline hook"
    1) 通过kprobe监控sys_execve的系统调用，使用争夺自旋锁的方式强制当前所有CPU等待"inline hook"的地址替换动作完成
    2) 通过kprobe获取到sys_execve在内核中的函数地址
    3) 直接拷贝sys_execve入口点开始的9字节的字节码，将这9字节字节码替换为：jmp fake_sys_execve(总共9字节)
    4) 在fake_sys_execve中，将窃取的原始的sys_execve入口点的汇编字节码重新执行一次
    5) 由于fake_sys_execve是inline hook到sys_execve中的，所以这个时候fake_sys_execve可以直接使用sys_execve的栈上的参数，这个时候，我们就可以正常执行fake_sys_execve的主体代码
    5) 当fake_sys_execve执行完毕之后，直接跳回到之前sys_execve开头那段被替换的地址之后的第一条指令，继续执行即可
/*
使用inline hook需要重点关注的问题就是：
    1) "inline hook"的关键动作是一段内核内存地址的替换过程
    2) 大多数情况下这个地址替换过程需要消耗超过1条的CPU指令去完成
    3) 在多线程/多CPU情况下，CPU在执行多条指令的期间可能会被打断，从而破坏"inline hook"这个过程的一致性，可能导致地址替换失败
    4) 需要使用自旋锁的机制强制保证这个地址替换(hook)的过程的"原子性"
*/
复制代码
复制代码

0x4: 模块卸载时旧的函数调用的返回导致的"bad memory address access"问题

模块在卸载的时候有可能有之前旧的用户态习系统调用请求hung在当前我们的hook模块中，不能直接粗暴的rmmod，否则会引起原始函数返回后ret到一块"not valid memory"中，解决这个问题的方案是采用内联汇编，构造直接返回的栈状态，下图解释

因为Linux GCC不支持nick裸函数，所以我们不能直接push origin_func、ret的方式构造特殊的栈状态，跳转到原始系统调用函数中

复制代码
复制代码 
if(sizeof(void*)==4)
{ 
    asm volatile ("movl %1,%%eax \n movl %%eax,%0":"=r"(old_func):"r"(old_func));
    asm volatile (".intel_syntax");//这里换用intel语法，gas语法简直不是给人用的
    asm volatile ("mov %esp,%ebp");
    asm volatile ("pop %ebp");//现在ebp的原始值已经被恢复了
    asm volatile (".att_syntax");//换回gas的att语法
    asm volatile ("pushl %eax");
    asm volatile ("ret");
}else
{ 
    asm volatile ("movq %1,%%rax \n movq %%rax,%0":"=r"(old_func):"r"(old_func));
    asm volatile (".intel_syntax");//这里换用intel语法，gas语法简直不是给人用的
    asm volatile ("mov %rsp,%rbp");
    asm volatile ("pop %rbp");
    asm volatile (".att_syntax");//换回gas的att语法
    asm volatile ("pushq %rax");
    asm volatile ("ret");
}
复制代码
复制代码

0x5:  动态获取系统调用函数在sys_call_table中的索引号

复制代码
复制代码 
1. 获取"kallsyms_lookup_name"的函数地址
    1) 如果linux内核直接导出了这个函数，则可以直接使用
    2) 或者使用kprobe机制去获取这个函数的地址
        2.1) kprobe注册"kallsyms_lookup_name"
        2.2) 获取kprobe注册后的函数地址
        2.3) kprobe解除注册
2. 调用kallsyms_lookup_name()获取我们要HOOK的函数在内核符号导出表的地址: hook_func_address
3. 使用kallsyms_lookup_name()获取sys_call_table的内核地址
3. 将hook_func_address在sys_call_table中逐行遍历，得到对应的偏移索引号
4. 使用动态获取的索引号进行sys_call_table replace hook
复制代码
复制代码

0x6: 总结

复制代码
复制代码 
/*
sys_call_table replace hook: 要解决的问题是让原始系统调用直接返回用户态系统调用的入口点之后
inline hook: 要解决的问题是保证地址替换的过程的原子性
*/
1. 32 bit
sys_execve: sys_call_table replace hook
sys_socketcall: sys_call_table replace hook
sys_init_module: sys_call_table replace hook

2. 64 bit
stub_execve: inline hook
sys_connect: sys_call_table replace hook
sys_init_module: sys_call_table replace hook
复制代码
复制代码

 

Copyright (c) 2014 LittleHann All rights reserved

 

 
 







本文转自张昺华-sky博客园博客，原文链接：http://www.cnblogs.com/sky-heaven/p/5053057.html ，如需转载请自行联系原作者
复制代码
文章标签：
服务网格
Linux
前端开发
rax
Shell
关键词：
Linux system
Linux Kernel
Linux bit
Linux export
Linux sys_call_table
桃子红了呐
目录
相关文章
bzf4tpxf3rljg
|
2月前
|
Docker 容器
14 response from daemon: open \\.\pipe\docker_engine_linux: The system cannot find the file speci
14 response from daemon: open \\.\pipe\docker_engine_linux: The system cannot find the file speci
bzf4tpxf3rljg
39 1
1387503158665997
|
2月前
|
存储 缓存 编译器
Linux kernel memory barriers 【ChatGPT】
Linux kernel memory barriers 【ChatGPT】
1387503158665997
55 11
阿迷创客
|
3月前
|
Linux 网络安全 开发工具
内核实验（二）：自定义一个迷你Linux ARM系统，基于Kernel v5.15.102， Busybox，Qemu
本文介绍了如何基于Linux Kernel 5.15.102版本和BusyBox创建一个自定义的迷你Linux ARM系统，并使用QEMU进行启动和调试，包括内核和BusyBox的编译配置、根文件系统的制作以及运行QEMU时的命令和参数设置。
阿迷创客
298 0
内核实验（二）：自定义一个迷你Linux ARM系统，基于Kernel v5.15.102， Busybox，Qemu
游客mldfis24krfue
|
3月前
|
安全 Linux
在Linux中，suid、sgid和sticky bit这几个术语意思？
在Linux中，suid、sgid和sticky bit这几个术语意思？
游客mldfis24krfue
136 3
დ旧言~
|
4月前
|
消息中间件 Linux
【Linux】进程间通信——system V(共享内存 | 消息队列 | 信号量)（下）
【Linux】进程间通信——system V(共享内存 | 消息队列 | 信号量)（下）
დ旧言~
69 0
დ旧言~
|
4月前
|
消息中间件 存储 Linux
【Linux】进程间通信——system V(共享内存 | 消息队列 | 信号量)（上）
【Linux】进程间通信——system V(共享内存 | 消息队列 | 信号量)（上）
დ旧言~
78 0
小蜗牛~向前冲
|
6月前
|
消息中间件 Unix Linux
[Linux打怪升级之路]-system V共享内存
[Linux打怪升级之路]-system V共享内存
小蜗牛~向前冲
65 1
[Linux打怪升级之路]-system V共享内存
欢喜躲在眉梢里
|
4月前
|
Shell Linux
Linux环境变量之shell中export定义全局变量和echo 变量的区别
Linux环境变量之shell中export定义全局变量和echo 变量的区别
欢喜躲在眉梢里
81 0
加油，旭杏
|
5月前
|
消息中间件 Linux
【Linux】System V 消息队列（不重要）
【Linux】System V 消息队列（不重要）
加油，旭杏
37 1
加油，旭杏
|
5月前
|
消息中间件 算法 Unix
【Linux】System V 共享内存
【Linux】System V 共享内存
加油，旭杏
52 1

热门文章

最新文章

  • 1
    Python3的安装与部署（Linux版本）
  • 2
    萌新的Linux学习之路（七）
  • 3
    linux系统中对逻辑卷(lvm)的实现
  • 4
    Linux终端执行shell脚本，提示权限不够的解决办法
  • 5
    Linux下如何查找可执行文件
  • 6
    linux下用文本处理器处理二进制文件后的终端乱码问题
  • 7
    Linux命令总结【待续】
  • 8
    linux新的API signalfd、timerfd、eventfd使用说明
  • 9
    linux内核分析之进程地址空间【转】
  • 10
    Linux 小知识翻译 - 「cron」
  • 1
    服务器Linux系统配置mysql数据库主从自动备份
    202
  • 2
    Linux文件系统
    53
  • 3
    linux静态库，动态库总结
    54
  • 4
    linux守护进程介绍 | Linux的热拔插UDEV机制
    71
  • 5
    基于linux串口实现语音刷抖音
    68
  • 6
    linux下实现串口功能
    51
  • 7
    linux下OLED屏开发-IIC协议
    114
  • 8
    实现linux定时器
    55
  • 9
    linux条件变量知识点总结
    72
  • 10
    linux互斥锁（pthread_mutex)知识点总结
    279

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux用户和组管理
  • Linux服务器运维基本操作
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • 部署Linux主机管理系统WDCP
  • 快速配置Linux云服务器
  • 基于Linux命令实现WordPress手动建站
  • Linux系统的安全登录
  • Linux指令入门-文件管理

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    无影云桌面