[关闭]
@devilogic 2018-07-12T15:16:59.000000Z 字数 42616 阅读 1266

算法变形引擎

devilogic

应看雪大哥之邀写一篇介绍变形引擎技术的文章。来丰富《加密与解密》第四版的内容。说实话已经好久没有直接搞这样的技术了。一直在折腾自己的一家小公司。所以这方面的武功已经废得差不多了。下文如果觉得有不妥之处还望见谅。

变形引擎原理介绍

变形引擎最先是在病毒中进行使用，其目的是对抗特征码提取。一个基础的模式如下所示：其中aaa等表示一些汇编指令。这里就不列出具体指令了。

  1. 解密代码(用来解密加密后的病毒体):
  2. aaa
  3. bbb
  4. ccc
  5. 加密后的病毒体:
  6. 调用(call) 感染模块
  7. aaa
  8. bbb
  9. ccc
  10. 感染模块:
  11. aaa
  12. bbb
  13. ccc
  14. 调用(call) 算法变形引擎
  15. aaa
  16. bbb
  17. ccc
  18. 算法变形引擎(生成新的解密代码并写入到新的病毒体中):
  19. aaa
  20. bbb
  21. ccc

以上的原理就是，利用算法变形引擎，将解密头算法进行变形，其实虽然称是解密算法，不如称为模式处理更为贴切。例如：。这样的式子，其中是要加密的字节，而是加密后的字节。那么解密公式就变成。而其中的是一个使用随机数控制的所谓的密钥。在数学的意义上，其实这个并没有所谓的强度。但是在生成的汇编代码却起到了特征变换的效果。在实际写程序的意义上也可以得到实现。因为它的实现并不困难。

这里有一篇08年，我原来写的Vulcano病毒分析。http://bbs.pediy.com/showthread.php?t=78862 这里详细分析了一个完整的算法变形引擎。

为什么称作是算法变形引擎，而不直接叫变形引擎呢？因为就我理解而言，病毒体并没有实现真正的变形。而本文所介绍的并非以上这种引擎，而是其中的一个子集，其作用呢也并非对抗特征码扫描，而是在软件保护上放置一个可变换的“加解密算法”的模块，这样每次加密时使用新的算法进行解密，毕竟很多情况下，破解者对加解密算法的强度不是很在意。他们只关心解密的整体流程。本文的这个小程序是用来来对抗静态脱壳机。是一个基本的框架。由于时间有限，在我的设想中仅仅算完成了个开头吧。待有空再补齐吧。

代码变形引擎介绍

首先，同学们可以从以下地址中迁出一套完整的源代码。
https://git.coding.net/devilogic/polycypt.git
我们一边看代码一边完成一个简单的算法变形的框架。在这里吐槽一下，在如今浮躁的社会，尤其是移动软件保护这个浮躁的领域。这点小代码也许在客户面前就是价值几万一年的产品或者一个牛逼技术的控标点。算了这里不是吐槽的地方，希望段哥审稿没有发现。

这里利用了虚拟解释语言的一个原理，就是首先我们写一个虚拟机只负责解释我们自己定义的指令，然后只处理我们自己规定的一个可执行文件格式。随后在写一个对应的汇编器，负责汇编代码。最后写一个变形引擎，每次由这个引擎生成加解密代码。在加密程序中，使用虚拟机执行随机加密算法字节码，在解密体中使用虚拟机执行随机解密算法字节码。

polycypt的编译与使用

目前只是一个基础的版本，算法的变形力度不够，以下是简单的帮助。

其中为了进行测试，使用了 "xxx_main.cpp"，进行外部测试。可单独编译成库进行使用。

使用polycypt随机生成加解密算法，执行

polycypt -t template_path result_dir 命令。

在result_dir中生成4个文件encrypt.asm，decrypt.asm，encrypt.pbc，decrypt.pbc，其中.asm文件是生成的汇编源代码，用于查看。.pbc是编译后的字节码文件。用pcvm进行执行。

template_path是模版路径，用于算法支持。<可选项>

pcvm编译与使用

编译pcvm时导入以下文件：
1. pcfile.h
2. pcvm.h
3. pcvm.cpp
4. pcvm_main.cpp

调试器开启

  1. if (vm.run((unsigned char*)codes, codesize, entry, false) == false) {
  2.   printf("error : %d\n", vm.error());
  3. }

虚拟机的run接口最后一个参数，如果设置为true则启动调试器模式。运行后会出现一个简单的调试器如下：
debug.jpg-370.3kB
调试只有三条指令

使用命令

  1. usage: pcvm [options] <bytecode file>
  2. -d                disasm
  3. -i <port> <file>  bind input io to file
  4. -o <port> <file>  bind output io to file

pcasm编译与使用

编译pcasm时导入以下文件：
1. pcfile.h
2. pcvm.h
3. pcasm.h
4. pcasm.cpp
5. pcvm_main.cpp

使用命令

  1. usage: pcasm <asm file> [out file]

polycypt编译与使用

编译polycryt时导入以下文件：
1. pcfile.h
2. pcasm.h
3. pcasm.cpp
4. pcasm.cpp
5. polycypt_alg0.cpp
6. polycypt_alg0.h
7. polycypt_error.h
8. polycypt_factory.cpp
9. polycypt_factory.h
10. polycypt.cpp
11. polycypt.h
12. polycypt_main.cpp

使用命令

  1. usage: polycypt [options] <output path>
  2. -t <template dir path>

虚拟机的设计与实现

这里的虚拟机设定不必太过于复杂，因为我们要达到的目的就是做基本的算术运算。可以控制一些基本流程。但是一些辅助操作还是要考虑，例如：虚拟机对外的数据的读入与输出。所以我也并没有费太多时间，核心的源文件也只有一个pcvm.cpp，想要嵌入到自己的代码中，只需要使用这个文件即可。

pcvm类的结构说明

我们首先按照重要程度来分析一下pcvm这个类。

  1. class pcvm {
  2. public:
  3.   pcvm();
  4.   virtual ~pcvm();
  6. public:
  7.   /* 字节序确定，但在这个版本中并没什么卵用(估计以后也不会支持) */
  8.   static bool is_big_endian();
  10.   /* 调试支持，用于调试PCVM */
  11. #ifdef SUPPORT_DEBUGER
  12.   /* 反汇编指定缓存代码 */
  13.   bool disasm_all(unsigned char *buf, size_t bufsize);
  14. #endif
  15.   /* 从偏移entry_offset处运行codes缓存中cs个字节长的代码
  16.    * 这里支持一个调试选项如果将debug设置为true，则运行起来
  17.    * 后会启动一个简单的调试器的控制台 */
  18.   bool run(const unsigned char *codes, 
  19.            size_t cs, 
  20.            unsigned entry_offset=0
  21. #ifdef SUPPORT_DEBUGER
  22.            ,bool debug=false
  23. #endif
  24.           );
  26.  /* 以下八个函数，用于设定与获取外部数据的流 */
  27.  bool set_input_io(int io, unsigned char *stream);
  28.  bool set_output_io(int io, unsigned char *stream);
  29.  bool set_input_io_size(int io, size_t size);
  30.  bool set_output_io_size(int io, size_t size);
  31.  unsigned char *get_input_io(int io);
  32.  unsigned char *get_output_io(int io);
  33.  size_t get_input_io_size(int io);
  34.  size_t get_output_io_size(int io);
  36.  /* 获取出错函数 */
  37.  int error();
  39. private:
  40.   /* 重置整个虚拟机 */
  41.   void reset();
  43.   /* 执行指令ins */
  44.   bool call(unsigned ins);
  46.   /* 以下三个函数都是与获取寄存器相关的 */
  47.   bool invalid_register(int i);
  48.   bool registers(int i, unsigned &v, bool four=false);
  49.   bool set_registers(int i, unsigned r, bool four=false);
  51.   /* 读取与写入数据到指定的内存地址 */
  52.   bool read_memory(unsigned char *address, unsigned char *v);
  53.   bool write_memory(unsigned char *address, unsigned v);
  55.   /* 读取一条指令 */
  56.   bool readi(unsigned &i);
  57.   /* 判定偏移是否合法 */
  58.   bool invalid_offset(unsigned off);
  59.   /* 通过偏移计算地址 */
  60.   bool calc_address(unsigned off, unsigned **addr);
  62.   /* 与设置与获取字节序相关 */
  63.   unsigned short get_te16(unsigned char *address);
  64.   unsigned int get_te32(unsigned char *address);
  65.   void set_te16(unsigned char *address, unsigned short v);
  66.   void set_te32(unsigned char *address, unsigned v);
  68.   /* 当虚拟机解释指令时，会将指令拆解成8种模式，无论指令再多
  69.    * 模式就这8种。这些函数会在指令执行函数中进行调用。
  70.    */
  71.   bool handle_ins_mode_op(unsigned ins, unsigned &op);
  72.   bool handle_ins_mode_op_imm(unsigned ins, unsigned &op, 
  73.                               unsigned &imm);
  74.   bool handle_ins_mode_op_reg(unsigned ins, unsigned &op, 
  75.                               unsigned &reg);
  76.   bool handle_ins_mode_op_reg_imm(unsigned ins, unsigned &op,
  77.                                   unsigned &reg, unsigned &imm);
  78.   bool handle_ins_mode_op_reg_reg(unsigned ins, unsigned &op,
  79.                                   unsigned &reg1, unsigned &reg2);
  80.   bool handle_ins_mode_op_mem_imm(unsigned ins, unsigned &op,
  81.                                   unsigned **address, 
  82.                                   unsigned &imm);
  83.   bool handle_ins_mode_op_mem_reg(unsigned ins, unsigned &op,
  84.                                   unsigned **address, 
  85.                                   unsigned &reg);
  86.   bool handle_ins_mode_op_mem_mem(unsigned ins, unsigned &op,
  87.                                   unsigned **address1, 
  88.                                   unsigned **address2);
  90.   /* 将4字节的整数指令转换成对应的模式结构 */
  91.   bool ins_2_opocde_mode(unsigned ins, 
  92.                          unsigned &opcode, 
  93.                          unsigned &mode);
  94.   bool ins_2_mode_op(unsigned ins, pcvm_ins_mode_op &mode);
  95.   bool ins_2_mode_op_imm(unsigned ins, pcvm_ins_mode_op_imm &mode);
  96.   bool ins_2_mode_op_reg(unsigned ins, pcvm_ins_mode_op_reg &mode);
  97.   bool ins_2_mode_op_reg_imm(unsigned ins, 
  98.                              pcvm_ins_mode_op_reg_imm &mode);
  99.   bool ins_2_mode_op_reg_reg(unsigned ins, 
  100.                              pcvm_ins_mode_op_reg_reg &mode);
  101.   bool ins_2_mode_op_mem_imm(unsigned ins, 
  102.                              pcvm_ins_mode_op_mem_imm &mode);
  103.   bool ins_2_mode_op_mem_reg(unsigned ins, 
  104.                              pcvm_ins_mode_op_mem_reg &mode);
  105.   bool ins_2_mode_op_mem_mem(unsigned ins, 
  106.                              pcvm_ins_mode_op_mem_mem &mode);
  108.   /* 指令执行 */
  109.   bool iMOV(unsigned ins, unsigned mode);
  110.   bool iPUSH(unsigned ins, unsigned mode);
  111.   bool iPOP(unsigned ins, unsigned mode);
  112.   ... 略去
  114.   /* 下面是支持调试器的辅助函数 */
  115. #ifdef SUPPORT_DEBUGER
  116.   void show_dbg_info();
  117.   bool disasm(unsigned ins, std::string &out);
  118.   void debugger(unsigned curr_ip);
  119. #endif
  121. private:
  122.   /* 寄存器组 */
  123.   unsigned _registers[PCVM_REG_NUMBER];
  124.   /* 标志寄存器 */
  125.   pcvm_flags_register _flags;
  126.   /* 整个内存空间 */
  127.   unsigned char *_space;
  128.   /* 字节码在内存中的位置 */
  129.   unsigned char *_code;
  130.   /* 栈在内存中的位置 */
  131.   unsigned char *_stack;
  132.   /* 代码长度 */
  133.   size_t _code_size;
  134.   /* 栈长度 */
  135.   size_t _stack_size;
  136.   /* 指令执行函数队列 */
  137.   ins_handle_fptr _handles[PCVM_OP_NUMBER];
  139.   /* 输入与输出流设定 */
  140.   unsigned char *_io_input[PCVM_IO_INPUT_NUMBER];
  141.   unsigned char *_io_output[PCVM_IO_OUTPUT_NUMBER];
  142.   size_t _io_input_size[PCVM_IO_INPUT_NUMBER];
  143.   size_t _io_output_size[PCVM_IO_OUTPUT_NUMBER];
  145.   /* 关机标志 */
  146.   bool _shutdown;
  147.   /* 字节序判定 */
  148.   bool _is_big_endian;
  149.   /* 出错代码 */
  150.   int _error;
  151. };

