怎么用Node.js脚本批量处理JS反混淆？自动化还原方案实现

一、批量反混淆的核心原理与技术选型

在逆向分析和前端安全审查中，开发者常常面对数十甚至上百个经过 js-obfuscator、Webpack Terser 或自定义加壳器处理的 JavaScript 文件。混淆器通常会执行变量混淆、字符串加密提取、常量拆分、对象属性计算化以及控制流平坦化等操作。

如果依赖文本正则查找替换，极易遭遇以下致命问题：

• 作用域穿透破坏：正则表达式无法感知词法作用域。一个局部同名变量或参数如果与全局解密函数名偶合，全局替换将直接造成脚本逻辑崩溃。
• 动态计算与递归解析失真：混淆代码中常常包含 _0x12a('0x1') + _0x12a('0x2') 这类嵌套或拼接调用，正则表达式在处理括号嵌套与逗号优先级时无法保持准确。
• 语法有效性无法保证：直接修改代码文本极易遗漏分号或破坏闭合括号，无法在批量处理场景下保障还原代码的语法正确率。

因此，成熟的批量反混淆方案必须建立在 AST（Abstract Syntax Tree，抽象语法树）之上。Node.js 生态中最完备的工具链当属 Babel 体系：

• @babel/parser：将 JavaScript 代码文本准确解析为符合 ESTree / Babel 规范的 AST 语法树。
• @babel/traverse：以访问者模式（Visitor Pattern）高效遍历节点，支持作用域绑定（Scope & Binding）追踪与节点精准替换。
• @babel/types：提供严格的 AST 节点类型判定与构建函数（如生成 stringLiteral、numericLiteral 等）。
• @babel/generator：将修改后的 AST 树重新序列化为整洁格式化的 JavaScript 源代码。
• node:vm：Node.js 内置虚拟机模块，提供隔离上下文安全执行混淆脚本中的自解密函数与大数组移位逻辑。

二、关键混淆特征与 AST 原地还原原理

自动化批量反混淆脚本并非单次遍历就能完成全部任务，而是遵循特定的还原先后次序。一个标准的流水线通常按以下四个步骤依次推进：

为了让初学者透彻理解每个环节的实现逻辑，我们剖析最核心的三种混淆特征在 AST 节点层面的匹配与变换机制：

1. 十六进制与数值计算折叠（Constant Folding）

混淆器通常将整数 100 替换为 0x64，或者拆解为位运算 0x10 ^ 0x74。在 AST 中，十六进制数本质上是数值字面量节点 NumericLiteral，但其 extra.raw 字段记录了原始字符串形式。只需将节点的 extra 字段清空，Babel 生成器就会自动输出十进制标准格式。

对于纯常量的二元表达式（BinaryExpression），可以通过 path.evaluate() 直接求解出确定结果并原地替换为字面量：

// 常量折叠处理逻辑
const constantFoldingVisitor = {
  BinaryExpression(path) {
    const evaluation = path.evaluate();
    if (evaluation.confident && typeof evaluation.value !== "function") {
      path.replaceWith(t.valueToNode(evaluation.value));
    }
  },
  NumericLiteral(path) {
    if (path.node.extra) {
      delete path.node.extra.raw; // 规范化十进制表达
    }
  }
};

2. 字符串数组提取与解密函数安全沙箱执行

这是现代 JS 混淆中最普遍的防护手段。混淆器将代码中的所有明文字符串抽取为一个全局数组，紧接着执行一个自执行函数对数组进行混淆洗牌（Shift），并通过一个专用函数（如 _0x4a12(index, key)）在运行时进行解密。

手工逆向往往是在控制台执行该解密函数，而在自动化批量脚本中，必须由脚本自动截取前置解密代码段并在独立的 vm 沙箱中预执行：

