JS `AST Visitor` `Pattern Matching`：自动化反混淆脚本开发

各位听众，早上好！今天咱们来聊聊一个挺有意思的话题：JS AST Visitor 和 Pattern Matching 在自动化反混淆脚本开发中的应用。说白了，就是教大家怎么用一些高级技巧，让那些混淆得乱七八糟的 JavaScript 代码乖乖现出原形。

一、混淆的那些事儿：为什么需要反混淆？

首先，咱们得知道为什么要反混淆。JavaScript 混淆技术，说好听点是为了保护知识产权，防止别人轻易抄袭你的代码；说难听点，就是增加逆向工程的难度，让你看不懂它到底干了些什么。常见的混淆手段包括：

• 变量名替换： 把 username 变成 a, b, c，让你猜都猜不到它原本是啥。
• 字符串加密： 把字符串藏起来，运行时再解密，避免直接暴露敏感信息。
• 控制流扁平化： 把代码逻辑打散，用 switch 语句或者其他方式让代码执行流程变得曲折离奇。
• 死代码插入： 往代码里塞一些永远不会执行的代码，干扰你的分析。
• 其他各种奇技淫巧： 比如把数字变成位运算，把函数调用变成数组索引等等。

面对这些花样百出的混淆手段，手工分析简直就是噩梦。想象一下，你要面对成千上万行毫无意义的变量名，追踪各种复杂的控制流，简直要崩溃。这时候，自动化反混淆脚本就显得尤为重要了。

二、AST (Abstract Syntax Tree) 简介：代码的另一种视角

要实现自动化反混淆，首先要理解代码的结构。AST，也就是抽象语法树，就是一种以树形结构表示代码语法的方式。可以将一段JS代码转换为一个树形结构，其中每个节点代表代码中的一个语法结构，比如变量声明、函数调用、表达式等等。

举个例子，对于简单的 JavaScript 代码 const x = 1 + 2;，它的 AST 结构大致如下：

{
  "type": "Program",
  "body": [
    {
      "type": "VariableDeclaration",
      "declarations": [
        {
          "type": "VariableDeclarator",
          "id": {
            "type": "Identifier",
            "name": "x"
          },
          "init": {
            "type": "BinaryExpression",
            "operator": "+",
            "left": {
              "type": "Literal",
              "value": 1,
              "raw": "1"
            },
            "right": {
              "type": "Literal",
              "value": 2,
              "raw": "2"
            }
          }
        }
      ],
      "kind": "const"
    }
  ],
  "sourceType": "script"
}

看不懂？没关系，简单来说，AST 把代码拆解成了各种节点，每个节点都有自己的类型（type）和属性。我们可以通过遍历 AST，分析代码的结构，从而实现各种反混淆操作。

三、AST Visitor：漫游代码世界的向导

AST Visitor 是一种设计模式，用于遍历 AST 中的节点。它提供了一系列 visit 函数，每个函数对应一种 AST 节点类型。当你使用 Visitor 遍历 AST 时，它会自动调用对应的 visit 函数，让你有机会对该节点进行处理。

常用的 JavaScript AST 工具库包括：

• acorn: 一个快速、小巧的 JavaScript 解析器，可以将 JavaScript 代码解析成 AST。
• escodegen: 一个代码生成器，可以将 AST 转换回 JavaScript 代码。
• estraverse: 一个 AST 遍历器，用于遍历 AST 中的节点。
• esprima: 另一个 JavaScript 解析器，功能与 acorn 类似。
• babel-parser: Babel 的解析器，功能强大，支持最新的 JavaScript 语法。
• @babel/traverse: Babel 的 AST 遍历器，功能强大，支持修改 AST。
• @babel/types: Babel 的 AST 类型定义，用于创建和检查 AST 节点。

以 @babel/traverse 为例，它提供了一个 traverse 函数，接受 AST 和一个 Visitor 对象作为参数。Visitor 对象可以定义各种 enter 和 exit 函数，用于在遍历到特定节点时执行相应的操作。

import * as parser from "@babel/parser";
import traverse from "@babel/traverse";
import generate from "@babel/generator";

const code = `const x = 1 + 2;`;

const ast = parser.parse(code);

traverse(ast, {
  enter(path) {
    if (path.isIdentifier({ name: "x" })) {
      path.node.name = "y"; // 将变量名 x 改为 y
    }
  }
});

const output = generate(ast, {}, code);

console.log(output.code); // 输出: const y = 1 + 2;

在这个例子中，我们定义了一个 Visitor 对象，它有一个 enter 函数，用于在遍历到 Identifier 节点时执行操作。如果 Identifier 节点的 name 属性是 "x"，我们就把它改成 "y"。通过这种方式，我们可以修改 AST，从而改变代码的行为。

四、Pattern Matching：精准打击混淆代码

Pattern Matching，也就是模式匹配，是一种在数据结构中查找特定模式的技术。在反混淆中，我们可以利用 Pattern Matching 找到特定的混淆代码模式，然后进行相应的处理。

例如，假设有一种混淆方式是将字符串加密后存储在一个数组中，然后在运行时通过数组索引来获取字符串。我们可以使用 Pattern Matching 找到这种模式，然后解密字符串。

import * as parser from "@babel/parser";
import traverse from "@babel/traverse";
import generate from "@babel/generator";
import * as t from "@babel/types";

