JS逆向进阶：原型链属性伪造补环境技术详解

1. JS逆向补环境技术解析

在前端安全领域，环境检测与反检测的对抗从未停止。今天我要分享的是一个在JS逆向中经常用到的进阶技巧——通过原型链层次的属性方法伪造来补全环境。这种方法相比简单的变量覆盖或函数重写，具有更好的隐蔽性和稳定性。

1.1 为什么需要补环境

现代前端安全检测通常会验证运行环境的真实性，比如检查事件对象是否来自真实的用户交互。以MouseEvent为例，浏览器原生生成的MouseEvent对象会有一个isTrusted属性，当事件由用户真实触发时该属性为true，而通过脚本创建的事件对象则为false。

环境检测代码通常会这样写：

javascript复制document.addEventListener('click', function(e) {
    if (!e.isTrusted) {
        // 检测到非真实事件，可能是自动化脚本
        blockRequest();
    }
});

1.2 传统补环境方式的局限

常见的补环境方法是在全局覆盖原生对象：

javascript复制const oldMouseEvent = window.MouseEvent;
window.MouseEvent = class extends oldMouseEvent {
    get isTrusted() { return true; }
}

这种方法虽然简单，但存在几个问题：

1. 容易被检测到原型链被修改
2. 无法精细控制属性描述符
3. 可能破坏原有对象的内部一致性

2. 原型链层次补环境实现

2.1 核心实现代码解析

让我们看一个更完善的实现方案：

javascript复制MouseEvent = function MouseEvent() {
    // 定义不可配置的isTrusted属性
    Object.defineProperty(this, "isTrusted", {
        configurable: false,  // 不可配置
        enumerable: true,     // 可枚举
        get: function () {    // getter始终返回true
            return true;
        },
        set: undefined        // 无setter
    });

    // 修改getter方法的name属性
    Object.defineProperty(
        Object.getOwnPropertyDescriptor(this, "isTrusted").get, 
        "name", {
            value: "get isTrusted",
            configurable: true,
            enumerable: false,
            writable: false
        }
    );

    // 修改getter方法的length属性
    Object.defineProperty(
        Object.getOwnPropertyDescriptor(this, "isTrusted").get,
        "length", {
            value: 0,
            configurable: true,
            enumerable: false,
            writable: false
        }
    );
}

2.2 关键技术点解析

1. 属性描述符控制：

   • configurable: false 使属性不可被删除或重新定义
   • enumerable: true 保持与原生行为一致
   • 通过getter函数而非直接赋值，更接近原生实现

2. 方法属性伪造：

   • 原生getter函数通常有正确的name和length属性
   • 我们通过二次defineProperty来完善这些细节

3. 原型链完整性：

   • 保持构造函数形式而非class继承
   • 不破坏原型链原有结构

2.3 测试验证

javascript复制temp1 = new MouseEvent();
console.log(temp1.isTrusted); // true
console.log(Object.getOwnPropertyDescriptors(
    Object.getOwnPropertyDescriptor(temp1, "isTrusted").get
));

输出结果应该显示getter函数具有正确的属性描述符，与原生实现高度一致。

3. 深度伪造技巧

3.1 完善原型链

更完整的实现还应该处理原型链：

javascript复制MouseEvent.prototype = Object.create(OriginalMouseEvent.prototype, {
    constructor: {
        value: MouseEvent,
        enumerable: false,
        writable: true,
        configurable: true
    }
});

// 复制原型方法
for (const key of Object.getOwnPropertyNames(OriginalMouseEvent.prototype)) {
    if (!MouseEvent.prototype.hasOwnProperty(key)) {
        Object.defineProperty(
            MouseEvent.prototype,
            key,
            Object.getOwnPropertyDescriptor(
                OriginalMouseEvent.prototype,
                key
            )
        );
    }
}

3.2 静态属性处理

别忘了处理静态属性和方法：

javascript复制Object.defineProperties(MouseEvent, {
    prototype: {
        value: MouseEvent.prototype,
        enumerable: false,
        writable: false,
        configurable: false
    },
    [Symbol.species]: {
        get() { return OriginalMouseEvent; },
        enumerable: false,
        configurable: true
    }
});

// 复制静态属性
for (const key of Object.getOwnPropertyNames(OriginalMouseEvent)) {
    if (!MouseEvent.hasOwnProperty(key)) {
        Object.defineProperty(
            MouseEvent,
            key,
            Object.getOwnPropertyDescriptor(
                OriginalMouseEvent,
                key
            )
        );
    }
}

4. 检测与反检测

4.1 常见检测手段

环境检测可能会使用以下方式：

1. toString检测：MouseEvent.toString()
2. 原型链检测：Object.getPrototypeOf(new MouseEvent())
3. 属性描述符检测：Object.getOwnPropertyDescriptor(new MouseEvent(), 'isTrusted')
4. 函数特征检测：Object.getOwnPropertyDescriptor(new MouseEvent(), 'isTrusted').get.name