1. 从根作用域（Program 节点）中识别并抽取字符串数组声明、洗牌函数和解密函数代码；
2. 使用 vm.createContext() 初始化隔离运行环境，注入必要的全局垫片（如 window、document 的最小 Mock 对象）；
3. 在沙箱中运行抽取出的解密逻辑，使解密函数挂载至沙箱上下文；
4. 遍历整个 AST 的 CallExpression，当调用的函数名为解密函数且传入实参均为字面量时，直接调用沙箱中的解密函数获得明文字符串；
5. 调用 path.replaceWith(t.stringLiteral(plainText)) 将混淆调用原地替换为明文字符串字面量；
6. 遍历完成后，将已被抽取的原始大数组及解密函数声明节点从 AST 根节点中彻底移除，消除冗余死代码。

3. 对象属性与计算访问表达式简化

为了阻碍语义理解，混淆器会将常规属性调用 document.cookie 改写为方括号计算属性形式 document['cookie']。在 AST 中，这种节点属于 MemberExpression，且 computed: true。

还原规则非常明确：如果属性节点为 StringLiteral，并且该字符串符合 JavaScript 合法标识符规范（可通过 t.isValidIdentifier(propertyName) 校验），则将其改写为普通属性访问（computed: false 并转为 Identifier）：

// 成员表达式简化逻辑
const memberSimplifierVisitor = {
  MemberExpression(path) {
    const { property, computed } = path.node;
    if (computed && t.isStringLiteral(property)) {
      const propValue = property.value;
      if (t.isValidIdentifier(propValue)) {
        path.node.property = t.identifier(propValue);
        path.node.computed = false;
      }
    }
  }
};

三、批量处理引擎架构与容错调度

在批量处理项目中，面对成百上千个脚本文件，单文件的偶发解析错误不能导致整体任务中断。流水线需要具备健壮的并发控制、执行超时熔断机制与双轨产物输出能力。

四、完整可执行的 Node.js 批量反混淆脚本

下面是一个经过工程化封装、开箱即用的完整批量反混淆脚本 batch-deobfuscate.js。该脚本不依赖第三方复杂框架，仅基于 Babel 核心包与 Node.js 原生模块实现。

1. 项目准备与依赖安装

# 初始化 Node.js 项目并安装 Babel 核心依赖
mkdir js-deobfuscate-tool && cd js-deobfuscate-tool
npm init -y
npm install @babel/parser @babel/traverse @babel/generator @babel/types

2. 批量处理脚本源码（batch-deobfuscate.js）

/**
 * batch-deobfuscate.js
 * Node.js 自动化批量反混淆脚本
 */
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const { execSync } = require("node:child_process");

const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const generator = require("@babel/generator").default;
const t = require("@babel/types");

// 配置参数
const CONFIG = {
  inputDir: path.resolve(__dirname, "./obfuscated"),
  outputDir: path.resolve(__dirname, "./restored"),
  quarantineDir: path.resolve(__dirname, "./quarantine"),
  vmTimeoutMs: 5000,
};

/**
 * 递归收集指定目录下所有的 .js 文件
 */
function collectJsFiles(dir) {
  let results = [];
  if (!fs.existsSync(dir)) return results;
  const list = fs.readdirSync(dir, { withFileTypes: true });
  for (const dirent of list) {
    const fullPath = path.join(dir, dirent.name);
    if (dirent.isDirectory()) {
      if (dirent.name !== "node_modules" && !dirent.name.startsWith(".")) {
        results = results.concat(collectJsFiles(fullPath));
      }
    } else if (dirent.isFile() && dirent.name.endsWith(".js")) {
      results.push(fullPath);
    }
  }
  return results;
}

/**
 * 安全抽取并执行混淆解密头
 */
