JS混淆常见手段解析：字符串加密与控制流平坦化还原思路

作者：性能诊所

时间：2026-11-04

深入解析JavaScript常见的字符串加密与控制流平坦化混淆机制，系统阐述基于AST与受控沙箱的自动化逆向还原思路、实现步骤与防御规避要点。

文章目录

在逆向分析被混淆的 JavaScript 脚本时，阅读障碍往往并非源自复杂的业务算法，而是混淆器人为制造的信息掩盖与执行流粉碎。其中，最核心的两项混淆手段是“字符串加密”与“控制流平坦化”：前者将关键标识符、API 名称及业务明文转为动态求值调用，使静态搜索失效；后者将结构化的线性与分支代码打散为一个基于无限循环和分支状态机的调度网络，切断上下文的直观联系。针对这两种混淆，逆向还原的基本逻辑不是依靠人工逐行猜测，而是基于抽象语法树（AST）分析工具，配合受控的沙箱环境进行自动化重构：通过“沙箱预求值与节点字面量替换”还原字符串，通过“分发序列追踪与状态块线性重组”消除控制流平坦化。

JS混淆常见手段解析：字符串加密与控制流平坦化还原思路 — 图 1：JS 逆向反混淆核心攻坚——字符串解密与控制流重构全景路线图

一、字符串加密混淆机制与解密还原

字符串在 JavaScript 业务逻辑中承担着不可或缺的语义角色，包括 API 路由、对象属性名、本地存储键名、加解密算法秘钥以及错误提示信息等。一旦字符串明文被剥离，代码的可读性就会断崖式下跌。混淆器正是利用这一特点，将代码中所有字面量字符串集中抽离并动态加密。

1. 混淆实现模式与核心特征

以业界主流混淆器（如 javascript-obfuscator）生成的代码为例，典型的字符串加密通常由固定且紧密耦合的“三件套”组成：

密文大数组（String Array）：定义在脚本顶部，包含脚本中提取出的所有字符串，可能经过 Base64、RC4 或十六进制编码。
移位自执行函数（IIFE Shuffle）：一段自执行代码，将大数组作为参数传入，内部通过 push 与 shift 操作对数组元素进行固定次数的循环移位，目的是破坏大数组在源代码中的静态下标索引。
解密包装函数（Decrypt Function）：接收一个或多个混淆参数（通常是十六进制下标或秘钥），内部调用计算逻辑，从移位后的大数组中获取密文、执行解密并返回明文字符串。为了提升性能，该函数内部往往还附带一个缓存字典。

在业务逻辑代码中，所有原本明文书写的字符串（如 console.log("success")）都会被替换为解密函数的调用形式（如 console[_0x2a1b('0x1')](_0x2a1b('0x2'))）。

// 混淆代码片段示例
var _0xa3f1 = ['log', 'success', 'hello'];
(function (_0x2d8105, _0x4b81bb) {
    var _0x4d7405 = function (_0x4f3ddb) {
        while (--_0x4f3ddb) {
            _0x2d8105['push'](_0x2d8105['shift']());
        }
    };
    _0x4d7405(++_0x4b81bb);
}(_0xa3f1, 0x1a4));

var _0x1c8b = function (_0x5aa6b6, _0x4f7110) {
    _0x5aa6b6 = _0x5aa6b6 - 0x0;
    var _0x3b5f02 = _0xa3f1[_0x5aa6b6];
    return _0x3b5f02;
};

// 实际调用点
console[_0x1c8b('0x0')](_0x1c8b('0x1'));

2. 还原原理与 AST 处理步骤

如果尝试依靠人工去手动逆推位移算法和解密算法，往往效率低下且容易出错。由于 JavaScript 是动态脚本语言，解密函数本身是图灵完备的纯函数（不依赖网络或外部 DOM），最稳定、最高效的还原方式是“借力打力”：通过 AST 定位该“三件套”，将其提取并在隔离沙箱中执行就绪，随后遍历整个语法树，拦截所有解密函数调用，就地求值并替换为字符串常量。

具体操作可划分为以下五个严密的步骤：

