deepspider 0.1.0

package/src/core/Sandbox.js

@@ -0,0 +1,181 @@
+/**
+ * DeepSpider - 沙箱管理器
+ * 基于 isolated-vm 的安全执行环境
+ */
+
+import ivm from 'isolated-vm';
+import { EnvMonitor } from './EnvMonitor.js';
+
+export class Sandbox {
+  constructor() {
+    this.isolate = null;
+    this.context = null;
+    this.missingEnv = [];
+    this.monitor = new EnvMonitor();
+    this.envLoaded = false;
+  }
+
+  async init(options = {}) {
+    const { memoryLimit = 128 } = options;
+
+    this.isolate = new ivm.Isolate({ memoryLimit });
+    this.context = await this.isolate.createContext();
+
+    const jail = this.context.global;
+    await jail.set('global', jail.derefInto());
+
+    await this._injectBase(jail);
+    await this._injectMonitor(jail);
+
+    return this;
+  }
+
+  // 加载环境代码
+  async loadEnv(envCode) {
+    if (!envCode) return;
+    await this.context.eval(envCode);
+    this.envLoaded = true;
+  }
+
+  async _injectBase(jail) {
+    // console
+    await jail.set('console', {
+      log: new ivm.Callback((...args) => console.log('[DeepSpider:sandbox]', ...args)),
+      error: new ivm.Callback((...args) => console.error('[DeepSpider:sandbox]', ...args)),
+      warn: new ivm.Callback((...args) => console.warn('[DeepSpider:sandbox]', ...args))
+    }, { copy: true });
+
+    // Base64
+    await jail.set('atob', new ivm.Callback((s) =>
+      Buffer.from(s, 'base64').toString('binary')
+    ));
+    await jail.set('btoa', new ivm.Callback((s) =>
+      Buffer.from(s, 'binary').toString('base64')
+    ));
+
+    // Timers (stub)
+    await jail.set('setTimeout', new ivm.Callback(() => 0));
+    await jail.set('setInterval', new ivm.Callback(() => 0));
+    await jail.set('clearTimeout', new ivm.Callback(() => {}));
+    await jail.set('clearInterval', new ivm.Callback(() => {}));
+  }
+
+  async _injectMonitor(jail) {
+    const self = this;
+
+    await jail.set('__recordMissing__', new ivm.Callback((path) => {
+      if (!self.missingEnv.includes(path)) {
+        self.missingEnv.push(path);
+      }
+    }));
+
+    const monitorCode = `
+      const window = global;
+      global.window = window;
+      global.self = window;
+
+      global.__createProxy__ = function(obj, path) {
+        return new Proxy(obj, {
+          get(t, p) {
+            if (typeof p === 'symbol') return t[p];
+            const fullPath = path ? path + '.' + p : String(p);
+            if (t[p] === undefined && !(p in t)) {
+              __recordMissing__(fullPath);
+            }
+            return t[p];
+          }
+        });
+      };
+    `;
+
+    await this.context.eval(monitorCode);
+  }
+
+  async inject(code) {
+    try {
+      await this.context.eval(code);
+      // 返回更多信息帮助 Agent 判断下一步
+      return {
+        success: true,
+        message: '代码已注入沙箱，请使用 sandbox_execute 验证执行',
+        codeLength: code.length,
+        hint: '建议调用 sandbox_execute 测试注入的函数是否可用'
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        hint: '注入失败，请检查代码语法'
+      };
+    }
+  }
+
+  async execute(code, options = {}) {
+    const { timeout = 5000 } = options;
+    this.missingEnv = [];
+
+    try {
+      const script = await this.isolate.compileScript(code);
+      const result = await script.run(this.context, { timeout });
+
+      // 记录到监控系统
+      this.missingEnv.forEach(p => this.monitor.logMissing(p));
+
+      return {
+        success: true,
+        result: this._serialize(result),
+        missingEnv: [...this.missingEnv],
+        stats: this.monitor.getStats()
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        errorType: this._classifyError(e),
+        missingEnv: [...this.missingEnv],
+        stats: this.monitor.getStats()
+      };
+    }
+  }
+
+  // 错误分类（帮助判断是环境缺失还是代码错误）
+  _classifyError(e) {
+    const msg = e.message || '';
+    if (/is not defined/.test(msg)) return 'undefined-reference';
+    if (/is not a function/.test(msg)) return 'not-a-function';
+    if (/Cannot read propert/.test(msg)) return 'null-access';
+    if (/timeout/.test(msg)) return 'timeout';
+    return 'runtime-error';
+  }
+
+  _serialize(val) {
+    if (val === undefined) return 'undefined';
+    if (val === null) return 'null';
+    if (typeof val === 'function') return `[Function]`;
+    if (typeof val === 'object') {
+      try { return JSON.stringify(val); }
+      catch { return '[Object]'; }
+    }
+    return String(val);
+  }
+
+  async reset() {
+    await this.dispose();
+    this.monitor.clearLogs();
+    this.envLoaded = false;
+    await this.init();
+  }
+
+  async dispose() {
+    if (this.context) {
+      this.context.release();
+      this.context = null;
+    }
+    if (this.isolate) {
+      this.isolate.dispose();
+      this.isolate = null;
+    }
+  }
+}
+
+export default Sandbox;