function extractAndInitDecryptor(ast, code) {
  const decryptorNodes = [];
  let decryptorFuncName = null;

  // 识别典型的混淆解密骨架：
  // 1. 全局大数组定义 (VariableDeclaration)
  // 2. 自执行移位函数 (ExpressionStatement -> IIFE)
  // 3. 解密函数 (FunctionDeclaration)
  const body = ast.program.body;
  const nodesToEvaluate = [];

  for (let i = 0; i < Math.min(body.length, 5); i++) {
    const node = body[i];
    if (t.isVariableDeclaration(node) || t.isExpressionStatement(node) || t.isFunctionDeclaration(node)) {
      nodesToEvaluate.push(node);
      if (t.isFunctionDeclaration(node) && !decryptorFuncName) {
        decryptorFuncName = node.id.name;
      }
    }
  }

  if (!decryptorFuncName || nodesToEvaluate.length === 0) {
    return null; // 未发现明确的标准解密函数头
  }

  // 生成待执行的初始化片段
  const setupAst = t.program(nodesToEvaluate);
  const setupCode = generator(setupAst).code;

  // 创建隔离的 vm 沙箱环境
  const sandbox = {
    window: {},
    document: {},
    navigator: { userAgent: "Mozilla/5.0" },
    console: { log: () => {} },
  };
  sandbox.window = sandbox;
  sandbox.global = sandbox;

  try {
    const context = vm.createContext(sandbox);
    const script = new vm.Script(setupCode);
    script.runInContext(context, { timeout: CONFIG.vmTimeoutMs });

    if (typeof context[decryptorFuncName] === "function") {
      return {
        funcName: decryptorFuncName,
        sandboxContext: context,
        nodeCountToRemove: nodesToEvaluate.length,
      };
    }
  } catch (err) {
    // 沙箱预运行异常返回 null
    return null;
  }

  return null;
}

/**
 * 单文件核心反混淆流水线
 */
function processSingleFile(filePath) {
  const rawCode = fs.readFileSync(filePath, "utf-8");

  // Step 1: 解析为 AST
  const ast = parser.parse(rawCode, {
    sourceType: "unambiguous",
    errorRecovery: true,
  });

  // Step 2: 提取并求解全局解密函数
  const decryptInfo = extractAndInitDecryptor(ast, rawCode);

  // Step 3: 多阶段 AST 遍历替换
  traverse(ast, {
    // 阶段 A: 解密函数调用原地还原为字面量
    CallExpression(path) {
      if (!decryptInfo) return;
      const { callee, arguments: args } = path.node;
      if (t.isIdentifier(callee, { name: decryptInfo.funcName })) {
        // 确保实参均为字面量
        const areAllLiterals = args.every(arg =>
          t.isStringLiteral(arg) || t.isNumericLiteral(arg)
        );
        if (areAllLiterals) {
          try {
            const callCode = generator(path.node).code;
            const plainText = vm.runInContext(callCode, decryptInfo.sandboxContext, {
              timeout: 1000,
            });
            if (typeof plainText === "string") {
              path.replaceWith(t.stringLiteral(plainText));
            } else if (typeof plainText === "number") {
              path.replaceWith(t.numericLiteral(plainText));
            }
          } catch (e) {
            // 若单个调用求解失败，保留原节点防崩溃
          }
        }
      }
    },

    // 阶段 B: 常量计算折叠与十六进制数规整
    BinaryExpression(path) {
      const evaluation = path.evaluate();
      if (evaluation.confident && typeof evaluation.value !== "function") {
        path.replaceWith(t.valueToNode(evaluation.value));
      }
    },
    NumericLiteral(path) {
      if (path.node.extra) {
        delete path.node.extra.raw;
      }
    },

    // 阶段 C: 成员表达式简化 (obj['prop'] -> obj.prop)
    MemberExpression(path) {
      const { property, computed } = path.node;
      if (computed && t.isStringLiteral(property)) {
        const propName = property.value;
        if (t.isValidIdentifier(propName)) {
          path.node.property = t.identifier(propName);
          path.node.computed = false;
        }
      }
    },
  });

  // 清除前置大数组及解密函数定义节点
  if (decryptInfo && decryptInfo.nodeCountToRemove > 0) {
    ast.program.body.splice(0, decryptInfo.nodeCountToRemove);
  }

  // Step 4: 代码生成
  const output = generator(ast, {
    retainLines: false,
    compact: false,
    comments: true,
  });

  return output.code;
}

