又是一道从userspace pwn到hypervisor的题目，虽然漏洞较为容易，但在利用和调试方面还是需要对虚拟化和kernel有一定的了解。在做题的过程中，也可以增进对KVM API，OS Kernel的内存管理和中断处理，以及x86-64的分页机制的理解，还是相当有趣的。

之前在TWCTF中，曾经出现过类似的题目EscapeMe. 受它的影响，本次Hitcon也出现了模式几乎一样的题目，玩了1天多感觉很有意思，在大佬的指导下体验了一回VM Escape.

赛后作者也放出了相关源码和利用，可以拿来复现一下
https://github.com/david942j/ctf-writeups/tree/master/hitcon-2018/abyss

Challenge Intro

整个题目由3个binary，hypervisor.elf，kernel.bin与user.elf，还有3个flag组成。

hypervisor.elf是一个利用KVM API来做虚拟化的程序，它会加载一个小型的内核kernel.bin，这个kernel就只实现了内存管理和中断处理的功能，提供了loader启动和libc加载需要的一些常见syscall，然后解析ELF启动一个用户态程序。这里直接加载ld.so.2来装载用户态程序user.elf.

user.elf就是一个标准的x86-64 ELF文件，也可以直接在host上启动。kernel.bin在处理syscall时，将一些与IO有关的例如read/write等通过 I/O Port (CPU的in/out指令) 交给hypervisor来处理。例如open这个syscall，kernel在做检查之后，直接通过hypercall传给hypervisor处理，然后hypervisor会在host上打开一个文件，并将其fd做一个映射返回给kernel. 所以实际上VM内做的open是可以打开host的文件的。

本题的3个flag都位于host上，flag1在pwn掉user.elf之后可以通过shellcode来读，flag2需要pwn掉内核，第3个flag由于不知道文件名，需要pwn掉hypervisor.

KVM Basis

在使用KVM来做虚拟化时，需要给VM分配VCPU和memory，通过ioctl的KVM_SET_USER_MEMORY_REGION request来给VM插上一块物理内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void *mem = mmap(0,
  MEM_SIZE,
  PROT_READ | PROT_WRITE,
  MAP_SHARED | MAP_ANONYMOUS,
  -1, 0);
...
struct kvm_userspace_memory_region region = {
  .slot = 0,
  .flags = 0,
  .guest_phys_addr = 0,
  .memory_size = MEM_SIZE,
  .userspace_addr = (size_t) mem
};
if(ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &region) < 0) {
  pexit("ioctl(KVM_SET_USER_MEMORY_REGION)");
}

这样一来hypervisor的mem这块位置就被作为VM的物理内存来使用了

当VCPU和memory都设置好之后，就可以使用ioctl的KVM_RUN request来启动VM，当遇到中断或者异常时，ioctl就会返回，这时可以通过检查exit_reason来得知中断或者异常的类型并做相应处理，例如I/O的请求，就可以这时进行处理。

User.elf

user.elf是一个传统的用户态pwnable，漏洞也比较容易发现，就是swap的时候没有检查可以直接改掉stack_pointer。需要注意的是程序内是没有NX的，所以可以直接修改GOT表来跳到bss的shellcode上，之后常规open flag/read/write即可拿到第1个flag.

Kernel.bin

kernel逆起来要稍稍复杂一点，但本身功能不多，结合与hypervisor之间约定的I/O Port相关的信息，可以找到它的系统调用表，然后逐个分析syscall即可。hypervisor给kernel的物理内存有0x2000000大小，kernel被加载到0的位置，0-0x200000为内核地址空间，高地址0x200000-0x2000000为userspace.

第2个flag的名字叫flag2，但是kernel在做open syscall的时候，对打开的参数做了一个白名单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int sys_open(const char *path) {
  if(!access_string_ok(path)) return -EFAULT;
  void *dst = copy_str_from_user(path);
  if(dst == 0) return -ENOMEM;

  /* do whitelist here */
  if(!(
#define OK(str) strcmp(dst, #str) == 0
      OK(ld.so.2) ||
      OK(/lib/x86_64-linux-gnu/libc.so.6) ||
      OK(/proc/sys/kernel/osrelease) ||
      OK(/etc/ld.so.cache) ||
      OK(./user.elf) ||
      OK(flag)
#undef OK
      )) return -ENOENT;

  int fd = hp_open(physical(dst));
  kfree(dst);
  return fd;
}

想要打开flag2，就只有exploit kernel了，在处理read syscall时，可以发现其没有检查kmalloc返回0的情况