结构切片与特征提取：通过 Babel 将代码解析为 AST，在顶层节点（Program.body）中检索前三个语句。根据节点特征匹配出：密文数组声明（VariableDeclaration）、移位自执行函数（ExpressionStatement 内含 CallExpression）以及解密函数定义（FunctionDeclaration 或 VariableDeclaration）。
沙箱环境加载与预执行：利用 Node.js 原生的 vm.createContext 创建纯净沙箱环境。将提取出的三件套源码拼装并载入沙箱中执行，使沙箱内的全局作用域具备正确的数组移位状态和可调用的解密函数对象。
遍历 AST 拦截目标调用：使用 @babel/traverse 监听 CallExpression。判断调用的函数名（node.callee.name）是否为解密函数标识符。同时检查传入参数是否全部为常量字面量（NumericLiteral 或 StringLiteral）。
受控求值与就地折叠：在沙箱中执行该调用表达式（例如 _0x1c8b('0x0')），获取其实际返回的明文字符串；随后调用 types.stringLiteral(result) 构造新的 AST 节点，使用 path.replaceWith() 覆盖原有的调用节点。
死代码修剪与作用域清理：当语法树中所有解密调用均被替换完成后，顶部的密文大数组、移位自执行函数以及解密函数本体均已成为零引用的冗余代码，直接调用 path.remove() 将其彻底从 AST 中剔除。

3. AST 还原脚本核心实现

在基于 Babel 的逆向工具链中，核心处理逻辑如下所示：

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

function decryptStrings(code) {
    const ast = parser.parse(code, { sourceType: "script" });

    // 1. 提取前 3 个节点作为解密运行依赖
    const decryptPartNodes = ast.program.body.slice(0, 3);
    const decryptCode = generator(types.program(decryptPartNodes)).code;

    // 2. 初始化 VM 沙箱并执行解密三件套
    const sandbox = {};
    vm.createContext(sandbox);
    vm.runInContext(decryptCode, sandbox);

    // 获取解密函数名（假设第三个节点为解密函数声明）
    const decryptFnName = "_0x1c8b";

    // 3. 遍历并替换 CallExpression
    traverse(ast, {
        CallExpression(path) {
            const { callee, arguments: args } = path.node;
            if (types.isIdentifier(callee, { name: decryptFnName })) {
                // 确保参数均为字面量，防止动态计算导致求值异常
                const areArgsLiteral = args.every(arg => types.isLiteral(arg));
                if (areArgsLiteral) {
                    const callCode = path.toString();
                    try {
                        const plainText = vm.runInContext(callCode, sandbox);
                        // 替换为字面量常量
                        path.replaceWith(types.stringLiteral(plainText));
                    } catch (err) {
                        console.error(`解密失败: ${callCode}`, err);
                    }
                }
            }
        }
    });

    // 4. 清除三件套死代码
    ast.program.body.splice(0, 3);

    return generator(ast).code;
}

避坑要点：暗桩检测与环境防御
部分商业混淆器会在解密函数或移位函数中内嵌“防格式化（Self-Defending）”检测：内部通过 Function.prototype.toString.call(...) 探测自身代码是否含有换行或空格，或者检测 window、document 的存在。如果在解密前使用了美化排版，或者在纯 Node.js 环境下未补充基础浏览器全局垫片（如 window = global），可能导致沙箱执行进入无限死循环或主动抛出异常退出。处理此类混淆时，必须在提取解密代码前保持原始单行紧凑形态，或静态剔除其内部的检测正则。

二、控制流平坦化混淆机制与逆向还原

在明文字符串复位后，代码语义的可读性得到了显著改善，但如果函数内部被应用了“控制流平坦化（Control Flow Flattening）”，代码依然极难通读。控制流平坦化是一种通过破坏程序结构来阻碍控制流图（CFG）分析的技术。

1. 控制流平坦化的结构特征

常规代码是结构化的：语句块之间按照自上而下的顺序执行，或者通过 if-else、for 等控制结构实现分支与循环。控制流平坦化将所有原本线性的基本块（Basic Blocks）强行拆散，放进一个巨大的 switch 语句的各个 case 分支中，并将整个 switch 置于一个 while (true) 的循环体内部。