我想在看过以上代码之后，大概这个虚拟机是什么样子的，上面的注释已经描述的比较清晰了。随后会针对一些核心功能进行详细介绍。

I/O设定

在上述代码中有一组这样的函数。

  1.  /* 以下八个函数，用于设定与获取外部数据的流 */
  2.  bool set_input_io(int io, unsigned char *stream);
  3.  bool set_output_io(int io, unsigned char *stream);
  4.  bool set_input_io_size(int io, size_t size);
  5.  bool set_output_io_size(int io, size_t size);
  6.  unsigned char *get_input_io(int io);
  7.  unsigned char *get_output_io(int io);
  8.  size_t get_input_io_size(int io);
  9.  size_t get_output_io_size(int io);

这几个函数是用于设定虚拟机对外数据的输入与输出的。在运行虚拟代码之前，可以通过上述函数要输入或者输出的数据，并使用get*_io函数获取输入或输出内容，如果要获取其对应的长度则使用get*_io_size。在后边指令解析有一组中断指令int 0,int 1,int 2,int 3来完成以上设定。

寄存器说明

在文件pcvm.h的13-31行，定义了以下枚举体，用来描述虚拟机的寄存器设定。

  1. enum PCVM_REG {
  2.   PCVM_REG_IP,              /* 地址寄存器 */
  3.   PCVM_REG_SB,              /* 栈基寄存器 */
  4.   PCVM_REG_SP,              /* 栈指针寄存器 */
  5.   PCVM_REG_RET,             /* 返回地址寄存器 */
  6.   PCVM_REG_R4,              /* 通用寄存器 */
  7.   PCVM_REG_R5,              /* 通用寄存器 */
  8.   PCVM_REG_R6,              /* 通用寄存器 */
  9.   PCVM_REG_R7,              /* 通用寄存器 */
  10.   PCVM_REG_R8,              /* 通用寄存器 */
  11.   PCVM_REG_R9,              /* 通用寄存器 */
  12.   PCVM_REG_R10,             /* 通用寄存器 */
  13.   PCVM_REG_R11,             /* 通用寄存器 */
  14.   PCVM_REG_R12,             /* 通用寄存器 */
  15.   PCVM_REG_R13,             /* 通用寄存器 */
  16.   PCVM_REG_R14,             /* 通用寄存器 */
  17.   PCVM_REG_R15,             /* 通用寄存器 */
  18.   PCVM_REG_NUMBER
  19. };

总共有16个寄存器，但是其实算法变形引擎并不需要这么多，起初我直接设定是256个寄存器，最后发现实在没那个必要。其中前4个寄存器都有特殊的功能。

标志寄存器说明

在文件pcvm.h142-149行中中定义了一个结构：

  1. typedef struct {
  2.   unsigned int C : 1;
  3.   unsigned int Z : 1;
  4.   unsigned int S : 1;
  5.   unsigned int O : 1;
  6.   unsigned int A : 3;
  7.   unsigned int reserve : 25;
  8. } pcvm_flags_register;

其实在虚拟机实际执行过程中并没有全部用到这些标志，因为此虚拟机毕竟不是要支持多复杂的语言来设计的，本着够用的原则先凑合着吧。再者其实在这个引擎中，这个标志位的设计有些画蛇添足了。自己做的虚拟机并不一定要完全模拟现实中机器的一些特性设定。只是为了程序可以顺利运行而做的设计，再者就是之前受真实的机器的影响在写程序时自然就这样写了一个结构。

标志 意义
C 运算结果是否产生进位
Z 运算结果是否为0
S 为1，则操作数值为有符号运算，0为无符号运算
O 溢出位，但是貌似并没有使用
A 取值为1,2,3，分别对应的1字节访问，2字节访问，4字节访问

内存读取与写入

这里首先看两个函数
读内存

  1. bool pcvm::read_memory(unsigned char *address, unsigned char *v) {
  2.   /* 访问寄存器如果为1，则使用1字节读取 */
  3.   if (_flags.A == 1) {
  4.     *v = *address;
  5.   }
  6.   /* 访问寄存器如果为2，则使用2字节读取 */
  7.   else if (_flags.A == 2) {
  8.     *(unsigned short*)v = get_te16(address);
  9.   }
  10.   /* 访问寄存器如果为3，则使用4字节读取 */
  11.   else if (_flags.A == 3) {
  12.     *(unsigned int *)v = get_te32(address);
  13.   }
  14.   else {
  15.     _error = PCVM_ERROR_INVALID_FLAG_A;
  16.     return false;
  17.   }
  18.   return true;
  19. }

与写内存

  1. bool pcvm::write_memory(unsigned char *address, unsigned v) {
  2.   /* 访问寄存器如果为1，则使用1字节写入 */
  3.   if (_flags.A == 1) {
  4.     *address = (unsigned char)(v & 0xFF);
  5.   }
  6.   /* 访问寄存器如果为2，则使用2字节写入 */
  7.   else if (_flags.A == 2) {
  8.     set_te16(address, (unsigned short)(v & 0xFFFF));
  9.   }
  10.   /* 访问寄存器如果为3，则使用4字节写入 */
  11.   else if (_flags.A == 3) {
  12.     set_te32(address, v);
  13.   }
  14.   else {
  15.     _error = PCVM_ERROR_INVALID_FLAG_A;
  16.     return false;
  17.   }
  18.   return true;
  19. }

因为是一个简单的虚拟机所以并未涉及更多的指令，只是简单的使用了标志寄存器来控制内存的访问粒度。

内存地址计算

通过以下函数可知pcvm的地址管理并不是十分的严谨。但是足够了。由于当指令访问内存时只可以通过寄存器中保存的偏移来计算内存地址。例如:
mov [r1], 5，那么[]中只可以是寄存器，不能是其他的。造成这种原因是因为我想把指令放到4字节内而不想做更复杂的处理。

  1. bool pcvm::calc_address(unsigned off, unsigned **addr)
  2. {
  3.   /* 首先检测偏移是否正确 */
  4.   if (invalid_offset(off)) {
  5.     _error = PCVM_ERROR_INVALID_ADDRESS;
  6.     return false;
  7.   }
  9.   /* _space就是虚拟机执行的内存空间的起始地址 */
  10.   *addr = reinterpret_cast<unsigned*>(_space + off);
  11.   return true;
  12. }

OPCODE编码

在pcvm.h中的33-60行。定义了一个枚举体。

  1. enum PCVM_OP {
  2.   PCVM_OP_MOV,      /* 数据移动指令 */
  3.   PCVM_OP_PUSH,     /* 压栈指令 */
  4.   PCVM_OP_POP,      /* 弹栈指令 */
  5.   PCVM_OP_CMP,      /* 对比指令 */
  6.   PCVM_OP_CALL,     /* 调用函数指令 */
  7.   PCVM_OP_RET,      /* 返回指令 */
  8.   PCVM_OP_JMP,      /* 跳转指令 */
  9.   PCVM_OP_JE,       /* 结果为0则指令 */
  10.   PCVM_OP_JNE,      /* 结果不为0指令 */
  11.   PCVM_OP_JB,       /* 小于则跳转指令 */
  12.   PCVM_OP_JA,       /* 大于则跳转指令 */
  13.   PCVM_OP_JBE,      /* 小于等于则跳转指令 */
  14.   PCVM_OP_JAE,      /* 大于等于则跳转指令 */
  15.   PCVM_OP_AND,      /* 与指令 */
  16.   PCVM_OP_OR,       /* 或指令 */
  17.   PCVM_OP_NOT,      /* 非指令 */
  18.   PCVM_OP_ADD,      /* 加法指令 */
  19.   PCVM_OP_SUB,      /* 减法指令 */
  20.   PCVM_OP_MUL,      /* 乘法指令 */
  21.   PCVM_OP_DIV,      /* 除法指令 */
  22.   PCVM_OP_MOD,      /* 取模指令 */    
  23.   PCVM_OP_SHL,      /* 左移指令 */
  24.   PCVM_OP_SHR,      /* 右移指令 */
  25.   PCVM_OP_INT,      /* 中断指令 */
  26.   PCVM_OP_NOP,      /* 空指令指令 */
  27.   PCVM_OP_NUMBER
  28. };

这里列出了这个虚拟机的所有指令，只有25条。最基本的流程控制欲算术指令。有一个INT指令。对于不同的参数进行不同操作。这些指令基本可以完成变形引擎的基础需求。

指令编码详解

在这节中主要探讨指令的具体执行流程。首先让我们探讨一下pcvm的指令编码的8种模式。
在pcvm.h的72-82行中定义了下列枚举体。用来解释指令的编码。

  1. enum PCVM_INS_MODE {
  2.   PCVM_INS_MODE_OP,             /* opcode */
  3.   PCVM_INS_MODE_OP_IMM,         /* opcode imm */
  4.   PCVM_INS_MODE_OP_REG,         /* opcode reg */
  5.   PCVM_INS_MODE_OP_REG_IMM,     /* opcode reg, imm */
  6.   PCVM_INS_MODE_OP_REG_REG,     /* opcode reg, reg */
  7.   PCVM_INS_MODE_OP_MEM_IMM,     /* opcode mem, imm */
  8.   PCVM_INS_MODE_OP_MEM_REG,     /* opcode mem, reg */
  9.   PCVM_INS_MODE_OP_MEM_MEM,     /* opcode mem, mem */
  10.   PCVM_INS_MODE_NUMBER
  11. };

此虚拟机的一条指令固定4字节，32位。下表列出了以上8种模式的字节编码：

模式名称 编码 举例说明
PCVM_INS_MODE_OP 5:opcode,3:mode,24:- nop
PCVM_INS_MODE_OP_IMM 5:opcode,3:mode,4:-,20:imm push 5
PCVM_INS_MODE_OP_REG 5:opcode,3:mode,4:reg,20:- pop r6
PCVM_INS_MODE_OP_REG_IMM 5:opcode,3:mode,4:reg,20:imm mov r4, 1
PCVM_INS_MODE_OP_REG_REG 5:opcode,3:mode,4:reg1,4:reg2,16:- mov r4,r5
PCVM_INS_MODE_OP_MEM_IMM 5:opcode,3:mode,4:reg,20:imm mov [r2], 3
PCVM_INS_MODE_OP_MEM_REG 5:opcode,3:mode,4:reg1,4:reg2,16:- mov [r3], r2
PCVM_INS_MODE_OP_MEM_MEM 5:opcode,3:mode,4:reg1,4:reg2,16:- mov [r3], [r2]

同样还定义了一组结构体用来记录解码后的信息，类似如下：

  1. typedef struct {
  2.   unsigned int opcode : 5;
  3.   unsigned int mode : 3;
  4.   unsigned int reserve : 24;
  5. } pcvm_ins_mode_op;
  7. typedef struct {
  8.   unsigned int opcode : 5;
  9.   unsigned int mode : 3;
  10.   unsigned int reserve : 4;
  11.   unsigned int imm : 20;
  12. } pcvm_ins_mode_op_imm;
  13. ...省略

