feat: support auto decompiling with cfr

2026-09-25 16:31:53 +08:00 · 2026-08-30 21:19:42 +08:00
parent b74c8f6155
commit 305bc0e12c
19 changed files with 692 additions and 29 deletions
@@ -0,0 +1,143 @@
+import type { DecompiledClass, DecompileRequest, DecompileResponse } from "./decompile.worker";
+import type { MemShellResult } from "@/types/memshell";
+
+import { useEffect, useState } from "react";
+
+export interface DecompiledSources {
+  shell: DecompiledClass | null;
+  injector: DecompiledClass | null;
+}
+
+interface DecompileState {
+  sources: DecompiledSources;
+  isDecompiling: boolean;
+  error: string | null;
+}
+
+const IDLE: DecompileState = {
+  sources: { shell: null, injector: null },
+  isDecompiling: false,
+  error: null,
+};
+
+const CACHE_LIMIT = 8;
+const cache = new Map<string, DecompiledSources>();
+
+function cacheGet(key: string) {
+  const value = cache.get(key);
+  if (value) {
+    cache.delete(key);
+    cache.set(key, value);
+  }
+  return value;
+}
+
+function cacheSet(key: string, value: DecompiledSources) {
+  cache.set(key, value);
+  if (cache.size > CACHE_LIMIT) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+}
+
+/** FNV-1a over both base64 payloads; cheap identity for one generation. */
+function cacheKey(shellBytes: string, injectorBytes: string) {
+  let hash = 0x811c9dc5;
+  for (const str of [shellBytes, injectorBytes]) {
+    for (let i = 0; i < str.length; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = Math.imul(hash, 0x01000193);
+    }
+  }
+  return `${(hash >>> 0).toString(36)}:${shellBytes.length}:${injectorBytes.length}`;
+}
+
+let worker: Worker | null = null;
+let nextId = 0;
+const pending = new Map<
+  number,
+  { resolve: (value: DecompiledSources) => void; reject: (reason: Error) => void }
+>();
+
+function getWorker() {
+  if (!worker) {
+    worker = new Worker(new URL("./decompile.worker.ts", import.meta.url), { type: "module" });
+    worker.onmessage = (event: MessageEvent<DecompileResponse>) => {
+      const { id, shell, injector, error } = event.data;
+      const entry = pending.get(id);
+      if (!entry) return;
+      pending.delete(id);
+      if (error || !shell || !injector) {
+        entry.reject(new Error(error ?? "decompile failed"));
+      } else {
+        entry.resolve({ shell, injector });
+      }
+    };
+    worker.onerror = (event) => {
+      const reason = new Error(event.message || "decompile worker failed");
+      for (const entry of pending.values()) entry.reject(reason);
+      pending.clear();
+    };
+  }
+  return worker;
+}
+
+function decompileInWorker(request: Omit<DecompileRequest, "id">) {
+  return new Promise<DecompiledSources>((resolve, reject) => {
+    const id = nextId++;
+    pending.set(id, { resolve, reject });
+    getWorker().postMessage({ ...request, id } satisfies DecompileRequest);
+  });
+}
+
+export function useDecompiledSources(generateResult: MemShellResult | undefined) {
+  const shellClassName = generateResult?.shellClassName;
+  const shellBytesBase64 = generateResult?.shellBytesBase64Str;
+  const injectorClassName = generateResult?.injectorClassName;
+  const injectorBytesBase64 = generateResult?.injectorBytesBase64Str;
+
+  const [state, setState] = useState<DecompileState>(IDLE);
+
+  useEffect(() => {
+    if (!shellClassName || !shellBytesBase64 || !injectorClassName || !injectorBytesBase64) {
+      setState(IDLE);
+      return;
+    }
+
+    const key = cacheKey(shellBytesBase64, injectorBytesBase64);
+    const cached = cacheGet(key);
+    if (cached) {
+      setState({ sources: cached, isDecompiling: false, error: null });
+      return;
+    }
+
+    let cancelled = false;
+    setState({ sources: { shell: null, injector: null }, isDecompiling: true, error: null });
+
+    decompileInWorker({
+      shellClassName,
+      shellBytesBase64,
+      injectorClassName,
+      injectorBytesBase64,
+    })
+      .then((sources) => {
+        cacheSet(key, sources);
+        if (!cancelled) setState({ sources, isDecompiling: false, error: null });
+      })
+      .catch((error: unknown) => {
+        if (!cancelled) {
+          setState({
+            sources: { shell: null, injector: null },
+            isDecompiling: false,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [injectorBytesBase64, injectorClassName, shellBytesBase64, shellClassName]);
+
+  return state;
+}