状态的分发调度通常依赖一个“分发器变量”或一个由固定分隔符组成的“执行序列字符串”（例如 '3|0|2|1'.split('|')）。状态机每次执行一个 case 块，在末尾修改状态计数器或执行 continue，强制回到循环头部，再由 switch 跳转到下一个 case。

// 原始结构化代码
function processOrder() {
    initAuth();
    sendReq();
    handleData();
    return val;
}

// 控制流平坦化混淆后的代码
function processOrder() {
    var _0x51c2 = '3|0|2|1'['split']('|');
    var _0x21d8 = 0;
    while (true) {
        switch (_0x51c2[_0x21d8++]) {
            case '0':
                sendReq();
                continue;
            case '1':
                return val;
            case '2':
                handleData();
                continue;
            case '3':
                initAuth();
                continue;
        }
        break;
    }
}

2. 还原思路与 AST 重构步骤

面对平坦化的状态机，反混淆的核心任务是“拓扑重排与降维”：识别出状态分发器中的预定执行顺序，按该顺序从 switch 中抽出对应的 case 内容，顺次拼接成一个扁平的语句数组，最后用这个语句数组直接替代整个 while 循环。

重构算法的核心逻辑包含四个关键阶段：

识别平坦化结构节点：定位满足以下特征的 AST 结构：外层是一个没有终止条件的 WhileStatement（如 while(true)），其子节点仅包含一个 BlockStatement，该块的首个语句为一个 SwitchStatement。
提取并解析分发序列：检查 WhileStatement 前置的兄弟节点（Sibling Nodes），寻找包含 .split('|') 或字面量数组的变量声明。提取该分发数组的具体内容，例如 ["3", "0", "2", "1"]。
建立分支映射字典与清洗跳转指令：遍历 SwitchStatement 的全部 SwitchCase，以 case.test.value 为键，其下包含的语句集合（consequent）为值构建字典映射。在提取语句时，需要剔除分支末尾专用于状态机跳转的 continue 语句与冗余的 break 语句，保留真实的业务语句与 return。
顺序展开与替换注入：根据提取到的分发序列数组，依次从字典映射中取出对应的语句块，拼装为一个平坦的 Statement 数组。利用 path.replaceWithMultiple(restructuredStatements) 将原有的 WhileStatement 整体替换，并同时移除前置的分发器变量。

3. AST 还原脚本核心实现

基于 Babel 的控制流平坦化重构核心代码实现如下：

function unflattenControlFlow(code) {
    const ast = parser.parse(code, { sourceType: "script" });

    traverse(ast, {
        WhileStatement(path) {
            const { node, parentPath } = path;

            // 1. 验证 while(true) 结构
            const isInfiniteWhile = (types.isBooleanLiteral(node.test, { value: true }) ||
                                    types.isUnaryExpression(node.test, { operator: "!" }));
            if (!isInfiniteWhile) return;

            // 2. 检查内部是否为单 switch 结构
            const bodyStatements = node.body.body;
            if (!bodyStatements || bodyStatements.length === 0) return;
            const switchStmt = bodyStatements[0];
            if (!types.isSwitchStatement(switchStmt)) return;

            // 3. 寻找前置分发器定义：var _0x51c2 = '3|0|2|1'.split('|')
            const prevSibling = path.getPrevSibling();
            if (!prevSibling.isVariableDeclaration()) return;

            const declarator = prevSibling.node.declarations[0];
            let orderArray = null;

            // 匹配 '3|0|2|1'.split('|') 表达式
            if (types.isCallExpression(declarator.init) &&
                types.isMemberExpression(declarator.init.callee) &&
                declarator.init.callee.property.name === "split" &&
                types.isStringLiteral(declarator.init.callee.object)) {
                const splitStr = declarator.init.callee.object.value;
                const separator = declarator.init.arguments[0].value;
                orderArray = splitStr.split(separator);
            }

            if (!orderArray) return;

            // 4. 将 Case 块映射到字典
            const caseMap = new Map();
            for (const switchCase of switchStmt.cases) {
                const key = switchCase.test.value;
                // 过滤掉状态机跳转使用的 continue 和 break
                const validStatements = switchCase.consequent.filter(stmt =>
                    !types.isContinueStatement(stmt) && !types.isBreakStatement(stmt)
                );
                caseMap.set(key, validStatements);
            }

            // 5. 按分发顺序拼装还原后的语句列表
            const restoredStatements = [];
            for (const stepKey of orderArray) {
                const stmts = caseMap.get(stepKey);
                if (stmts) {
                    restoredStatements.push(...stmts);
                }
            }

            // 6. 替换 While 节点并删除分发变量声明
            path.replaceWithMultiple(restoredStatements);
            prevSibling.remove();
        }
    });

    return generator(ast).code;
}

