逆向之虚拟机保护

默小白 发表于 2019-1-29 15:50

本帖最后由默小白于 2019-1-29 16:13 编辑

转自：https://xz.aliyun.com/t/3851
考试周终于过去了，是时候又要开始学习了。所以就研究下逆向中的虚拟机保护技术，下面记录下学习的过程以及一些收获。

基础概念

逆向中的虚拟机保护是一种基于虚拟机的代码保护技术。它将基于x86汇编系统中的可执行代码转换为字节码指令系统的代码，来达到不被轻易逆向和篡改的目的。简单点说就是将程序的代码转换自定义的操作码(opcode)，然后在程序执行时再通过解释这些操作码，选择对应的函数执行，从而实现程序原有的功能。

vm_start：

虚拟机的入口函数，对虚拟机环境进行初始化

vm_dispatcher:

调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。

opcode :

程序可执行代码转换成的操作码

虚拟机执行的基本流程

https://xzfile.aliyuncs.com/media/upload/picture/20190114150417-9c015e14-17ca-1.png
实现一个小型的虚拟机

这里我通过实现一个简化版的小型虚拟机来加深对虚拟机的认识，语言用的是C语言。要想实现虚拟机的话需要完成两个目标：

1.定义一套opcode

2.实现opcode的解释器

opcode只是一个标识，可以随便定义，这里我定义了4条指令，每条指令分别对应着一个字节的字节码。而opcode的解释器是用来对opcode进行解释，从而选择对应的handle函数执行。

定义opcode
enum opcodes
{
MOV = 0xf1,
XOR = 0xf2,
RET = 0xf4,
READ = 0xf5,
};因为我只是为了理解，所以就只定义了几个常用指令。这里我用了共用体来定义opcode，比较方便。

实现解释器

opcode定义完后，就可以开始实现解释opcode的解释器了。解释器我们需要实现一个虚拟环境以及各个opcode对应的handle函数。虚拟环境则是真实物理机的一个虚拟，是自己定义的字节码运行的环境。

一些关键的结构体

vm_cpu
typedef struct vm_cpus
{
int r1; 虚拟寄存器r1
int r2; 虚拟寄存器r2
int r3; 虚拟寄存器r3
unsigned char *eip; 指向正在解释的opcode的地址
vm_opcode op_list; opcode列表，存放了所有的opcode及其对应的处理函数
}vm_cpu;</font>
vm_opcode
typedef struct
{
unsigned char opcode;
void (*handle)(void *);

}vm_opcode;其中 r1-r3是我定义的通用寄存器，用来传参或者是存放返回值，eip指向正在解释的opcode的地址，op_list则存放了所有opcode及其对应的handle函数。

实现了虚拟环境后就可以开始实现解释器了。解释器的功能就是对opcode解析，选择相应的handle函数，并且将相应的参数传递给handle函数。由handle函数来解释执行一条指令

关键函数

vm_init
void vm_init(vm_cpu *cpu) //初始化虚拟机环境
{
cpu->r1 = 0;
cpu->r2 = 0;
cpu->r3 = 0;
cpu->eip = (unsigned char *)vm_code; //将eip指向opcode的地址

cpu->op_list.opcode = 0xf1;
cpu->op_list.handle = (void (*)(void *))mov; //将操作字节码与对应的handle函数关联在一起

cpu->op_list.opcode = 0xf2;
cpu->op_list.handle = (void (*)(void *))xor;

cpu->op_list.opcode = 0xf5;
cpu->op_list.handle = (void (*)(void *))read_;

vm_stack = malloc(0x512);
memset(vm_stack,0,0x512);
}

vm_start
void vm_start(vm_cpu *cpu)
{
/*
进入虚拟机
eip指向要被解释的opcode地址
*/
cpu->eip = (unsigned char*)opcodes;
while((*cpu->eip)!= RET)//如果opcode不为RET，就调用vm_dispatcher来解释执行
{
   vm_dispatcher(*cpu->eip);
}
}vm_dispatcher
void vm_dispatcher(vm_cpu *cpu)
{
int i;
for(i=0 ; i < OPCODE_N ; i++)
{
   if(*cpu->eip == cpu->op_list.opcode)
   {
         cpu->op_list.handle(cpu);
         break;
   }
}

}
handles
void mov(vm_cpu *cpu);
void xor(vm_cpu *cpu);    //xor flag
void read_(vm_cpu *cpu); //call read ,read the flag

void xor(vm_cpu *cpu)
{
int temp;
temp = cpu->r1 ^ cpu->r2;
temp ^= 0x12;
cpu->r1 = temp;
cpu->eip +=1;             //xor指令占一个字节
}

void read_(vm_cpu *cpu)
{

char *dest = vm_stack;
read(0,dest,12);       //用于往虚拟机的栈上读入数据
cpu->eip += 1;          //read_指令占一个字节
}

