深入讲解如何使用Babel与抽象语法树(AST)自动化分析和还原被混淆的JavaScript代码,涵盖字符串解密、常量折叠、属性还原、控制流平坦化消除及安全执行边界。
怎么利用AST抽象语法树还原混淆的JavaScript代码
时间:2026-11-17
浏览:434
文章目录
一、准备工作与工具链环境配置
在 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 文本代码。
二、常见的混淆特征模式识别
主流的 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 内部语句,消除循环结构。 |
三、关键还原技术的分步实现
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();
}
}
}
}
});
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 还原混淆代码时,有几个关键的技术边界与安全约束必须严格遵守:
不要在宿主环境中裸执行未知解密代码:很多混淆脚本会嵌入针对 Node.js 运行时的探测代码(例如检测 process.mainModule、fs 模块或内置反调试死循环)。如果直接使用 eval() 执行解密段,可能导致本机文件被误改或内存溢出。推荐在 Node.js 中使用独立的 vm.createContext(),并传入纯净的上下文空对象,同时设置 timeout: 2000 等超时限制。
此外,还需要注意作用域(Scope)污染问题。混淆器常常在不同函数内部复用同名变量(例如都在不同局部声明 _0x1a2b)。在编写 AST 替换脚本时,尽量通过 path.scope.getBinding() 来精确确认标识符的绑定范围,切忌全局按名字“一刀切”替换,以免破坏正常的变量遮蔽逻辑。
最后,AST 解混淆的本质是“消除结构性与计算性噪音”,恢复代码原有的算法执行流。对于混淆过程中已被单向丢弃的信息(如原始变量的业务语义名称、原始行内注释),仍需配合动态断点调试与逆向分析工具进行语义补充。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。