GK/3.31GK/other_code/控制流平坦化-状态机为变量/ast.js

const fs = require("fs");//文件读写
const parse = require("@babel/parser"); //解析为ast
const traverse = require('@babel/traverse').default;//遍历节点
const t = require('@babel/types');//类型
const generator = require('@babel/generator').default;//ast解析为代码


//读取混淆js文件
const jsCode = fs.readFileSync('./encode.js', {encoding: 'utf-8'});


const visitor = {
    WhileStatement(path) {                // 处理 While 循环语句
        const {test, body} = path.node;   // 解构循环条件和循环体

        // 硬编码状态变量名和初始值（需后续从代码动态提取）
        let init_name = 'index';           // 状态变量名（示例值）
        let init_value = 0;                // 初始状态值（示例值）

        const switch_body = body.body[0];  // 提取循环体内的第一个（）语句

        // 验证是否为 Switch 语句，否则终止处理
        if (!t.isSwitchStatement(switch_body)) return;

        const {discriminant, cases} = switch_body;  // 解构 Switch 的条件和分支列表

        // 验证 Switch 条件是否为指定状态变量
        if (!t.isIdentifier(discriminant, {name: init_name})) return;

        const ret_body = [];               // 存储最终生成的代码块集合
        let end_flag = false;              // 终止循环处理标志

        while (true) {                     // 循环处理所有状态分支
            if (end_flag) break;            // 检测终止条件

            for (const each_case of cases) { // 遍历 Switch 的所有 case 分支
                const {test, consequent} = each_case;

                // 跳过非当前状态的 case 分支
                if (init_value !== test.value) continue;

                // 移除分支末尾的 continue 语句
                if (t.isContinueStatement(consequent[consequent.length - 1])) {
                    consequent.pop();
                }

                // 处理状态变量更新逻辑
                if (t.isExpressionStatement(consequent[consequent.length - 1])) {
                    const {expression} = consequent[consequent.length - 1];

                    // 解析状态变量赋值表达式
                    if (t.isAssignmentExpression(expression)) {
                        const {left, right} = expression;

                        // 更新状态变量值并移除赋值语句
                        if (t.isIdentifier(left, {name: init_name})) {
                            init_value = right.value;
                            consequent.pop();
                        }
                    }
                }

                // 检测 return 语句作为终止信号
                if (t.isReturnStatement(consequent[consequent.length - 1])) {
                    end_flag = true;
                }

                ret_body.push(...consequent);  // 合并处理后的代码块
                break;                         // 退出当前分支处理循环
            }
        }

        path.replaceInline(ret_body);      // 用线性代码替换原循环结构
    }
};

let ast = parse.parse(jsCode);//js转ast
traverse(ast, visitor)  // 处理控制流平坦化

let {code} = generator(ast)

console.log(code)