Disassemble bytecode

Author: fergarrui

package-lock.json

@@ -66,8 +66,6 @@
   },
   "dependencies": {
     "@types/express": "^4.16.0",
-    "@webassemblyjs/leb128": "^1.8.5",
-    "@webassemblyjs/wasm-parser": "^1.8.5",
     "async-polling": "^0.2.1",
     "bn.js": "^4.11.8",
     "body-parser": "^1.18.3",

package.json

@@ -1,3 +1,5 @@
+import { Int64 } from "./Int64";
+
 export class BytesReader {
 
   private pointer: number
@@ -43,7 +45,7 @@ export class BytesReader {
     return result
   }
 
-  private readVarInt32(): number {
+  readVarInt32(): number {
     var result = 0
     var shift = 0
     while (true) {
@@ -61,6 +63,32 @@ export class BytesReader {
     return (result << ashift) >> ashift
   }
 
+  readVarInt64(): number {
+    var result = new Uint8Array(8);
+    var i = 0;
+    var c = 0;
+    var shift = 0;
+    while (true) {
+      var byte = parseInt(this.readBytesToHex(1), 16)
+      c |= (byte & 0x7F) << shift;
+      shift += 7;
+      if (shift > 8) {
+        result[i++] = c & 0xFF;
+        c >>= 8;
+        shift -= 8;
+      }
+      if ((byte & 0x80) === 0)
+        break;
+    }
+    var ashift = (32 - shift);
+    c = (c << ashift) >> ashift;
+    while (i < 8) {
+      result[i++] = c & 0xFF;
+      c >>= 8;
+    }
+    return new Int64(result).toDouble();
+  }
+
   getPointer(): number {
     return this.pointer
   }

src/api/bytecode/ewasm/BytesReader.ts

@@ -1,11 +1,31 @@
 import { WasmValueType } from "./wasmTypes";
+import { WasmOpcode, WasmOpcodes } from "./WasmOpcodes";
 
 export interface FunctionBody {
   locals: FunctionLocal[]
   bytecodeHex: string
+  opcodes: WasmOpcode[]
+  formattedOpcodes: string
 }
 
 export interface FunctionLocal {
   count: number
   valueType: WasmValueType
 }
+
+export const formatOpcodes = (opcodes: WasmOpcode[]): string => {
+  const newLine = '\n'
+  const tab = '  '
+  let formattedCode = ''
+  let indentation = 0
+  for (const op of opcodes) {
+    formattedCode += `${tab.repeat(indentation)}${op.opcode.name} ${op.immediates}`
+    formattedCode += newLine
+    if (WasmOpcodes.isBlockStart(op)) {
+      indentation++
+    } else if (WasmOpcodes.isBlockEnd(op)) {
+      indentation--
+    }
+  }
+  return formattedCode
+}

src/api/bytecode/ewasm/FunctionBody.ts

@@ -0,0 +1,28 @@
+export class Int64 {
+
+  private _data: Uint8Array;
+
+  constructor (data) {
+    this._data = data || new Uint8Array(8);
+  }
+  
+  public toInt32(): number {
+    return this._data[0] | (this._data[1] << 8) | (this._data[2] << 16) | (this._data[3] << 24);
+  }
+  
+  public toDouble(): number {
+    var power = 1;
+    var sum;
+    if (this._data[7] & 0x80) {
+      sum = -1;
+      for (var i = 0; i < 8; i++, power *= 256)
+        sum -= power * (0xFF ^ this._data[i]);
+    } else {
+      sum = 0;
+      for (var i = 0; i < 8; i++, power *= 256)
+        sum += power * this._data[i];
+    }
+    return sum;
+  }
+  
+}

src/api/bytecode/ewasm/Int64.ts

@@ -0,0 +1,8 @@
+export enum OpcodeImmediateType {
+
+  U32, // varuint32
+  I32, // varuint32
+  I64, // varint64
+  BYTE,
+  VECTOR_U32
+}

src/api/bytecode/ewasm/OpcodeImmediateType.ts

@@ -4,7 +4,9 @@ import { BytesReader } from "./BytesReader";
 import { WasmSection, WasmTypeSectionPayload, WasmSectionPayload, WasmExportSectionPayload, WasmCodeSectionPayload } from "./WasmSection";
 import { WasmSectionType, WasmType, WasmValueType, getWasmValueType, getExternalType } from "./wasmTypes";
 import { FuncType } from "./FuncType";
-import { FunctionBody, FunctionLocal } from "./FunctionBody";
+import { FunctionBody, FunctionLocal, formatOpcodes } from "./FunctionBody";
+import { WasmOpcode, WasmOpcodeDefinition, WasmOpcodes, Immediate } from "./WasmOpcodes";
+import { OpcodeImmediateType } from "./OpcodeImmediateType";
 
 
 @injectable()
@@ -35,24 +37,34 @@ export class WasmBinaryParser {
       throw new Error(`WASM binary version=${version}, supported=${this.WASM_V1}`)
     }
 
-    const wasmSections: WasmSection[] = []
+    const sections: WasmSection[] = []
     while(!reader.finished()) {
       const sectionId = reader.readBytesToNumber(1)
       const sectionType = WasmSectionType[sectionId.toString()]
       const payloadLength = reader.readVarUint32()
       const payloadData = reader.readBytes(payloadLength)
       const payloadHex = payloadData.toString('hex')
       const payload = this.parseSectionPayload(payloadData, sectionId)
-      wasmSections.push({
+      sections.push({
         sectionType,
-        payloadLength,
-        payloadData,
         payloadHex,
         payload
       })
     }
-    console.log(JSON.stringify(wasmSections))
-    return
+
+    // removeme
+    const sec = sections.find(section =>  {
+      return section.sectionType.toString() == WasmSectionType[WasmSectionType.Code.toString()]
+    });
+    const outp: WasmCodeSectionPayload = sec.payload as WasmCodeSectionPayload;
+    // console.log(JSON.stringify(outp.functions[1]))
+    const mapp = outp.functions[3].opcodes.map(p => `[0x${p.opcode.code.toString(16)}] ${p.opcode.name} ${p.immediates}`)
+    // console.log(mapp)
+    console.log(outp.functions[2].formattedOpcodes)
+    // console.log(JSON.stringify(wasmSections))
+    return {
+      sections
+    }
   }
 
   parseSectionPayload(payload: Buffer, sectionId: number): WasmSectionPayload {
@@ -142,12 +154,54 @@ export class WasmBinaryParser {
       })
       localsCounter++
     }
-    const functionInstructions = reader.readBytes(body.length - reader.getPointer())
-    const bytecodeHex = functionInstructions.toString('hex')
+    const bytecodeBuffer: Buffer = reader.readBytes(body.length - reader.getPointer())
+    const opcodes: WasmOpcode[] = this.parseFunctionBytecode(bytecodeBuffer)
+    const bytecodeHex: string = bytecodeBuffer.toString('hex')
+    const formattedOpcodes = formatOpcodes(opcodes)
     return {
       bytecodeHex,
-      locals
+      locals,
+      opcodes,
+      formattedOpcodes
+    }
+  }
+
+  parseFunctionBytecode(bytecode: Buffer): WasmOpcode[] {
+    const reader = new BytesReader(bytecode)
+    const opcodes: WasmOpcode[] = []
+    while(!reader.finished()) {
+      const opcodeByte = reader.readBytesToNumber(1)
+      const immediates: string[] = []
+      const opcodeDefinition: WasmOpcodeDefinition = WasmOpcodes.getDefinition(opcodeByte)
+      if(!opcodeDefinition) {
+        throw new Error(`Opcode not implemented: ${opcodeByte} [${opcodeByte.toString(16)}]`)
+      }
+      for(const immediate of opcodeDefinition.immediates) {
+        // TODO refactor
+        if (immediate.type === OpcodeImmediateType.U32) {
+          const immediateValue = reader.readVarUint32()
+          const valueFormatted = immediateValue < 0? `-0x${(immediateValue * -1).toString(16)}`: `0x${immediateValue.toString(16)}`
+          immediates.push(valueFormatted)
+        } else if (immediate.type === OpcodeImmediateType.I32) {
+          const immediateValue = reader.readVarInt32()
+          const valueFormatted = immediateValue < 0? `-0x${(immediateValue * -1).toString(16)}`: `0x${immediateValue.toString(16)}`
+          immediates.push(valueFormatted)
+        } else if (immediate.type === OpcodeImmediateType.I64) {
+          const immediateValue = reader.readVarInt64()
+          const valueFormatted = immediateValue < 0? `-0x${(immediateValue * -1).toString(16)}`: `0x${immediateValue.toString(16)}`
+          immediates.push(valueFormatted)
+        } else if (immediate.type === OpcodeImmediateType.BYTE) {
+          const immediateValue = reader.readBytesToNumber(1)
+          const valueFormatted = immediateValue < 0? `-0x${(immediateValue * -1).toString(16)}`: `0x${immediateValue.toString(16)}`
+          immediates.push(valueFormatted)
+        }
+      }
+      opcodes.push({
+        opcode: opcodeDefinition,
+        immediates
+      })
     }
+    return opcodes
   }
 
   parseFuncType(reader: BytesReader, index: number): FuncType {