怎么利用AST抽象语法树还原混淆的JavaScript代码

作者:极速慢跑

时间:2026-11-17

浏览:434

深入讲解如何使用Babel与抽象语法树(AST)自动化分析和还原被混淆的JavaScript代码,涵盖字符串解密、常量折叠、属性还原、控制流平坦化消除及安全执行边界。

文章目录
还原混淆JavaScript代码的核心路径,是将无序、编码或变形的源代码解析为抽象语法树(AST),利用树形遍历定位特征模式(如字符串加密函数调用、常量二元运算、对象属性混淆与扁平化分支分发器),在内存节点树中执行等价替换与逻辑展开,最后将修剪规整后的AST逆向重新生成为高可读性的结构化代码。
怎么利用AST抽象语法树还原混淆的JavaScript代码
图 1:基于 Babel 工具链的 JavaScript 混淆代码 AST 分析与还原核心架构

一、准备工作与工具链环境配置

在 JavaScript 逆向工程与代码审计中,纯正则替换容易因为代码跨行、括号嵌套或变量作用域遮蔽而引发语法错误。AST(Abstract Syntax Tree,抽象语法树)将源代码的字符序列解析为严谨的树状层级对象,使得代码变换变成对具体节点属性的精确修改。

还原工作推荐在 Node.js 环境下使用成熟的 Babel 编译器工具族。在本地空目录中初始化项目并安装以下必要模块:

npm init -y
npm install @babel/parser @babel/traverse @babel/generator @babel/types

各个模块的分工明确且专一:

  • @babel/parser:负责将一段 JavaScript 字符串源码解析为符合 ESTree/Babel AST 规范的语法树对象。
  • @babel/traverse:维护树状路径状态,通过定义各种节点类型的访问者函数(Visitor),在遍历树的过程中提供查找、替换、插入及作用域(Scope)追踪能力。
  • @babel/types:提供各类 AST 节点的新建工厂函数(如 t.stringLiteral())和断言校验方法(如 t.isIdentifier())。
  • @babel/generator:将处理修改后的 AST 重新序列化输出为格式化规范的 JavaScript 文本代码。
怎么利用AST抽象语法树还原混淆的JavaScript代码
图 2:AST 语法树节点分解与 Path 访问器就地替换原理

二、常见的混淆特征模式识别

主流的 JavaScript 混淆工具(如 javascript-obfuscator、JSFuck 等)主要采用以下五类典型变形策略,解混淆脚本必须针对性地设计各个 Visitor 处理分支:

混淆类型 代码混淆表现特征 AST 处理对策
字符串抽离与移位 定义大数组提取字符串,前置 IIFE 自执行函数执行位移洗牌,代码各处调用解码函数 _0x12ab(0x1)。 在隔离环境中执行前置数组与解密逻辑,定位解密 CallExpression 并替换为计算结果。
对象属性方括号化 将常规成员访问转为字符串方括号访问,如 window['document']['location']。 遍历 MemberExpression,检查合法标识符后将 computed: true 转为点号访问。
常量计算膨胀 使用恒真/恒假表达式与算术拆分,如 !![] 代替 true,0x1a + 0x2b * 3。 借助 path.evaluate() 就地折叠已知常量的二元与逻辑运算。
死代码注入 插入永远无法到达的分支,如 if ("abc" === "xyz") { ... }。 计算 IfStatement 中 test 的真假,剔除无效分支或保留有效分支内部语句块。
控制流平坦化 将顺序执行的代码切分为片段存入 switch...case,通过全局数组和 while(true) 循环调度。 提取分发器状态索引数组,按编号重组 Case 内部语句,消除循环结构。
怎么利用AST抽象语法树还原混淆的JavaScript代码
图 3:针对混淆 JavaScript 代码的五阶段解混淆流水线

三、关键还原技术的分步实现

1. 字符串解密与原地替换

混淆代码通常将所有敏感字符串(URL、字段名、密钥等)提取到一个一维数组中,并通过 IIFE 移位函数打乱顺序,最后暴露一个解密函数供业务代码调用。例如:

// 混淆代码片段示例
var _0xa1 = ["log", "hello_world", "trace"];
(function(arr, count) {
  while (--count) {
    arr.push(arr.shift());
  }
})(_0xa1, 2);

function _0xd3(index) {
  return _0xa1[index];
}

console[_0xd3(0)](_0xd3(1));

