deepspider 0.1.0

package/src/env/CryptoHook.js

@@ -0,0 +1,205 @@
+/**
+ * DeepSpider - 加密函数 Hook
+ * 运行时捕获加密函数的参数和密钥
+ */
+
+import { HookBase } from './HookBase.js';
+
+export class CryptoHook {
+  /**
+   * 生成 CryptoJS Hook 代码
+   */
+  generateCryptoJSHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  if (typeof CryptoJS !== 'undefined') {
+    // AES
+    ['encrypt', 'decrypt'].forEach(method => {
+      if (CryptoJS.AES && CryptoJS.AES[method]) {
+        const original = CryptoJS.AES[method];
+        CryptoJS.AES[method] = deepspider.native(function(data, key, options) {
+          const entry = deepspider.log('crypto', {
+            algo: 'CryptoJS.AES.' + method,
+            data: String(data).slice(0, 100),
+            key: String(key),
+            options: JSON.stringify(options)
+          });
+          deepspider.linkCrypto(entry);
+          return original.apply(this, arguments);
+        }, original);
+      }
+    });
+
+    // DES
+    if (CryptoJS.DES) {
+      ['encrypt', 'decrypt'].forEach(method => {
+        if (CryptoJS.DES[method]) {
+          const original = CryptoJS.DES[method];
+          CryptoJS.DES[method] = deepspider.native(function(data, key) {
+            const entry = deepspider.log('crypto', {
+              algo: 'CryptoJS.DES.' + method,
+              data: String(data).slice(0, 100),
+              key: String(key)
+            });
+            deepspider.linkCrypto(entry);
+            return original.apply(this, arguments);
+          }, original);
+        }
+      });
+    }
+
+    // Hash
+    ['MD5', 'SHA1', 'SHA256', 'SHA512'].forEach(algo => {
+      if (CryptoJS[algo]) {
+        const original = CryptoJS[algo];
+        CryptoJS[algo] = deepspider.native(function(message) {
+          const entry = deepspider.log('crypto', { algo: 'CryptoJS.' + algo, message: String(message).slice(0, 100) });
+          deepspider.linkCrypto(entry);
+          return original.apply(this, arguments);
+        }, original);
+      }
+    });
+
+    // HMAC
+    ['HmacMD5', 'HmacSHA1', 'HmacSHA256', 'HmacSHA512'].forEach(algo => {
+      if (CryptoJS[algo]) {
+        const original = CryptoJS[algo];
+        CryptoJS[algo] = deepspider.native(function(message, key) {
+          const entry = deepspider.log('crypto', { algo: 'CryptoJS.' + algo, message: String(message).slice(0, 100), key: String(key) });
+          deepspider.linkCrypto(entry);
+          return original.apply(this, arguments);
+        }, original);
+      }
+    });
+
+    console.log('[DeepSpider:crypto] CryptoJS Hook 已启用');
+  }
+})();
+`;
+  }
+
+  /**
+   * 生成国密 SM Hook 代码
+   */
+  generateSMCryptoHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  if (typeof sm2 !== 'undefined') {
+    const origEnc = sm2.doEncrypt;
+    sm2.doEncrypt = deepspider.native(function(msg, pubKey) {
+      const entry = deepspider.log('crypto', { algo: 'SM2.encrypt', msg: msg.slice(0, 100), publicKey: pubKey.slice(0, 50) });
+      deepspider.linkCrypto(entry);
+      return origEnc.apply(this, arguments);
+    }, origEnc);
+
+    const origDec = sm2.doDecrypt;
+    sm2.doDecrypt = deepspider.native(function(data) {
+      const entry = deepspider.log('crypto', { algo: 'SM2.decrypt', data: data.slice(0, 100) });
+      deepspider.linkCrypto(entry);
+      return origDec.apply(this, arguments);
+    }, origDec);
+  }
+
+  if (typeof sm3 !== 'undefined') {
+    const orig = sm3;
+    sm3 = deepspider.native(function(data) {
+      const entry = deepspider.log('crypto', { algo: 'SM3', data: String(data).slice(0, 100) });
+      deepspider.linkCrypto(entry);
+      return orig.apply(this, arguments);
+    }, orig);
+  }
+
+  if (typeof sm4 !== 'undefined' && sm4.encrypt) {
+    const orig = sm4.encrypt;
+    sm4.encrypt = deepspider.native(function(data, key) {
+      const entry = deepspider.log('crypto', { algo: 'SM4.encrypt', data: data.slice(0, 100), key });
+      deepspider.linkCrypto(entry);
+      return orig.apply(this, arguments);
+    }, orig);
+  }
+
+  console.log('[DeepSpider:crypto] SM Crypto Hook 已启用');
+})();
+`;
+  }
+
+  /**
+   * 生成 RSA Hook 代码
+   */
+  generateRSAHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  if (typeof JSEncrypt !== 'undefined') {
+    const proto = JSEncrypt.prototype;
+    const origSetPub = proto.setPublicKey;
+    proto.setPublicKey = deepspider.native(function(key) {
+      const entry = deepspider.log('crypto', { algo: 'RSA.setPublicKey', key: key.slice(0, 100) });
+      deepspider.linkCrypto(entry);
+      return origSetPub.apply(this, arguments);
+    }, origSetPub);
+
+    const origEnc = proto.encrypt;
+    proto.encrypt = deepspider.native(function(data) {
+      const entry = deepspider.log('crypto', { algo: 'RSA.encrypt', data: String(data).slice(0, 100) });
+      deepspider.linkCrypto(entry);
+      return origEnc.apply(this, arguments);
+    }, origEnc);
+  }
+
+  if (typeof forge !== 'undefined' && forge.pki && forge.pki.rsa) {
+    const orig = forge.pki.rsa.encrypt;
+    forge.pki.rsa.encrypt = deepspider.native(function(data) {
+      const entry = deepspider.log('crypto', { algo: 'forge.rsa.encrypt', data: String(data).slice(0, 100) });
+      deepspider.linkCrypto(entry);
+      return orig.apply(this, arguments);
+    }, orig);
+  }
+
+  console.log('[DeepSpider:crypto] RSA Hook 已启用');
+})();
+`;
+  }
+
+  /**
+   * 生成通用加密函数 Hook
+   */
+  generateGenericCryptoHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  const keywords = ['encrypt', 'decrypt', 'sign', 'hash', 'md5', 'sha', 'aes', 'des', 'rsa', 'hmac'];
+
+  for (const key in window) {
+    try {
+      if (typeof window[key] === 'function') {
+        const lk = key.toLowerCase();
+        if (keywords.some(kw => lk.includes(kw))) {
+          const orig = window[key];
+          window[key] = deepspider.native(function() {
+            const entry = deepspider.log('crypto', { algo: 'generic.' + key, args: Array.from(arguments).map(a => String(a).slice(0, 100)) });
+            deepspider.linkCrypto(entry);
+            return orig.apply(this, arguments);
+          }, orig);
+        }
+      }
+    } catch(e) {}
+  }
+
+  console.log('[DeepSpider:crypto] Generic Crypto Hook 已启用');
+})();
+`;
+  }
+}
+
+export default CryptoHook;

