JS 代码虚拟化 (Code Virtualization) 混淆的原理是什么？如何通过动态分析还原其虚拟指令集？ - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位听众，早上好！我是今天的主讲人，很高兴能和大家一起探讨 JavaScript 代码虚拟化这个有点神秘又有点酷炫的话题。咱们今天就来扒一扒 JS 代码虚拟化的底裤，看看它到底是怎么运作的，以及如何通过动态分析来窥探它的内心世界，也就是还原它的虚拟指令集。

一、什么是代码虚拟化？别告诉我你以为是VR！

首先，让我们抛开那些高大上的定义，用人话来解释一下代码虚拟化。简单来说，代码虚拟化就像是给你的 JS 代码穿上了一层“虚拟机壳”。原始的 JS 代码不再直接被 JS 引擎执行，而是被编译成一种自定义的“虚拟指令集”。然后，一个用 JS 编写的“虚拟机解释器”会负责解释和执行这些虚拟指令。

你可以把这个过程想象成这样：

原始 JS 代码： 就像是你要说的一句话“你好世界”。
虚拟指令集： 就像是你把这句话翻译成只有你自己和特定的人才能理解的暗号“123456”。
虚拟机解释器： 就像是你那个能把暗号“123456”翻译回“你好世界”的人。

为什么要搞这么复杂？

原因很简单：保护代码。虚拟化后的代码，即使被别人拿到，也无法直接理解其逻辑，因为他们不知道你的虚拟指令集是什么，也不知道你的虚拟机解释器是如何工作的。这大大增加了逆向工程的难度。

二、虚拟化的基本流程：从源码到虚机代码

一般来说，JS 代码虚拟化包含以下几个关键步骤：

源码解析（Parsing）： 将 JS 源码解析成抽象语法树（AST）。这是一个标准流程，很多 JS 工具都会用到。
中间表示（IR）： 将 AST 转换成一种中间表示形式，例如三地址码（Three-Address Code）。这一步是为了方便后续的优化和代码生成。
代码转换（Code Transformation）： 这是最核心的步骤。将中间表示形式的代码转换成虚拟指令序列。这一步需要定义一套虚拟指令集，并为每个 IR 指令选择对应的虚拟指令。
虚拟机生成（VM Generation）： 根据虚拟指令集，生成一个 JS 编写的虚拟机解释器。这个解释器负责读取和执行虚拟指令。
代码注入（Code Injection）： 将虚拟机解释器和虚拟指令序列注入到原始 JS 代码中。

三、虚拟指令集的设计：灵魂工程师的艺术

虚拟指令集的设计是虚拟化的关键。一个好的虚拟指令集应该具有以下特点：

完备性： 能够表达所有 JS 代码的逻辑。
复杂性： 足够复杂，增加逆向难度。
效率： 尽量提高虚拟机的执行效率。

一个简单的虚拟指令集可能包含以下指令：

指令名称	操作数	描述
PUSH	value	将 value 压入栈
POP	register	将栈顶元素弹出到 register 中
ADD	register1, register2, register3	将 register1 和 register2 的值相加，结果保存到 register3 中
SUB	register1, register2, register3	将 register1 和 register2 的值相减，结果保存到 register3 中
MUL	register1, register2, register3	将 register1 和 register2 的值相乘，结果保存到 register3 中
DIV	register1, register2, register3	将 register1 和 register2 的值相除，结果保存到 register3 中
JMP	address	跳转到 address
JZ	register, address	如果 register 的值为 0，则跳转到 address
CALL	address	调用 address 处的函数
RET		从函数返回
LOAD	register, address	从 address 处加载值到 register 中
STORE	register, address	将 register 的值保存到 address 处

四、虚拟机解释器的实现：幕后英雄

虚拟机解释器是一个 JS 函数，它负责读取虚拟指令序列，并根据指令的类型执行相应的操作。一个简单的虚拟机解释器可能长这样：

function vm(bytecode) {
  let stack = [];
  let registers = {};
  let pc = 0; // 程序计数器

  while (pc < bytecode.length) {
    let instruction = bytecode[pc++];
    switch (instruction.opcode) {
      case "PUSH":
        stack.push(instruction.operand);
        break;
      case "POP":
        registers[instruction.operand] = stack.pop();
        break;
      case "ADD":
        registers[instruction.operand3] = registers[instruction.operand1] + registers[instruction.operand2];
        break;
      case "JMP":
        pc = instruction.operand;
        break;
      // 其他指令的处理
      default:
        console.error("Unknown opcode:", instruction.opcode);
        return;
    }
  }
}

这个 vm 函数接收一个 bytecode 参数，它是一个包含虚拟指令序列的数组。函数内部维护了一个栈 stack，一个寄存器对象 registers，以及一个程序计数器 pc。 vm 函数会不断循环，读取 bytecode 中的指令，并根据指令的 opcode 执行相应的操作。

五、动态分析：窥探虚机的内心世界

现在，我们来聊聊如何通过动态分析来还原虚拟指令集。动态分析是指在程序运行的过程中，通过观察程序的行为来推断其内部逻辑。

1. 确定虚拟机入口点：找到入口，才能入戏

首先，我们需要找到虚拟机解释器的入口点。这通常是一个 JS 函数，它接收虚拟指令序列作为参数，并负责执行这些指令。可以通过以下方法来找到入口点：