使用 AST 处理该模式时,首先截取前置的数组定义、自执行移位函数和解密函数定义节点,利用 Node.js 提供的 vm 模块在隔离上下文中运行该部分代码,使当前进程获得实际解密能力。随后编写 Visitor 遍历全部 CallExpression:

const traverse = require('@babel/traverse').default;
const t = require('@babel/types');

// 匹配并内联解密函数调用
traverse(ast, {
  CallExpression(path) {
    const { callee, arguments: args } = path.node;
    // 匹配解密函数名称 _0xd3
    if (t.isIdentifier(callee, { name: '_0xd3' })) {
      if (args.length === 1 && t.isNumericLiteral(args[0])) {
        const index = args[0].value;
        // 在预置好的解密上下文中执行运算
        const realValue = decryptContext._0xd3(index);
        // 原地替换为纯文字面量节点
        path.replaceWith(t.stringLiteral(realValue));
      }
    }
  }
});

在完成全量替换后,原始的字符串大数组与解密函数在代码中已无任何引用,此时可通过 path.scope.getBinding('_0xa1') 检查其引用计数为 0 后直接执行 path.remove() 删除无用声明。

2. 对象属性访问语法规范化

混淆器往往将常见的对象调用改写为方括号字符串形式,例如 console['log'] 或 document['getElementById']。还原逻辑需将符合 JavaScript 变量命名规则的字符串键值转换为常规的点符号访问:

traverse(ast, {
  MemberExpression(path) {
    const { property, computed } = path.node;
    // 如果是方括号字符串访问形式: obj['prop']
    if (computed && t.isStringLiteral(property)) {
      const propValue = property.value;
      // 验证属性名是否为合法的 JS 标识符且非保留字
      if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propValue)) {
        path.node.property = t.identifier(propValue);
        path.node.computed = false; // 转换为 obj.prop
      }
    }
  }
});

3. 常量折叠与死代码清除

混淆逻辑中充斥着无意义的算术计算和恒真/恒假判断。Babel 的 path.evaluate() 能直接推导确定性的静态表达式计算值:

traverse(ast, {
  // 折叠二元运算与一元运算
  "BinaryExpression|UnaryExpression"(path) {
    const evaluated = path.evaluate();
    if (evaluated.confident) {
      path.replaceWith(t.valueToNode(evaluated.value));
    }
  },
  // 清除僵尸分支
  IfStatement(path) {
    const testResult = path.get('test').evaluate();
    if (testResult.confident) {
      if (testResult.value) {
        // 条件恒真: 用 consequent 替换整个 if 语句
        path.replaceWith(path.node.consequent);
      } else {
        // 条件恒假: 保留 alternate (若存在) 或直接移除
        if (path.node.alternate) {
          path.replaceWith(path.node.alternate);
        } else {
          path.remove();
        }
      }
    }
  }
});
怎么利用AST抽象语法树还原混淆的JavaScript代码
图 4:控制流平坦化分发器结构及其线性展开对比

4. 控制流平坦化的线性重构

控制流平坦化(Control Flow Flattening)将原本线性的业务代码切碎放入 SwitchCase 分支中,外层包裹 while(true) 循环。

还原的基本思路是:首先从上一级作用域中提取分发顺序数组(例如 "3|1|2|0".split("|"));其次遍历 SwitchStatement 的 cases 列表,以每个 case 的 test 值为键建立语句映射表;然后依照分发顺序依次提取对应的语句节点,过滤掉 continue 与 break 语句;最后用一个由这些语句组成的 BlockStatement 节点直接替换整个 WhileStatement。