/**
 * 批量执行主流程
 */
function runBatch() {
  console.log("=== Node.js 批量反混淆工具启动 ===");
  const files = collectJsFiles(CONFIG.inputDir);
  console.log(`检索到待处理文件总数: ${files.length}`);

  if (!fs.existsSync(CONFIG.outputDir)) fs.mkdirSync(CONFIG.outputDir, { recursive: true });
  if (!fs.existsSync(CONFIG.quarantineDir)) fs.mkdirSync(CONFIG.quarantineDir, { recursive: true });

  let successCount = 0;
  let failCount = 0;
  const startTime = Date.now();

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    const relativePath = path.relative(CONFIG.inputDir, file);
    const targetPath = path.join(CONFIG.outputDir, relativePath);
    const targetDir = path.dirname(targetPath);

    console.log(`[${i + 1}/${files.length}] 正在处理: ${relativePath}`);

    try {
      const restoredCode = processSingleFile(file);

      // 确保目标目录存在并写盘
      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
      fs.writeFileSync(targetPath, restoredCode, "utf-8");

      // 静态语法验证: node --check
      execSync(`node --check "${targetPath}"`, { stdio: "ignore" });

      successCount++;
    } catch (err) {
      failCount++;
      console.error(`  - 处理异常，隔离保存: ${err.message}`);
      const quarantinePath = path.join(CONFIG.quarantineDir, relativePath);
      const qDir = path.dirname(quarantinePath);
      if (!fs.existsSync(qDir)) fs.mkdirSync(qDir, { recursive: true });
      fs.copyFileSync(file, quarantinePath);
    }
  }

  const durationSec = ((Date.now() - startTime) / 1000).toFixed(2);
  console.log("=== 批量处理完成 ===");
  console.log(`耗时: ${durationSec} 秒 | 成功: ${successCount} 个 | 异常隔离: ${failCount} 个`);
}

// 执行任务
runBatch();

五、自动化执行、语法校验与结果验证

将待还原的混淆 JS 脚本统一放置在 ./obfuscated/ 目录下（支持任意多层子目录嵌套）。在命令行中直接启动脚本：

# 启动批量反混淆任务
node batch-deobfuscate.js

终端将实时输出逐个文件的处理进度与最终统计汇报：

=== Node.js 批量反混淆工具启动 ===
检索到待处理文件总数: 4
[1/4] 正在处理: core/analytics.js
[2/4] 正在处理: utils/crypto-helper.js
[3/4] 正在处理: vendors/checkout.min.js
[4/4] 正在处理: auth/session.js
=== 批量处理完成 ===
耗时: 1.42 秒 | 成功: 4 个 | 异常隔离: 0 个

执行完毕后，可通过两项具体手段验证还原质量：

1. 语法完整性自检：脚本内置了 node --check 静态校验。若代码存在语法错误，该文件会自动捕获异常并转存至隔离目录 ./quarantine/，确保 ./restored/ 目录中的每一个产物都是完全合法的 ECMAScript 源码。
2. 代码格式美化（可选）：使用 Prettier 对还原后的代码目录进行批量排版，消除混淆时残留的紧凑空行与缩进差异：

   npx prettier --write "./restored/**/*.js"

六、方案全流程总结与实践准则

在规模化工业级实践中，搭建自动化反混淆体系需要兼顾代码语义还原度、沙箱运行安全性与长期可维护性。以下总结了本方案的核心实践准则：

七、常见陷阱与注意事项防范

针对更加复杂的控制流平坦化（如包含 while(true) + switch(case) 的状态机），通常需要配合 AST 遍历提取状态流转数组（如 "3|1|4|2".split('|')），并按顺序将各个 case 代码块按线性顺序重组为普通语句块。由于各混淆版本的状态分发器格式差异较大，建议将控制流平坦化还原作为独立的 Pass 插件挂载在 AST 流水线中，实现针对性扩展。