4.2 应对策略

1. 保持toString一致：

javascript复制MouseEvent.toString = function() {
    return 'function MouseEvent() { [native code] }';
};

2. 处理原型链检测：

javascript复制Object.setPrototypeOf(MouseEvent, OriginalMouseEvent);

3. 函数特征完善：

javascript复制const getter = Object.getOwnPropertyDescriptor(
    new OriginalMouseEvent('click'), 
    'isTrusted'
).get;

Object.defineProperty(
    Object.getOwnPropertyDescriptor(new MouseEvent(), 'isTrusted').get,
    'toString', {
        value: getter.toString.bind(getter),
        enumerable: false,
        configurable: true,
        writable: true
    }
);

5. 实战应用与注意事项

5.1 实际应用场景

1. 自动化测试中模拟用户交互
2. 爬虫绕过前端事件验证
3. 浏览器扩展修改页面行为

5.2 注意事项

1. 执行时机：

   • 必须在目标代码执行前完成补环境
   • 建议通过脚本注入或重写原生API的方式实现

2. 兼容性问题：

   • 不同浏览器对事件对象的实现有差异
   • 需要针对目标环境调整实现

3. 性能影响：

   • 频繁创建伪造对象可能影响性能
   • 在关键路径上避免过度使用

4. 法律风险：

   • 仅限合法用途
   • 尊重网站的使用条款

5.3 调试技巧

1. 使用Object.getOwnPropertyDescriptors全面检查对象
2. 对比原生对象和伪造对象的差异
3. 使用Proxy对象监控属性访问

javascript复制const monitored = new Proxy(new MouseEvent(), {
    get(target, prop) {
        console.log('Accessing:', prop);
        return target[prop];
    }
});

6. 高级技巧扩展

6.1 动态补环境

更高级的实现可以根据运行环境动态调整：

javascript复制function getPatchedMouseEvent() {
    const OriginalMouseEvent = window.MouseEvent;
    
    return function MouseEvent() {
        const event = new OriginalMouseEvent(...arguments);
        
        Object.defineProperty(event, 'isTrusted', {
            configurable: false,
            enumerable: true,
            get: () => true,
            set: undefined
        });
        
        return event;
    };
}

window.MouseEvent = getPatchedMouseEvent();

6.2 多层级伪造

对于更严格的环境检测，可能需要伪造多个层次：

javascript复制function deepPatchEvent(constructor) {
    const handler = {
        construct(target, args) {
            const instance = new target(...args);
            
            Object.defineProperty(instance, 'isTrusted', {
                configurable: false,
                enumerable: true,
                get: () => true,
                set: undefined
            });
            
            return instance;
        }
    };
    
    return new Proxy(constructor, handler);
}

window.MouseEvent = deepPatchEvent(window.MouseEvent);

6.3 隐藏补丁痕迹

使补丁更难被检测：

javascript复制let isPatching = false;

const originalDefineProperty = Object.defineProperty;
Object.defineProperty = function(obj, prop, desc) {
    if (isPatching && obj === window && prop === 'MouseEvent') {
        return originalDefineProperty(obj, prop, {
            configurable: true,
            enumerable: true,
            writable: true,
            value: desc.value
        });
    }
    return originalDefineProperty(obj, prop, desc);
};

isPatching = true;
window.MouseEvent = function MouseEvent() { /*...*/ };
isPatching = false;

7. 常见问题排查

7.1 问题：补环境后被检测到

解决方案：

1. 检查是否遗漏了某些属性或方法
2. 使用Object.getOwnPropertyNames对比原生对象
3. 验证原型链是否完整

7.2 问题：某些方法调用报错

解决方案：

1. 确保复制了所有原型方法
2. 正确处理this绑定
3. 保持方法签名一致

7.3 问题：性能明显下降

解决方案：

1. 避免在热路径上频繁创建对象
2. 考虑使用对象池
3. 简化不必要的属性定义

8. 最佳实践建议

1. 模块化实现：

javascript复制// patch-event.js
export function patchMouseEvent() {
    // 补环境实现
}

// 使用时
import { patchMouseEvent } from './patch-event';
patchMouseEvent();

2. 配置化：

javascript复制const config = {
    isTrusted: true,
    timeStamp: Date.now(),
    // 其他可配置属性
};

function createPatchedEvent(config) {
    // 根据配置生成补丁
}

3. 版本适配：

javascript复制function getBrowserVersion() {
    // 检测浏览器版本
    return 'chrome-90';
}

const patches = {
    'chrome-90': require('./patches/chrome-90'),
    'firefox-88': require('./patches/firefox-88')
};

patches[getBrowserVersion()].apply();

在实际项目中，补环境是一项需要细致和耐心的工作。每个属性、每个方法的实现都需要仔细推敲，确保与原生行为一致。我曾在某个项目中花了整整两天时间才完美补全一个事件对象的所有细节，但最终的效果非常值得——我们的自动化脚本能够稳定运行数月而不被检测到。