这里定义了一组函数来将一个4字节的整数转换成上述的结构体。

  1. bool ins_2_opocde_mode(unsigned ins, unsigned &opcode, 
  2.                        unsigned &mode);
  3. bool ins_2_mode_op(unsigned ins, pcvm_ins_mode_op &mode);
  4. bool ins_2_mode_op_imm(unsigned ins, pcvm_ins_mode_op_imm &mode);
  5. ...省略

因为每条指令的模式都存在两种字段opcode与mode，所以无论后面的函数在执行后第一个调用的函数就是ins_2_opocde_mode，由它来解析指令。

  1. bool pcvm::ins_2_opocde_mode(unsigned ins, 
  2.                              unsigned & opcode,
  3.                              unsigned & mode) {
  4.   /* 通过位移来获取拆解整数 */
  5.   opcode = ins >> 27;
  6.   mode = (ins >> 24) & 0x07;
  8.   /* 验证opcode合法性 */
  9.   if (opcode >= PCVM_OP_NUMBER) {
  10.     _error = PCVM_ERROR_INVALID_OPCODE;
  11.     return false;
  12.   }
  14.   /* 验证mode合法性 */
  15.   if (mode >= PCVM_INS_MODE_NUMBER) {
  16.     _error = PCVM_ERROR_INVALID_MODE;
  17.     return false;
  18.   }
  20.   return true;
  21. }

其余的解码函数都要首先调用以上的函数并填充解码结构。这里使用ins_2_mode_op_reg_imm来讲解，其余几个函数都与之类似。

  1. bool pcvm::ins_2_mode_op_reg_imm(unsigned ins,
  2.                                  pcvm_ins_mode_op_reg_imm & mode) {
  3.   unsigned op = 0, mod = 0;
  4.   /* 解析出opcode与mode */
  5.   if (ins_2_opocde_mode(ins, op, mod) == false) return false;
  7.   /* 填充解码结构 */
  8.   mode.opcode = op;
  9.   mode.mode = mod;
  10.   mode.reg = (ins >> 20) & 0x0F;
  11.   mode.imm = ins & 0xFFFFF;
  13.   return true;
  14. }

解码处理函数

定义了8个函数，具体的指令执行函数就是执行这些函数来获取自己所需的信息。命名规范为handle_ins_mode_xxx，它们是一组外层函数其内还是调用ins_2_mode_xxx来实现。这里就不一一说明了。

  1. bool handle_ins_mode_op(unsigned ins, unsigned &op);
  2. bool handle_ins_mode_op_imm(unsigned ins, unsigned &op, 
  3.                             unsigned &imm);
  4. ...省略

这里有几个与内存相关的函数在调用ins_2_mode_xxx进一步的对内存地址进行核算。

算术指令

关于算术指令的处理模式都大致相同一共有5种。其中iNOT是个特例，因为它只有not reg一种模式。随后再对它进行分析

模式
算术指令 reg, imm
算术指令 reg, reg
算术指令 mem, imm
算术指令 mem, reg
算术指令 mem, mem

下表列出了所有算术指令。

指令函数
iAND
iOR
iNOT
iADD
iSUB
iMUL
iDIV
iMOD
iSHL
iSHR

这里以iADD为例做解释：

  1. bool pcvm::iADD(unsigned ins, unsigned mode) {
  2.   unsigned v1 = 0, v2 = 0;
  3.   unsigned opcode = 0;
  4.   /* 判断模式是否是add reg, imm */
  5.   if (mode == PCVM_INS_MODE_OP_REG_IMM) {
  6.     unsigned reg = 0, imm = 0;
  7.     /* 从中取出reg与imm的具体值 */
  8.     if (handle_ins_mode_op_reg_imm(ins, opcode, reg, imm) == false)
  9.       return false;
  10.     /* 将reg中的值读取出来到v1 */
  11.     if (registers(reg, v1) == false) return false;
  12.     /* 将imm写入到v2的值中 */
  13.     if (write_memory(reinterpret_cast<unsigned char*>(&v2), imm) == false)
  14.       return false;
  16.     /* 如果S标志被设置，那么作为有符号数进行计算 */
  17.     if (_flags.S) {
  18.       int v1_ = (int)v1;
  19.       int v2_ = (int)v2;
  20.       v1_ += v2_;
  21.       v1 = (unsigned)v1_;
  22.     }
  23.     /* 作为无符数直接进行计算 */
  24.     else {
  25.       v1 += v2;
  26.     }
  28.     /* 将结果设置到reg处 */
  29.     if (set_registers(reg, v1) == false) return false;
  30.   }
  31.   /* 处理add reg, reg模式 */
  32.   else if (mode == PCVM_INS_MODE_OP_REG_REG) {
  33.     unsigned reg1 = 0, reg2 = 0;
  34.     /* 从ins中取出opcode，以及两个寄存器的索引 */
  35.     if (handle_ins_mode_op_reg_reg(ins, opcode, reg1, reg2) == false)
  36.       return false;
  37.     /* 读取出两个寄存器的值 */
  38.     if (registers(reg1, v1) == false) return false;
  39.     if (registers(reg2, v2) == false) return false;
  41.     /* 查看符号标志位
  42.      * 如果是有符号位则进行类型转换
  43.      */
  44.     if (_flags.S) {
  45.       int v1_ = (int)v1;
  46.       int v2_ = (int)v2;
  47.       v1_ += v2_;
  48.       v1 = (unsigned)v1_;
  49.     }
  50.     else {
  51.       v1 += v2;
  52.     }
  54.     /* 设置寄存器的值 */
  55.     if (set_registers(reg1, v1) == false) return false;
  56.   }
  57.   /* 处理add [mem], imm模式 */
  58.   else if (mode == PCVM_INS_MODE_OP_MEM_IMM) {
  59.     unsigned *address = nullptr, imm = 0;
  60.     /* 取出opcode,要访问的地址以及立即数 */
  61.     if (handle_ins_mode_op_mem_imm(ins, opcode, &address, imm) == false)
  62.       return false;
  63.     /* 取出立即数并写入到v2临时变量中 */
  64.     if (write_memory(reinterpret_cast<unsigned char*>(&v2), imm) == false)
  65.       return false;
  66.     /* 从address的地址中取出数值 */
  67.     if (write_memory(reinterpret_cast<unsigned char*>(&v1), *address) == false)
  68.       return false;
  69.     /* 按照符号进行处理 */
  70.     if (_flags.S) {
  71.       int v1_ = (int)v1;
  72.       int v2_ = (int)v2;
  73.       v1_ += v2_;
  74.       v1 = (unsigned)v1_;
  75.     }
  76.     else {
  77.       v1 += v2;
  78.     }
  80.     /* 最终把结果写入到address指向的地址中 */
  81.     if (write_memory(reinterpret_cast<unsigned char*>(address), v1) == false)
  82.       return false;
  83.   }
  84.   /* 处理add [mem], reg模式 */
  85.   else if (mode == PCVM_INS_MODE_OP_MEM_REG) {
  86.     unsigned *address = nullptr, reg = 0;
  87.     /* 从ins中取出opcode, address以及要操作的寄存器 */
  88.     if (handle_ins_mode_op_mem_reg(ins, opcode, &address, reg) == false)
  89.       return false;
  90.     /* 从address指向的内存中取出数值 */
  91.     if (write_memory(reinterpret_cast<unsigned char*>(&v1), *address) == false)
  92.       return false;
  93.     /* 从寄存器中读取出值 */
  94.     if (registers(reg, v2) == false)
  95.       return false;
  97.     /* 按照符号寄存器进行运算 */
  98.     if (_flags.S) {
  99.       int v1_ = (int)v1;
  100.       int v2_ = (int)v2;
  101.       v1_ += v2_;
  102.       v1 = (unsigned)v1_;
  103.     }
  104.     else {
  105.       v1 += v2;
  106.     }
  108.     /* 将结果写入到address指向的内存中 */
  109.     if (write_memory(reinterpret_cast<unsigned char*>(address), v1) == false)
  110.       return false;
  111.   }
  112.   /* 处理add [mem1], [mem2]模式 */
  113.   else if (mode == PCVM_INS_MODE_OP_MEM_MEM) {
  114.     unsigned *address1 = nullptr, *address2 = nullptr;
  115.     /* 从指令中取出两个要操作的地址 */
  116.     if (handle_ins_mode_op_mem_mem(ins, opcode, &address1, &address2) == false)
  117.       return false;
  118.     /* 从两个地址中取出数值 */
  119.     if (write_memory(reinterpret_cast<unsigned char*>(&v1), *address1) == false)
  120.       return false;
  121.     if (write_memory(reinterpret_cast<unsigned char*>(&v2), *address2) == false)
  122.       return false;
  124.     /* 按照符号寄存器进行计算 */
  125.     if (_flags.S) {
  126.       int v1_ = (int)v1;
  127.       int v2_ = (int)v2;
  128.       v1_ += v2_;
  129.       v1 = (unsigned)v1_;
  130.     }
  131.     else {
  132.       v1 += v2;
  133.     }
  135.     /* 将结果写入到address1指向的内存中 */
  136.     if (write_memory(reinterpret_cast<unsigned char*>(address1), v1) == false)
  137.       return false;
  138.   }
  139.   else {
  140.     _error = PCVM_ERROR_INVALID_MODE;
  141.     return false;
  142.   }
  144.   return true;
  145. }

基本算术指令都是按照这个流程来运行的，只是最后的具体运算不同而已。唯一不同的是NOT指令。它只有一种模式就是对寄存器中的值做非运算，见下代码：

  1. bool pcvm::iNOT(unsigned ins, unsigned mode)
  2. {
  3.   unsigned opcode = 0;
  4.   /* 处理 not reg */
  5.   if (mode == PCVM_INS_MODE_OP_REG) {
  6.     unsigned reg = 0, value = 0;
  7.     /* 从ins中取出opcode以及reg */
  8.     if (handle_ins_mode_op_reg(ins, opcode, reg) == false)
  9.       return false;
  11.     /* 做NOT操作 */
  12.     if (registers(reg, value) == false) return false;
  13.     if (set_registers(reg, ~value) == false) return false;
  14.   }
  15.   else {
  16.     _error = PCVM_ERROR_INVALID_MODE;
  17.     return false;
  18.   }
  19.   return true;
  20. }

数据转移指令

下表列出了所有数据转移指令。

指令函数
MOV
PUSH
POP

首先看一下著名的MOV：

  1. bool pcvm::iMOV(unsigned ins, unsigned mode) {
  2.   unsigned opcode = 0;
  3.   /* 处理 mov reg, imm */
  4.   if (mode == PCVM_INS_MODE_OP_REG_IMM) {
  5.     unsigned reg = 0, imm = 0;
  6.     if (handle_ins_mode_op_reg_imm(ins, opcode, reg, imm) == false)
  7.       return false;
  8.     /* 最后直接设置立即数到指定的寄存器 */
  9.     return set_registers(reg, imm);
  10.   }
  11.   /* mov reg,reg */
  12.   else if (mode == PCVM_INS_MODE_OP_REG_REG) {
  13.     unsigned reg1 = 0, reg2 = 0;
  14.     if (handle_ins_mode_op_reg_reg(ins, opcode, reg1, reg2) == false)
  15.       return false;
  16.     unsigned v = 0;
  17.     /* 从源寄存器中读取设置到目的寄存器中 */
  18.     if (registers(reg2, v) == false) return false;
  19.     return set_registers(reg1, v);
  20.   }
  21. /* 此处省略吧 ！！！
  22.  * 剩下的就是其余的处理
  23.  */
  24. }

