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 定位该“三件套”，将其提取并在隔离沙箱中执行就绪，随后遍历整个语法树，拦截所有解密函数调用，就地求值并替换为字符串常量。

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

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

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

在明文字符串复位后，代码语义的可读性得到了显著改善，但如果函数内部被应用了“控制流平坦化（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. 完整规范化作业清单

3. 核心原则总结

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