iris-decompiler 1.0.0

package/dist/parser.js

@@ -0,0 +1,582 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBytecode = parseBytecode;
+const types_1 = require("./types");
+const LBC_VERSION_MIN = 3;
+const LBC_VERSION_MAX = 13;
+const LBC_VERSION_CLASSES = 100;
+const K_ROBLOX_SHUFFLE_MARKER_OP = types_1.Op.PREPVARARGS;
+class Reader {
+    constructor(data) {
+        this.offset = 0;
+        this.data = data;
+        this.size = data.length;
+    }
+    readU8() {
+        if (this.offset + 1 > this.size)
+            return null;
+        return this.data[this.offset++];
+    }
+    readU32() {
+        if (this.offset + 4 > this.size)
+            return null;
+        let v = 0;
+        v |= this.data[this.offset++];
+        v |= this.data[this.offset++] << 8;
+        v |= this.data[this.offset++] << 16;
+        v |= this.data[this.offset++] << 24;
+        return v >>> 0;
+    }
+    readI32() {
+        if (this.offset + 4 > this.size)
+            return null;
+        let v = 0;
+        v |= this.data[this.offset++];
+        v |= this.data[this.offset++] << 8;
+        v |= this.data[this.offset++] << 16;
+        v |= this.data[this.offset++] << 24;
+        return v; // signed 32-bit
+    }
+    readU64() {
+        if (this.offset + 8 > this.size)
+            return null;
+        // JS numbers can't hold full 64-bit; read as two 32-bit halves and combine.
+        let lo = 0;
+        lo |= this.data[this.offset++];
+        lo |= this.data[this.offset++] << 8;
+        lo |= this.data[this.offset++] << 16;
+        lo |= this.data[this.offset++] << 24;
+        let hi = 0;
+        hi |= this.data[this.offset++];
+        hi |= this.data[this.offset++] << 8;
+        hi |= this.data[this.offset++] << 16;
+        hi |= this.data[this.offset++] << 24;
+        return (hi * 0x100000000 + lo) >>> 0;
+    }
+    readF32() {
+        if (this.offset + 4 > this.size)
+            return null;
+        const buf = new Uint8Array(4);
+        for (let i = 0; i < 4; i++)
+            buf[i] = this.data[this.offset++];
+        return new DataView(buf.buffer).getFloat32(0, true);
+    }
+    readF64() {
+        if (this.offset + 8 > this.size)
+            return null;
+        const buf = new Uint8Array(8);
+        for (let i = 0; i < 8; i++)
+            buf[i] = this.data[this.offset++];
+        return new DataView(buf.buffer).getFloat64(0, true);
+    }
+    skip(n) {
+        if (this.offset + n > this.size)
+            return false;
+        this.offset += n;
+        return true;
+    }
+    take(n) {
+        if (!this.skip(n))
+            return null;
+        return this.data.subarray(this.offset - n, this.offset);
+    }
+    varint() {
+        let out = 0;
+        for (let shift = 0; shift < 35; shift += 7) {
+            const b = this.readU8();
+            if (b === null)
+                return null;
+            out |= (b & 0x7f) << shift;
+            if ((b & 0x80) === 0)
+                return out >>> 0;
+        }
+        return null;
+    }
+    varint64() {
+        let out = 0;
+        for (let shift = 0; shift < 70; shift += 7) {
+            const b = this.readU8();
+            if (b === null)
+                return null;
+            out |= (b & 0x7f) << shift;
+            if ((b & 0x80) === 0)
+                return out >>> 0;
+        }
+        return null;
+    }
+}
+function recoverOpcodeKey(mainCode) {
+    if (mainCode.length === 0)
+        return 1;
+    const wire = mainCode[0] & 0xff;
+    if (wire === K_ROBLOX_SHUFFLE_MARKER_OP)
+        return 1;
+    for (let key = 1; key < 256; key += 2) {
+        if (((wire * key) & 0xff) === K_ROBLOX_SHUFFLE_MARKER_OP)
+            return key;
+    }
+    return 1;
+}
+function decodeOpcodeShuffle(code, key) {
+    if (key === 1)
+        return;
+    for (let i = 0; i < code.length; i++) {
+        const wire = code[i] & 0xff;
+        const real = (wire * key) & 0xff;
+        code[i] = (code[i] & 0xffffff00) | real;
+        if (opHasAuxAt(code[i]) && i + 1 < code.length)
+            i++;
+    }
+}
+function opHasAuxAt(insn) {
+    const op = insn & 0xff;
+    switch (op) {
+        case types_1.Op.GETGLOBAL:
+        case types_1.Op.SETGLOBAL:
+        case types_1.Op.GETIMPORT:
+        case types_1.Op.GETTABLEKS:
+        case types_1.Op.SETTABLEKS:
+        case types_1.Op.NAMECALL:
+        case types_1.Op.JUMPIFEQ:
+        case types_1.Op.JUMPIFLE:
+        case types_1.Op.JUMPIFLT:
+        case types_1.Op.JUMPIFNOTEQ:
+        case types_1.Op.JUMPIFNOTLE:
+        case types_1.Op.JUMPIFNOTLT:
+        case types_1.Op.NEWTABLE:
+        case types_1.Op.SETLIST:
+        case types_1.Op.FORGLOOP:
+        case types_1.Op.LOADKX:
+        case types_1.Op.FASTCALL2:
+        case types_1.Op.FASTCALL2K:
+        case types_1.Op.FASTCALL3:
+        case types_1.Op.JUMPXEQKNIL:
+        case types_1.Op.JUMPXEQKB:
+        case types_1.Op.JUMPXEQKN:
+        case types_1.Op.JUMPXEQKS:
+        case types_1.Op.GETUDATAKS:
+        case types_1.Op.SETUDATAKS:
+        case types_1.Op.NAMECALLUDATA:
+        case types_1.Op.NEWCLASSMEMBER:
+        case types_1.Op.CALLFB:
+        case types_1.Op.CMPPROTO:
+        case types_1.Op.NEWCLASS:
+            return true;
+        default:
+            return false;
+    }
+}
+function parseProto(r, p, index, version, typesversion) {
+    const proto = p.protos[index];
+    proto.id = index;
+    let payloadStart = 0;
+    if (version >= 12) {
+        const protoSize = r.varint();
+        if (protoSize === null)
+            return false;
+        payloadStart = r.offset;
+        const maxstack = r.readU8();
+        const numparams = r.readU8();
+        const nups = r.readU8();
+        const isVararg = r.readU8();
+        if (maxstack === null || numparams === null || nups === null || isVararg === null)
+            return false;
+        proto.maxstack = maxstack;
+        proto.numparams = numparams;
+        proto.nups = nups;
+        proto.is_vararg = isVararg;
+    }
+    else {
+        const maxstack = r.readU8();
+        const numparams = r.readU8();
+        const nups = r.readU8();
+        const isVararg = r.readU8();
+        if (maxstack === null || numparams === null || nups === null || isVararg === null)
+            return false;
+        proto.maxstack = maxstack;
+        proto.numparams = numparams;
+        proto.nups = nups;
+        proto.is_vararg = isVararg;
+    }
+    if (version >= 4) {
+        const flags = r.readU8();
+        if (flags === null)
+            return false;
+        proto.flags = flags;
+        const typesize = r.varint();
+        if (typesize === null)
+            return false;
+        if (typesize) {
+            if (!r.skip(typesize))
+                return false;
+        }
+    }
+    const sizecode = r.varint();
+    if (sizecode === null)
+        return false;
+    proto.code = new Array(sizecode).fill(0);
+    for (let i = 0; i < sizecode; i++) {
+        const c = r.readU32();
+        if (c === null)
+            return false;
+        proto.code[i] = c >>> 0;
+    }
+    const sizek = r.varint();
+    if (sizek === null)
+        return false;
+    proto.k = new Array(sizek);
+    for (let j = 0; j < sizek; j++)
+        proto.k[j] = (0, types_1.makeConstant)();
+    for (let j = 0; j < sizek; j++) {
+        const tag = r.readU8();
+        if (tag === null)
+            return false;
+        const c = proto.k[j];
+        switch (tag) {
+            case 0:
+                c.kind = types_1.ConstKind.Nil;
+                break;
+            case 1: {
+                const v = r.readU8();
+                if (v === null)
+                    return false;
+                c.kind = types_1.ConstKind.Boolean;
+                c.boolean = v !== 0;
+                break;
+            }
+            case 2: {
+                const num = r.readF64();
+                if (num === null)
+                    return false;
+                c.kind = types_1.ConstKind.Number;
+                c.number = num;
+                break;
+            }
+            case 3: {
+                const id = r.varint();
+                if (id === null)
+                    return false;
+                if (id - 1 < 0 || id - 1 >= p.strings.length) {
+                    console.error(`proto ${index} const ${j}: string id ${id} missing (have ${p.strings.length} strings) @${r.offset}`);
+                    return false;
+                }
+                c.kind = types_1.ConstKind.String;
+                c.str = p.strings[id - 1];
+                break;
+            }
+            case 4: {
+                const id = r.readU32();
+                if (id === null)
+                    return false;
+                c.kind = types_1.ConstKind.Import;
+                c.importId = id >>> 0;
+                break;
+            }
+            case 5: {
+                const keys = r.varint();
+                if (keys === null)
+                    return false;
+                c.kind = types_1.ConstKind.Table;
+                for (let i = 0; i < keys; i++) {
+                    const key = r.varint();
+                    if (key === null)
+                        return false;
+                    const e = { key: key | 0, value: -1 };
+                    c.table.push(e);
+                }
+                break;
+            }
+            case 6: {
+                const fid = r.varint();
+                if (fid === null)
+                    return false;
+                if (fid >= p.protos.length)
+                    return false;
+                c.kind = types_1.ConstKind.Closure;
+                c.closureProto = fid | 0;
+                break;
+            }
+            case 7: {
+                const x = r.readF32();
+                const y = r.readF32();
+                const z = r.readF32();
+                const w = r.readF32();
+                if (x === null || y === null || z === null || w === null)
+                    return false;
+                c.kind = types_1.ConstKind.Vector;
+                c.vec = [x, y, z];
+                break;
+            }
+            case 8: {
+                const keys = r.varint();
+                if (keys === null)
+                    return false;
+                c.kind = types_1.ConstKind.TableWithConstants;
+                for (let i = 0; i < keys; i++) {
+                    const key = r.varint();
+                    const value = r.readI32();
+                    if (key === null || value === null)
+                        return false;
+                    const e = { key: key | 0, value: value | 0 };
+                    c.table.push(e);
+                }
+                break;
+            }
+            case 9: {
+                const isNegative = r.readU8();
+                const magnitude = r.varint64();
+                if (isNegative === null || magnitude === null)
+                    return false;
+                c.kind = types_1.ConstKind.Integer;
+                c.integer = isNegative ? (~magnitude + 1) | 0 : magnitude | 0;
+                break;
+            }
+            case 10: {
+                const a = r.varint();
+                const b = r.varint();
+                const count = r.varint();
+                if (a === null || b === null || count === null)
+                    return false;
+                for (let i = 0; i < count; i++) {
+                    const mid = r.varint();
+                    if (mid === null)
+                        return false;
+                }
+                c.kind = types_1.ConstKind.ClassShape;
+                break;
+            }
+            case 11: {
+                const x = r.readF64();
+                const y = r.readF64();
+                const z = r.readF64();
+                const w = r.readF64();
+                if (x === null || y === null || z === null || w === null)
+                    return false;
+                c.kind = types_1.ConstKind.VectorD;
+                c.vec = [x, y, z];
+                break;
+            }
+            default:
+                return false;
+        }
+    }
+    const sizep = r.varint();
+    if (sizep === null)
+        return false;
+    proto.children = new Array(sizep);
+    for (let i = 0; i < sizep; i++) {
+        const fid = r.varint();
+        if (fid === null)
+            return false;
+        if (fid >= p.protos.length)
+            return false;
+        proto.children[i] = fid >>> 0;
+    }
+    const linedefined = r.varint();
+    if (linedefined === null)
+        return false;
+    proto.linedefined = linedefined | 0;
+    {
+        const nameid = r.varint();
+        if (nameid === null)
+            return false;
+        const s = p.strings[nameid - 1];
+        if (s)
+            proto.debugname = s;
+    }
+    const lineinfo = r.readU8();
+    if (lineinfo === null)
+        return false;
+    if (lineinfo) {
+        const linegaplog2 = r.readU8();
+        if (linegaplog2 === null)
+            return false;
+        const bytes = new Array(sizecode);
+        for (let i = 0; i < sizecode; i++) {
+            const b = r.readU8();
+            if (b === null)
+                return false;
+            bytes[i] = b;
+        }
+        const intervals = ((sizecode - 1) >> linegaplog2) + 1;
+        const abs = new Array(intervals);
+        for (let i = 0; i < intervals; i++) {
+            const v = r.readI32();
+            if (v === null)
+                return false;
+            abs[i] = v;
+        }
+        proto.lineinfo = new Array(sizecode).fill(-1);
+        let groupLine = 0;
+        let j = 0;
+        for (let group = 0; group < intervals && j < sizecode; group++) {
+            groupLine += abs[group];
+            const groupEnd = Math.min(sizecode, (group + 1) << linegaplog2);
+            let running = 0;
+            for (; j < groupEnd; j++) {
+                running += bytes[j];
+                proto.lineinfo[j] = groupLine + running;
+            }
+        }
+    }
+    const debuginfo = r.readU8();
+    if (debuginfo === null)
+        return false;
+    if (debuginfo) {
+        const sizelocvars = r.varint();
+        if (sizelocvars === null)
+            return false;
+        proto.locvars = [];
+        for (let i = 0; i < sizelocvars; i++) {
+            const nameid = r.varint();
+            const start = r.varint();
+            const end = r.varint();
+            const reg = r.readU8();
+            if (nameid === null || start === null || end === null || reg === null)
+                return false;
+            const lv = { name: "", startpc: start | 0, endpc: end | 0, reg };
+            const s = p.strings[nameid - 1];
+            if (s)
+                lv.name = s;
+            proto.locvars.push(lv);
+        }
+        const sizeupvalues = r.varint();
+        if (sizeupvalues === null)
+            return false;
+        proto.upnames = [];
+        for (let i = 0; i < sizeupvalues; i++) {
+            const nameid = r.varint();
+            if (nameid === null)
+                return false;
+            proto.upnames.push(p.strings[nameid - 1] || "");
+        }
+    }
+    if (version >= 11) {
+        const fbsize = r.varint();
+        if (fbsize === null)
+            return false;
+        for (let i = 0; i < fbsize; i++) {
+            const slottype = r.readU8();
+            const pc = r.varint();
+            if (slottype === null || pc === null)
+                return false;
+        }
+    }
+    if (version >= 12) {
+        if ((proto.flags & (1 << 3)) !== 0) {
+            const cost = r.varint64();
+            if (cost === null)
+                return false;
+        }
+    }
+    return true;
+}
+function parseBytecode(data, out, err) {
+    out = Object.assign(out, (0, types_1.makeProgram)());
+    const r = new Reader(data);
+    const versionRaw = r.readU8();
+    if (versionRaw === null) {
+        err.msg = "bytecode is too small to be valid";
+        return false;
+    }
+    const version = versionRaw >>> 0;
+    if (version === 0) {
+        if (r.offset < data.length) {
+            err.msg = new TextDecoder().decode(data.subarray(r.offset));
+        }
+        else {
+            err.msg = "failed to load bytecode";
+        }
+        return false;
+    }
+    if ((version < LBC_VERSION_MIN || version > LBC_VERSION_MAX) && version !== LBC_VERSION_CLASSES) {
+        err.msg = `bytecode version mismatch (expected [3..13], got ${version})`;
+        return false;
+    }
+    let typesversion = 0;
+    if (version >= 4) {
+        const tv = r.readU8();
+        if (tv === null) {
+            err.msg = "unexpected end of bytecode";
+            return false;
+        }
+        typesversion = tv >>> 0;
+        if (typesversion < 1 || typesversion > 3) {
+            err.msg = `bytecode type info version mismatch (expected [1..3], got ${typesversion})`;
+            return false;
+        }
+    }
+    const stringCount = r.varint();
+    if (stringCount === null) {
+        err.msg = "unexpected end of bytecode reading string count";
+        return false;
+    }
+    out.strings = new Array(stringCount);
+    for (let i = 0; i < stringCount; i++) {
+        const length = r.varint();
+        if (length === null) {
+            err.msg = "unexpected end of bytecode reading string length";
+            return false;
+        }
+        const bytes = r.take(length);
+        if (bytes === null) {
+            err.msg = "unexpected end of bytecode reading string data";
+            return false;
+        }
+        out.strings[i] = new TextDecoder().decode(bytes);
+    }
+    if (typesversion === 3) {
+        let index = r.readU8();
+        if (index === null) {
+            err.msg = "unexpected end of bytecode reading userdata remap";
+            return false;
+        }
+        while (index !== 0) {
+            const nameid = r.varint();
+            if (nameid === null) {
+                err.msg = "unexpected end of bytecode reading userdata remap name";
+                return false;
+            }
+            if (nameid === 0 || nameid > out.strings.length) {
+                err.msg = "invalid string reference in userdata remap table";
+                return false;
+            }
+            index = r.readU8();
+            if (index === null) {
+                err.msg = "unexpected end of bytecode reading userdata remap index";
+                return false;
+            }
+        }
+    }
+    const protoCount = r.varint();
+    if (protoCount === null) {
+        err.msg = "unexpected end of bytecode reading proto count";
+        return false;
+    }
+    out.protos = new Array(protoCount);
+    for (let i = 0; i < protoCount; i++)
+        out.protos[i] = (0, types_1.makeProto)();
+    for (let i = 0; i < protoCount; i++) {
+        if (!parseProto(r, out, i, version, typesversion)) {
+            err.msg = `failed to parse proto #${i}`;
+            return false;
+        }
+    }
+    const mainid = r.varint();
+    if (mainid === null) {
+        err.msg = "unexpected end of bytecode reading main proto id";
+        return false;
+    }
+    if (mainid >= out.protos.length) {
+        err.msg = "invalid main proto id";
+        return false;
+    }
+    out.main = mainid | 0;
+    const key = recoverOpcodeKey(out.protos[out.main].code);
+    if (key !== 1) {
+        for (const proto of out.protos)
+            decodeOpcodeShuffle(proto.code, key);
+    }
+    out.encodingKey = key | 0;
+    return true;
+}