压栈操作，压栈只能处理两种模式，push imm以及push reg

  1. bool pcvm::iPUSH(unsigned ins, unsigned mode) {
  2.   unsigned opcode = 0;
  3.   /* 压栈，首先读取当前栈寄存器的值，然后减去一个4字节(32位系统) */
  4.   unsigned offset = _registers[PCVM_REG_SP] - sizeof(unsigned);
  6.   /* push imm */
  7.   if (mode == PCVM_INS_MODE_OP_IMM) {
  8.     unsigned imm = 0;
  9.     if (handle_ins_mode_op_imm(ins, opcode, imm) == false)
  10.       return false;
  12.     /* 校验偏移是否有效 */
  13.     if (invalid_offset(offset)) {
  14.       _error = PCVM_ERROR_INVALID_ADDRESS;
  15.       return false;
  16.     }
  18.     /* 通过offset计算虚拟内存的地址 */
  19.     unsigned *address = nullptr;
  20.     if (calc_address(offset, &address) == false) return false;
  21.     /* 写入到内存 */
  22.     if (write_memory(reinterpret_cast<unsigned char*>(address),     imm) == false)
  23.       return false;
  24.   }
  25.   /* push reg */
  26.   else if (mode == PCVM_INS_MODE_OP_REG) {
  27.     /* 省略了... 与之前大同小异 */
  28.   }
  29.   else {
  30.     _error = PCVM_ERROR_INVALID_MODE;
  31.     return false;
  32.   }
  33.   /* 重新设置栈寄存器的指针 */
  34.   _registers[PCVM_REG_SP] -= sizeof(unsigned);
  35.   return true;
  36. }

弹栈操作，只能处理一种模式pop reg

  1. bool pcvm::iPOP(unsigned ins, unsigned mode) {
  2.   unsigned opcode = 0;
  3.   /* pop reg */
  4.   if (mode == PCVM_INS_MODE_OP_REG) {
  5.     unsigned reg = 0;
  6.     if (handle_ins_mode_op_reg(ins, opcode, reg) == false)
  7.       return false;
  8.     /* 取出当前栈指向的偏移并转换成地址 */
  9.     unsigned offset = _registers[PCVM_REG_SP];
  10.     if (invalid_offset(offset)) {
  11.       _error = PCVM_ERROR_INVALID_ADDRESS;
  12.       return false;
  13.     }
  14.     unsigned *address = nullptr;
  15.     if (calc_address(offset, &address) == false) return false;
  16.     /* 从栈地址中读取出值并设置给寄存器 */
  17.     if (set_registers(reg, *address) == false) return false;
  18.   }
  19.   else {
  20.     _error = PCVM_ERROR_INVALID_MODE;
  21.     return false;
  22.   }
  24.   /* 最后移动栈指针 */
  25.   _registers[PCVM_REG_SP] += sizeof(unsigned);
  26.   return true;
  27. }

流程控制指令

下表列出了所有流程指令。

指令函数
CALL
RET
JMP
JE
JNE
JB
JA
JBE
JAE

除了跳转指令，使用cmp指令来判定流程走向。

cmp指令

可以处理以下几种模式，cmp reg, imm,cmp reg, reg,cmp mem, imm,cmp mem, reg,cmp mem, mem。

  1. bool pcvm::iCMP(unsigned ins, unsigned mode) {
  2.   /* ...以下代码忽略，其意思就是从各种模式中取出数据 */
  3.   /* 最后的值相减 */
  4.   int res = static_cast<int>(v1) - static_cast<int>(v2);
  6.   /* 最后设置一些标志位 */
  7.   if (res == 0) _flags.Z = 1; else _flags.Z = 0;
  8.   if (res < 0) _flags.C = 1; else _flags.C = 0;
  10.   return true;
  11. }

各种跳转指令

这里只列出一些有代表意义的，例如CALL,RET与JMP其余的判定跳转只是在JMP的基础上增加了标志位判定而已。

call指令

这个指令只能处理两种模式call imm与call reg。代码分析如下:

  1. bool pcvm::iCALL(unsigned ins, unsigned mode) {
  2.   /*
  3.    * 得到返回地址栈的偏移
  4.    */
  5.   unsigned offset = _registers[PCVM_REG_SP] - sizeof(unsigned);
  6.   if (invalid_offset(offset)) {
  7.     _error = PCVM_ERROR_INVALID_ADDRESS;
  8.     return false;
  9.   }
  10.   /* 通过偏移得到地址 */
  11.   unsigned *address = nullptr;
  12.   if (calc_address(offset, &address) == false) return false;
  13.   /*将当前的地址也就是call指令的后一条指令的地址写入到返回地址栈*/
  14.   unsigned next_address = _registers[PCVM_REG_IP];
  15.   if (write_memory(reinterpret_cast<unsigned char*>(address), next_address) == false)
  16.     return false;
  18.   unsigned opcode = 0, jmpto = 0;
  19.   /* call imm模式 */
  20.   if (mode == PCVM_INS_MODE_OP_IMM) {
  21.     unsigned imm = 0;
  22.     if (handle_ins_mode_op_imm(ins, opcode, imm) == false)
  23.       return false;
  24.     jmpto = imm;
  25.   }
  26.   /* call reg模式 */
  27.   else if (mode == PCVM_INS_MODE_OP_REG) {
  28.     unsigned reg = 0, imm;
  29.     if (handle_ins_mode_op_reg(ins, opcode, reg) == false)
  30.       return false;
  31.     /* 从寄存器中读取出偏移 */
  32.     if (registers(reg, imm, true) == false) return false;
  33.     jmpto = imm & 0xFFFFF;
  34.   }
  35.   else {
  36.     _error = PCVM_ERROR_INVALID_MODE;
  37.     return false;
  38.   }
  40.   /* 设定栈与调用地址 */
  41.   _registers[PCVM_REG_IP] = jmpto;
  42.   _registers[PCVM_REG_SP] = offset;
  44.   return true;
  45. }

ret指令

好吧，到了返回指令了，也很简单从栈中取出返回地址设定IP寄存器即可。

  1. bool pcvm::iRET(unsigned ins, unsigned mode) {
  2.   /*
  3.    * 把偏移从栈中弹出
  4.    */
  5.   unsigned offset = _registers[PCVM_REG_SP];
  6.   if (invalid_offset(offset)) {
  7.     _error = PCVM_ERROR_INVALID_ADDRESS;
  8.     return false;
  9.   }
  10.   unsigned *address = nullptr;
  11.   /* 通过偏移计算地址 */
  12.   if (calc_address(offset, &address) == false) return false;
  14.   /* 取出最后的返回地址 */
  15.   _registers[PCVM_REG_IP] = *address;
  17.   /* 将栈恢复 */
  18.   _registers[PCVM_REG_SP] = offset + sizeof(unsigned);
  20.   return true;
  21. }

jmp指令

处理两种模式jmp imm与jmp reg。其中寄存器与立即数保存的都直接是地址，取出后直接设置给IP寄存器即可，这里没按照现实计算机的偏移原则是因为觉得实在没有必要弄那么复杂，而虚拟机的内存已经限定在了1MB内，所以直接使用地址即可。

  1. bool pcvm::iJMP(unsigned ins, unsigned mode)
  2. {
  3.   unsigned opcode = 0, address = 0;
  4.   /* jmp imm */
  5.   if (mode == PCVM_INS_MODE_OP_IMM) {
  6.     unsigned imm = 0;
  7.     if (handle_ins_mode_op_imm(ins, opcode, imm) == false)
  8.       return false;
  9.     address = imm;
  10.   }
  11.   /* jmp reg */
  12.   else if (mode == PCVM_INS_MODE_OP_REG) {
  13.     unsigned reg = 0, imm;
  14.     if (handle_ins_mode_op_reg(ins, opcode, reg) == false)
  15.       return false;
  16.     if (registers(reg, imm, true) == false) return false;
  17.     address = imm & 0xFFFFF;
  18.   }
  19.   else {
  20.     _error = PCVM_ERROR_INVALID_MODE;
  21.     return false;
  22.   }
  23.   /* 设定跳转地址 */
  24.   _registers[PCVM_REG_IP] = address;
  26.   return true;
  27. }

其余的条件跳转指令，只不过是增加了标志位判定而已。举个例子：

  1. bool pcvm::iJE(unsigned ins, unsigned mode)
  2. {
  3.   /* 判定标志位是否为0 */
  4.   if (_flags.Z == 0) {
  5.     return true;
  6.   }
  7.   return iJMP(ins, mode);
  8. }

其余几个都大同小异而已。

中断指令

首先这里列出了各个中断的说明，其实说是中断也就是这样一个名字而已，使用这种设计减少了指令的个数，而且可以方便的扩展功能而已。

中断号 说明 
  1. bool pcvm::iINT(unsigned ins, unsigned mode)
  2. {
  3.   unsigned opcode = 0;
  4.   if (mode == PCVM_INS_MODE_OP_IMM) {
  5.     unsigned imm = 0;
  6.     if (handle_ins_mode_op_imm(ins, opcode, imm) == false)
  7.       return false;
  9.     /* int 0
  10.      * 从R4寄存器中取出输入端口号
  11.      * 从R5寄存器中取出要读取数据的长度
  12.      * 然后将数据写入到当前栈指针所指向的内存
  13.      * 最后将长度写入到R4寄存器中
  14.      */
  15.     if (imm == 0) {
  16.       unsigned port = 0, size = 0;
  17.       if (registers(PCVM_REG_R4, port) == false) return false;
  18.       if (port >= PCVM_IO_INPUT_NUMBER) {
  19.         _error = PCVM_ERROR_INVALID_IO_ACCESS;
  20.         return false;
  21.       }
  23.       if (registers(PCVM_REG_R5, size) == false) return false;
  24.       /* fixme: check size */
  26.       unsigned offset = _registers[PCVM_REG_SP];
  27.       if (invalid_offset(offset)) {
  28.         _error = PCVM_ERROR_INVALID_ADDRESS;
  29.         return false;
  30.       }
  31.       unsigned *address = nullptr;
  32.       if (calc_address(offset, &address) == false) return false;
  34.       if (_io_input[port] == nullptr) {
  35.         _error = PCVM_ERROR_IO_NOT_BOUNAD;
  36.         return false;
  37.       }
  38.       /* 写入数据 */
  39.       memcpy(address, _io_input[port], size);
  41.       if (set_registers(PCVM_REG_R4, size) == false) return false;
  42.     }
  43.     /* int 1
  44.      * 从R4寄存器中取出输出端口号
  45.      * 从R5寄存器中取出要写入数据的长度
  46.      * 然后将当前栈指针所指向的内存的数据写入到端口的缓存中
  47.      * 最后将长度写入到R4寄存器中
  48.      */
  49.     else if (imm == 1) {
  50.       unsigned port = 0, size = 0;
  51.       if (registers(PCVM_REG_R4, port) == false) return false;
  52.       if (port >= PCVM_IO_INPUT_NUMBER) {
  53.         _error = PCVM_ERROR_INVALID_IO_ACCESS;
  54.         return false;
  55.       }
  57.       if (registers(PCVM_REG_R5, size) == false) return false;
  58.       /* fixme: check size */
  60.       unsigned offset = _registers[PCVM_REG_SP];
  61.       if (invalid_offset(offset)) {
  62.         _error = PCVM_ERROR_INVALID_ADDRESS;
  63.         return false;
  64.       }
  65.       unsigned *address = nullptr;
  66.       if (calc_address(offset, &address) == false) return false;
  68.       if (_io_output[port] == nullptr) {
  69.         _error = PCVM_ERROR_IO_NOT_BOUNAD;
  70.         return false;
  71.       }
  72.       memcpy(_io_output[port], address, size);
  74.       if (set_registers(PCVM_REG_R4, size) == false) return false;
  75.     }
  76.     /* int 2
  77.      * 从R4寄存器中读取出输入端口
  78.      * 将指定的端口中存在多少个数据放入到R5中
  79.      */
  80.     else if (imm == 2) {
  81.       unsigned port = 0;
  82.       if (registers(PCVM_REG_R4, port) == false) return false;
  83.         if (port >= PCVM_IO_INPUT_NUMBER) {
  84.           _error = PCVM_ERROR_INVALID_INT_PARAM;
  85.           return false;
  86.         }
  87.       set_registers(PCVM_REG_R5, _io_input_size[port]);
  88.     }
  89.     /* int 3
  90.      * 从R4寄存器中读取出输出端口
  91.      * 将要写入多少个数据长度放入到指定输出端口保存长度中
  92.      * 上层可以通过get_output_io_size(port)来获取这个长度
  93.      */
  94.     else if (imm == 3) {
  95.       unsigned port = 0, size = 0;
  96.       if (registers(PCVM_REG_R4, port) == false) return false;
  97.       if (port >= PCVM_IO_OUTPUT_NUMBER) {
  98.         _error = PCVM_ERROR_INVALID_INT_PARAM;
  99.         return false;
  100.       }
  101.       if (registers(PCVM_REG_R5, size) == false) return false;
  102.       _io_output_size[port] = size;
  103.     }
  104.     /* int 4
  105.      * 读取R4寄存器的值只可以是1,2,4。用来控制对数据的操作粒度
  106.      * 1表示1字节，2表示2字节，4表示4字节。
  107.      */
  108.     else if (imm == 4) {
  109.       unsigned unit = 0;
  110.       if (registers(PCVM_REG_R4, unit) == false) return false;
  111.       if ((unit != 1) || (unit != 2) || (unit != 4)) {
  112.         _error = PCVM_ERROR_INVALID_INT_PARAM;
  113.         return false;
  114.       }
  115.       _flags.A = unit;
  116.     }
  117.     /* int 5
  118.      * R4为大于0表示以后采用无符号计算
  119.      * R4小于等于0则采用有有符号计算
  120.      */
  121.     else if (imm == 5) {
  122.       unsigned sign = 0;
  123.       if (registers(PCVM_REG_R4, sign) == false) return false;
  124.       _flags.S = !(sign > 0);
  125.     }
  126.     /* int 9
  127.      * 直接关机
  128.      */
  129.     else if (imm == 9) {
  130.       _shutdown = true;
  131.     }
  132.     else {
  133.       _error = PCVM_ERROR_INVALID_INT_NUMBER;
  134.       return false;
  135.     }
  136.   }
  137.   else {
  138.     _error = PCVM_ERROR_INVALID_MODE;
  139.     return false;
  140.   }
  142.   return true;
  143. }

