虚拟机

虚拟机逆向（Virtual Machine Reverse Engineering）是指对软件中自实现的虚拟机（或称解释器）进行反向分析的技术

程序将原本的原生代码或关键逻辑编译成自定义的字节码（bytecode），然后由一个解释器循环（VM loop）执行这些字节码。逆向工程师需要：

  • 识别出虚拟机结构（操作码表、虚拟寄存器、虚拟栈、内存模型等）

  • 提取字节码，并反汇编为人类可读的虚拟指令

  • 理解虚拟指令序列的算法逻辑，以破解保护、提取算法或找到漏洞

虚拟机分类

根据虚拟机的执行模型，通常分为两类

基于栈的虚拟机

操作数隐式地通过一个虚拟栈传递，指令执行时从栈顶弹出操作数，计算结果再压回栈顶

常见例子：Java 虚拟机（JVM）、Python 字节码、.NET CLR

特征：大量 push/pop 指令，运算指令无显式操作数

基于寄存器的虚拟机

操作数显式指定虚拟寄存器索引，结果也存入虚拟寄存器

常见例子：Dalvik (Android)、Lua VM

特征：指令通常包含 “寄存器索引” 字段，如 add r1, r2, r3

实战案例

signal（VM 逆向）

pasted_1784271296885_uo9ffc.png

IDA 逆向分析这个 vm_operad() 函数

传入的参数 v4 是 &unk_403040 地址的值

pasted_1784271527967_ikuh4p.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
88
89
90
91
92
int __cdecl vm_operad(int *a1, int a2)   // a1: 字节码数组, a2: 字节码长度
{
  int result;
  char Str[200];                       // 虚拟机内存/寄存器区
  char v4;                             // 累加器 (ACC)
  int v5;                              // 内存写入指针 (用于 case 8)
  int v6;                              // 栈/缓冲指针1 (与 v8 同步)
  int v7;                              // 校验比较指针 (用于 case 7)
  int v8;                              // 操作数读取指针 (用于算术/存取)
  int v9;                              // 指令指针 (IP)

  v9 = 0;
  v8 = 0;
  v7 = 0;
  v6 = 0;
  v5 = 0;

  while ( 1 )
  {
    result = v9;
    if ( v9 >= a2 )                    // IP 超出范围则退出
      return result;

    switch ( a1[v9] )                  // 取指
    {
      case 1:                          // PUSH: 将累加器存入缓冲区，同时移动指针
        Str[v6 + 100] = v4;
        ++v9;
        ++v6;
        ++v8;
        break;

      case 2:                          // ADD: v4 = imm + Str[v8]
        v4 = a1[v9 + 1] + Str[v8];
        v9 += 2;
        break;

      case 3:                          // SUB: v4 = Str[v8] - imm
        v4 = Str[v8] - LOBYTE(a1[v9 + 1]);
        v9 += 2;
        break;

      case 4:                          // XOR: v4 = imm ^ Str[v8]
        v4 = a1[v9 + 1] ^ Str[v8];
        v9 += 2;
        break;

      case 5:                          // MUL: v4 = imm * Str[v8]
        v4 = a1[v9 + 1] * Str[v8];
        v9 += 2;
        break;

      case 6:                          // NOP: 跳过1字节
        ++v9;
        break;

      case 7:                          // CMP: 若 Str[v7+100] != imm 则失败退出
        if ( Str[v7 + 100] != a1[v9 + 1] )
        {
          printf("what a shame...");
          exit(0);
        }
        ++v7;
        v9 += 2;
        break;

      case 8:                          // STORE: 将累加器存入 Str[v5]，v5++
        Str[v5] = v4;
        ++v9;
        ++v5;
        break;

      case 10:                         // READ: 读取用户输入到 Str
        read(Str);
        ++v9;
        break;

      case 11:                         // DEC: v4 = Str[v8] - 1
        v4 = Str[v8] - 1;
        ++v9;
        break;

      case 12:                         // INC: v4 = Str[v8] + 1
        v4 = Str[v8] + 1;
        ++v9;
        break;

      default:                         // 无效指令，跳过（实际是 continue，可能死循环）
        continue;
    }
  }
}

程序中的 114 个整数如下

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
10,

4,16,8,3,5,1,
4,32,8,5,3,1,
3,2,8,11,1,
12,8,4,4,1,
5,3,8,3,33,1,
11,8,11,1,
4,9,8,3,32,1,
2,81,8,4,36,1,
12,8,11,1,
5,2,8,2,37,1,
2,54,8,4,65,1,
2,32,8,5,1,1,
5,3,8,2,37,1,
4,9,8,3,32,1,
2,65,8,12,1,

7,34,
7,63,
7,52,
7,50,
7,114,
7,51,
7,24,
7,-89,
7,49,
7,-15,
7,40,
7,-124,
7,-63,
7,30,
7,122

第一条指令是 10，即调用 read(Str) 读取输入

之后是 15 组字符变换，最后是 15 组比较指令

目标数组为

1
2
3
34, 63, 52, 50, 114,
51, 24, -89, 49, -15,
40, -124, -63, 30, 122

令输入字符为 x[i]，首先是第 0 位

1
2
3
4
4,16    temp = x ^ 16
8       写回
3,5     temp = temp - 5
1       保存结果

方程式

1
(x ^ 16) - 5 = 34

由此得到

位置 变换 目标 解
0 (x ^ 16) - 5 34 7
1 (x ^ 32) * 3 63 5
2 (x - 2) - 1 52 7
3 (x + 1) ^ 4 50 5
4 x * 3 - 33 114 1
5 (x - 1) - 1 51 5
6 (x ^ 9) - 32 24 1
7 (x + 81) ^ 36 -89 2
8 (x + 1) - 1 49 1
9 x * 2 + 37 -15 f
10 (x + 54) ^ 65 40 3
11 (x + 32) * 1 -124 d
12 x * 3 + 37 -63 4
13 (x ^ 9) - 32 30 7
14 (x + 65) + 1 122 8

所以 flag 就是 flag{757515121f3d478}