@isopodlabs/binary_libs 0.1.5 → 0.2.0

package/dist/elf.js

@@ -47,7 +47,7 @@ const Ident = {
     file_class: binary.asEnum(binary.UINT8, CLASS),
     encoding: binary.asEnum(binary.UINT8, DATA),
     version: binary.UINT8,
-    _: binary.If(obj => obj.file_class === 'CLASS64', {
+    _: binary.If(s => s.obj.file_class === 'CLASS64', {
         //64 bit only
         osabi: binary.asEnum(binary.UINT8, OSABI),
         abiversion: binary.UINT8,
@@ -616,12 +616,12 @@ function readDataAs(data, type) {
         return binary.RemainingArrayType(type).get(new binary.stream(data.data));
 }
 class ELFFile {
-    segments;
-    sections;
-    header;
     static check(data) {
         return binary.utils.decodeText(data.subarray(0, 4), 'utf8') === '\x7fELF';
     }
+    segments;
+    sections;
+    header;
     getDynamic;
     getRel;
     getRelA;

package/dist/mach.d copy.ts

@@ -0,0 +1,505 @@
+import * as binary from '@isopodlabs/binary';
+declare class mach_stream extends binary.endianStream {
+    base: Uint8Array;
+    mem?: binary.memory | undefined;
+    constructor(base: Uint8Array, data: Uint8Array, be: boolean, mem?: binary.memory | undefined);
+    subdata(offset: number, size?: number): Uint8Array;
+    substream(offset: number, size?: number): mach_stream;
+    getmem(address: bigint, size: number): Uint8Array | Promise<Uint8Array> | undefined;
+}
+declare const fat_arch: {
+    cputype: binary.TypeT<string>;
+    cpusubtype: binary.TypeT<string | number>;
+    offset: binary.TypeT<number>;
+    size: binary.TypeT<number>;
+    align: binary.TypeT<number>;
+    contents: binary.TypeT<MachFile | undefined>;
+};
+export declare enum CMD {
+    SEGMENT = 1,// segment of this file to be mapped
+    SYMTAB = 2,// link-edit stab symbol table info
+    SYMSEG = 3,// link-edit gdb symbol table info (obsolete)
+    THREAD = 4,// thread
+    UNIXTHREAD = 5,// unix thread (includes a stack)
+    LOADFVMLIB = 6,// load a specified fixed VM shared library
+    IDFVMLIB = 7,// fixed VM shared library identification
+    FVMFILE = 9,// fixed VM file inclusion (internal use)
+    DYSYMTAB = 11,// dynamic link-edit symbol table info
+    LOAD_DYLIB = 12,// load a dynamically linked shared library
+    ID_DYLIB = 13,// dynamically linked shared lib ident
+    LOAD_DYLINKER = 14,// load a dynamic linker
+    ID_DYLINKER = 15,// dynamic linker identification
+    PREBOUND_DYLIB = 16,// modules prebound for a dynamically linked shared library
+    ROUTINES = 17,// image routines
+    SUB_FRAMEWORK = 18,// sub framework
+    SUB_UMBRELLA = 19,// sub umbrella
+    SUB_CLIENT = 20,// sub client
+    SUB_LIBRARY = 21,// sub library
+    TWOLEVEL_HINTS = 22,// two-level namespace lookup hints
+    PREBIND_CKSUM = 23,// prebind checksum
+    LOAD_WEAK_DYLIB = 2147483672,// load a dynamically linked shared library that is allowed to be missing (all symbols are weak imported).
+    SEGMENT_64 = 25,// 64-bit segment of this file to be mapped
+    ROUTINES_64 = 26,// 64-bit image routines
+    UUID = 27,// the uuid
+    RPATH = 2147483676,// runpath additions
+    CODE_SIGNATURE = 29,// local of code signature
+    SEGMENT_SPLIT_INFO = 30,// local of info to split segments
+    REEXPORT_DYLIB = 2147483679,// load and re-export dylib
+    LAZY_LOAD_DYLIB = 32,// delay load of dylib until first use
+    ENCRYPTION_INFO = 33,// encrypted segment information
+    DYLD_INFO = 34,// compressed dyld information
+    DYLD_INFO_ONLY = 2147483682,// compressed dyld information only
+    LOAD_UPWARD_DYLIB = 2147483683,// load upward dylib
+    VERSION_MIN_MACOSX = 36,// build for MacOSX min OS version
+    VERSION_MIN_IPHONEOS = 37,// build for iPhoneOS min OS version
+    FUNCTION_STARTS = 38,// compressed table of function start addresses
+    DYLD_ENVIRONMENT = 39,// string for dyld to treat like environment variable
+    MAIN = 2147483688,// replacement for LC_UNIXTHREAD
+    DATA_IN_CODE = 41,// table of non-instructions in __text
+    SOURCE_VERSION = 42,// source version used to build binary
+    DYLIB_CODE_SIGN_DRS = 43,// Code signing DRs copied from linked dylibs
+    ENCRYPTION_INFO_64 = 44,// 64-bit encrypted segment information
+    LINKER_OPTION = 45,// linker options in MH_OBJECT files
+    LINKER_OPTIMIZATION_HINT = 46,// optimization hints in MH_OBJECT files
+    VERSION_MIN_TVOS = 47,// build for AppleTV min OS version
+    VERSION_MIN_WATCHOS = 48,// build for Watch min OS version
+    NOTE = 49,// arbitrary data included within a Mach-O file
+    BUILD_VERSION = 50,// build for platform min OS version
+    DYLD_EXPORTS_TRIE = 2147483699,// used with linkedit_data_command, payload is trie
+    DYLD_CHAINED_FIXUPS = 2147483700
+}
+declare const cmd_table: {
+    1: {
+        get(s: mach_stream): {
+            data: binary.MappedMemory | undefined;
+            segname: string;
+            vmaddr: number;
+            vmsize: number;
+            fileoff: number;
+            filesize: number;
+            maxprot: number;
+            initprot: number;
+            nsects: number;
+            flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+            sections: Record<string, any> | undefined;
+        };
+    };
+    25: {
+        get(s: mach_stream): {
+            data: binary.MappedMemory | undefined;
+            segname: string;
+            vmaddr: bigint;
+            vmsize: bigint;
+            fileoff: bigint;
+            filesize: bigint;
+            maxprot: number;
+            initprot: number;
+            nsects: number;
+            flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+            sections: Record<string, any> | undefined;
+        };
+    };
+    6: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        minor_version: binary.TypeT<binary.hex<number | bigint>>;
+        header_addr: binary.TypeT<binary.hex<number | bigint>>;
+    };
+    7: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        minor_version: binary.TypeT<binary.hex<number | bigint>>;
+        header_addr: binary.TypeT<binary.hex<number | bigint>>;
+    };
+    12: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    13: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    2147483672: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    2147483679: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    32: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    2147483683: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        timestamp: binary.TypeT<number>;
+        current_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        compatibility_version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+    };
+    18: {
+        get(s: binary.stream): string;
+    };
+    19: {
+        get(s: binary.stream): string;
+    };
+    20: {
+        get(s: binary.stream): string;
+    };
+    21: {
+        get(s: binary.stream): string;
+    };
+    14: {
+        get(s: binary.stream): string;
+    };
+    15: {
+        get(s: binary.stream): string;
+    };
+    39: {
+        get(s: binary.stream): string;
+    };
+    2147483676: {
+        get(s: binary.stream): string;
+    };
+    16: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        nmodules: binary.TypeT<number>;
+        linked_modules: {
+            get(s: binary.stream): string;
+        };
+    };
+    4: {
+        flavor: binary.TypeT<number>;
+        count: binary.TypeT<number>;
+    };
+    5: {
+        flavor: binary.TypeT<number>;
+        count: binary.TypeT<number>;
+    };
+    17: {
+        init_address: binary.TypeT<bigint> | binary.TypeT<number>;
+        init_module: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved1: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved2: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved3: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved4: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved5: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved6: binary.TypeT<bigint> | binary.TypeT<number>;
+    };
+    26: {
+        init_address: binary.TypeT<bigint> | binary.TypeT<number>;
+        init_module: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved1: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved2: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved3: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved4: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved5: binary.TypeT<bigint> | binary.TypeT<number>;
+        reserved6: binary.TypeT<bigint> | binary.TypeT<number>;
+    };
+    2: {
+        get(s: binary._stream): (string | {
+            strx: number;
+            flags: {
+                ext: number | bigint;
+                type: string;
+                pext: number | bigint;
+                stab: string;
+            };
+            sect: number;
+            desc: {
+                ref: string;
+                flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+                align: number | bigint;
+            };
+            value: number | bigint;
+        })[][] | undefined;
+    };
+    22: {
+        get(s: mach_stream): {
+            sub_image: number | bigint;
+            toc: number | bigint;
+        }[] | undefined;
+    };
+    23: {
+        cksum: binary.TypeT<number>;
+    };
+    27: {
+        uuid: binary.TypeT<Uint8Array>;
+    };
+    29: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    30: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    38: {
+        get(s: mach_stream): {
+            data: Uint8Array;
+            contents: (number | bigint)[];
+        };
+    };
+    41: {
+        get(s: mach_stream): {
+            data: Uint8Array;
+            contents: {
+                offset: binary.hex<number | bigint>;
+                length: number;
+                kind: string;
+            }[];
+        };
+    };
+    43: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    46: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    2147483699: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    2147483700: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    33: {
+        cryptoff: binary.TypeT<number>;
+        cryptsize: binary.TypeT<number>;
+        cryptid: binary.TypeT<number>;
+    };
+    44: {
+        cryptoff: binary.TypeT<number>;
+        cryptsize: binary.TypeT<number>;
+        cryptid: binary.TypeT<number>;
+        pad: binary.TypeT<number>;
+    };
+    36: {
+        version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        reserved: binary.TypeT<number>;
+    };
+    37: {
+        version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        reserved: binary.TypeT<number>;
+    };
+    47: {
+        version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        reserved: binary.TypeT<number>;
+    };
+    48: {
+        version: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        reserved: binary.TypeT<number>;
+    };
+    34: {
+        rebase: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        weak_bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        lazy_bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        exprt: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+    };
+    2147483682: {
+        rebase: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        weak_bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        lazy_bind: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+        exprt: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+    };
+    3: {
+        get(s: mach_stream): Uint8Array | undefined;
+    };
+    9: {
+        name: {
+            get(s: binary.stream): string;
+        };
+        header_addr: binary.TypeT<number>;
+    };
+    2147483688: {
+        entryoff: binary.TypeT<number>;
+        stacksize: binary.TypeT<number>;
+    };
+    42: {
+        version: binary.TypeT<{
+            a: number | bigint;
+            b: number | bigint;
+            c: number | bigint;
+            d: number | bigint;
+            e: number | bigint;
+        }>;
+    };
+    50: {
+        platform: binary.TypeT<string>;
+        minos: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        sdk: binary.TypeT<Record<string, bigint | boolean> | Record<string, number | boolean>>;
+        tools: binary.TypeT<Record<string, {
+            tool: string;
+            version: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        }>>;
+    };
+    45: {
+        count: binary.TypeT<number>;
+    };
+    49: {
+        data_owner: binary.TypeT<string>;
+        data: {
+            get(s: mach_stream): Uint8Array | undefined;
+        };
+    };
+    11: {
+        localsym: {
+            first: binary.TypeT<number>;
+            count: binary.TypeT<number>;
+        };
+        extdefsym: {
+            first: binary.TypeT<number>;
+            count: binary.TypeT<number>;
+        };
+        undefsym: {
+            first: binary.TypeT<number>;
+            count: binary.TypeT<number>;
+        };
+        toc: {
+            get(s: mach_stream): {
+                symbol_index: number;
+                module_index: number;
+            }[] | undefined;
+        };
+        modtab: {
+            get(s: mach_stream): ({
+                objc_module_info_addr: number;
+                objc_module_info_size: number;
+                module_name: number;
+                extdefsym: never;
+                refsym: never;
+                localsym: never;
+                extrel: never;
+                init_iterm: never;
+            } | {
+                objc_module_info_size: number;
+                objc_module_info_addr: bigint;
+                module_name: number;
+                extdefsym: never;
+                refsym: never;
+                localsym: never;
+                extrel: never;
+                init_iterm: never;
+            })[] | undefined;
+        };
+        extrefsym: {
+            get(s: mach_stream): {
+                symbol_index: number | bigint;
+                flags: number | bigint;
+            }[] | undefined;
+        };
+        indirectsym: {
+            get(s: mach_stream): {
+                symbol_index: number | bigint;
+                flags: number | bigint;
+            }[] | undefined;
+        };
+        extrel: {
+            get(s: mach_stream): {
+                address: number;
+                symbol_ref: {
+                    symbol_index: number | bigint;
+                    flags: number | bigint;
+                };
+            }[] | undefined;
+        };
+        locrel: {
+            get(s: mach_stream): {
+                address: number;
+                symbol_ref: {
+                    symbol_index: number | bigint;
+                    flags: number | bigint;
+                };
+            }[] | undefined;
+        };
+    };
+};
+export declare class MachFile {
+    header: any;
+    commands: {
+        cmd: CMD;
+        data: any;
+    }[];
+    ready: Promise<void>;
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array, mem?: binary.memory);
+    load(data: Uint8Array, be: boolean, bits: 32 | 64, mem?: binary.memory): Promise<void>;
+    getCommand<T extends CMD>(cmd: T): binary.ReadType<typeof cmd_table[T]>;
+    getSegment(name: string): {
+        data: binary.MappedMemory | undefined;
+        segname: string;
+        vmaddr: number;
+        vmsize: number;
+        fileoff: number;
+        filesize: number;
+        maxprot: number;
+        initprot: number;
+        nsects: number;
+        flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        sections: Record<string, any> | undefined;
+    } | {
+        data: binary.MappedMemory | undefined;
+        segname: string;
+        vmaddr: bigint;
+        vmsize: bigint;
+        fileoff: bigint;
+        filesize: bigint;
+        maxprot: number;
+        initprot: number;
+        nsects: number;
+        flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+        sections: Record<string, any> | undefined;
+    } | undefined;
+}
+export declare class FATMachFile {
+    archs: binary.ReadType<typeof fat_arch>[];
+    static check(data: Uint8Array): boolean;
+    constructor(data: Uint8Array, mem?: binary.memory);
+    load(file: binary.endianStream, mem?: binary.memory): void;
+}
+export {};

package/dist/mach.d.ts

@@ -61,15 +61,19 @@ export declare enum CMD {
     DYLD_CHAINED_FIXUPS = 2147483700
 }
 export declare class MachFile {
-    header: any;
-    commands: {
-        cmd: CMD;
-        data: any;
-    }[];
-    ready: Promise<void>;
     static check(data: Uint8Array): boolean;
+    header: {
+        magic: number;
+        cputype: string;
+        cpusubtype: string | number;
+        filetype: string;
+        ncmds: number;
+        sizeofcmds: number;
+        flags: Record<string, bigint | boolean> | Record<string, number | boolean>;
+    };
+    private commands;
     constructor(data: Uint8Array, mem?: binary.memory);
-    load(data: Uint8Array, be: boolean, bits: 32 | 64, mem?: binary.memory): Promise<void>;
+    load(data: Uint8Array, be: boolean, bits: 64 | 32, mem?: binary.memory): void;
     getCommand(cmd: CMD.SEGMENT): {
         data: binary.MappedMemory | undefined;
         segname: string;

package/dist/mach.js

@@ -966,9 +966,6 @@ const cmd_table = {
     },
 };
 class MachFile {
-    header;
-    commands = [];
-    ready;
     static check(data) {
         switch (binary.UINT32_BE.get(new binary.stream(data))) {
             case 0xfeedface:
@@ -980,25 +977,27 @@ class MachFile {
                 return false;
         }
     }
+    header;
+    commands = [];
     constructor(data, mem) {
         const magic = binary.UINT32_LE.get(new binary.stream(data));
         switch (magic) {
             case 0xfeedface:
-                this.ready = this.load(data, false, 32, mem);
+                this.load(data, false, 32, mem);
                 break;
             case 0xcefaedfe:
-                this.ready = this.load(data, true, 32, mem);
+                this.load(data, true, 32, mem);
                 break;
             case 0xfeedfacf:
-                this.ready = this.load(data, false, 64, mem);
+                this.load(data, false, 64, mem);
                 break;
             case 0xcffaedfe:
-                this.ready = this.load(data, true, 64, mem);
+                this.load(data, true, 64, mem);
                 break;
             default: throw new Error('not a mach file');
         }
     }
-    async load(data, be, bits, mem) {
+    load(data, be, bits, mem) {
         const file = new binary.endianStream(data, be);
         const h = binary.read(file, header);
         const cpu = CPU_TYPE[h.cputype];
@@ -1008,14 +1007,14 @@ class MachFile {
         for (let i = 0; i < h.ncmds; ++i) {
             const cmd = binary.read(file, command);
             const file2 = new mach_stream(data, file.read_buffer(cmd.cmdsize - 8), file.be, mem);
-            const result = await binary.read(file2, cmd_table[cmd.cmd] ?? {});
+            const result = binary.read(file2, cmd_table[cmd.cmd] ?? {});
             this.commands.push({ cmd: cmd.cmd, data: result });
         }
         this.header = h;
         const funcs = this.getCommand(CMD.FUNCTION_STARTS);
         if (funcs) {
             const array = funcs.contents;
-            const text = await this.getSegment('__TEXT');
+            const text = this.getSegment('__TEXT');
             let acc = BigInt(text?.vmaddr ?? 0);
             for (const i in array)
                 array[i] = (acc += BigInt(array[i]));