虚拟机调试器

如果SUPPORT_DEBUGER宏开始，则虚拟机的整个代码会将调试器模块编译到其中。其主要入口函数为debugger。并在run函数中的循环中调用。

  1.   while (_shutdown == false) {
  3.     /* 每在执行一条指令前首先进入调试器，如果调试模式开启的化。*/
  4. #ifdef SUPPORT_DEBUGER
  5.     if (debug) {
  6.       debugger(_registers[PCVM_REG_IP]);
  7.     }
  8. #endif
  10.     if (readi(ins) == false) {
  11.       if (_error == PCVM_ERROR_OVER_CODE_SIZE_LIMIT) {
  12.         _error = PCVM_ERROR_SUCCESS;
  13.         return true;
  14.       }
  15.       return false;
  16.     }
  17.     if (call(ins) == false) return false;
  18.   }
  20.   return true;

每执行一次会弹出一个如下图所示的简单界面。
debug.jpg-370.3kB
调试只有三条指令

其实简单的排错够了。有兴趣的朋友直接读代码即可，实现很简单。

虚拟机汇编器的设计与实现

现在进入汇编器的代码分析，这个汇编器比较简单，不过汇编器一直都没复杂过。因为我并没有设计宏的概念，所以不涉及到什么语法上的处理。所以本汇编器，没有语法处理部分，就是使用词法处理将字符串转换成标记，按照每条指令可以处理的模式进行汇编。其中稍微麻烦一点的是需要将标签记录下来，以供当汇编完成后的重定位处理。
最后定义了一个很简单的文件格式将代码写入到其中。汇编器只有三份文件pcasm.h,pcasm.cpp,pcasm_main.cpp。

汇编器结构介绍

在pcasm.h中可以看到完整的汇编器所需的结构的定义。
标签定义，其中有两项，address是全局文件的地址。mode_address是当前模块的地址

  1. typedef struct {
  2.     unsigned address;
  3.     unsigned mode_address;
  4. } pcasm_label;

重定位项的类型，其实只有一个其实就是基地址重定位，后边在链接一节中会详细说明。

  1. enum {
  2.     PCASM_REL_FIXLST20B,
  3.     PCASM_REL_NUMBER
  4. };

重定位项结构，type其实只有一个值就是上面枚举体定义的。address是当前要重定位的地址。symbol是符号字符串，用于表明要重定位的是哪个标签。用于去符号表中进行查询。

  1. typedef struct {
  2.     int type;
  3.     unsigned address;
  4.     std::string symbol;
  5. } pcasm_relocate;

词法分析中所用到的标记结构，token表示标记的整型定义，这些值我在这个结构的后边列出了。text是标记的字面值结构，用于保存这个结构当前的值，例如一个字符串，一个整数，一个寄存器等等，用于后边的汇编。这里需要一点点编译原理的知识，其实如果往深里将，做软件保护壳和做一个编译器没什么区别，如果要做一个精品，需要以下一个流程。

Created with Raphaël 2.1.2反汇编bin文件处理反汇编后的代码（保护）重写进行汇编进行链接End

其实把这个流程进行扩展可以完成一个二进制编译器。其实我一直想做一个这种程序，人生有很多无奈，从去年年底就开始计划写，由于每天要处理种种事情，所以并没有大量时间进行编写，虽然时间挤挤就有了，但是有时候还真挤不出来。

  1. typedef struct {
  2.     int token;
  3.     pcasm_text text;
  4. } pcasm_token;
  6. enum {
  7.     TOKEN_OP,                   /* OPCODE */
  8.     TOKEN_REG,                  /* 寄存器 */
  9.     TOKEN_IMM,                  /* 立即数 */
  10.     TOKEN_DEF_LABEL,            /* 定义标记 */
  11.     TOKEN_REF_LABEL,            /* 引用标记 */
  12.     TOKEN_COLON,                /* 冒号 */
  13.     TOKEN_LPARAM,               /* 左括号 */
  14.     TOKEN_RPARAM,               /* 右括号 */
  15.     TOKEN_COMMA,                /* 逗号 */
  16.     TOKEN_INCLUDE,              /* include文件包含 */
  17.     TOKEN_STRING,               /* 字符串 */
  18.     TOKEN_EOF,                  /* 到达末尾了 */
  19.     TOKEN_NUMBER                /* 标记数量 */
  20. };

标记字面值，在token里的子结构，用于根据token的不同，提供不同的值对应。从下面字段中的名称就可以看出它们是对应哪些标记了。别告诉我，你看不懂，如果这样的话，你手中的这本书可以直接丢到书柜了。

  1. typedef struct {
  2.     unsigned opcode;
  3.     std::string str;
  4.     unsigned reg;
  5.     unsigned imm;
  6.     std::vector<unsigned char> data;
  7. } pcasm_text;

下面就是汇编器的主类定义，这里因为篇幅原因，将一些不重要的函数以及重复性过高的函数去掉了。

  1. class pcasm {
  2. public:
  3.     pcasm();
  4.     virtual ~pcasm();
  6.     /* 主流程入口 */
  7.     bool compile(const std::string &asm_file, std::vector<unsigned char> &bytecodes, bool is_file=true);
  8.     /* 汇编并做重定位处理 */
  9.     bool make(const std::string &asm_file, std::vector<unsigned char> &bytecodes);
  10.     /* 将代码写入到pc文件格式中 */
  11.     bool make_pcfile(unsigned char *bytecodes, size_t bcsize, unsigned char **pcfile, size_t &pcfile_size);
  12.     /* 获取当前出错代码 */
  13.     int error();
  15. public:
  16.     /* 初始化 */
  17.     static void init();
  18.     /* 链接操作，其实就是负责重定位 */
  19.     static int pclink(std::vector<unsigned char> &bytecodes);
  20.     /* 获得汇编好后代码的入口偏移 */
  21.     static unsigned entry();
  23. private:
  24.     /* 重新设定此类的所有数据 */
  25.     void reset();
  27.     /* 汇编成一条指令函数集合 */
  28.     unsigned write_mode_op(unsigned opcode);
  29.     unsigned write_mode_op_imm(unsigned opcode, unsigned imm);
  30.     /* 省略... */
  32.     /* 具体指令编译函数 */
  33.     bool MOV_REG_LAB(unsigned opcode, std::vector<unsigned char> &bytecodes);
  34.     bool MOV_MEM_LAB(unsigned opcode, std::vector<unsigned char> &bytecodes);
  35.     /* 省略... */
  36.     bool cMOV(std::vector<unsigned char> &bytecodes);
  38.     /* 其余指令省略... */
  40.     /* 处理包含文件标记 */
  41.     bool cInclude(std::vector<unsigned char> &bytecodes);
  42.     /* 定义一个标记 */
  43.     bool cDefLabel(pcasm_token &token);
  45.     /* 第一遍处理 */
  46.     bool pass1();
  47.     /* 第二遍处理 */
  48.     bool pass2(std::vector<unsigned char> &bytecodes);
  50.     /* 进行词法扫描 */
  51.     bool scanner(pcasm_token &token);
  52.     /* 进行汇编主入口 */
  53.     bool parser(std::vector<unsigned char> &bytecodes);
  54.     /* 设置出错代码 */
  55.     void set_error(int err);
  56.     /* 当前一组标记是否匹配 */
  57.     bool match(std::vector<int> tokens);
  59.     /* 增加地址 */
  60.     bool plus_address(unsigned plus=sizeof(unsigned));
  62. private:
  63.     /* 操作当前的字符串流 */
  64.     bool teste();
  65.     int readc();
  66.     bool plusp(int plus=1);
  67.     bool decp(int dec=1);
  69.     /* 汇编操作集合 */
  70.     int write_ins(int ins, std::vector<unsigned char> &bytecodes);
  71.     int write_datas(const std::vector<unsigned char> &datas, std::vector<unsigned char> &bytecodes);
  72.     int write_imm(unsigned data, std::vector<unsigned char> &bytecodes);
  73.     int write_string(const std::string &str, std::vector<unsigned char> &bytecodes);
  75.     /* 对词法标记的操作集合 */
  76.     pcasm_token next_token();
  77.     void rollback_token(int num = 1);
  79.     /* 忽略... */
  80. };

首先让我们从compile开始吧。

  1. bool pcasm::compile(const std::string & asm_file, std::vector<unsigned char> &bytecodes, bool is_file) {
  2.     reset();
  3.     /* 如果是文件，则读取文件 */
  4.     if (is_file) {
  5.         std::string source = s_read_file(asm_file);
  6.         if (source == "") return false;
  7.         _source = source;
  8.     }
  9.     else {
  10.         /* 直接使用字符串作为源代码 */
  11.         _source = asm_file;
  12.     }
  14.     /* 第一遍处理 */
  15.     if (pass1() == false) return false;
  16.     /* 第二遍处理 */
  17.     if (pass2(bytecodes) == false) return false;
  19.     return true;
  20. }

而make与make_pcfile只是对上面这个函数进行了进一步的封装而已。下面我们就来看下这两遍处理。

第一遍处理

  1. bool pcasm::pass1()
  2. {
  3.     pcasm_token token;
  4.     _token_source.clear();
  5.     /* 循环扫描源代码文本并将标记填充到_token_source向量中 */
  6.     do {
  7.         if (scanner(token) == false) {
  8.             return false;
  9.         }
  10.         _token_source.push_back(token);
  11.     } while (token.token != TOKEN_EOF);
  12.     return true;
  13. }