package/src/env/AntiAntiDebug.js

@@ -0,0 +1,111 @@
+/**
+ * DeepSpider - 反反调试模块
+ * 绕过常见的反调试检测
+ */
+
+import { HookBase } from './HookBase.js';
+
+export class AntiAntiDebug {
+  /**
+   * 绕过无限 debugger
+   */
+  generateAntiDebuggerCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  const origCtor = Function.prototype.constructor;
+  Function.prototype.constructor = deepspider.native(function(...args) {
+    if (args[0] && args[0].includes('debugger')) {
+      deepspider.log('debug', { action: 'block.debugger.constructor' });
+      return function() {};
+    }
+    return origCtor.apply(this, args);
+  }, origCtor);
+
+  const origEval = eval;
+  eval = deepspider.native(function(code) {
+    if (typeof code === 'string' && code.includes('debugger')) {
+      deepspider.log('debug', { action: 'block.debugger.eval' });
+      code = code.replace(/debugger/g, '');
+    }
+    return origEval(code);
+  }, origEval);
+
+  const origSetInterval = setInterval;
+  setInterval = deepspider.native(function(fn, delay) {
+    if (fn.toString().includes('debugger')) {
+      deepspider.log('debug', { action: 'block.debugger.setInterval' });
+      return 0;
+    }
+    return origSetInterval(fn, delay);
+  }, origSetInterval);
+
+  console.log('[DeepSpider:debug] 无限 debugger 防护已启用');
+})();
+`;
+  }
+
+  /**
+   * 绕过控制台检测
+   */
+  generateAntiConsoleDetectCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  Object.defineProperty(window, 'outerWidth', { get: () => window.innerWidth });
+  Object.defineProperty(window, 'outerHeight', { get: () => window.innerHeight + 100 });
+
+  const origLog = console.log;
+  console.log = deepspider.native(function(...args) {
+    if (args[0]?.toString?.().includes('devtools')) {
+      deepspider.log('debug', { action: 'block.console.devtools' });
+      return;
+    }
+    return origLog.apply(console, args);
+  }, origLog);
+
+  console.table = function() {};
+  console.clear = function() {};
+
+  console.log('[DeepSpider:debug] 控制台检测防护已启用');
+})();
+`;
+  }
+
+  /**
+   * 绕过 CDP 检测
+   */
+  generateAntiCDPDetectCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
+  delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
+
+  Object.defineProperty(navigator, 'webdriver', {
+    get: () => false,
+    configurable: true
+  });
+
+  console.log('[DeepSpider:debug] CDP 检测防护已启用');
+})();
+`;
+  }
+
+  /**
+   * 生成完整的反反调试代码
+   */
+  generateFullAntiDebugCode() {
+    return [
+      this.generateAntiDebuggerCode(),
+      this.generateAntiConsoleDetectCode(),
+      this.generateAntiCDPDetectCode(),
+    ].join('\n');
+  }
+}
+
+export default AntiAntiDebug;

package/src/env/AsyncHook.js

@@ -0,0 +1,68 @@
+/**
+ * DeepSpider - 异步追踪 Hook
+ * 追踪 Promise、setTimeout 等异步调用
+ */
+
+import { HookBase } from './HookBase.js';
+
+export class AsyncHook {
+  /**
+   * 生成 Promise Hook 代码
+   */
+  generatePromiseHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  const originalThen = Promise.prototype.then;
+  Promise.prototype.then = deepspider.native(function(onFulfilled, onRejected) {
+    const stack = new Error().stack;
+
+    const wrappedFulfilled = onFulfilled ? function(value) {
+      deepspider.log('async', { action: 'promise.then', stack });
+      return onFulfilled(value);
+    } : onFulfilled;
+
+    return originalThen.call(this, wrappedFulfilled, onRejected);
+  }, originalThen);
+
+  console.log('[DeepSpider:async] Promise Hook 已启用');
+})();
+`;
+  }
+
+  /**
+   * 生成 setTimeout/setInterval Hook 代码
+   */
+  generateTimerHookCode() {
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  const origSetTimeout = setTimeout;
+  const origSetInterval = setInterval;
+
+  setTimeout = deepspider.native(function(fn, delay) {
+    deepspider.log('timer', { action: 'setTimeout', delay });
+    return origSetTimeout(function() {
+      deepspider.log('timer', { action: 'setTimeout.callback', delay });
+      if (typeof fn === 'function') fn.apply(this, arguments);
+    }, delay);
+  }, origSetTimeout);
+
+  setInterval = deepspider.native(function(fn, delay) {
+    deepspider.log('timer', { action: 'setInterval', delay });
+    return origSetInterval(function() {
+      if (typeof fn === 'function') fn.apply(this, arguments);
+    }, delay);
+  }, origSetInterval);
+
+  console.log('[DeepSpider:timer] Timer Hook 已启用');
+})();
+`;
+  }
+}
+
+export default AsyncHook;

package/src/env/BrowserAPIList.js

@@ -0,0 +1,265 @@
+/**
+ * DeepSpider - 浏览器 API 列表
+ * 借鉴 v_jstools 的 v_getsetfunc_list.js
+ * 用于批量 Hook 和环境代码生成
+ */
+
+// Getter/Setter 属性列表 [类名, 属性名]
+export const GETSET_LIST = [
+  // Navigator
+  ['Navigator', 'userAgent'],
+  ['Navigator', 'platform'],
+  ['Navigator', 'language'],
+  ['Navigator', 'languages'],
+  ['Navigator', 'cookieEnabled'],
+  ['Navigator', 'onLine'],
+  ['Navigator', 'hardwareConcurrency'],
+  ['Navigator', 'deviceMemory'],
+  ['Navigator', 'maxTouchPoints'],
+  ['Navigator', 'webdriver'],
+  ['Navigator', 'vendor'],
+  ['Navigator', 'appVersion'],
+  ['Navigator', 'appName'],
+  ['Navigator', 'product'],
+  ['Navigator', 'productSub'],
+
+  // Screen
+  ['Screen', 'width'],
+  ['Screen', 'height'],
+  ['Screen', 'availWidth'],
+  ['Screen', 'availHeight'],
+  ['Screen', 'colorDepth'],
+  ['Screen', 'pixelDepth'],
+
+  // Document
+  ['Document', 'cookie'],
+  ['Document', 'domain'],
+  ['Document', 'referrer'],
+  ['Document', 'title'],
+  ['Document', 'URL'],
+  ['Document', 'documentElement'],
+  ['Document', 'body'],
+  ['Document', 'head'],
+  ['Document', 'hidden'],
+  ['Document', 'visibilityState'],
+
+  // Location
+  ['Location', 'href'],
+  ['Location', 'protocol'],
+  ['Location', 'host'],
+  ['Location', 'hostname'],
+  ['Location', 'port'],
+  ['Location', 'pathname'],
+  ['Location', 'search'],
+  ['Location', 'hash'],
+  ['Location', 'origin'],
+
+  // Window
+  ['Window', 'innerWidth'],
+  ['Window', 'innerHeight'],
+  ['Window', 'outerWidth'],
+  ['Window', 'outerHeight'],
+  ['Window', 'screenX'],
+  ['Window', 'screenY'],
+  ['Window', 'devicePixelRatio'],
+  ['Window', 'localStorage'],
+  ['Window', 'sessionStorage'],
+  ['Window', 'name'],
+
+  // HTMLElement
+  ['HTMLElement', 'offsetWidth'],
+  ['HTMLElement', 'offsetHeight'],
+  ['HTMLElement', 'clientWidth'],
+  ['HTMLElement', 'clientHeight'],
+  ['HTMLElement', 'scrollWidth'],
+  ['HTMLElement', 'scrollHeight'],
+  ['HTMLElement', 'innerHTML'],
+  ['HTMLElement', 'innerText'],
+  ['HTMLElement', 'textContent'],
+
+  // Canvas
+  ['HTMLCanvasElement', 'width'],
+  ['HTMLCanvasElement', 'height'],
+  ['CanvasRenderingContext2D', 'fillStyle'],
+  ['CanvasRenderingContext2D', 'strokeStyle'],
+  ['CanvasRenderingContext2D', 'font'],
+
+  // WebGL
+  ['WebGLRenderingContext', 'drawingBufferWidth'],
+  ['WebGLRenderingContext', 'drawingBufferHeight'],
+];
+
+// 方法列表 [类名, 方法名]
+export const FUNC_LIST = [
+  // Document
+  ['Document', 'getElementById'],
+  ['Document', 'getElementsByClassName'],
+  ['Document', 'getElementsByTagName'],
+  ['Document', 'getElementsByName'],
+  ['Document', 'querySelector'],
+  ['Document', 'querySelectorAll'],
+  ['Document', 'createElement'],
+  ['Document', 'createTextNode'],
+  ['Document', 'createEvent'],
+  ['Document', 'write'],
+  ['Document', 'writeln'],
+
+  // Element
+  ['Element', 'querySelector'],
+  ['Element', 'querySelectorAll'],
+  ['Element', 'getAttribute'],
+  ['Element', 'setAttribute'],
+  ['Element', 'removeAttribute'],
+  ['Element', 'hasAttribute'],
+  ['Element', 'getBoundingClientRect'],
+  ['Element', 'getClientRects'],
+
+  // Canvas
+  ['HTMLCanvasElement', 'getContext'],
+  ['HTMLCanvasElement', 'toDataURL'],
+  ['HTMLCanvasElement', 'toBlob'],
+  ['CanvasRenderingContext2D', 'fillRect'],
+  ['CanvasRenderingContext2D', 'fillText'],
+  ['CanvasRenderingContext2D', 'strokeText'],
+  ['CanvasRenderingContext2D', 'measureText'],
+  ['CanvasRenderingContext2D', 'getImageData'],
+  ['CanvasRenderingContext2D', 'putImageData'],
+  ['CanvasRenderingContext2D', 'drawImage'],
+
+  // WebGL
+  ['WebGLRenderingContext', 'getParameter'],
+  ['WebGLRenderingContext', 'getExtension'],
+  ['WebGLRenderingContext', 'getSupportedExtensions'],
+  ['WebGLRenderingContext', 'getShaderPrecisionFormat'],
+  ['WebGL2RenderingContext', 'getParameter'],
+
+  // Navigator
+  ['Navigator', 'getBattery'],
+  ['Navigator', 'getGamepads'],
+  ['Navigator', 'sendBeacon'],
+  ['Navigator', 'vibrate'],
+
+  // Window
+  ['Window', 'getComputedStyle'],
+  ['Window', 'matchMedia'],
+  ['Window', 'requestAnimationFrame'],
+  ['Window', 'cancelAnimationFrame'],
+  ['Window', 'fetch'],
+  ['Window', 'open'],
+  ['Window', 'close'],
+  ['Window', 'postMessage'],
+
+  // Storage
+  ['Storage', 'getItem'],
+  ['Storage', 'setItem'],
+  ['Storage', 'removeItem'],
+  ['Storage', 'clear'],
+  ['Storage', 'key'],
+
+  // Performance
+  ['Performance', 'now'],
+  ['Performance', 'getEntries'],
+  ['Performance', 'getEntriesByType'],
+  ['Performance', 'getEntriesByName'],
+
+  // Crypto
+  ['Crypto', 'getRandomValues'],
+  ['SubtleCrypto', 'encrypt'],
+  ['SubtleCrypto', 'decrypt'],
+  ['SubtleCrypto', 'sign'],
+  ['SubtleCrypto', 'verify'],
+  ['SubtleCrypto', 'digest'],
+
+  // Event
+  ['EventTarget', 'addEventListener'],
+  ['EventTarget', 'removeEventListener'],
+  ['EventTarget', 'dispatchEvent'],
+];
+
+// HTML 标签到类的映射
+export const HTML_TAG_MAP = {
+  HTMLElement: ['abbr', 'address', 'article', 'aside', 'b', 'bdi', 'bdo', 'cite', 'code', 'dd', 'dfn', 'dt', 'em', 'figcaption', 'figure', 'footer', 'header', 'hgroup', 'i', 'kbd', 'main', 'mark', 'nav', 'noscript', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'small', 'strong', 'sub', 'summary', 'sup', 'u', 'var', 'wbr'],
+  HTMLAnchorElement: ['a'],
+  HTMLAreaElement: ['area'],
+  HTMLAudioElement: ['audio'],
+  HTMLBRElement: ['br'],
+  HTMLBaseElement: ['base'],
+  HTMLBodyElement: ['body'],
+  HTMLButtonElement: ['button'],
+  HTMLCanvasElement: ['canvas'],
+  HTMLDListElement: ['dl'],
+  HTMLDataElement: ['data'],
+  HTMLDataListElement: ['datalist'],
+  HTMLDetailsElement: ['details'],
+  HTMLDialogElement: ['dialog'],
+  HTMLDivElement: ['div'],
+  HTMLEmbedElement: ['embed'],
+  HTMLFieldSetElement: ['fieldset'],
+  HTMLFormElement: ['form'],
+  HTMLFrameSetElement: ['frameset'],
+  HTMLHRElement: ['hr'],
+  HTMLHeadElement: ['head'],
+  HTMLHeadingElement: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
+  HTMLHtmlElement: ['html'],
+  HTMLIFrameElement: ['iframe'],
+  HTMLImageElement: ['img'],
+  HTMLInputElement: ['input'],
+  HTMLLIElement: ['li'],
+  HTMLLabelElement: ['label'],
+  HTMLLegendElement: ['legend'],
+  HTMLLinkElement: ['link'],
+  HTMLMapElement: ['map'],
+  HTMLMetaElement: ['meta'],
+  HTMLMeterElement: ['meter'],
+  HTMLOListElement: ['ol'],
+  HTMLObjectElement: ['object'],
+  HTMLOptGroupElement: ['optgroup'],
+  HTMLOptionElement: ['option'],
+  HTMLOutputElement: ['output'],
+  HTMLParagraphElement: ['p'],
+  HTMLPictureElement: ['picture'],
+  HTMLPreElement: ['pre'],
+  HTMLProgressElement: ['progress'],
+  HTMLQuoteElement: ['blockquote', 'q'],
+  HTMLScriptElement: ['script'],
+  HTMLSelectElement: ['select'],
+  HTMLSlotElement: ['slot'],
+  HTMLSourceElement: ['source'],
+  HTMLSpanElement: ['span'],
+  HTMLStyleElement: ['style'],
+  HTMLTableCaptionElement: ['caption'],
+  HTMLTableCellElement: ['td', 'th'],
+  HTMLTableColElement: ['col', 'colgroup'],
+  HTMLTableElement: ['table'],
+  HTMLTableRowElement: ['tr'],
+  HTMLTableSectionElement: ['thead', 'tbody', 'tfoot'],
+  HTMLTemplateElement: ['template'],
+  HTMLTextAreaElement: ['textarea'],
+  HTMLTimeElement: ['time'],
+  HTMLTitleElement: ['title'],
+  HTMLTrackElement: ['track'],
+  HTMLUListElement: ['ul'],
+  HTMLVideoElement: ['video'],
+};
+
+// 获取类的原型链
+export function getPrototypeChain(className) {
+  const chains = {
+    'HTMLDivElement': ['HTMLDivElement', 'HTMLElement', 'Element', 'Node', 'EventTarget'],
+    'HTMLCanvasElement': ['HTMLCanvasElement', 'HTMLElement', 'Element', 'Node', 'EventTarget'],
+    'HTMLInputElement': ['HTMLInputElement', 'HTMLElement', 'Element', 'Node', 'EventTarget'],
+    'Document': ['Document', 'Node', 'EventTarget'],
+    'Window': ['Window', 'EventTarget'],
+    'Navigator': ['Navigator'],
+    'Screen': ['Screen'],
+    'Location': ['Location'],
+  };
+  return chains[className] || [className];
+}
+
+export default {
+  GETSET_LIST,
+  FUNC_LIST,
+  HTML_TAG_MAP,
+  getPrototypeChain,
+};

package/src/env/CookieHook.js

@@ -0,0 +1,48 @@
+/**
+ * DeepSpider - Cookie 监控模块
+ * 监控 document.cookie 的读写操作
+ */
+
+import { HookBase } from './HookBase.js';
+
+export class CookieHook {
+  /**
+   * 生成 Cookie Hook 代码
+   */
+  generateCookieHookCode(options = {}) {
+    const { trackRead = true, trackWrite = true } = options;
+
+    return HookBase.getBaseCode() + `
+(function() {
+  const deepspider = window.__deepspider__;
+  if (!deepspider) return;
+
+  const cookieDesc = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie') ||
+                     Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie');
+
+  if (cookieDesc) {
+    Object.defineProperty(document, 'cookie', {
+      ${trackRead ? `
+      get: function() {
+        const value = cookieDesc.get.call(document);
+        deepspider.log('cookie', { action: 'read', value: value?.slice(0, 100) });
+        return value;
+      },
+      ` : 'get: cookieDesc.get,'}
+      ${trackWrite ? `
+      set: function(val) {
+        deepspider.log('cookie', { action: 'write', value: val });
+        return cookieDesc.set.call(document, val);
+      },
+      ` : 'set: cookieDesc.set,'}
+      configurable: true
+    });
+  }
+
+  console.log('[DeepSpider:cookie] Cookie Hook 已启用');
+})();
+`;
+  }
+}
+
+export default CookieHook;