前端反爬分析：基于环境日志补全 Window 对象缺失属性

模式二：类型检查

// 不仅检查存在，还检查类型
if (typeof window.someProperty === 'function') {
  // 如果是函数，还会检查 toString
  console.log(window.someProperty.toString());
}

模式三：原型链深度检查

// 有些检测会深入检查原型链
if (window.someProperty instanceof SomeConstructor) {
  // 检查构造函数
}

在实际的日志中，看到了大量对 toString() 方法的调用检查：

方法：toString 函数：getBattery 结果：function getBattery() { [native code] }
方法：toString 函数：Element 结果：function Element() { [native code] }

这告诉我们一个重要的细节：函数必须返回正确的 [native code] 标识。如果你补的函数返回的是自定义的实现，toString() 结果不对，很容易被识别出来。

1.3 实战：从日志到补环境清单

让我们实际分析一段日志，提取出需要补的环境属性。假设我们有如下日志片段：

从这个表格可以看出，我们需要补全的属性分为几类：

1. 自定义属性：如 UA_Opt、__acjs 等，这些是网站自己注入的
2. 浏览器特有属性：如 mozPaintCount（Firefox）、webkitRTCPeerConnection（WebKit）
3. 插件相关属性：如 chrome 对象及其子属性
4. 事件相关属性：如 attachEvent（IE）、DeviceMotionEvent 等

注意：不是所有 undefined 都需要补。有些属性在某些浏览器中本来就是 undefined，比如 IE 的 attachEvent 在 Chrome 中就是 undefined。关键是要根据 UserAgent 来匹配正确的属性集。

2. Window 对象补全：从基础到高级

补环境的核心就是补 Window 对象，因为几乎所有浏览器 API 都挂载在 Window 或其子对象上。但 Window 对象太庞大了，直接全部补全不现实，也没必要。我们需要的是按需补全。

2.1 基础属性补全策略

通常会把 Window 属性分为几个优先级：

第一优先级：高频检测属性 这些属性在几乎所有的环境检测中都会被检查，必须优先补全。

// 基础 Window 属性补全
const basicWindowProperties = {
  // 自定义属性
  UA_Opt: {},
  __acjs: 1,
  __acjs_awsc_140: { getUA: function() {}, isReadyForSC: function() {} },
  _uab_module: 1,
  // 浏览器对象
  chrome: {
    runtime: {},
    csi: function() {},
    loadTimes: function() {},
    // 注意：chrome.history 在普通页面中通常是 undefined
    history: undefined,
    bookmarks: undefined,
    cookies: undefined,
    system: undefined
  },
  // 移动端特有
  WeixinJSBridge: undefined, // 微信环境
  __wxjs_environment: undefined,
  AlipayJSBridge: undefined, // 支付宝环境
  // 调试相关（通常为 undefined）
  Debug: undefined,
  __BROWSERTOOLS_DOMEXPLORER_ADDED: undefined,
  __IE_DEVTOOLBAR_CONSOLE_EVAL_RESULT: undefined
};

第二优先级：浏览器引擎特有属性 根据 UserAgent 决定补哪些。

// 根据 UA 判断浏览器类型
function getBrowserType(ua) {
  if (ua.includes('Firefox')) return 'firefox';
  if (ua.includes('Chrome')) return 'chrome';
  if (ua.includes('Safari')) return 'safari';
  if (ua.includes('MSIE') || ua.includes('Trident')) return 'ie';
  return 'chrome'; // 默认
}

// 浏览器特有属性
const browserSpecificProperties = {
  firefox: {
    mozPaintCount: 0,
    mozInnerScreenX: 0,
    InstallTrigger: undefined
  },
  chrome: {
    chrome: { /* 已在上面的 basicWindowProperties 中定义 */ },
    webkitStorageInfo: undefined
  },
  safari: {
    safari: undefined,
    webkitRTCPeerConnection: function() { [native code] }
  },
  ie: {
    ActiveXObject: function() { [native code] },
    attachEvent: function() { [native code] },
    ScriptEngineBuildVersion: 0,
    ScriptEngineMajorVersion: 0,
    ScriptEngineMinorVersion: 0
  }
};

2.2 函数属性的特殊处理

函数属性的补全要特别小心，因为检测代码不仅会检查函数是否存在，还会检查：

1. 函数类型：必须是 function
2. toString 结果：必须包含 [native code]
3. 原型链：构造函数要有正确的原型

这里有个技巧：我们可以用 Proxy 来拦截对函数的访问，确保 toString() 返回正确的结果。

// 创建原生函数代理
function createNativeFunctionProxy(originalName, customImplementation = null) {
  return new Proxy(customImplementation || function() {}, {
    get(target, prop) {
      if (prop === 'toString') {
        return () => `function ${originalName}() { [native code] }`;
      }
      return Reflect.get(target, prop);
    },
    apply(target, thisArg, argumentsList) {
      // 如果有自定义实现，使用自定义实现
      if (customImplementation) {
        return customImplementation.apply(thisArg, argumentsList);
      }
      // 否则返回一个合理值
      return undefined;
    }
  });
}

// 应用函数代理
window.Bluetooth = createNativeFunctionProxy('Bluetooth');
window.BluetoothDevice = createNativeFunctionProxy('BluetoothDevice');
window.BluetoothUUID = createNativeFunctionProxy('BluetoothUUID');

// 对于有实际用途的函数，可以提供简单实现
window.getBattery = createNativeFunctionProxy('getBattery', async function() {
  return {
    charging: false,
    chargingTime: Infinity,
    dischargingTime: Infinity,
    level: 1.0,
    onchargingchange: null,
    onchargingtimechange: null,
    ondischargingtimechange: null,
    onlevelchange: null
  };
});

2.3 对象属性的深度补全

有些属性不是简单的值或函数，而是复杂的对象。这时候需要递归补全。

// 深度补全对象属性
function deepPatchObject(target, source) {
  for (const key in source) {
    if (source.hasOwnProperty(key)) {
      if (typeof source[key] === 'object' && source[key] !== null) {
        if (!target[key] || typeof target[key] !== 'object') {
          target[key] = {};
        }
        deepPatchObject(target[key], source[key]);
      } else {
        // 特殊处理：如果 target 已有该属性且不是 undefined，保留原值
        if (target[key] === undefined) {
          target[key] = source[key];
        }
      }
    }
  }
  return target;
}

// 补全 performance 对象
const performancePatch = { timing: {} };