reverse-skills-max: initial public release (restored, redacted, hardened)

vendor-new/js-reverse-automation--skill/js-reverse-automation/scripts/hook_templates.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Hook template generator.
+
+Generates various hook templates for common browser APIs.
+
+Usage:
+  python3 scripts/hook_templates.py --type cookie --output generated/hooks/cookie.js
+  python3 scripts/hook_templates.py --type all --output generated/hooks/
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+TEMPLATES = {
+    "cookie": r'''
+// Cookie Hook - Monitor document.cookie access
+(function() {
+  let _cookie = document.cookie;
+  const originalDesc = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
+
+  Object.defineProperty(document, 'cookie', {
+    get: function() {
+      console.log('[HOOK] cookie.get:', _cookie.substring(0, 100));
+      return _cookie;
+    },
+    set: function(value) {
+      console.log('[HOOK] cookie.set:', value.substring(0, 200));
+      _cookie = value;
+      if (originalDesc && originalDesc.set) {
+        originalDesc.set.call(document, value);
+      }
+    },
+    configurable: true
+  });
+  console.log('[HOOK] cookie hook installed');
+})();
+''',
+
+    "xhr": r'''
+// XMLHttpRequest Hook - Monitor XHR open/send
+(function() {
+  const originalOpen = XMLHttpRequest.prototype.open;
+  const originalSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function(method, url) {
+    this.__hook = { method, url, timestamp: Date.now() };
+    console.log('[HOOK] xhr.open:', method, url);
+    return originalOpen.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.send = function(body) {
+    if (this.__hook) {
+      this.__hook.body = body;
+      console.log('[HOOK] xhr.send:', this.__hook.method, this.__hook.url,
+        body ? body.substring(0, 200) : '(no body)');
+    }
+    return originalSend.apply(this, arguments);
+  };
+  console.log('[HOOK] xhr hook installed');
+})();
+''',
+
+    "fetch": r'''
+// Fetch Hook - Monitor fetch calls
+(function() {
+  const originalFetch = window.fetch;
+  window.fetch = function(input, init) {
+    const url = typeof input === 'string' ? input : input && input.url;
+    const method = (init && init.method) || 'GET';
+    const body = init && init.body;
+    console.log('[HOOK] fetch:', method, url, body ? body.substring(0, 200) : '(no body)');
+    return originalFetch.apply(this, arguments);
+  };
+  console.log('[HOOK] fetch hook installed');
+})();
+''',
+
+    "eval": r'''
+// Eval Hook - Monitor eval/Function calls
+(function() {
+  const originalEval = window.eval;
+  const originalFunction = window.Function;
+
+  window.eval = function(code) {
+    console.log('[HOOK] eval:', typeof code === 'string' ? code.substring(0, 200) : typeof code);
+    return originalEval.apply(this, arguments);
+  };
+
+  window.Function = function(...args) {
+    console.log('[HOOK] new Function:', args.length, 'args');
+    return originalFunction.apply(this, args);
+  };
+  console.log('[HOOK] eval hook installed');
+})();
+''',
+
+    "json": r'''
+// JSON Hook - Monitor JSON.parse/stringify
+(function() {
+  const originalParse = JSON.parse;
+  const originalStringify = JSON.stringify;
+
+  JSON.parse = function(text) {
+    console.log('[HOOK] JSON.parse:', typeof text === 'string' ? text.substring(0, 200) : typeof text);
+    return originalParse.apply(this, arguments);
+  };
+
+  JSON.stringify = function(value) {
+    const result = originalStringify.apply(this, arguments);
+    console.log('[HOOK] JSON.stringify:', result.substring(0, 200));
+    return result;
+  };
+  console.log('[HOOK] json hook installed');
+})();
+''',
+
+    "base64": r'''
+// Base64 Hook - Monitor atob/btoa
+(function() {
+  const originalAtob = window.atob;
+  const originalBtoa = window.btoa;
+
+  window.atob = function(encoded) {
+    console.log('[HOOK] atob:', encoded.substring(0, 100));
+    return originalAtob.apply(this, arguments);
+  };
+
+  window.btoa = function(text) {
+    console.log('[HOOK] btoa:', text.substring(0, 100));
+    return originalBtoa.apply(this, arguments);
+  };
+  console.log('[HOOK] base64 hook installed');
+})();
+''',
+
+    "websocket": r'''
+// WebSocket Hook - Monitor WebSocket messages
+(function() {
+  const originalSend = WebSocket.prototype.send;
+
+  WebSocket.prototype.send = function(data) {
+    console.log('[HOOK] ws.send:', typeof data === 'string' ? data.substring(0, 200) : typeof data);
+    return originalSend.apply(this, arguments);
+  };
+  console.log('[HOOK] websocket hook installed');
+})();
+''',
+
+    "crypto": r'''
+// Crypto Hook - Monitor crypto.subtle operations
+(function() {
+  if (!window.crypto || !window.crypto.subtle) return;
+
+  const original = window.crypto.subtle;
+  const methods = ['encrypt', 'decrypt', 'digest', 'sign', 'verify', 'generateKey', 'importKey', 'exportKey'];
+
+  methods.forEach(method => {
+    if (original[method]) {
+      const originalMethod = original[method].bind(original);
+      original[method] = function(...args) {
+        console.log('[HOOK] crypto.subtle.' + method, args.length, 'args');
+        return originalMethod.apply(this, args);
+      };
+    }
+  });
+  console.log('[HOOK] crypto hook installed');
+})();
+''',
+}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Hook template generator.")
+    parser.add_argument("--type", required=True, choices=list(TEMPLATES.keys()) + ["all"],
+                        help="Hook type to generate.")
+    parser.add_argument("--output", required=True, help="Output file or directory.")
+    args = parser.parse_args()
+
+    output = Path(args.output)
+
+    if args.type == "all":
+        output.mkdir(parents=True, exist_ok=True)
+        for name, template in TEMPLATES.items():
+            (output / f"{name}.js").write_text(template.strip(), encoding="utf-8")
+        print(f"[OK] all hooks written to {output}")
+    else:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(TEMPLATES[args.type].strip(), encoding="utf-8")
+        print(f"[OK] {args.type} hook written to {output}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())