解决JS逆向常见报错：缺少DOM环境导致代码运行失败

图 0：JS 逆向分析中的 DOM 环境缺失解决主干概览

一、报错现象与成因分析

在提取前端登录验签、数据解密或设备指纹生成算法时，分析人员通常会将一段打包好的 JavaScript 代码单独导出并在本地 Node.js 脚本中调用。然而，几乎所有未做脱敏处理的代码在初次执行时都会立即中断，控制台输出典型的异常栈：

ReferenceError: window is not defined
    at Object.<anonymous> (/workspace/decrypt.js:42:15)
    at Module._compile (node:internal/modules/cjs/loader:1256:14)

// 或者：
ReferenceError: document is not defined
    at HTMLCanvasElement.createElement (/workspace/decrypt.js:108:9)

// 以及属性链条断裂：
TypeError: Cannot read properties of undefined (reading 'createElement')
TypeError: Cannot read properties of undefined (reading 'userAgent')

这类报错的本质是运行宿主差异（Host Environment Divergence）。Google V8 引擎本身只遵循 ECMAScript 规范，定义了诸如 Array、Object、Function、Promise 等核心语言对象。在浏览器中，宿主程序（如 Chrome）在 V8 引擎基础之上注入了 Web API，包含 window（顶级全局作用域对象）、document（DOM 树入口）、navigator（浏览器信息）以及 location 等。而在 Node.js 中，顶层宿主对象为 global，其附加的标准库是文件系统 fs、网络 http、操作系统接口等，根本不包含任何 W3C DOM 标准相关的定义。

图 1：宿主环境能力隔离导致前端脚本在 Node.js 中执行断裂

二、排查与定位：确定代码对 DOM 的真实依赖

遇到报错并不意味着需要盲目引入一个庞大的仿真库。加密脚本中对 DOM 的访问通常分为两类：

1. 参与计算的有效数据依赖：例如算法读取了 document.title 作为 Hash 盐值，通过 canvas.toDataURL() 提取图形渲染指纹，或者读取屏幕尺寸 window.screen.width。这类依赖必须提供与目标网页一致的确定值，否则生成的加密串会被服务端判定非法。
2. 环境检测与蜜罐探针：很多商业防护前端（如各类滑块、设备指纹 SDK）会故意执行 typeof window !== 'undefined'、检测 window.chrome、以及校验原型链 Object.prototype.toString.call(document) === '[object HTMLDocument]'。这类操作的目的纯粹是判断当前运行环境是否为 Node.js 爬虫。

图 2：针对未知混淆代码的定位、归类与决策路径

三、三种主流解决方案与实施细节

解决 DOM 环境缺失问题，主要有以下三种手段。根据代码复杂度从轻量到重量依次选择：

方案一：手动定义基础全局对象（轻量补桩）

如果目标加密逻辑较为独立，只是在最外层读取了部分浏览器常量，直接在执行代码之前通过 Node.js 的 global 绑定缺失的全局对象是最简便、执行性能最高的方式。

// 基础补桩脚本：polyfill_basic.js
const window = {
  navigator: {
    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    platform: 'MacIntel',
    languages: ['zh-CN', 'zh', 'en'],
    webdriver: false,
    appVersion: '5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
  },
  location: {
    href: 'https://example.com/login',
    origin: 'https://example.com',
    protocol: 'https:',
    host: 'example.com',
    pathname: '/login',
    search: '',
    hash: ''
  },
  screen: {
    width: 1920,
    height: 1080,
    colorDepth: 24,
    availWidth: 1920,
    availHeight: 1040
  },
  document: {}
};

// 构造自引用关系
window.window = window;
window.self = window;
window.top = window;

// 绑定 document 基础方法
window.document = {
  characterSet: 'UTF-8',
  referrer: '',
  cookie: '',
  createElement: function(tag) {
    return {
      tagName: tag.toUpperCase(),
      getContext: function(type) {
        // 当算法读取 canvas 指纹时提供模拟桩
        return {
          fillText: function() {},
          arc: function() {},
          fillRect: function() {}
        };
      },
      toDataURL: function() {
        return 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
      }
    };
  },
  getElementById: function() { return null; },
  addEventListener: function() {}
};

// 挂载至全局，兼容直接访问未修饰变量 (如直接访问 navigator 而非 window.navigator)
global.window = window;
global.document = window.document;
global.navigator = window.navigator;
global.location = window.location;
global.screen = window.screen;

// 载入待逆向的目标加密文件
// require('./encrypt_target.js');

方案二：基于 ES6 Proxy 的动态探针（高效排查）

当遇到经过商业混淆（如 Obfuscator、Control Flow Flattening）的代码时，往往“补了一个报错，又出一个新报错”，人工猜测耗时极长。使用 Proxy 对未实现的对象建立拦截层，能在控制台精确打印出脚本尝试访问的属性、原型链和方法调用参数：

// proxy_probe.js：动态拦截与缺失告警探针
function createProbeProxy(targetObj, name) {
  return new Proxy(targetObj, {
    get(target, prop, receiver) {
      const val = Reflect.get(target, prop, receiver);
      if (val !== undefined) {
        // 若属性已存在且是对象，继续代理以支持链式排查
        if (typeof val === 'object' && val !== null) {
          return createProbeProxy(val, `${name}.${String(prop)}`);
        }
        return val;
      }
      // 捕获未定义属性读取
      console.warn(`[DOM探针告警] 尝试读取未定义属性: ${name}.${String(prop)}`);
      
      // 返回一个空函数/对象的通用代理，防止代码立即报 TypeError
      const fallback = function() {
        console.warn(`[DOM探针告警] 尝试调用未定义方法: ${name}.${String(prop)}()`);
        return createProbeProxy({}, `${name}.${String(prop)}()`);
      };
      return createProbeProxy(fallback, `${name}.${String(prop)}`);
    },
    set(target, prop, value) {
      console.log(`[DOM探针写入] 设定属性: ${name}.${String(prop)} =`, value);
      return Reflect.set(target, prop, value);
    }
  });
}