搜索关键字： 搜索包含 "virtual machine", "interpreter", "bytecode" 等关键字的 JS 代码。
观察代码结构： 寻找包含 switch 语句或者大量 if-else 语句的函数，这些函数很可能就是虚拟机解释器。
Hook 函数调用： 使用 Chrome DevTools 或其他调试工具，Hook JS 函数的调用，观察哪些函数接收的参数看起来像是虚拟指令序列。

2. 跟踪指令执行流程：顺藤摸瓜，水落石出

找到虚拟机入口点后，我们可以使用调试工具来跟踪指令的执行流程。具体步骤如下：

设置断点： 在虚拟机解释器的入口点设置断点。
单步执行： 单步执行代码，观察每一条指令的执行过程。
记录指令信息： 记录每一条指令的 opcode、操作数，以及执行后的状态变化（例如，栈的变化、寄存器的变化）。

3. 分析指令行为：抽丝剥茧，还原真相

通过跟踪指令执行流程，我们可以收集到大量的指令信息。接下来，我们需要分析这些信息，还原虚拟指令集的定义。

整理指令列表： 将收集到的所有 opcode 整理成一个列表。
推断指令含义： 根据指令的操作数和执行后的状态变化，推断指令的含义。
编写指令描述： 为每一条指令编写详细的描述，包括指令的名称、操作数、描述等。

代码示例：Hooking 和指令信息记录

下面是一个使用 Chrome DevTools Hook 函数调用并记录指令信息的示例代码：

(function() {
  // 假设我们已经找到了虚拟机入口点 vmFunction
  let originalVmFunction = vmFunction;

  vmFunction = function(bytecode) {
    console.log("VM入口点被调用，指令序列:", bytecode); // 打印完整的指令序列

    // 记录指令信息
    bytecode.forEach((instruction, index) => {
      console.log(`[指令 ${index}] Opcode: ${instruction.opcode}, 操作数: ${JSON.stringify(instruction.operands || instruction.operand)}`);
    });

    // 调用原始的虚拟机函数
    let result = originalVmFunction(bytecode);
    return result;
  };
})();

这段代码会 Hook vmFunction 函数的调用，并在控制台打印指令序列和每一条指令的信息。通过观察控制台输出，我们可以逐步了解虚拟指令集的定义。

4. 编写脚本自动化分析：解放双手，提高效率

手动分析指令信息非常耗时。为了提高效率，我们可以编写脚本来自动化分析过程。

数据收集： 编写脚本来收集指令信息，并将信息保存到文件中。
数据分析： 编写脚本来分析收集到的数据，自动推断指令的含义，并生成指令描述。
指令集生成： 编写脚本将分析结果生成为易于阅读的指令集文档。

六、一个完整的动态分析案例：解剖麻雀

假设我们有以下虚拟指令序列：

[
  { opcode: "PUSH", operand: 10 },
  { opcode: "PUSH", operand: 20 },
  { opcode: "ADD", operand1: "R1", operand2: "R2", operand3: "R3" },
  { opcode: "POP", operand: "R1" },
  { opcode: "POP", operand: "R2" },
  { opcode: "PUSH", operand: "R3" }
]

通过动态分析，我们可以观察到以下行为：

PUSH 10: 将 10 压入栈。
PUSH 20: 将 20 压入栈。
ADD R1, R2, R3: 将 R1 和 R2 的值相加，结果保存到 R3 中。此时 R1 和 R2 的值尚未定义，需要结合后续的 POP 指令才能确定。
POP R1: 将栈顶元素（20）弹出到 R1 中。
POP R2: 将栈顶元素（10）弹出到 R2 中。注意栈的顺序，后进先出。
PUSH R3: 将 R3 的值（30）压入栈。

根据以上观察，我们可以推断出以下指令定义：

指令名称	操作数	描述
PUSH	value	将 value 压入栈
POP	register	将栈顶元素弹出到 register 中
ADD	register1, register2, register3	将 register1 和 register2 的值相加，结果保存到 register3 中

七、动态分析的挑战与应对

动态分析虽然强大，但也面临一些挑战：

反调试： 虚拟机会检测调试器，并采取措施阻止调试。
- 应对： 可以使用反反调试技术，例如修改调试器、绕过检测代码等。
代码膨胀： 虚拟化后的代码通常会变得非常庞大，增加了分析的难度。
- 应对： 可以使用代码精简技术，例如删除无用代码、合并重复代码等。
指令混淆： 虚拟机会对指令进行混淆，例如使用等价指令替换、插入垃圾指令等。
- 应对： 需要仔细分析指令的行为，才能还原其真实含义。
动态生成指令： 一些高级的虚拟化技术会动态生成指令，使得静态分析变得更加困难。
- 应对： 需要重点关注动态生成的指令，并跟踪其执行流程。

八、总结：虚拟化攻防，永无止境

JS 代码虚拟化是一种强大的代码保护技术，它可以有效地防止代码被逆向工程。但是，任何防御手段都不是绝对安全的。通过动态分析，我们可以还原虚拟指令集，并最终破解虚拟化保护。虚拟化攻防是一个永无止境的过程，我们需要不断学习新的技术，才能在这个领域保持领先。

感谢大家的聆听！希望今天的讲座能让大家对 JS 代码虚拟化有更深入的了解。如果大家有什么问题，欢迎提问。

发表回复 取消回复

发表回复取消回复