第一遍处理的功能还是很明确，就是在填充一个由标记组成的队列。而scanner就是在返回词法标记而已。以下列出部分代码。

  1. bool pcasm::scanner(pcasm_token &token)
  2. {
  3.     int c = 0;
  4.     std::string str;
  5.     /* 测试是否到达源代码末尾 */
  6.     while (teste() == false) {
  7.         /* 读取一个字符 */
  8.         c = readc();
  9.         /* 跳过空白符 */
  10.         if ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n')) {
  11.             continue;
  12.         }
  13.         /* 处理注释 */
  14.         else if (c == ';') {
  15.             do {
  16.                 c = readc();
  17.                 if (c == -1) {
  18.                     token.token = TOKEN_EOF;
  19.                     return true;
  20.                 }
  21.             } while (c != '\n');
  22.             continue;
  23.         }
  25.         switch (c) {
  26.         /* 16进制数的读取 */
  27.         case 'x':
  28.             str.clear();
  29.             do {
  30.                 c = readc();
  31.                 if (s_is_hexchar(c) == false) {
  32.                     decp();
  33.                     break;
  34.                 }
  35.                 str.push_back(c);
  36.             } while (true);
  38.             if (str.empty() == false) {
  39.                 char *hexptr = nullptr;
  40.                 token.text.imm = static_cast<unsigned>(strtol(str.c_str(), &hexptr, 16));
  41.                 token.token = TOKEN_IMM;
  42.                 return true;
  43.             }
  44.             else {
  45.                 _error = PCASM_ERROR_SCAN_INVALID_CHAR;
  46.                 return false;
  47.             }
  48.             break;
  49.         /* 中间的部分省略了好多... */
  51.         /* 关于标签的操作，这个是最复杂的一个了 */
  52.         case '@':
  53.             token.text.str.clear();
  54.             /* 读取一个字符 */
  55.             c = readc();
  56.             if (c == -1) {
  57.                 _error = PCASM_ERROR_SCAN_QUOTATION_NOT_CLOSE;
  58.                 return false;
  59.             }
  60.             /* 如果当前字符是字母或者是下划线
  61.              * 继续读取，标签只允许字母，数字，下划线
  62.              * 并且只能以下划线与字母开头
  63.              */
  64.             if ((isalpha(c)) || (c == '_')) {
  65.                 int len = 1;
  66.                 while ((c == '_') || isalnum(c)) {
  67.                     if (len >= PCASM_MAX_LABEL) {
  68.                         _error =  
  69.                         PCASM_ERROR_SCAN_LABNAME_OVER_LIMIT;
  70.                         _errstr = token.text.str;
  71.                         return false;
  72.                     }
  73.                     token.text.str.push_back(c);
  74.                     c = readc();
  75.                     len++;
  76.                 }
  77.                 /* 如果标号名后接一个冒号则视为标号的定义 */
  78.                 if (c == ':') {
  79.                     token.token = TOKEN_DEF_LABEL;
  80.                     return true;
  81.                 }
  82.                 /* 如果仅是标号名则视为引用标号 */
  83.                 else {
  84.                     token.token = TOKEN_REF_LABEL;
  85.                     return true;
  86.                 }
  87.             }
  88.             break;
  89.         default:
  90.             _error = PCASM_ERROR_SCAN_NOT_MATCH_TOKEN_START_CHAR;
  91.             return false;
  92.         }
  93.     }
  95.     token.token = TOKEN_EOF;
  96.     return true;
  97. }

第二遍处理

pass2这个函数只是一个外包装而已，忽略它，在它里面调用了pass2函数。这个函数主要就是从pass1压入的标记队列中，依次取出并且按照既定的规范开始进行汇编。

  1. bool pcasm::parser(std::vector<unsigned char> &bytecodes)
  2. {
  3.     pcasm_token token;
  4.     do {
  5.         /* 取得下一个标记 */
  6.         token = next_token();
  7.         /* 遇到末尾则退出 */
  8.         if (token.token == TOKEN_EOF) {
  9.             break;
  10.         }
  11.         /* 遇到指令标记 */
  12.         else if (token.token == TOKEN_OP) {
  13.             /* 执行对应的指令汇编函数
  14.              * _handles是一个私有变量，保存了各条指令的汇编函数指针
  15.              * 直接从标记字面值中获取索引进行寻址。
  16.              */
  17.             if ((this->*_handles[token.text.opcode])(bytecodes) == false)
  18.         return false;
  19.             /* 汇编一条指令则增加地址 */
  20.             if (plus_address() == false) return false;
  21.         }
  22.         /* 遇到include标记则调用cInclude函数 */
  23.         else if (token.token == TOKEN_INCLUDE) {
  24.             if (cInclude(bytecodes) == false)
  25.         return false;
  26.         }
  27.         /* 遇到标记定义 */
  28.         else if (token.token == TOKEN_DEF_LABEL) {
  29.             if (cDefLabel(token) == false)
  30.         return false;
  31.         }
  32.         /* 遇到立即数 */
  33.         else if (token.token == TOKEN_IMM) {
  34.             if (plus_address(write_imm(token.text.imm, bytecodes)) == false)
  35.         return false;
  36.         }
  37.         /* 遇到字符串 */
  38.         else if (token.token == TOKEN_STRING) {
  39.             if (plus_address(write_string(token.text.str, bytecodes)) == false)
  40.         return false;
  41.         }
  42.         else {
  43.             _error = PCASM_ERROR_SYNTAX_INCONFORMITY_TOKEN;
  44.             return false;
  45.         }
  46.     } while (true);
  47.     return true;
  48. }

指令地址

这里我设计了两个地址_address其实是模块内的地址，就是单一一个文件拥有的地址，还有一个s_address就是全局地址，是当链接成完整的一套字节码程序时的真实地址。在最初本想使用_address作为唯一的地址，然后在链接的阶段在做重定位并合成最后的地址，这样做更符合一个真实的链接器的过程，但是实在由于我太懒了，所以就偷工减料了。这里特别指出这些。

  1. bool pcasm::plus_address(unsigned plus)
  2. {
  3.     /* 任意单一的模块不能超过1MB的空间 */
  4.     if (s_address >= (1024 * 1024)) {
  5.         _error = PCASM_ERROR_CODE_OVER_LIMIT;
  6.         return false;
  7.     }
  9.     _address += plus;           /* 全局的地址增加 */
  10.     s_address += plus;
  11.     return true;
  12. }

指令汇编

