Luac 字节码混淆工具

Lua 模块在 WASM 内置 Lua 环境中运行，可访问全部 luac.* 函数。模块是一个 Lua chunk，执行后必须返回一个 table。

return {
    name        = "my_obfuscator",  -- 必填，唯一标识符
    label       = "我的混淆器",       -- 可选，显示名称
    description = "模块功能描述",     -- 可选

    -- 必填，混淆入口函数
    -- proto: luac.Proto userdata
    apply = function(proto)
        -- 可读写 proto 字段：
        --   proto.code       table  指令数组 (1-based, 32-bit integer)
        --   proto.k          table  常量表 (1-based)
        --   proto.p          table  子 Proto 数组 (1-based)
        --   proto.sizecode   number 指令数量 (可写)
        --   proto.sizek      number 常量数量
        --   proto.sizep      number 子 proto 数量
        --   proto.numparams  number 参数数量 (可写)
        --   proto.is_vararg  number 是否可变参数 (可写)
        --   proto.linedefined number 起始行号 (可写)

        -- 指令操作函数：
        --   luac.GET_OPCODE(inst)  luac.SET_OPCODE(inst, op)
        --   luac.GETARG_A(inst)    luac.SETARG_A(inst, a)
        --   luac.GETARG_B(inst)    luac.SETARG_B(inst, b)
        --   luac.GETARG_C(inst)    luac.SETARG_C(inst, c)
        --   luac.GETARG_Bx(inst)   luac.SETARG_Bx(inst, bx)
        --   luac.GETARG_sBx(inst)  luac.SETARG_sBx(inst, sbx)
        --   luac.GETARG_Ax(inst)   luac.SETARG_Ax(inst, ax)
        --   luac.CREATE_ABC(op,a,b,c)
        --   luac.CREATE_ABx(op,a,bx)
        --   luac.CREATE_AsBx(op,a,sbx)
        --   luac.CREATE_Ax(op,ax)

        -- 操作码常量：luac.OP_MOVE, luac.OP_LOADK, ... luac.OP_EXTRAARG(47)
        -- 扩展操作码：luac.OP_FULLOPSIZE(48)
        -- 操作码名称表：luac.OPCODE_NAMES[1..47]

        -- 字节码导入导出：
        --   luac.undump(str, force_encrypted) -> proto
        --   luac.dump(proto) -> str

        -- 可直接调用内置混淆模块：
        --   luac.bool_obfuscate_c(proto)
        --   luac.num_obfuscate_c(proto)
        --   luac.str_encrypt_c(proto)
        --   ... 等全部 19 个内置模块

        -- 示例：在末尾插入 MOVE 0 0
        local n = proto.sizecode
        proto.code[n+1] = luac.CREATE_ABC(luac.OP_MOVE, 0, 0, 0)
        proto.sizecode = n + 1

        return true  -- 成功返回 true
    end
}

模块按注册顺序在内置模块之后执行。修改 proto.code 后必须同步更新 proto.sizecode。

JS 模块在浏览器页面环境中运行，可直接调用 WASM C API 和操作内存。模块是一个 JS 文件，通过 module.exports 导出对象。

// 自定义 JS 模块示例
module.exports = {
    name: "my_js_obfuscator",   // 必填，唯一标识符
    label: "我的JS混淆器",        // 可选，显示名称
    description: "模块功能描述",  // 可选

    // 必填，混淆入口函数
    // api 对象包含：
    //   api.handle    number  当前 proto 的注册表句柄
    //   api.Module    object  emscripten Module 对象
    //   api.call(name, retType, argTypes, args)  封装的 ccall
    //   api.log(msg)  写日志到页面
    //   api.fmtBytes(n)  格式化字节数
    apply: function(api) {
        // === 可用的 WASM C 函数 ===
        // api.call('wasm_apply', 'number',
        //   ['number','string'], [api.handle, 'num_obfuscate_c'])
        // api.call('wasm_apply_custom', 'number',
        //   ['number','string'], [api.handle, 'lua_mod_name'])
        // api.call('wasm_dump', 'number',
        //   ['number','number'], [api.handle, outLenPtr])
        // api.call('wasm_load', 'number',
        //   ['number','number'], [dataPtr, len])
        // api.call('wasm_free', null, ['number'], [handle])
        // api.call('wasm_last_error', 'string', [], [])

        // === 直接操作 WASM 内存 ===
        // var ptr = api.Module._malloc(100);
        // api.Module.HEAPU8.set([0x1B,0x4C,0x75,0x61], ptr);
        // var val = api.Module.getValue(ptr, 'i32');
        // api.Module._free(ptr);

        // === 示例：调用内置模块 + 自定义操作 ===
        // api.call('wasm_apply', 'number',
        //   ['number','string'], [api.handle, 'bool_obfuscate_c']);
        // api.log('已完成布尔混淆');

        // === 示例：dump 当前字节码并分析 ===
        // var lenPtr = api.Module._malloc(4);
        // var bcPtr = api.call('wasm_dump', 'number',
        //   ['number','number'], [api.handle, lenPtr]);
        // var bcLen = api.Module.getValue(lenPtr, 'i32');
        // var bytes = api.Module.HEAPU8.subarray(bcPtr, bcPtr + bcLen);
        // api.log('当前字节码: ' + api.fmtBytes(bcLen));
        // api.call('wasm_free_dump', null, ['number'], [bcPtr]);
        // api.Module._free(lenPtr);

        return true;  // 成功返回 true，返回 false 视为失败
    }
};

JS 模块在内置模块和 Lua 自定义模块之后、按选择顺序执行。可自由组合调用内置模块，实现流水线编排。