const code = `
const _0x1234 = ["Hello", "World"];
const message = _0x1234[0] + " " + _0x1234[1];
`;

const ast = parser.parse(code);

traverse(ast, {
  BinaryExpression(path) {
    if (path.node.operator === "+" &&
        t.isMemberExpression(path.node.left) &&
        t.isIdentifier(path.node.left.object) &&
        path.node.left.object.name === "_0x1234" &&
        t.isLiteral(path.node.left.property) &&
        t.isMemberExpression(path.node.right) &&
        t.isIdentifier(path.node.right.object) &&
        path.node.right.object.name === "_0x1234" &&
        t.isLiteral(path.node.right.property)) {

      // 提取数组索引
      const index1 = path.node.left.property.value;
      const index2 = path.node.right.property.value;

      // 替换为字符串
      path.replaceWith(
        t.stringLiteral("Hello" + " " + "World")
      );
    }
  }
});

const output = generate(ast, {}, code);

console.log(output.code); // 输出: const _0x1234 = ["Hello", "World"]; const message = "Hello World";

在这个例子中，我们定义了一个 BinaryExpression 的 Visitor，用于查找加法表达式。如果加法表达式的左右两边都是数组访问表达式，并且数组名是 "_0x1234"，我们就认为它符合我们的模式。然后，我们提取数组索引，从数组中获取字符串，并将整个表达式替换为字符串字面量。

五、实战：自动化反混淆脚本开发

接下来，我们来看一个更复杂的例子，演示如何使用 AST Visitor 和 Pattern Matching 开发一个自动化反混淆脚本。假设我们遇到了一种混淆方式，它将字符串进行 Base64 编码，然后在运行时解码。

import * as parser from "@babel/parser";
import traverse from "@babel/traverse";
import generate from "@babel/generator";
import * as t from "@babel/types";
import { Buffer } from 'node:buffer';

const code = `
const encodedString = "SGVsbG8gV29ybGQh";
const decodedString = atob(encodedString);
console.log(decodedString);
`;

const ast = parser.parse(code);

traverse(ast, {
  CallExpression(path) {
    if (t.isIdentifier(path.node.callee, { name: "atob" }) &&
        t.isStringLiteral(path.node.arguments[0])) {
      // 提取 Base64 编码的字符串
      const encodedString = path.node.arguments[0].value;

      // 解码 Base64 字符串
      const decodedString = Buffer.from(encodedString, 'base64').toString('utf-8');

      // 替换为字符串字面量
      path.replaceWith(
        t.stringLiteral(decodedString)
      );
    }
  }
});

const output = generate(ast, {}, code);

console.log(output.code);

在这个例子中，我们定义了一个 CallExpression 的 Visitor，用于查找函数调用表达式。如果函数名是 "atob"，并且参数是字符串字面量，我们就认为它符合我们的模式。然后，我们提取 Base64 编码的字符串，使用 atob 函数解码，并将整个函数调用替换为解码后的字符串字面量。

六、高级技巧：更上一层楼

除了上面介绍的基本技巧，还有一些高级技巧可以帮助你更好地进行反混淆：

• 控制流分析： 分析代码的控制流，可以帮助你理解代码的执行逻辑，从而更好地进行反混淆。
• 数据流分析： 分析代码的数据流，可以帮助你追踪变量的值，从而更好地进行反混淆。
• 符号执行： 使用符号执行技术，可以模拟代码的执行过程，从而推导出变量的值，更好地进行反混淆。
• 机器学习： 使用机器学习技术，可以自动识别混淆模式，并进行相应的处理。

这些高级技巧比较复杂，需要深入理解编译原理和程序分析的知识。

七、总结：反混淆之路，永无止境

JavaScript 反混淆是一个充满挑战的领域。混淆技术不断发展，反混淆技术也需要不断进步。掌握 AST Visitor 和 Pattern Matching 等技术，可以帮助你更好地应对各种混淆手段，保护你的代码安全。

技术点	描述	示例
AST (抽象语法树)	代码的树形表示，方便程序分析和修改。	const x = 1 + 2; 转换为 AST 后，可以访问到变量名 x，操作符 +，以及数字 1 和 2。
AST Visitor	遍历 AST 的工具，允许在遍历过程中对节点进行操作。	使用 @babel/traverse，可以定义 enter 和 exit 函数，在遍历到特定类型的节点时执行自定义逻辑，例如修改变量名。
Pattern Matching	识别特定代码模式的技术，例如识别加密字符串的模式。	识别 _0x1234[0] 这种数组访问模式，可以用于解密字符串数组。
控制流分析	分析代码的执行流程，例如识别 if 语句和循环。	可以用于理解控制流扁平化后的代码逻辑。
数据流分析	分析变量的值如何变化，例如追踪变量的赋值。	可以用于识别变量名替换后的代码，例如将 a 替换回 username。
符号执行	模拟代码的执行过程，推导变量的值。	可以用于计算复杂的表达式，例如将 (1 + 2) * 3 替换为 9。
机器学习	自动识别混淆模式。	可以训练模型识别特定的混淆函数或变量名，并自动进行反混淆。

希望今天的讲座对大家有所帮助。记住，反混淆是一场猫鼠游戏，需要不断学习和探索。祝大家在反混淆的道路上越走越远！感谢各位的聆听！