package/src/env/EnvCodeGenerator.js

@@ -0,0 +1,157 @@
+/**
+ * DeepSpider - 环境代码生成器
+ * 借鉴 v_jstools 的 make_env_1_v3.js
+ * 根据 Hook 收集的数据生成可在 Node.js 运行的浏览器环境代码
+ */
+
+import { GETSET_LIST, FUNC_LIST, HTML_TAG_MAP } from './BrowserAPIList.js';
+
+export class EnvCodeGenerator {
+  constructor() {
+    this.envData = {};
+  }
+
+  /**
+   * 从 Hook 日志生成环境代码
+   */
+  generateFromLogs(logs) {
+    this.parseEnvLogs(logs);
+    return this.generateCode();
+  }
+
+  /**
+   * 解析环境日志
+   */
+  parseEnvLogs(logs) {
+    for (const log of logs) {
+      if (log._type === 'env' && log.path) {
+        const parts = log.path.split('.');
+        const className = parts[0];
+        const propName = parts[1];
+        if (!this.envData[className]) {
+          this.envData[className] = { props: {}, methods: {} };
+        }
+        if (log.type === 'get' || log.type === 'set') {
+          this.envData[className].props[propName] = log.value;
+        } else if (log.type === 'call') {
+          this.envData[className].methods[propName] = log.result;
+        }
+      }
+    }
+  }
+
+  /**
+   * 生成环境代码
+   */
+  generateCode() {
+    const lines = [];
+    lines.push('// DeepSpider 生成的浏览器环境代码');
+    lines.push('// 生成时间: ' + new Date().toISOString());
+    lines.push('');
+    lines.push(this.generateSafeWrapper());
+    lines.push(this.generateBaseClasses());
+    lines.push(this.generateGlobalObjects());
+    return lines.join('\n');
+  }
+
+  /**
+   * 生成安全包装函数
+   */
+  generateSafeWrapper() {
+    return `
+// 安全函数包装器
+function v_saf(fn) {
+  return function() {
+    try { return fn.apply(this, arguments); }
+    catch(e) { return undefined; }
+  };
+}`;
+  }
+
+  /**
+   * 生成基础类
+   */
+  generateBaseClasses() {
+    return `
+// EventTarget 基类
+class EventTarget {
+  constructor() { this._listeners = {}; }
+  addEventListener(type, fn) {
+    if (!this._listeners[type]) this._listeners[type] = [];
+    this._listeners[type].push(fn);
+  }
+  removeEventListener(type, fn) {
+    if (!this._listeners[type]) return;
+    this._listeners[type] = this._listeners[type].filter(f => f !== fn);
+  }
+  dispatchEvent(event) {
+    const fns = this._listeners[event.type] || [];
+    fns.forEach(fn => fn.call(this, event));
+    return true;
+  }
+}
+
+// Node 基类
+class Node extends EventTarget {
+  constructor() {
+    super();
+    this.childNodes = [];
+    this.parentNode = null;
+  }
+  appendChild(node) { node.parentNode = this; this.childNodes.push(node); return node; }
+  removeChild(node) {
+    const idx = this.childNodes.indexOf(node);
+    if (idx > -1) this.childNodes.splice(idx, 1);
+    node.parentNode = null;
+    return node;
+  }
+}`;
+  }
+
+  /**
+   * 生成全局对象
+   */
+  generateGlobalObjects() {
+    const nav = this.envData.navigator?.props || {};
+    const scr = this.envData.screen?.props || {};
+
+    return `
+// Navigator
+var navigator = {
+  userAgent: ${JSON.stringify(nav.userAgent || 'Mozilla/5.0')},
+  platform: ${JSON.stringify(nav.platform || 'Win32')},
+  language: ${JSON.stringify(nav.language || 'zh-CN')},
+  cookieEnabled: true,
+  onLine: true,
+  webdriver: false,
+};
+
+// Screen
+var screen = {
+  width: ${scr.width || 1920},
+  height: ${scr.height || 1080},
+  colorDepth: 24,
+};
+
+// Location
+var location = { href: '', protocol: 'https:', host: '', pathname: '/' };
+
+// Document
+var document = {
+  cookie: '',
+  createElement: function(tag) { return {}; },
+  getElementById: function(id) { return null; },
+  querySelector: function(sel) { return null; },
+};
+
+// Window
+var window = this;
+window.navigator = navigator;
+window.screen = screen;
+window.location = location;
+window.document = document;
+`;
+  }
+}
+
+export default EnvCodeGenerator;