void mov(vm_cpu *cpu)
{
//mov指令的参数都隐藏在字节码中，指令表示后的一个字节是寄存器标识，第二到第五是要mov的数据在vm_stack上的偏移
//我这里只是实现了从vm_stack上取数据和存数据到vm_stack上
unsigned char *res = cpu->eip + 1;//寄存器标识
int *offset = (int *) (cpu->eip + 2); //数据在vm_stack上的偏移
char *dest = 0;
dest = vm_stack;

switch (*res) {
   case 0xe1:
         cpu->r1 = *(dest + *offset);
         break;

   case 0xe2:
         cpu->r2 = *(dest + *offset);
         break;

   case 0xe3:
         cpu->r3 = *(dest + *offset);
         break;
   case 0xe4:
   {
         int x = cpu->r1;
         *(dest + *offset) = x;
         break;

   }
}

cpu->eip += 6;
//mov指令占六个字节，所以eip要向后移6位
}
要执行的伪代码

解释器到这就实现完了。接下来是要将想要实现功能的伪代码转成自定义的opcode，伪代码的功能是从标准输入中读取12个字节的字符串，然后将读入的字符串每个字符与0x0还有0x12进行异或，并且将结果存储在虚拟机的栈上。写出来大致就是下面这样子
/*
call read_
MOV R1,flag
XOR
MOV R1,0x20; //这是将R1的值送到vm_stack+0x20的位置，后面的同上
MOV R1,flag
XOR
MOV R1,0x21;
MOV R1,flag
XOR
MOV R1,0x22
MOV R1,flag
XOR
MOV R1,0x23;
MOV R1,flag
XOR
MOV R1,0x24;
MOV R1,flag
XOR
MOV R1,0x25;
MOV R1,flag
XOR
MOV R1,0x26;
MOV R1,flag
XOR
MOV R1,0x26
MOV R1,flag
XOR
MOV R1,0X27
MOV R1,flag
XOR
MOV R1,0x28
MOV R1,flag
XOR
MOV R1,0X29
MOV R1,flag
XOR
MOV R1,0x2A
MOV R1,flag
XOR
MOV R1,0x2b
*/
将它转换成对应的字节码，然后用解释器去解释执行就可以实现伪代码的功能。

unsigned char vm_code[] = {
0xf5,
0xf1,0xe1,0x0,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x20,0x00,0x00,0x00,
0xf1,0xe1,0x1,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x21,0x00,0x00,0x00,
0xf1,0xe1,0x2,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x22,0x00,0x00,0x00,
0xf1,0xe1,0x3,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x23,0x00,0x00,0x00,
0xf1,0xe1,0x4,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x24,0x00,0x00,0x00,
0xf1,0xe1,0x5,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x25,0x00,0x00,0x00,
0xf1,0xe1,0x6,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x26,0x00,0x00,0x00,
0xf1,0xe1,0x7,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x27,0x00,0x00,0x00,
0xf1,0xe1,0x8,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x28,0x00,0x00,0x00,
0xf1,0xe1,0x9,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x29,0x00,0x00,0x00,
0xf1,0xe1,0xa,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2a,0x00,0x00,0x00,
0xf1,0xe1,0xb,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2b,0x00,0x00,0x00,
0xf1,0xe1,0xc,0x00,0x00,0x00,0xf2,0xf1,0xe4,0x2c,0x00,0x00,0x00,
0xf4
};

至此，一个简化版的小型虚拟机就实现完了。我在虚拟机中实现了对输入字符串简单的异或加密，并将加密后的值存储到指定位置。我觉得这个过程是十分有意义的，让我加深了对虚拟机保护的了解。因为能力有限，所以就只实现了一个很简单的小型虚拟机。虚拟机相关的题目还没有做，等有时间再去做一下。

最后将代码放在附件上，有需要的可以下载。

logo_tu 发表于 2019-1-29 17:22

好厉害的样子哦

zhangtianwang 发表于 2019-1-29 17:26

看着一排排的数据就知道非常厉害

FYX 发表于 2019-1-29 17:31

看的有点头晕收藏了改天继续看！

hzyh 发表于 2019-1-29 22:03

好厉害的样子哦，赞

埖落发表于 2019-1-30 08:47

学习了，来看看分享

CNSingle_net 发表于 2019-4-22 14:42

解释执行只写了部分的实现核心，首当其冲的堆栈维护问题需要楼主细致研究一下，感谢分享，吾爱有你更精彩！

javayuan 发表于 2021-4-13 23:10

太强了，本来看大佬们的虚拟机wp就有是似懂非懂，很多东西看起来会了到自己调试的时候又不会了，看了楼主的帖子后豁然开朗，感谢大佬

页: [1]

吾爱破解 - 52pojie.cn's Archiver

逆向之虚拟机保护