// 用探针代理初始化关键宿主
const baseWindow = {
  navigator: { userAgent: 'Mozilla/5.0' },
  document: {}
};
baseWindow.window = baseWindow;

global.window = createProbeProxy(baseWindow, 'window');
global.document = global.window.document;
global.navigator = global.window.navigator;

方案三：集成自动化 DOM 仿真库（jsdom）

当脚本不仅读取属性，还依赖真实 DOM 操作（如通过 document.createElement('canvas') 进行真实着色渲染，或者利用 MutationObserver 监听节点变动）时，手动补齐工作量巨大且易出错。此时直接引入 jsdom 是最完备的标准方案。

// 依赖安装命令 (终端执行)：
// npm install jsdom canvas

// jsdom_sandbox.js：创建标准 DOM 沙箱
const { JSDOM } = require('jsdom');

const dom = new JSDOM(
  `<!DOCTYPE html><html><head><title>Login</title></head><body><div id="container"></div></body></html>`,
  {
    url: 'https://example.com/login',
    referrer: 'https://example.com/',
    contentType: 'text/html',
    runScripts: 'dangerously',
    resources: 'usable'
  }
);

// 将 jsdom 的 window 映射到 Node 的 global 作用域
const domWindow = dom.window;

// 覆盖关键全局变量
global.window = domWindow;
global.document = domWindow.document;
global.navigator = domWindow.navigator;
global.location = domWindow.location;
global.screen = domWindow.screen;
global.HTMLElement = domWindow.HTMLElement;
global.HTMLCanvasElement = domWindow.HTMLCanvasElement;

// 若需要使用真实的 Canvas 绘图特征
try {
  const { createCanvas } = require('canvas');
  domWindow.HTMLCanvasElement.prototype.getContext = function(type) {
    const canvas = createCanvas(this.width || 300, this.height || 150);
    return canvas.getContext(type);
  };
} catch (e) {
  console.log('未安装 node-canvas，使用默认桩');
}

// 执行目标函数验证
console.log('DOM 环境就绪，标题:', document.title);
console.log('当前 URL:', location.href);

图 3：三种方案在工程实践中的关键指标与选型参考

四、防检测避坑：原型链与环境特征修正

在许多防护强度较高的网站中，简单的 global.window = {} 即使没有抛出未定义异常，计算出的加密结果依然会被服务端拒绝。这是因为现代反爬虫脚本普遍包含了环境指纹检测陷阱。

1. 原型链检测与构造函数校验

检测代码通常不直接读取属性，而是检查对象的原型关系。例如：

// 常见的检测逻辑：
if (Object.getPrototypeOf(document) !== HTMLDocument.prototype) {
  // 命中检测：断定为纯 Node 模拟环境
  triggerRiskControl();
}

如果仅用普通字面量对象 { } 作为 document，其原型直接指向 Object.prototype，检测会瞬间触发。正确的修补做法是建立符合浏览器标准的类继承关系：

// 模拟原生原型链
function HTMLDocument() {}
HTMLDocument.prototype = Object.create(Object.prototype);
HTMLDocument.prototype.constructor = HTMLDocument;

function Document() {}
Document.prototype = Object.create(HTMLDocument.prototype);

const documentInstance = Object.create(Document.prototype);
global.HTMLDocument = HTMLDocument;
global.Document = Document;
global.document = documentInstance;

2. toString 欺骗与防篡改

在浏览器中执行 window.navigator.toString() 返回的是 "[object Navigator]"，而自定义对象默认返回 "[object Object]"。此外，原生方法如 document.getElementById.toString() 的输出必须是 "function getElementById() { [native code] }"。

// 修正对象的 toString 输出
Object.defineProperty(global.navigator, Symbol.toStringTag, {
  value: 'Navigator',
  configurable: true
});

// 修正补丁函数的 [native code] 特征
function patchNativeToString(fn, fnName) {
  const nativeString = `function ${fnName}() { [native code] }`;
  Object.defineProperty(fn, 'toString', {
    value: function() { return nativeString; },
    configurable: true,
    writable: true
  });
}

patchNativeToString(document.createElement, 'createElement');

3. 清理 Node.js 宿主自带特征

很多逆向脚本在开始加密之前会扫描作用域中是否存在 Node.js 的专有对象。若存在，便直接篡改加密内部的常数矩阵：

// 清除或隐藏 Node.js 专有特征
delete global.process;
delete global.Buffer;
delete global.GLOBAL;
delete global.root;

图 4：完整补环境从语法消除到反爬对抗的四重防御闭环

五、验证与结论

在完成 DOM 环境补充后，如何确认代码已经真正修复并可投入使用？建议按照以下两个步骤进行终态验证：

• 同入参加密值对齐：在浏览器控制台中固定一段测试输入参数（如相同的密码明文与固定的时间戳 timestamp），获取控制台生成的密文。在本地 Node.js 脚本中使用相同参数执行，核对生成的密文字符串是否完全一致。
• 实际请求重放验证：将本地脚本计算得到的密文、Token 或 Cookie 代入到实际 HTTP 请求头或负载中，向目标服务端发起真实数据请求。如果服务端正常返回业务 JSON 且无风控拦截，即证明当前补齐的 DOM 环境已成功满足验证要求。

缺少 DOM 环境是 JS 逆向工程中最基础也是最核心的必经关卡。通过掌握由浅入深的三层修补方案，配合对原型链与原生特征的细致还原，即可快速解决各类代码执行中断，稳定复用前端算法。