package/src/env/EnvDumper.js

@@ -0,0 +1,356 @@
+/**
+ * DeepSpider - 环境自吐模块
+ * 通过 Proxy 递归代理全局对象，记录所有环境访问
+ */
+
+import { HookBase } from './HookBase.js';
+
+export class EnvDumper {
+  constructor() {
+    this.logs = [];
+    this.maxValueLength = 70;
+  }
+
+  /**
+   * 生成环境自吐注入代码
+   * @param {Object} options - 配置选项
+   * @returns {string} 可注入沙箱的 JS 代码
+   */
+  generateDumpCode(options = {}) {
+    const {
+      targets = ['window', 'document', 'navigator', 'location'],
+      maxValueLength = 70,
+      enableCallStack = false,
+      skipInternals = true,
+    } = options;
+
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__ || global.__deepspider__;
+  if (!deepspider) {
+    console.error('[DeepSpider:env] 请先注入 HookBase');
+    return;
+  }
+  const MAX_VALUE_LENGTH = ${maxValueLength};
+  const ENABLE_CALL_STACK = ${enableCallStack};
+  const SKIP_INTERNALS = ${skipInternals};
+
+  // 截取值长度
+  function truncateValue(value) {
+    if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) {
+      return value.substring(0, MAX_VALUE_LENGTH) + "...";
+    }
+    if (typeof value !== "object" || value === null) {
+      return value;
+    }
+    try {
+      const str = JSON.stringify(value);
+      if (str.length > MAX_VALUE_LENGTH) {
+        return str.substring(0, MAX_VALUE_LENGTH) + "...";
+      }
+      return str;
+    } catch {
+      return "[Object]";
+    }
+  }
+
+  // 序列化值
+  function serializeValue(value) {
+    if (value === undefined) return "undefined";
+    if (value === null) return "null";
+    if (typeof value === "function") return "[Function]";
+    if (typeof value === "symbol") return value.toString();
+    if (typeof value === "object") {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return "[Object]";
+      }
+    }
+    return String(value);
+  }
+
+  // 记录日志
+  function logEnv(type, path, details = {}) {
+    const entry = {
+      type,
+      path,
+      ...details
+    };
+    if (ENABLE_CALL_STACK) {
+      entry.stack = new Error().stack;
+    }
+    deepspider.log('env', entry);
+
+    // 格式化输出
+    const pathStr = ('"' + path + '"').padEnd(50, " ");
+    switch (type) {
+      case 'get':
+        console.log(\`[DeepSpider:env] 获取: \${pathStr} | 值= \${truncateValue(details.value)}\`);
+        break;
+      case 'set':
+        console.log(\`[DeepSpider:env] 设置: \${pathStr} | 值= \${truncateValue(details.value)}\`);
+        break;
+      case 'call':
+        console.log(\`[DeepSpider:env] 调用: \${pathStr} | 参数= \${truncateValue(details.args)}\`);
+        break;
+      case 'construct':
+        console.log(\`[DeepSpider:env] 构造: \${pathStr} | 参数= \${truncateValue(details.args)}\`);
+        break;
+      case 'missing':
+        console.log(\`[DeepSpider:env] 缺失: \${pathStr}\`);
+        if (typeof __recordMissing__ === 'function') {
+          __recordMissing__(path);
+        }
+        break;
+    }
+  }
+
+  // 判断是否跳过的内部属性
+  function shouldSkipKey(key, name) {
+    if (!SKIP_INTERNALS) return false;
+
+    const skipKeys = [
+      'window', 'self', 'global', 'globalThis',
+      '_globalObject', 'prototype', '__proto__'
+    ];
+
+    if (skipKeys.includes(key) || key === name) return true;
+    if (typeof key === 'string' && (key.startsWith('__') && key.endsWith('__'))) return true;
+    if (typeof key === 'symbol') return true;
+
+    return false;
+  }
+
+  // 创建代理处理器
+  function createHandler(name) {
+    const proxyCache = new WeakMap();
+
+    return {
+      get(target, key, receiver) {
+        // 跳过 Symbol 和特殊属性
+        if (typeof key === 'symbol' || key === 'toString' || key === 'valueOf') {
+          return Reflect.get(target, key, receiver);
+        }
+
+        const value = target[key];
+        const fullPath = name + '.' + String(key);
+
+        // 内部属性简单返回
+        if (shouldSkipKey(key, name)) {
+          return value;
+        }
+
+        // 记录缺失
+        if (value === undefined && !(key in target)) {
+          logEnv('missing', fullPath);
+          return undefined;
+        }
+
+        // 处理函数
+        if (typeof value === 'function') {
+          // 检查是否是构造函数
+          const isConstructor = value.prototype !== undefined;
+
+          return new Proxy(value, {
+            apply(fn, thisArg, args) {
+              const result = Reflect.apply(fn, target, args);
+              logEnv('call', fullPath, { args: serializeValue(args), result: serializeValue(result) });
+              return result;
+            },
+            construct(fn, args, newTarget) {
+              logEnv('construct', fullPath, { args: serializeValue(args) });
+              return Reflect.construct(fn, args, newTarget);
+            },
+            get(fn, prop) {
+              // 代理函数的属性访问
+              if (prop === 'prototype' || typeof prop === 'symbol') {
+                return fn[prop];
+              }
+              const propValue = fn[prop];
+              if (typeof propValue === 'function') {
+                return new Proxy(propValue, createHandler(fullPath + '.' + String(prop)));
+              }
+              return propValue;
+            }
+          });
+        }
+
+        // 处理对象 - 递归代理
+        if (value !== null && typeof value === 'object') {
+          // 使用缓存避免重复代理
+          if (proxyCache.has(value)) {
+            return proxyCache.get(value);
+          }
+
+          logEnv('get', fullPath, { value: serializeValue(value) });
+
+          const proxy = new Proxy(value, createHandler(fullPath));
+          proxyCache.set(value, proxy);
+          return proxy;
+        }
+
+        // 基本类型
+        logEnv('get', fullPath, { value: serializeValue(value) });
+        return value;
+      },
+
+      set(target, key, value, receiver) {
+        const fullPath = name + '.' + String(key);
+        logEnv('set', fullPath, { value: serializeValue(value) });
+        return Reflect.set(target, key, value, receiver);
+      },
+
+      apply(target, thisArg, args) {
+        logEnv('call', name, { args: serializeValue(args) });
+        return Reflect.apply(target, thisArg, args);
+      },
+
+      construct(target, args, newTarget) {
+        logEnv('construct', name, { args: serializeValue(args) });
+        return Reflect.construct(target, args, newTarget);
+      }
+    };
+  }
+
+  // 代理指定的全局对象
+  const targets = ${JSON.stringify(targets)};
+
+  for (const target of targets) {
+    if (typeof global[target] !== 'undefined') {
+      try {
+        global[target] = new Proxy(global[target], createHandler(target));
+      } catch (e) {
+        console.log('[DeepSpider:env] 无法代理:', target, e.message);
+      }
+    }
+  }
+
+  console.log('[DeepSpider:env] 环境自吐已启用，监控目标:', targets.join(', '));
+})();
+`;
+  }
+
+  /**
+   * 生成基础环境桩代码
+   * 在注入自吐代码前，先创建基础的全局对象
+   */
+  generateBaseEnv() {
+    return `
+// 基础环境桩
+if (typeof window === 'undefined') {
+  global.window = global;
+}
+if (typeof self === 'undefined') {
+  global.self = global;
+}
+if (typeof document === 'undefined') {
+  global.document = {
+    cookie: '',
+    referrer: '',
+    URL: 'about:blank',
+    domain: '',
+    title: '',
+    body: null,
+    head: null,
+    documentElement: null,
+    createElement: function(tag) { return { tagName: tag }; },
+    getElementById: function() { return null; },
+    getElementsByTagName: function() { return []; },
+    getElementsByClassName: function() { return []; },
+    querySelector: function() { return null; },
+    querySelectorAll: function() { return []; },
+    addEventListener: function() {},
+    removeEventListener: function() {},
+  };
+}
+if (typeof navigator === 'undefined') {
+  global.navigator = {
+    userAgent: '',
+    platform: '',
+    language: 'zh-CN',
+    languages: ['zh-CN'],
+    cookieEnabled: true,
+    onLine: true,
+    hardwareConcurrency: 4,
+    maxTouchPoints: 0,
+    webdriver: false,
+  };
+}
+if (typeof location === 'undefined') {
+  global.location = {
+    href: 'about:blank',
+    protocol: 'https:',
+    host: '',
+    hostname: '',
+    port: '',
+    pathname: '/',
+    search: '',
+    hash: '',
+    origin: '',
+  };
+}
+if (typeof screen === 'undefined') {
+  global.screen = {
+    width: 1920,
+    height: 1080,
+    availWidth: 1920,
+    availHeight: 1040,
+    colorDepth: 24,
+    pixelDepth: 24,
+  };
+}
+if (typeof localStorage === 'undefined') {
+  const storage = {};
+  global.localStorage = {
+    getItem: (k) => storage[k] || null,
+    setItem: (k, v) => { storage[k] = String(v); },
+    removeItem: (k) => { delete storage[k]; },
+    clear: () => { for (const k in storage) delete storage[k]; },
+    get length() { return Object.keys(storage).length; },
+    key: (i) => Object.keys(storage)[i] || null,
+  };
+}
+if (typeof sessionStorage === 'undefined') {
+  global.sessionStorage = { ...global.localStorage };
+}
+`;
+  }
+
+  /**
+   * 解析环境日志，提取需要补全的环境
+   */
+  parseEnvLogs(logsJson) {
+    try {
+      const logs = JSON.parse(logsJson);
+      const missing = new Set();
+      const calls = [];
+      const gets = [];
+
+      for (const log of logs) {
+        switch (log.type) {
+          case 'missing':
+            missing.add(log.path);
+            break;
+          case 'call':
+            calls.push({ path: log.path, args: log.args });
+            break;
+          case 'get':
+            gets.push({ path: log.path, value: log.value });
+            break;
+        }
+      }
+
+      return {
+        missing: Array.from(missing),
+        calls,
+        gets,
+        total: logs.length,
+      };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+}
+
+export default EnvDumper;