feat: automatic parse functions for use

Author: LittleSwift

electron/main.js

@@ -6,10 +6,13 @@ import Binaryen from "binaryen";
 import * as fs from "node:fs";
 import express from "express";
 import serveIndex from "serve-index";
+import {parseRules} from "./parse.js";
 
 const isDev = process.env.NODE_ENV === 'development';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const rules = JSON.parse(fs.readFileSync(path.join(__dirname, "rules.json"), "utf-8"));
+
 
 function createWindow() {
   const win = new BrowserWindow({
@@ -43,6 +46,13 @@ function createWindow() {
         let buffer = Buffer.concat(chunks);
 
         try {
+          const parsed = parseRules(buffer, rules);
+          const parsedFunctions = {};
+
+          for (let key in parsed) {
+            parsedFunctions[key] = parsed[key].substring(5);
+          }
+
           const module = Binaryen.readBinary(buffer);
 
           const newModule = Binaryen.readBinary(buffer);
@@ -296,33 +306,33 @@ function createWindow() {
             WebAssembly.instantiate = async function(buffer, imports = {}) {
               const wasmFunctionNames = ${JSON.stringify(funcNames)};
               window.ayuHooks.functions = wasmFunctionNames;
-        
+              window.ayuHooks.parsedFunctions = ${JSON.stringify(parsedFunctions)};
+              
               if (!imports.hooks) imports.hooks = {};
-        
+              
               Object.values(wasmFunctionNames).forEach(name => {
                 const preName = 'pre_' + name;
                 const postName = 'post_' + name;
-        
+                
                 if (!imports.hooks[preName]) {
                   imports.hooks[preName] = (...args) => {
                     // console.log('Calling hook:', preName, 'with args:', args);
                     return window.ayuHooks?.[preName]?.(...args) ? 0 : 1;
                   };
                 }
-        
+                
                 if (!imports.hooks[postName]) {
                   imports.hooks[postName] = (ret) => {
                     // console.log('Calling hook:', postName, 'with return value:', ret);
                     return window.ayuHooks?.[postName]?.(ret) ?? ret;
                   };
                 }
               });
-        
+              
               return originalInstantiate.call(this, buffer, imports);
             };
           `);
 
-          // await new Promise(resolve=>fs.writeFile("out.wat", newModule.emitText(), resolve));
           console.log("Validate");
           newModule.validate();
           console.log("Validate pass");

electron/parse.js

@@ -0,0 +1,70 @@
+import { decode } from "@webassemblyjs/wasm-parser";
+import { traverse } from "@webassemblyjs/ast";
+
+export function parseRules(wasmBytes, rules) {
+  const ast = decode(wasmBytes);
+
+  const funcs = [];
+
+  traverse(ast, {
+    Func({ node }) {
+      if (node.signature) {
+        funcs.push(node);
+      }
+    }
+  });
+
+  function matchParams(wasmParams, ruleParams) {
+    if (!ruleParams) return true;
+    const paramTypes = wasmParams.map(p => p.valtype);
+    return JSON.stringify(paramTypes) === JSON.stringify(ruleParams);
+  }
+
+  function matchBody(instrs, ruleBody) {
+    if (!ruleBody) return true;
+    let j = 0;
+    for (let i = 0; i < instrs.length && j < ruleBody.length; i++) {
+      const instr = instrs[i];
+      const pat = ruleBody[j];
+      const actualInstr = instr.object ? instr.object + '.' + instr.id : instr.id;
+      if (actualInstr === pat) {
+        j++;
+      } else {
+        j = 0;
+      }
+    }
+    return j === ruleBody.length;
+  }
+
+  const matches = {};
+  for (let i = 0; i < funcs.length; i++) {
+    const type = funcs[i].signature;
+    const body = funcs[i].body;
+    if(funcs[i].name.value=="func_2564"){
+      debugger;
+    }
+
+    for (const rule of rules) {
+      if (
+        matchParams(type?.params || [], rule.param) &&
+        matchBody(body, rule.body)
+      ) {
+        if (rule.parsedName) {
+          if (matches[rule.parsedName] !== undefined) {
+            throw new Error(
+              `Rule "${rule.parsedName}" is matching multiple functions: [${matches[rule.parsedName]}, ${funcs[i].name.value}]`
+            );
+          }
+          matches[rule.parsedName] = funcs[i].name.value;
+        }
+      }
+    }
+  }
+
+  for (const rule of rules) {
+    if (rule.parsedName && !Object.keys(matches).includes(rule.parsedName)) {
+      throw new Error(`Rule "${rule.parsedName}" is not matching any functions`);
+    }
+  }
+  return matches;
+}

electron/rules.json

@@ -0,0 +1,17 @@
+[
+  {
+    "parsedName": "main",
+    "body": [
+      "get_global",
+      "i32.const",
+      "i32.sub",
+      "tee_local",
+      "set_global",
+      "i32.const",
+      "call",
+      "i32.const",
+      "u32.load8_u",
+      "i32.eqz"
+    ]
+  }
+]

package.json

@@ -18,6 +18,8 @@
   },
   "dependencies": {
     "@jsprismarine/brigadier": "^0.13.1",
+    "@webassemblyjs/ast": "^1.14.1",
+    "@webassemblyjs/wasm-parser": "^1.14.1",
     "binaryen": "^123.0.0",
     "dom-to-image": "^2.6.0",
     "express": "^5.1.0",