@specy/x86 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,223 +0,0 @@
-import { uc } from './x86/deps/unicorn-x86.min';
-import { ks } from './x86/deps/keystone-x86.min';
-import { cs } from './x86/deps/capstone-x86.min';
-import { X86InstructionCode, X86InstructionNames } from "./instructions";
-import { enumKeys } from "./utils";
-export { X86InstructionNames, X86InstructionCode, };
-export var X86ConditionFlags;
-(function (X86ConditionFlags) {
-    X86ConditionFlags[X86ConditionFlags["C"] = 0] = "C";
-    X86ConditionFlags[X86ConditionFlags["P"] = 1] = "P";
-    X86ConditionFlags[X86ConditionFlags["A"] = 2] = "A";
-    X86ConditionFlags[X86ConditionFlags["Z"] = 3] = "Z";
-    X86ConditionFlags[X86ConditionFlags["S"] = 4] = "S";
-    X86ConditionFlags[X86ConditionFlags["O"] = 5] = "O";
-})(X86ConditionFlags || (X86ConditionFlags = {}));
-export var X86Register;
-(function (X86Register) {
-    X86Register[X86Register["EAX"] = 19] = "EAX";
-    X86Register[X86Register["EBX"] = 21] = "EBX";
-    X86Register[X86Register["ECX"] = 22] = "ECX";
-    X86Register[X86Register["ESP"] = 30] = "ESP";
-    X86Register[X86Register["EBP"] = 20] = "EBP";
-    X86Register[X86Register["EDI"] = 23] = "EDI";
-    X86Register[X86Register["ESI"] = 29] = "ESI";
-    X86Register[X86Register["EDX"] = 24] = "EDX";
-})(X86Register || (X86Register = {}));
-export const X86_REGISTERS = enumKeys(X86Register);
-export const X86_STACK_POINTER_REGISTER = X86Register.ESP;
-export const X86_PROGRAM_COUNTER_REGISTER = 26;
-export const X86_FLAGS_REGISTER = 25;
-function signed32ToUnsigned32(value) {
-    if (value < 0) {
-        return value + Math.pow(2, 32);
-    }
-    return value;
-}
-function calculatePageSize(size) {
-    const pageSize = 4096;
-    return Math.ceil(size / pageSize) * pageSize;
-}
-function simplifyError(e) {
-    return typeof e === 'string' ? e : e.message;
-}
-export class X86Interpreter {
-    code;
-    assembler;
-    interpreter;
-    disambler;
-    constructor(code, assembler, interpreter, disambler) {
-        this.code = code;
-        this.assembler = assembler;
-        this.interpreter = interpreter;
-        this.disambler = disambler;
-    }
-    static START_ADDRESS = 0x1000;
-    static STACK_START_ADDRESS = 0xf0000;
-    static STACK_SIZE = 0xf0000;
-    codeBuffer = null;
-    instructions = [];
-    endAddress = 0;
-    hook = (handle, addr_lo, addr_hi, size, user_data) => {
-    };
-    getInstructions() {
-        try {
-            return this.disambler.disasm(this.codeBuffer, X86Interpreter.START_ADDRESS);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    assemble() {
-        try {
-            this.codeBuffer = this.assembler.asm(this.code);
-            const instructions = this.getInstructions();
-            this.instructions = instructions.map((ins, i) => {
-                return {
-                    address: ins.address,
-                    bytes: ins.bytes,
-                    size: ins.size,
-                    id: ins.id,
-                    text: `${ins.mnemonic} ${ins.op_str}`,
-                    name: ins.mnemonic,
-                    line: i,
-                };
-            });
-            this.endAddress = X86Interpreter.START_ADDRESS + this.codeBuffer.length;
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    initialize() {
-        if (!this.codeBuffer) {
-            throw new Error('Code buffer is not initialized. Please call assemble() first.');
-        }
-        this.interpreter.mem_map(X86Interpreter.START_ADDRESS, calculatePageSize(this.codeBuffer.length), uc.PROT_ALL);
-        this.interpreter.mem_write(X86Interpreter.START_ADDRESS, this.codeBuffer);
-        this.interpreter.mem_map(X86Interpreter.STACK_START_ADDRESS, calculatePageSize(X86Interpreter.STACK_SIZE), uc.PROT_ALL);
-        this.interpreter.reg_write_i32(X86Register.ESP, X86Interpreter.STACK_START_ADDRESS + X86Interpreter.STACK_SIZE);
-        this.interpreter.reg_write_i32(X86Register.EBP, X86Interpreter.STACK_START_ADDRESS + X86Interpreter.STACK_SIZE);
-        this.interpreter.reg_write_i32(X86_PROGRAM_COUNTER_REGISTER, X86Interpreter.START_ADDRESS);
-    }
-    simulate(limit) {
-        try {
-            const address = this.getProgramCounter();
-            this.interpreter.emu_start(address, this.endAddress, 0, limit);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    simulateWithBreakpoints(breakpoints, limit) {
-        const breakpointsMap = new Map(breakpoints.map((bp) => [bp, true]));
-        const handle = this.interpreter.hook_add(uc.HOOK_CODE, (_, address) => {
-            if (breakpointsMap.has(address)) {
-                this.interpreter.emu_stop();
-            }
-        });
-        try {
-            this.simulate(limit);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-        finally {
-            this.interpreter.hook_del(handle);
-        }
-    }
-    step() {
-        this.simulate(1);
-    }
-    getRegisterValue(register) {
-        try {
-            const signed = this.interpreter.reg_read_i32(register);
-            return signed32ToUnsigned32(signed);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    setRegisterValue(register, value) {
-        try {
-            this.interpreter.reg_write_i32(register, value);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    getStackPointer() {
-        return this.getRegisterValue(X86_STACK_POINTER_REGISTER);
-    }
-    getProgramCounter() {
-        return this.getRegisterValue(X86_PROGRAM_COUNTER_REGISTER);
-    }
-    getRegistersValues() {
-        return X86_REGISTERS.map((reg) => {
-            return this.getRegisterValue(X86Register[reg]);
-        });
-    }
-    readMemoryBytes(address, length) {
-        try {
-            return this.interpreter.mem_read(address, length);
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    setMemoryBytes(address, bytes) {
-        try {
-            this.interpreter.mem_write(address, bytes);
-        }
-        catch (e) {
-        }
-    }
-    getNextStatement() {
-        const pc = this.getProgramCounter();
-        const instruction = this.instructions.find((ins) => ins.address === pc);
-        return instruction ?? null;
-    }
-    isTerminated() {
-        return this.getNextStatement() === null;
-    }
-    getConditionFlags() {
-        const flags = this.interpreter.reg_read_i32(X86_FLAGS_REGISTER);
-        return {
-            [X86ConditionFlags.C]: (flags >> 0) & 1,
-            [X86ConditionFlags.P]: (flags >> 2) & 1,
-            [X86ConditionFlags.A]: (flags >> 4) & 1,
-            [X86ConditionFlags.Z]: (flags >> 6) & 1,
-            [X86ConditionFlags.S]: (flags >> 7) & 1,
-            [X86ConditionFlags.O]: (flags >> 11) & 1,
-        };
-    }
-    getStatementAtAddress(address) {
-        const instruction = this.instructions.find((ins) => ins.address === address);
-        return instruction ?? null;
-    }
-    getSource() {
-        this.instructions.map((ins) => ins.text).join('/n');
-    }
-    getStatementAtSourceLine(lineIndex) {
-        return this.instructions[lineIndex] ?? null;
-    }
-    getAssembledStatements() {
-        return this.instructions;
-    }
-    static create(code) {
-        try {
-            const keystone = new ks.Keystone(ks.ARCH_X86, ks.MODE_32);
-            keystone.option(ks.OPT_SYNTAX, ks.OPT_SYNTAX_INTEL);
-            const interpreter = new X86Interpreter(code, keystone, new uc.Unicorn(uc.ARCH_X86, uc.MODE_32), new cs.Capstone(cs.ARCH_X86, cs.MODE_32));
-            return interpreter;
-        }
-        catch (e) {
-            throw new Error(simplifyError(e));
-        }
-    }
-    dispose() {
-        this.interpreter.close();
-        this.assembler.close();
-        this.disambler.close();
-    }
-}