js怎么判断原型是否被修改过

Array.prototype

Object.prototype

Object.prototype

Array.prototype

// 假设在所有外部脚本加载之前执行
const initialObjectPrototypeKeys = new Set(Object.getOwnPropertyNames(Object.prototype));
const initialArrayPrototypeKeys = new Set(Object.getOwnPropertyNames(Array.prototype));

function checkPrototypeModification(targetPrototype, initialKeysSet, prototypeName = 'Unknown') {
    const currentKeys = new Set(Object.getOwnPropertyNames(targetPrototype));
    let modified = false;
    const addedKeys = [];

    for (const key of currentKeys) {
        if (!initialKeysSet.has(key)) {
            addedKeys.push(key);
            modified = true;
        }
    }

    if (modified) {
        console.warn(`警告：${prototypeName} 原型可能已被修改！检测到新增属性/方法:`, addedKeys);
        // 你可以进一步检查这些新增属性的具体值或类型
    } else {
        console.log(`${prototypeName} 原型目前看起来是干净的。`);
    }
    return modified;
}

// 稍后在代码运行时，比如在某个关键操作前
// checkPrototypeModification(Object.prototype, initialObjectPrototypeKeys, 'Object.prototype');
// checkPrototypeModification(Array.prototype, initialArrayPrototypeKeys, 'Array.prototype');

// 实际使用时，你可能需要更复杂的逻辑来处理属性值的变化，而不仅仅是新增属性。
// 但对于原型污染，新增属性是最常见的表现形式。

Object.prototype

__proto__

constructor

Array.prototype.map

String.prototype

Array.prototype

first()

last()

Object.freeze()

no-extend-native

// 这是一个概念性的示例，实际应用中需要更严谨的错误处理和性能考量
function monitorPrototype(targetPrototype, prototypeName = 'Unknown') {
    const modifications = [];

    const handler = {
        set(target, prop, value, receiver) {
            console.warn(`[${prototypeName} Proxy] 检测到属性写入：${String(prop)} =`, value);
            modifications.push({
                type: 'set',
                property: prop,
                value: value,
                timestamp: new Date().toISOString()
            });
            return Reflect.set(target, prop, value, receiver);
        },
        deleteProperty(target, prop) {
            console.warn(`[${prototypeName} Proxy] 检测到属性删除：${String(prop)}`);
            modifications.push({
                type: 'delete',
                property: prop,
                timestamp: new Date().toISOString()
            });
            return Reflect.deleteProperty(target, prop);
        },
        // 还可以拦截 defineProperty, getOwnPropertyDescriptor 等
    };

    // 替换原始原型，这通常需要非常小心，并且只在开发或测试环境进行
    // 因为直接替换内置原型可能导致不可预料的问题
    // 例如：
    // const originalArrayPrototype = Array.prototype;
    // Array.prototype = new Proxy(originalArrayPrototype, handler);
    // 这种做法非常激进，不推荐在生产环境直接替换内置原型。
    // 更实用的方式是监控你自己的自定义类原型。

    // 对于Object.prototype，你不能直接替换它。
    // Proxy更适合用于你自己的自定义对象或类实例。
    // 但如果你真的想监控一个对象，可以这样做：
    // const myObject = {};
    // const proxiedMyObject = new Proxy(myObject, handler);
    // Object.setPrototypeOf(proxiedMyObject, targetPrototype); // 让它继承目标原型
    // 这样，对 proxiedMyObject 的操作会被拦截，但对 targetPrototype 本身的操作不会。
    // 这说明了直接监控内置原型修改的复杂性。
    // Proxy的主要用处在于拦截对“被代理对象”的操作，而不是其原型链上的操作。
    // 如果要监控原型链上的修改，需要代理原型本身，而内置原型通常不推荐被替换。

    // 更实际的Proxy应用场景：
    // 监控一个自定义类的原型
    class MyCustomClass {}
    const originalMyCustomClassPrototype = MyCustomClass.prototype;
    MyCustomClass.prototype = new Proxy(originalMyCustomClassPrototype, handler);

    // 此时，任何对 MyCustomClass.prototype 的修改都会被 Proxy 拦截。
    // MyCustomClass.prototype.newMethod = function() {}; // 会触发 Proxy 的 set 拦截
    // delete MyCustomClass.prototype.newMethod; // 会触发 Proxy 的 deleteProperty 拦截

    return {
        getModifications: () => modifications,
        // 可以提供一个方法来恢复原始原型，但同样要小心
    };
}

// 示例用法（仅限自定义类原型，内置原型替换风险极高）
// const myClassMonitor = monitorPrototype(MyCustomClass.prototype, 'MyCustomClass.prototype');
// MyCustomClass.prototype.testProp = 'hello';
// console.log(myClassMonitor.getModifications());

// 在你的应用程序启动的早期
const canaryKey = Symbol('__my_app_prototype_canary_key__'); // 使用Symbol避免命名冲突
Object.defineProperty(Object.prototype, canaryKey, {
    value: 'my_secret_canary_value_12345',
    writable: false, // 让它不可写，增加安全性
    configurable: true, // 允许删除，以便检测删除操作
    enumerable: false // 不可枚举，避免污染for...in循环
});

// 在后续需要检查的时候
function checkObjectPrototypeCanary() {
    if (!Object.prototype.hasOwnProperty(canaryKey)) {
        console.error('严重警告：Object.prototype上的金丝雀属性已被删除！原型可能已被恶意修改！');
        return false;
    }
    if (Object.prototype[canaryKey] !== 'my_secret_canary_value_12345') {
        console.error('严重警告：Object.prototype上的金丝雀属性值被修改！原型可能已被恶意修改！');
        return false;
    }
    // console.log('Object.prototype金丝雀属性正常。');
    return true;
}

// 可以在关键操作前调用：
// checkObjectPrototypeCanary();