traverse(ast, {
  WhileStatement(path) {
    const { test, body } = path.node;
    // 匹配 while (true) 或 while (!![]) 结构
    if (!t.isBooleanLiteral(test, { value: true }) && !t.isUnaryExpression(test)) return;
    if (!t.isBlockStatement(body) || body.body.length === 0) return;

    // 定位内部的 Switch 语句
    const switchNode = body.body[0];
    if (!t.isSwitchStatement(switchNode)) return;

    // 获取并解析调度控制数组 (例如从前序兄弟节点或绑定中提取)
    const prevSibling = path.getPrevSibling();
    if (!prevSibling || !prevSibling.isVariableDeclaration()) return;

    // 解析出执行顺序数组: ['2', '0', '1']
    const dispatchOrder = ["2", "0", "1"]; 
    const caseMap = new Map();

    switchNode.cases.forEach(c => {
      const key = c.test.value;
      // 过滤掉 case 结尾的 continue/break 语句
      const cleanStatements = c.consequent.filter(stmt => !t.isContinueStatement(stmt) && !t.isBreakStatement(stmt));
      caseMap.set(key, cleanStatements);
    });

    // 依序重新组装线性语句列表
    const restoredStatements = [];
    dispatchOrder.forEach(step => {
      if (caseMap.has(step)) {
        restoredStatements.push(...caseMap.get(step));
      }
    });

    // 用线性语句块替换整个 while 循环,并移除先前的调度变量声明
    path.replaceWith(t.blockStatement(restoredStatements));
    prevSibling.remove();
  }
});

四、完整端到端执行脚本示例

将上述各项还原技术整合为一个结构完整的独立 Node.js 脚本 deobfuscate.js。在终端运行该脚本,即可直接完成对目标混淆代码的读取、解析、解密、折叠与重写:

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

// 1. 读取待还原的混淆代码
const rawCode = fs.readFileSync('obfuscated.js', 'utf-8');

// 2. 解析为 AST 语法树
const ast = parser.parse(rawCode, {
  sourceType: 'script',
  allowReturnOutsideFunction: true
});

// 3. 阶段一:对象属性语法规范化 (obj['prop'] -> obj.prop)
traverse(ast, {
  MemberExpression(path) {
    const { property, computed } = path.node;
    if (computed && t.isStringLiteral(property)) {
      if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(property.value)) {
        path.node.property = t.identifier(property.value);
        path.node.computed = false;
      }
    }
  }
});

// 4. 阶段二:常量表达式静态折叠与计算
traverse(ast, {
  "BinaryExpression|UnaryExpression"(path) {
    const res = path.evaluate();
    if (res.confident && typeof res.value !== 'object') {
      path.replaceWith(t.valueToNode(res.value));
    }
  }
});

// 5. 阶段三:无效分支消除
traverse(ast, {
  IfStatement(path) {
    const testRes = path.get('test').evaluate();
    if (testRes.confident) {
      if (testRes.value) {
        path.replaceWith(path.node.consequent);
      } else if (path.node.alternate) {
        path.replaceWith(path.node.alternate);
      } else {
        path.remove();
      }
    }
  }
});

// 6. 重新生成并导出高可读性 JavaScript 文本
const output = generator(ast, {
  retainLines: false,
  compact: false,
  comments: true
}, rawCode);

fs.writeFileSync('restored.js', output.code, 'utf-8');
console.log('AST 还原流程执行完毕,已导出至 restored.js');

执行与验证:在项目目录下运行命令:

node deobfuscate.js

运行后控制台输出 AST 还原流程执行完毕,已导出至 restored.js。打开生成的 restored.js,对比原始混淆代码,可以观察到十六进制数字已转为十进制,字符方括号访问已转为点号,无用的判断分支已被剔除。

怎么利用AST抽象语法树还原混淆的JavaScript代码
图 5:AST 还原能力矩阵与安全沙箱执行边界

五、注意事项与安全执行边界

在实际工程中利用 AST 还原混淆代码时,有几个关键的技术边界与安全约束必须严格遵守:

不要在宿主环境中裸执行未知解密代码:很多混淆脚本会嵌入针对 Node.js 运行时的探测代码(例如检测 process.mainModule、fs 模块或内置反调试死循环)。如果直接使用 eval() 执行解密段,可能导致本机文件被误改或内存溢出。推荐在 Node.js 中使用独立的 vm.createContext(),并传入纯净的上下文空对象,同时设置 timeout: 2000 等超时限制。

此外,还需要注意作用域(Scope)污染问题。混淆器常常在不同函数内部复用同名变量(例如都在不同局部声明 _0x1a2b)。在编写 AST 替换脚本时,尽量通过 path.scope.getBinding() 来精确确认标识符的绑定范围,切忌全局按名字“一刀切”替换,以免破坏正常的变量遮蔽逻辑。

最后,AST 解混淆的本质是“消除结构性与计算性噪音”,恢复代码原有的算法执行流。对于混淆过程中已被单向丢弃的信息(如原始变量的业务语义名称、原始行内注释),仍需配合动态断点调试与逆向分析工具进行语义补充。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章