4. 复杂变种与还原局限性

上述还原逻辑建立在“静态线性分发”的基础之上。但在实战对抗中，控制流平坦化还会演化出更高级的变种：

动态分支跳转（非固定静态序列）：混淆器不使用静态的 '3|0|2|1' 字符串，而是在某些 case 块内部通过计算动态更新指针（例如 if (x > 0) index = 2; else index = 5;）。这种结构本质上是真正的有向图状态机，无法直接压平成单一直线，需要借助“控制流图（CFG）重构算法”拆分为对应的 if-else 结构。
多层嵌套平坦化：函数本身被平坦化，而平坦化内部的某一特定分支又套嵌了另一层平坦化的 while-switch。对此类结构，还原脚本应自底向上（从最内层循环开始）逐层展开。

三、反混淆工程实践流水线与依赖协同

在面对一个经过深度混淆的工业级脚本时，单纯针对单一手段编写脚本往往会遭遇执行异常。各种混淆手段之间存在严密的依赖协同关系，必须遵循合理的逆向处理流水线。

1. 处理顺序的强依赖性

在工程化反混淆流水线中，必须先解密字符串，再进行控制流平坦化还原。其根本原因在于：混淆器通常对平坦化分发器本身也施加了字符串加密。例如分发器语句可能写为：

var _0x51c2 = _0x1c8b('0x3')['split'](_0x1c8b('0x4'));

如果先执行控制流平坦化脚本，AST 匹配器将无法读取到 '3|0|2|1' 和 '|' 字面量，导致状态链提取直接判定为空而跳过处理。只有先完成字符串的求值常量折叠，将上述语句还原为清晰的 var _0x51c2 = '3|0|2|1'.split('|')，后续的控制流重构逻辑才能顺利捕获特征。

2. 完整规范化作业清单

处理阶段	主要任务	对应 AST 节点与转换策略
阶段一：语法规范化	统一进制、折叠一元常量、展开逗号表达式	将 `NumericLiteral` 的十六进制值规范为十进制；遍历 `SequenceExpression` 展开为独立表达式语句；将 `obj['fn']()` 规范为 `obj.fn()`。
阶段二：字符串解密	内存沙箱执行三件套，就地折叠调用	捕获 `CallExpression`，经 `vm` 上下文计算后替换为 `StringLiteral`；随后通过 `path.remove()` 清理密文数组与解密器。
阶段三：控制流平坦化还原	状态机拓扑分析与线性展开	匹配 `WhileStatement` 内的 `SwitchStatement`，基于分发序列重排 `case` 语句，重构为 `BlockStatement` 并剔除死分支。
阶段四：清理与重格式化	死代码剔除与美化排版	移除无引用的状态计数变量与中间别名；使用 Prettier 对生成的代码进行语义层级的结构重排与对齐。

3. 核心原则总结

逆向还原混淆代码的核心并不是与混淆算法硬碰硬，而是理解混淆器破坏代码的抽象语法规则。字符串加密破坏的是“标识符与字面量的绑定”，通过“沙箱执行 + 常量折叠”能够迅速还原其静态语义；控制流平坦化破坏的是“基本块的拓扑秩序”，通过“分发路径捕获 + AST 节点重排”能够抹平状态机的跳转外壳。掌握这两项核心手段的还原思路，不仅能够解决绝大多数日常逆向分析中的可读性瓶颈，也为进一步处理更高级的动态混淆奠定了坚实的技术底座。