在汇编器类中定义一个变量ins_compile_fptr _handles[PCVM_OP_NUMBER];，它是一个函数指针队列，保存了每条指令的汇编函数。这个变量在pcasm::pcasm的构造函数中进行填充。

  1. pcasm::pcasm()
  2. {
  3.     reset();
  4.     _handles[PCVM_OP_MOV] = &pcasm::cMOV;
  5.     _handles[PCVM_OP_PUSH] = &pcasm::cPUSH;
  6.     _handles[PCVM_OP_POP] = &pcasm::cPOP;
  7.     _handles[PCVM_OP_CMP] = &pcasm::cCMP;
  8.     _handles[PCVM_OP_CALL] = &pcasm::cCALL;
  9.     /* 省略... */

其中cXXX函数，c表示compile，编译的意思，而后边跟的就是指令的名称。这里拿cMOV函数来举例，其余的指令与之基本相同。

  1. bool pcasm::cMOV(std::vector<unsigned char> &bytecodes)
  2. {
  3.     if (MOV_REG_IMM(PCVM_OP_MOV, bytecodes) || 
  4.         MOV_REG_REG(PCVM_OP_MOV, bytecodes) || 
  5.         MOV_MEM_IMM(PCVM_OP_MOV, bytecodes) ||
  6.         MOV_MEM_REG(PCVM_OP_MOV, bytecodes) || 
  7.         MOV_MEM_MEM(PCVM_OP_MOV, bytecodes) || 
  8.         MOV_REG_LAB(PCVM_OP_MOV, bytecodes) ||
  9.         MOV_MEM_LAB(PCVM_OP_MOV, bytecodes)) {
  10.         return true;
  11.     }
  12.     return false;
  13. }

以上函数的参数是汇编输出字节码的缓存队列，在函数中调用了一组MOV_XXX_YYY的一组函数，从函数名可以看出mov指令的语法结构。函数会依次进行调用，如果前者不为true则进入下一个。直到其中一个成功。让我们进入MOV_REG_IMM看看。

  1. bool pcasm::MOV_REG_IMM(unsigned opcode, std::vector<unsigned char> &bytecodes)
  2. {
  3.     /* 语法: "mov reg, 12345" */
  4.     /* 以下将此指令的模式压入一个tokens的队列 */
  5.     std::vector<int> tokens;
  6.     tokens.push_back(TOKEN_REG);
  7.     tokens.push_back(TOKEN_COMMA);
  8.     tokens.push_back(TOKEN_IMM);
  9.     /* 以tokens为目标来检查当前的代码是否匹配 */
  10.     if (match(tokens) == false) {
  11.         _error = PCASM_ERROR_SYNTAX_NOT_MATCH_TOKEN;
  12.         return false;
  13.     }
  15.     /* 如果语法匹配则调用对应的指令汇编函数合并成一个4字节 */
  16.     int ins = write_mode_op_reg_imm(opcode, _text_stack[0].reg, _text_stack[2].imm);
  17.     /* 最后将汇编好的指令ins写入到输出缓存bytecodes中 */
  18.     write_ins(ins, bytecodes);
  19.     return true;
  20. }

以上代码中，出现了一个_text_stack这样的变量来获取寄存器以及立即数的具体值，让我们先看下match函数的实现。

  1. bool pcasm::match(std::vector<int> tokens)
  2. {
  3.     pcasm_token token;
  4.     _text_stack.clear();
  5.     _err_on_token = TOKEN_NUMBER;
  6.     if (tokens.empty()) return false;
  7.     int count = 0;
  8.     /* 遍历我们的目标标记队列 */
  9.     for (auto t : tokens) {
  10.         count++;/* 计数标记 */
  11.         /* 获取下一个标记 */
  12.         token = next_token();
  13.         /* 如果当前读取的标记与目标队列中取出的标记相同
  14.          * 则将它的字面值压入到_text_stack中
  15.          */
  16.         if (token.token == t) {
  17.             _text_stack.push_back(token.text);
  18.         }
  19.         /* 如果没有匹配
  20.          * 则调用rollback_token函数进行回退
  21.          */
  22.         else {
  23.             rollback_token(count);
  24.             _text_stack.clear();
  25.             _error = PCASM_ERROR_SYNTAX_NOT_MATCH_TOKEN;
  26.             _err_on_token = t;
  27.             return false;
  28.         }
  29.     }
  31.     return true;
  32. }

以上函数当在标记不匹配的时候要将读取的标记再次压入到标记流中。

  1. void pcasm::rollback_token(int num)
  2. {
  3.     if (_token_pos - num < 0) _token_pos = 0;
  4.     else _token_pos -= num;
  5. }

以上函数实现也比较简单，就是将当前标记的位置变量_token_pos减少参数num个来完成标记流的回退。与之对应的是next_token函数。用于从标记流中获取标记。

  1. pcasm_token pcasm::next_token()
  2. {
  3.     if (_token_source.empty()) {
  4.         pcasm_token token;
  5.         token.token = TOKEN_NUMBER;
  6.         return token;
  7.     }
  8.     /* 这里最重要的就是控制_token_pos的值以达到控制
  9.      * 标记流的作用
  10.      */
  11.     return _token_source[_token_pos++];
  12. }

当匹配完成后就是调用类似名为write_xxx之类的函数汇编一条4字节的指令了。让我们看一个例子：

  1. /* | 5 : opcode | 3 : mode | 24 : -| */
  2. unsigned pcasm::write_mode_op(unsigned opcode) {
  3.     unsigned ins = 0;;
  4.     ins = opcode << 27;
  5.     ins |= (PCVM_INS_MODE_OP << 24);
  7.     return ins;
  8. }

就是按照编码规则做了一些位操作而已。在真实的汇编器中，无疑这部分就是按照体系结构的编码规则做操作而已。汇编器就是这么的简单。
如果一条指令没有引用标记则大体流程也就这样了，无疑就是调用不同模式的写入函数以及填充不同的编码模式而已。而如果一条指令引用了标记则就会牵扯出重定位一说。大多出现在跳转指令以及内存访问模式中。

重定位信息

这里说先说明下为什么需要重定位。下面拿push label这条指令来举例。

  1. bool pcasm::PUSH_LAB(unsigned opcode, std::vector<unsigned char> &bytecodes)
  2. {
  3.     std::vector<int> tokens;
  4.     /* 压入一个"引用标号"的标记 */
  5.     tokens.push_back(TOKEN_REF_LABEL);
  6.     /* 如果不匹配则退出 */
  7.     if (match(tokens) == false) {
  8.         _error = PCASM_ERROR_SYNTAX_NOT_MATCH_TOKEN;
  9.         return false;
  10.     }
  12.     /* 建立一个重定位项目 */
  13.     pcasm_relocate rel;
  14.     rel.type = PCASM_REL_FIXLST20B;
  15.     /* 当前指令的地址，以后重定位需要 */
  16.     rel.address = s_address;
  17.     /* 符号的名称 */
  18.     rel.symbol = _text_stack[0].str;
  19.     /* 压入s_relocates，重定位列表 */
  20.     s_relocates.push_back(rel);
  22.     /* 写入opocde imm一条指令, 后边的imm为0
  23.      * 这个imm就是后边重定位时要修正的偏移
  24.      */
  25.     int ins = write_mode_op_imm(opcode, 0);
  26.     write_ins(ins, bytecodes);
  27.     return true;
  28. }

上边的代码就是一个普通的push imm的操作。但是由于push指令后的立即数可以由一个标号表示。
到这里首先讲讲为什么要重定位，其实重定位分为静态重定位与动态重定位两种。其中后者在操作系统加载到内存时使用。而静态重定位用于在编译时将各个文件合并到一起时规划地址。而我们现在做的就是静态重定位。下面看一片代码。来解释静态重定位。

  1. test:
  2. ;; 一些指令
  3. push test
  4. ;; 其余一些指令

这个test是标号，如果test在push之前，那么可以很容易的计算出地址。在指令push后直接写入地址就好。如果test在push后，在push时就不能直接写入地址了。因为此时还不知道test的地址。所以首先需要遍历所有的代码统计所有的标记，然后转换成地址。在其后链接的时候在将地址填上。

标记定义

在scanner中，如果发现标号的定义则返回TOKEN_DEF_LABEL标记。随后则调用cDefLabel函数。

  1. bool pcasm::cDefLabel(pcasm_token &token)
  2. {
  3.     /* 如果没有发现符号，则创建符号 */
  4.     if (s_symbols.find(token.text.str) == s_symbols.end()) {
  5.         s_symbols[token.text.str] = std::shared_ptr<pcasm_label>(new pcasm_label);
  6.         if (s_symbols[token.text.str] == nullptr) {
  7.             _error = PCASM_ERROR_ALLOC_MEMORY;
  8.             _errstr = token.text.str;
  9.             return false;
  10.         }
  11.         /* 写入模块地址与当前的地址 */
  12.         s_symbols[token.text.str]->mode_address = _address;
  13.         s_symbols[token.text.str]->address = s_address;
  14.     }
  15.     /* 符号存在 */
  16.     else {
  17.         _error = PCASM_ERROR_SYNTAX_SAME_LABEL;
  18.         return false;
  19.     }
  20.     return true;
  21. }

包含文件

在parser中如果发现了TOKEN_INCLUDE标记。则调用cInclude。

  1. bool pcasm::cInclude(std::vector<unsigned char> &bytecodes)
  2. {
  3.     pcasm_token token;
  4.     token = next_token();
  5.     /* 如果非字符串则直接退出 */
  6.     if (token.token != TOKEN_STRING) {
  7.         _error = PCASM_ERROR_SYNTAX_NOT_MATCH_TOKEN;
  8.         return false;
  9.     }
  11.     /* 如果在符号表中没有找到这个字符串，
  12.      * 则创建一个pcasm的类
  13.      */
  14.     if (s_sources.find(token.text.str) == s_sources.end()) {
  15.         s_sources[token.text.str] = std::shared_ptr<pcasm>(new pcasm());
  16.         if (s_sources[token.text.str] == nullptr) {
  17.             _error = PCASM_ERROR_ALLOC_MEMORY;
  18.             return false;
  19.         }
  20.         /* 在标记中存在源文件的字符串使用make生成对应字节码 */
  21.         if (s_sources[token.text.str]->make(token.text.str, bytecodes) == false) {
  22.             _error = s_sources[token.text.str]->error();
  23.             _errstr = token.text.str;
  24.             return false;
  25.         }
  26.     }
  28.     return true;
  29. }

当遇到包含标签就会进入指定的源文件进行汇编操作，并且在同一个字节码缓存内，一同作为输出。

汇编立即数

在parser中如果发现了TOKEN_IMM标记。则调用write_imm。此函数会将立即数标记中的数写入到字节码队列中。并返回写入的字节数，最后返回的字节数增加到当前地址上修正这些地址。

  1. int pcasm::write_imm(unsigned data, std::vector<unsigned char> &bytecodes)
  2. {
  3.     /* 好吧一个字节一个字节的写到字节码队列中 */
  4.     unsigned char *ptr = reinterpret_cast<unsigned char*>(&data);
  5.     for (int i = 0; i < sizeof(int); i++) {
  6.         bytecodes.push_back(*ptr++);
  7.     }
  8.     return sizeof(unsigned);
  9. }

汇编字符串

在parser中如果发现了TOKEN_STRING标记。则调用write_string。

  1. int pcasm::write_string(const std::string &str, std::vector<unsigned char> &bytecodes) {
  2.     /* 遍历字符串并且压入字节码队列 */
  3.     for (auto c : str) {
  4.         bytecodes.push_back(c);
  5.     }
  7.     /* 字符串如果不够4字节的对齐则使用0字节补齐 */
  8.     int s1 = str.size();
  9.     int s2 = s_up4(s1);
  10.     if (s2 > s1) {
  11.         s1 = s2 - s1;
  12.         while (s1--) {
  13.             bytecodes.push_back(0);
  14.         }
  15.     }
  16.     /* 返回写入到字节数(包含补齐的0字节) */
  17.     return s2;
  18. }

链接处理

链接过程是独立的，由外部进行调用。

  1. int pcasm::pclink(std::vector<unsigned char>& bytecodes)
  2. {
  3.     /* 如果字节码队列为空则直接退出 */
  4.     if (bytecodes.empty()) return false;
  5.     /* 分配一块内存空间 */
  6.     size_t size = bytecodes.size();
  7.     /* 分配最后链接后的空间 */
  8.     unsigned char *ptr = new unsigned char[size + 1];
  9.     if (ptr == nullptr) {
  10.         return PCASM_ERROR_ALLOC_MEMORY;
  11.     }
  13.     /* 遍历所有字节代码并写入 */
  14.     size_t i = 0;
  15.     for (auto b : bytecodes) {
  16.         ptr[i++] = b;
  17.     }
  19.     /* 遍历所有重定位项目 */
  20.     for (auto r : s_relocates) {
  21.         /* 从重定位表中找到符号，如果找不到则返回链接失败 */
  22.         if (s_symbols.find(r.symbol) == s_symbols.end()) {
  23.             return PCASM_ERROR_LINK_NOT_FOUND_LABEL;
  24.         }
  25.         /* 从重定位项中取出要重定位的地址
  26.          * 随后取出要重定位的指令
  27.          */
  28.         unsigned ins = *reinterpret_cast<unsigned*>(ptr + r.address);
  29.         /* 好吧，随后将符号的地址设置给指令 */
  30.         ins |= (s_symbols[r.symbol]->address & 0xFFFFF);
  31.         *reinterpret_cast<unsigned*>(ptr + r.address) = ins;
  32.     }
  34.     bytecodes.clear();
  35.     /* 再将重定位好的代码再次写回到字节码队列中 */
  36.     for (size_t i = 0; i < size; i++) {
  37.         bytecodes.push_back(ptr[i]);
  38.     }
  40.     if (ptr) delete[] ptr;
  41.     return PCASM_ERROR_SUCCESS;
  42. }

s_relocates里保存了所有标号的重定位信息。填充这个结构在指令汇编的时候，如果遇到XXX_YYY_LAB的函数。则填充这个变量。

随机加密算法生成器的设计与实现

好了，有了以上的两个基础就可以进入我们的真正的目的了。为了到达我们真正的目的，写了N行代码就是为了实现这个最终目的。

程序自己写程序

其实这节的标题就是我一直以来的梦想，这里先意淫一下。没别的意思，按照本文的程度还远远没有达到。

框架设计

在文件polycypt.h中定义了这个框架。这个框架会随机选取一个算法工厂类进行使用。

  1. /* 变形引擎配置 */
  2. typedef struct {
  3.     /* 算法引擎工厂索引,-1表示随机 */
  4.     int factory;
  5. } polycypt_config;
  7. class polycypt {
  8. public:
  9.     polycypt();
  10.     polycypt(const polycypt_config &config);
  11.     virtual ~polycypt();
  13.     /* 运行
  14.      * output_dir : 结果输出目录
  15.      * template_dir : 算法模块目录
  16.      */
  17.     bool run(const std::string &output_dir, const std::string         &template_dir);
  19.     /* 出错代码 */
  20.     int error();
  22. private:
  23.     void reset();                   /* 重设 */
  24.     void load_algs();               /* 加载算法 */
  25.     int random(size_t n = 100);     /* 生成一个随机值 */
  27. private:
  28.     /* 配置 */
  29.     polycypt_config _config;
  30.     /* 工厂类队列 */
  31.     std::vector<std::shared_ptr<polycypt_factory> > _factories;
  32.     /* 出错代码 */
  33.     int _error;
  34. };

在运行后，调用make后进行加解密算法的对称生成，本引擎的目的就在于此，运行一次后就依照算法模板随机生成一套加解密对应的算法。当然这里提到了模板，我毕竟还没实现我的梦想，另外一方面这只是一个框架引擎，我并没有实现很牛逼的生成算法。

当前的工作原理是这样的首先随机选取一个算法模板，然后调用加解密算法生成工厂。当前引擎自带一个DEMO，在一个叫做polycypt_alg0.cpp的文件中实现。而下面的函数就会按照参数配置随机生成加解密算法。

  1. /* output_dir : 结果输出目录 
  2.  * template_dir : 模板目录
  3.  * generate_source ： TRUE:输出生成的源代码
  4.  */
  5. bool polycypt_factory::make(const std::string &output_dir, const std::string &template_dir, bool generate_source) {
  6.   /* 获取临时模板目录 */
  7.   std::string template_file = template_dir;
  8.   if (*template_file.end() != '/') {
  9.     template_file.append("/");
  10.   }
  11.   /* 默认的汇编源代码文件 */
  12.   template_file.append("startup.asm");
  14.   /* 读取模板文件 */
  15.   _startup_template = s_read_file(template_file);
  16.   if (_startup_template == "") {
  17.     _error = POLYCYPT_ERROR_READ_FILE;
  18.     return false;
  19.   }
  21.   std::string local_dir = output_dir;
  22.   if (*local_dir.end() != '/') {
  23.     local_dir.append("/");
  24.   }
  26.   /* 产生对应的加解密算法 */
  27.   std::string encrypt_source, decrypt_source;
  28.   if (generate(encrypt_source, decrypt_source) == false) {
  29.     return false;
  30.   }
  32.   /* 如果generate_source为TRUE则将加解密算法的源代码输出 */
  33.   if (generate_source) {
  34.     /* 生成加解密源代码的路径 */
  35.     std::string encrypt_source_path, decrypt_source_path;
  36.     encrypt_source_path = local_dir + "encrypt.asm";
  37.     decrypt_source_path = local_dir + "decrypt.asm";
  38.     /* 生成对应的加解密源文件，其实没什么用，就是让开发者
  39.      * 看看生成的什么东西
  40.      */
  41.     if (s_write_text_file(encrypt_source_path, encrypt_source) == false) {
  42.       _error = POLYCYPT_ERROR_WRITE_FILE;
  43.       return false;
  44.     }
  45.     if (s_write_text_file(decrypt_source_path, decrypt_source) == false) {
  46.       _error = POLYCYPT_ERROR_WRITE_FILE;
  47.       return false;
  48.     }
  49.   }
  51.   /* 编译加解密算法成对应的字节码 */
  52.   if (compile(encrypt_source, decrypt_source) == false) {
  53.     return false;
  54.   }
  56.   /* 对解密算法生成的字节码进行链接 */
  57.   if (pcasm::pclink(_encrypt_bytecodes) != PCASM_ERROR_SUCCESS) {
  58.     _error = POLYCYPT_ERROR_LINK;
  59.     return false;
  60.   }
  62.   /* 对加密算法生成的字节码进行链接 */
  63.   if (pcasm::pclink(_decrypt_bytecodes) != PCASM_ERROR_SUCCESS) {
  64.     _error = POLYCYPT_ERROR_LINK;
  65.     return false;
  66.   }
  68.   /* 将生成好的文件写入到算法变形引擎固有的文件格式中 */
  69.   std::string en_file, de_file;
  70.   en_file = local_dir + "encrypt.pbc";
  71.   de_file = local_dir + "decrypt.pbc";
  73.   if (make_pcfile(en_file, _encrypt_bytecodes) == false) {
  74.     return false;
  75.   }
  77.   if (make_pcfile(de_file, _decrypt_bytecodes) == false) {
  78.     return false;
  79.   }
  81.   return true;
  82. }

这个算法工厂就是可以自行进行编写，然后后台引擎进行调用。

算法工厂类

所有的插桩算法都是继承自这个类，所有算法实现的基础模型都是基于这个类来实现。

  1. class polycypt_factory {
  2. public:
  3.     polycypt_factory();
  4.     virtual ~polycypt_factory();
  6.     /* 产生加解密算法 */
  7.     virtual bool generate(std::string &encrypt, std::string        &decrypt);
  8.     /* 编译 */
  9.     virtual bool compile(const std::string &encrypt, const std::string &decrypt);
  10.     /* 产生编译后的字节码并输出 */
  11.   virtual bool make(const std::string &output_dir, const std::string &template_dir, bool generate_source=false);
  13. protected:
  14.     /* 这里都是内置的一些功能函数 */
  15.     virtual void reset();
  16.     /* 产生一个随机的符号名称 */
  17.     virtual bool make_symbol(std::string &symbol);
  18.     /* 产生随机数 */
  19.     virtual int random(size_t n = 100);
  20.     /* 产生pc格式的文件 */
  21.     virtual bool make_pcfile(const std::string &path, std::vector<unsigned char> &bytecodes);
  23. protected:
  24.     /* 产生加密算法 */
  25.     virtual bool generate_encrypt(std::string &encrypt);
  26.     /* 产生解密算法 */
  27.     virtual bool generate_decrypt(std::string &decrypt);
  29. protected:
  30.     /* 这些是做高级的算法生成支持 */
  31.     unsigned _ip;                               /* ip地址寄存器 */
  32.     unsigned _registers[PCVM_REG_NUMBER];       /* 寄存器队列 */
  33.     bool _idle_registers[PCVM_REG_NUMBER];      /* 空闲寄存器 */
  34.     int _error;                                 /* 错误代码 */
  36.     /* startup.asm的模板字符串 */
  37.     std::string _startup_template;
  38.     /* 汇编器 */
  39.     pcasm _asmer;
  40.     /* 加密算法字节码 */
  41.     std::vector<unsigned char> _encrypt_bytecodes;
  42.     /* 解密算法字节码 */
  43.     std::vector<unsigned char> _decrypt_bytecodes;
  44. };

以后的算法类主要重载两个接口。

  1.   virtual bool generate_encrypt(std::string &encrypt);
  2.   virtual bool generate_decrypt(std::string &decrypt);

其余的接口可以不实现。polycypt类会调用选定的工厂类的generate_encrypt函数以及generate_decrypt函数。产生两对字符串，随后调用compile进行遍历，这里就不具体展开这一细节了。

DEMO介绍

这里是一个DEMO，实现文件是polycypt_alg0.cpp。继承自polycypt_factory工厂类。这个算法并没有做到我想象的程度，只是一个例子而已。
就是每次随机生成一个密码表，并且随机使用其中一个。然后循环异或目标而已。

  1. class polycypt_alg0 : public polycypt_factory {
  2. public:
  3.     polycypt_alg0();
  4.     virtual ~polycypt_alg0();
  6. protected:
  7.   /* 产生加密算法 */
  8.   virtual bool generate_encrypt(std::string &encrypt);
  9.   /* 产生解密算法 */
  10.   virtual bool generate_decrypt(std::string &decrypt);
  12. protected:
  13.   /* 产生xor的汇编代码 */
  14.   virtual bool generate_xor(std::ostringstream &oss);
  15.   /* 产生随机的密钥 */
  16.   virtual bool generate_keytab(std::ostringstream &oss);
  17.   /* 产生算法起始 */
  18.   virtual bool generate_algorithm_start(std::ostringstream &oss);
  19.   /* 产生算法结束 */
  20.   virtual bool generate_algorithm_end(std::ostringstream &oss);
  22. private:
  23.   std::ostringstream _keytab;       /* 密钥表 */
  24.   int _keyidx;                      /* 密钥索引 */
  25. };

xor指令

因为虚拟机没有xor指令。所以只能使用模拟来完成。这个函数就是依次将汇编字符串写入字符串缓存中。

  1. /* (~a & b) | (a & ~b) */
  2. bool polycypt_alg0::generate_xor(std::ostringstream &oss) {
  3.   /*
  4.    * r10 = 密钥
  5.    * r11 = 数据指针
  6.    * r12 = 临时变量
  7.    * r13 = 临时变量
  8.    */
  9.   oss << "@xor:\n";
  10.   oss << "push r4\n";
  11.   oss << "sub sp, 4\n";
  12.   oss << "mov [sp], [r11]\n";
  13.   oss << "pop r4\n";
  14.   oss << "not r4\n";              /* ~a */
  15.   oss << "mov [r12], r4\n";
  16.   oss << "and [r12], [r10]\n";    /* ~a & b */
  17.   oss << "sub sp, 4\n";
  18.   oss << "mov [sp], [r10]\n";
  19.   oss << "pop r4\n";
  20.   oss << "not r4\n";              /* ~b */
  21.   oss << "mov [r13], [r11]\n";
  22.   oss << "and [r13], r4\n";       /* a & ~b */
  23.   oss << "or [r13], [r12]\n";     /* (~a & b) | (a & ~b) */
  24.   oss << "sub sp, 4\n";
  25.   oss << "mov [sp], [r13]\n";
  26.   oss << "pop r3\n";
  27.   oss << "pop r4\n";
  28.   oss << "ret\n";
  29.   return true;
  30. }

产生随机密钥表

随机产生一组密钥表。

  1. bool polycypt_alg0::generate_keytab(std::ostringstream &oss) {
  2.   /* 密钥表 */
  3.   oss << "@keytab:\n";
  4.   /* 两个循环 16 * 16 = 256 */
  5.   for (int i = 0; i < 16; i++) {
  6.     for (int j = 0; j < 16; j++) {
  7.       char buf[64] = {0};
  8.       /* 随机产生一个4字节的数 */
  9.       sprintf(buf, "x%x", random(0xFFFFFFFF));
  10.       oss << buf;
  11.       oss << " ";
  12.     }
  13.     oss << "\n";
  14.   }
  15.   oss << "\n";
  16.   return true;
  17. }

算法起始与结束

产生算法的起始代码以及结束代码。

  1. bool polycypt_alg0::generate_algorithm_start(std::ostringstream &oss) {
  2.   /*
  3.    * r10 = 密钥
  4.    * r11 = 数据指针
  5.    * r12 = 临时变量1
  6.    * r13 = 临时变量2
  7.    */
  8.   generate_xor(oss);
  9.   oss << _keytab.str();
  10.   oss << "@key: 0\n";
  11.   oss << "@data: 0\n";
  12.   oss << "@tmp1: 0\n";
  13.   oss << "@tmp2: 0\n";
  14.   oss << "@algorithm:\n";
  15.   oss << "push r5\n";
  16.   oss << "push r4\n";
  17.   oss << "mov r4, sp\n";
  18.   oss << "add r4, 12\n";
  19.   oss << "div r5, 4\n";
  21.   /* 获取密钥表 */
  22.   oss << "push r6\n";
  23.   char buf[64] = {0};
  24.   sprintf(buf, "%d", _keyidx);
  25.   oss << "mov r6, " << buf << "\n";
  26.   oss << "mul r6, 4\n";
  27.   oss << "add r6, @keytab\n";
  28.   oss << "mov r10, @key\n";
  29.   oss << "mov [r10], [r6]\n";
  30.   oss << "pop r6\n";
  32.   /* 设置临时变量 */
  33.   oss << "mov r12, @tmp1\n";
  34.   oss << "mov r13, @tmp2\n";
  36.   /* 设置数据指针 */
  37.   oss << "mov r11, @data\n";
  39.   /* 循环处理加解密功能 */
  40.   oss << "@loop:\n";
  41.   oss << "cmp r5, 0\n";
  42.   oss << "je @algorithm_end\n";
  43.   oss << "mov [r11], [r4]\n";
  44.   oss << "call @xor\n";
  46.   /* 保存结果 */
  47.   oss << "mov [r4], r3\n";
  48.   oss << "add r4, 4\n";
  49.   oss << "sub r5, 1\n";
  50.   oss << "jmp @loop\n";
  51.   return true;
  52. }

产生算法末尾块，用于跳出函数。

  1. bool polycypt_alg0::generate_algorithm_end(std::ostringstream &oss) {
  2.   oss << "@algorithm_end:\n";
  3.   oss << "pop r4\n";
  4.   oss << "pop r5\n";
  5.   oss << "ret\n";
  6.   return true;
  7. }

_startup.asm

这套汇编代码就是一个启动函数，用于链接加解密代码。

  1. ;;
  2. ;;  startup.asm
  3. ;;  polycypt
  4. ;;
  5. ;;  Created by logic.yan on 16/3/28.
  6. ;;  Copyright © 2016年 nagain. All rights reserved.
  7. ;;
  9. @_start:
  10. ;; 从I/O端口0读取数据长度
  11. mov r4, 0
  12. int 2
  13. ;; 如果 r5 是 0, 则退出
  14. cmp r5, 0
  15. je @exit
  16. ;; r5是数据长度, 4字节对齐
  17. ;; ~3u & (3 + v)
  18. mov r7, r5
  19. add r7, 3
  20. mov r6, 3
  21. not r6
  22. and r7, r6
  23. ;; 分配内存空间
  24. sub sp, r7
  25. int 0
  27. ;; 调用对应的算法
  28. call @algorithm
  30. @output2io:
  31. ;; 写入数据到I/O端口0之后解密到sp指针处，r5是加解密数据的长度
  32. mov r4, 0
  33. int 1
  34. ;; 设置输出I/O端口0的数据长度
  35. mov r4, 0
  36. int 3
  37. ;; exit
  38. @exit:
  39. ;; 是否内存空间
  40. add sp, r7
  41. int 9

之后的想法

其实，上述东西真没实现我想要的东西，但是一个框架算是有了。从工厂类的类变量可以看出来其实我想做的是自扩散的生成算法。而不仅仅这个。汇编语言其实还是不是很方便。就算简单的四折混合运算直接喷成汇编代码考虑的东西也会很多。如果之后有时间，我会先再加一个简单的语言编译器。然后再利用随机生成对应的源代码。这样就不用考虑寄存器选取，堆栈等问题。生成的算法也更强大一些。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注