1
2
3
4
5
6
7
8
9
int64_t sys_read(int fildes, void *buf, uint64_t nbyte) {
  if(fildes < 0) return -EBADF;
  if(!access_ok(VERIFY_WRITE, buf, nbyte)) return -EFAULT;
  void *dst = kmalloc(nbyte, MALLOC_NO_ALIGN);
  int64_t ret = hp_read(fildes, physical(dst), nbyte);
  if(ret >= 0) memcpy(buf, dst, ret);
  kfree(dst);
  return ret;
}

这里作者使用的方式是将内存耗尽，首先mmap一块0x1000000的内存，之后再read 0x1000000 bytes，这样kmalloc就会因为空间不足而返回0，这样就直接从0开始read，可以直接改掉内核代码，执行内核shellcode了。在hypervisor处理完read再次进到VM时，实际是从in/out那里开始执行，一直覆盖到那里就可以了。之后执行内核shellcode，利用hypercall open flag2/read/write就可以拿到flag2.

Hypervisor.elf

现在我们已经可以调用任意hypercall了，在hypervisor里有一个0x8008 port可以处理ioctl请求，但整个kernel并没有使用这个port，也不提供ioctl这个syscall. 看一下ioctl hypercall的处理就会发现，没有做任何检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* I'm sorry.. this is a backdoor.. */
static int hp_handle_ioctl(VM *vm) {
  static int ret = UNUSED_VAR;
  PROCESS {
    uint32_t offset = FETCH_U32;
    const uint64_t *kbuf = (uint64_t*) MEM_AT(offset);
    int fd = kbuf[0];
    unsigned long request = kbuf[1];
    uint32_t paddr = kbuf[2];
    if(paddr == 0) ret = ioctl(fd, request, 0);
    else ret = ioctl(fd, request, MEM_AT(paddr));
    if(ret < 0) ret = -errno;
  } THEN_RETURN(ret);
  return 0;
}

这就意味着我们可以在host上以任意参数来调用一个ioctl，回想之前KVM的memory分配，我们其实就可以直接用KVM_SET_USER_MEMORY_REGION来将hypervisor其他的可写内存给插到VM里面。首先需要读一下/proc/self/maps文件leak hypervisor的地址，之后构造一个memory region.

1
2
3
4
5
6
7
struct kvm_userspace_memory_region region = {
  .slot = 1,
  .flags = 0,
  .guest_phys_addr = 0x2000000,
  .memory_size = 0x21000,
  .userspace_addr = [stack_addr]
};

这样就可以把hypervisor的栈直接映射到VM里0x2000000的位置，也就是说在VM里操作这块的物理内存就相当于操作hypervisor的stack. 但现在我们还不能直接在kernel中访问这块地址，因为它没有页表项。看一下x86-64的页表结构

Page Translation

图片来源:https://www.cs.uaf.edu/2012/fall/cs301/lecture/11_05_mmap.html

在64位的long mode下，所有的访存都需要经过页表，而hypervisor和kernel并没有为高于0x2000000设置页映射，所以我们需要手动为它加上一个页表项。kernel在刚启动时对page table做了下面的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
/* Maps
 *  0x8000000000 ~ 0x8002000000 -> 0 ~ 0x2000000
 */
void init_pagetable() {
  uint64_t* pml4;
  asm("mov %[pml4], cr3" : [pml4]"=r"(pml4));
  uint64_t* pdp = (uint64_t*) ((uint64_t) pml4 + 0x3000);
  pml4[1] = PDE64_PRESENT | PDE64_RW | (uint64_t) pdp; // 0x8000000000
  uint64_t* pd = (uint64_t*) ((uint64_t) pdp + 0x1000);
  pdp[0] = PDE64_PRESENT | PDE64_RW | (uint64_t) pd;
  for(uint64_t i = 0; i < 0x10; i++)
    pd[i] = PDE64_PRESENT | PDE64_RW | PDE64_PS | (i * KERNEL_PAGING_SIZE);
}

在PML4的第1项上放了1个PDP，在PDP中初始化了16个page，这些Page都是带有PDE64_PS标志位的，这代表着它们不是下一级PD的地址，而是1个0x200000(2MB)的page的直接映射。因为PML4的第1项对应的Virtual Address的39-47位为1，实际上就是一组0x8000000000 ~ 0x8002000000到0 ~ 0x2000000的映射。

我们可以如法炮制，在PDP的末尾加上1项，将0x8002000000 ~ 0x8002200000映射到0x2000000 ~ 0x2200000，这样就可以通过0x8002000000来访问物理地址0x2000000，也就是hypervisor栈的底部了。

之后就是在这段内存中搜索KVM_RUN这个ioctl调用的返回地址，并把ROP链布置上去，再用hlt触发中断就可以了。