Ewasm support

.gitignore

@@ -5,3 +5,7 @@ dist/*
 coverage/*
 .vscode/*
 contracts/*
+*.txt
+*.json
+*.cfg
+*.viz

README.md

@@ -61,9 +61,14 @@ Add contracts to `./contracts` (you will need to create the directory) and empty
   * Scan the directory as described above
   * You won't get source code mappings when clicking in operations of the CFG
 
+### eWASM /  WASM analysis
+
+A `.wasm` file can be analyzed. Check [(e)Wasm Readme](./WASM.md) for more details
+
 # Features
 
   * **Now interactive** :star2:: it has a sepparate frontend and API instead of building a static HTML file like in earlier versions
+  * Initial **eWASM/WASM** support added
   * **Control flow graph**: the CFG can be built without debugging a transaction.
   * **Disassembler**: just disassembled opcodes can be seen, from runtime and constructor
   * **Source mapping**: snippet of code related to the selected instruction is highlighted in the editor left panel
@@ -83,3 +88,4 @@ Add contracts to `./contracts` (you will need to create the directory) and empty
   * ~~Only runtime debugging is supported for now (no constructor)~~
   * You must run it against a node that supports `debug_traceTransaction`, like Geth or Ganache, therefore, Infura is not supported
   * It was rewritten, so new bugs may appear
+  * eWASM/WASM cannot be debugged yet

WASM.md

@@ -0,0 +1,35 @@
+# (e)WASM
+
+If there are `.wasm` files in the provided path they can be analyzed.
+For now debugging is not possible.
+
+The analysis will:
+* Parse the WASM binary
+* Identify WASM binary sections (for now they are not shown, but there will be a 'Summary' section)
+* Functions call graph
+* Functions are detected, bytecode is disassembled
+* Functions control flow graph
+* Some symbols are resolved with exported names if possible to make graphs/bytecode more readable
+
+TODO:
+
+* Analyze a (e)WASM contract address (API ready, FE in progress)
+* Show more details about the binary (preloaded memory, elements, etc)
+
+### Function call graph
+
+Example of a function CFG:
+
+![Function CFG](./images/function_cfg.png)
+
+### Function disassembled bytecode
+
+Example of a function bytecode:
+
+![Function Bytecode](./images/function_bytecode.png)
+
+### Wasm module callgraph
+
+Example of a WASM module callgraph
+
+![Module callgraph](./images/callgraph.png)

package.json

@@ -79,6 +79,7 @@
     "bn.js": "^4.11.8",
     "body-parser": "^1.18.3",
     "brace": "^0.11.1",
+    "command-exists": "^1.2.8",
     "copyfiles": "^2.1.0",
     "d3": "^5.7.0",
     "d3-graphviz": "^2.6.0",
@@ -101,7 +102,9 @@
     "reflect-metadata": "^0.1.12",
     "solc": "^0.5.8",
     "terser": "3.14.1",
+    "tmp": "^0.1.0",
     "tsoa": "2.3.81",
+    "wabt": "^1.0.12",
     "web3": "1.0.0-beta.37",
     "winston": "^2.2.0"
   },
@@ -135,6 +138,7 @@
     "sinon": "^8.0.2",
     "style-loader": "^0.23.1",
     "ts-jest": "^22.4.6",
+    "ts-node": "^8.5.4",
     "tslint-config-prettier": "^1.14.0",
     "typescript": "^3.1.3",
     "webpack": "^4.25.1",

src/api/bytecode/EVMDisassembler.ts

@@ -1,6 +1,6 @@
 import { Disassembler } from './Disassembler'
 import { Operation } from './Operation'
-import { Opcodes } from './Opcodes'
+import { EVMOpcodes } from './EVMOpcodes'
 import { injectable, inject } from 'inversify'
 import { Opcode } from './Opcode'
 import { DisassembledContract } from './DisassembledContract'
@@ -106,7 +106,7 @@ export class EVMDisassembler implements Disassembler {
 
     for (let i = 0; i < operations.length; i++) {
       const code = operations[i]
-      const opcode: Opcode = Opcodes.opcodes[parseInt(code, 16)] || Opcodes.opcodes[-1]
+      const opcode: Opcode = EVMOpcodes.opcodes[parseInt(code, 16)] || EVMOpcodes.opcodes[-1]
       if (this.isPush(opcode)) {
         const parameters = opcode.parameters
         const argument = `${operations.slice(i + 1, i + parameters + 1).join('')}`

src/api/bytecode/Opcodes.ts → src/api/bytecode/EVMOpcodes.ts

@@ -1,6 +1,6 @@
 import { Opcode } from './Opcode'
 
-export class Opcodes {
+export class EVMOpcodes {
   static opcodes = {}
 
   static populate() {
@@ -161,4 +161,4 @@ export class Opcodes {
   }
 }
 
-Opcodes.populate()
+EVMOpcodes.populate()

src/api/bytecode/ewasm/BytesReader.ts

@@ -0,0 +1,99 @@
+import { Int64 } from "./Int64";
+
+export class BytesReader {
+
+  private pointer: number
+  private buffer: Buffer
+
+  constructor(buffer: Buffer) {
+    this.buffer = buffer
+    this.pointer = 0
+  }
+
+  readBytes(bytesNumber: number): Buffer {
+    const result = this.buffer.slice(this.pointer, bytesNumber + this.pointer)
+    this.pointer += bytesNumber
+    return result
+  }
+
+  readBytesToHex(bytesNumber: number): string {
+    const result = this.readBytes(bytesNumber)
+    return result.toString('hex')
+  }
+
+  readBytesToNumber(bytesNumber: number): number {
+    const result = this.readBytesToHex(bytesNumber)
+    return parseInt(result, 16)
+  }
+
+  readBytesToUtf8String(bytesNumber: number): string {
+    const result = this.readBytes(bytesNumber)
+    return result.toString('utf8')
+  }
+
+  readVarUint32(): number {
+    var result = 0
+    var shift = 0
+    while (true) {
+      var byte = parseInt(this.readBytesToHex(1), 16)
+      result |= (byte & 0x7F) << shift
+      shift += 7
+      if ((byte & 0x80) === 0){
+        break
+      }
+    }
+    return result
+  }
+
+  readVarInt32(): number {
+    var result = 0
+    var shift = 0
+    while (true) {
+      var byte = parseInt(this.readBytesToHex(1), 16)
+      result |= (byte & 0x7F) << shift
+      shift += 7
+      if ((byte & 0x80) === 0) {
+        break;
+      }
+    }
+    if (shift >= 32) {
+      return result
+    }
+    var ashift = (32 - shift)
+    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
+  }
+
+  finished(): boolean {
+    return this.pointer >= this.buffer.length
+  }
+}

src/api/bytecode/ewasm/EWasmModuleResponse.ts

@@ -0,0 +1,7 @@
+import { WasmBinary } from "./WasmBinary";
+
+export interface EWasmModuleResponse {
+  binary: WasmBinary
+  dotCallGraph: string
+  functionsCfg: string[]
+}

src/api/bytecode/ewasm/ExportEntry.ts

@@ -0,0 +1,7 @@
+import { WasmExternalKind } from "./wasmTypes";
+
+export interface ExportEntry {
+  name: string
+  kind: WasmExternalKind
+  index: number
+}

src/api/bytecode/ewasm/FuncType.ts

@@ -0,0 +1,26 @@
+import { WasmValueType } from "./wasmTypes";
+
+export interface FuncType {
+  params: WasmValueType[]
+  results: WasmValueType[]
+}
+
+export const printSignature = (index: number, funcType: FuncType): string => {
+  let signature = `func_${index}(`
+  signature += funcType.params.map(p => p.toString()).join(',')
+  signature += ')'
+  signature += ':'
+  const results = funcType.results.length > 0 ? funcType.results.map(r => r.toString()).join(',') : 'void'
+  signature += results
+  return signature
+}
+
+export const printSignatureForGraph = (index: number, funcType: FuncType): string => {
+  let signature = `type_${index}_params_`
+  signature += funcType.params.map(p => p.toString()).join('_')
+  signature += '_'
+  signature += 'results_'
+  const results = funcType.results.length > 0 ? funcType.results.map(r => r.toString()).join('_') : 'void'
+  signature += results
+  return signature
+}