当前位置:   article > 正文

js逆向环境自吐(第七版)_自吐环境代码

自吐环境代码

前言

写了一个简单的环境自吐直接看缺了什么,借助了chatgpt的一些提示,如果有不正确的地方请指正。(仅供学习使用)代码在最下面。

  • 第五版增加了详细注释
  • 第六版支持了浏览器和Node使用,在浏览器上用需要将window变成windows,浏览器window暂时不支持使用代理(貌似用插件可以实现,正在寻找解决办法中…)
  • 第七版对代码进行了微调,新增了小红书X-S自吐样例

实践

1.某宝
在这里插入图片描述

2.某夕夕

在这里插入图片描述
3.某团
在这里插入图片描述
4.某红书X-S
在这里插入图片描述

Reference

chatgpt机器人

代码

window = new function monitorWindow() {
    // 设置打印字符串长度
    const MAX_VALUE_LENGTH = 70;
    /**
     截取 value 值,用于在日志中输出时限制字符串长度,避免日志过长。
     @param {Object} value - 需要被截取的值。
     @returns {Object} 返回截取后的字符串值。
     */
    function truncateValue(value) {
        if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) {
            return value.substring(0, MAX_VALUE_LENGTH) + "...";
        }

        if (typeof value !== "object") {
            return value;
        }

        const keys = Object.keys(value);
        const result = {};

        if (keys.length > 2) {
            result[keys[0]] = value[keys[0]].toString().substring(0,MAX_VALUE_LENGTH) + "...";
        }

        return "{" + Object.entries(result).map(([k, v]) => `${k}: ${v}`).join(", ") + "}";
    }

    /**
     序列化 value 值,用于在日志中输出时处理对象或方法。
     @param {Object} value - 需要被序列化的值。
     @returns {Object} 返回序列化后的字符串值。
     */
    function serializeValue(value) {
        if (typeof value === "object") {
            try {
                return JSON.stringify(value);
            } catch {
                return value;
            }
        }
        return value;
    }

    /**
     * 创建代理处理程序,用于对被代理对象的属性访问、属性设置、方法调用等进行监听并打印操作日志。
     * @param {Object} name - 对象名。
     * @returns {Object} 返回代理处理程序。
     */
    function createHandler(name) {

        function shouldSkipKey(key, name) {

            if (key === 'window' || key === 'self' || key === 'global' ||key === 'globalThis' || key === name || key === "_globalObject") {
                return true;
            }

            if (typeof key === 'string' && (key.startsWith('__') || key.endsWith('__'))) {
                return true;
            }

            return String(key) === "Symbol(impl)" || String(key) === "Element" || String(key) === "prototype" || truncateValue(serializeValue(name)).includes("Symbol(impl)");


        }
        return {
            get(target, key, receiver) {
                // 打印调用栈
                // console.log(new Error().stack);
                // target=Object.defineProperty(target)
                // 获取属性值

                const value = target[key];

                // 不打印toString和valueOf特定的信息
                if (key === Symbol.unscopables || key === 'toString' || key === 'valueOf') {
                    return Reflect.get(target, key, receiver);
                }

                // 内部属性
                if (shouldSkipKey(key, name)) {
                    console.log(`访问: "${(String(key) + "\"内部属性").padEnd(28, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`,truncateValue(serializeValue(value)));
                    return value;
                }

                // 处理代理函数的构造函数
                if (typeof value === 'function' && value.hasOwnProperty('prototype')) {
                    try{
                        new value
                        // console.log(`调用了构造函数: ${String(key).padEnd(22, " ")} |"参数": ${JSON.stringify(value)}`);
                        return new Proxy(value,createHandler(`${String(name)}.${String(key)}`))
                    }catch (e) {
                    }
                }

                // 处理代理对象的属性访问和设置()
                if (typeof value === 'function' && !value.hasOwnProperty('prototype')) {
                    return function getFunc(...args) {
                        try{
                            var result = Reflect.apply(value, target, args);
                            console.log(`调用了函数: ${(String(key)).padEnd(27, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${truncateValue(serializeValue(args))}`);
                            return result
                        } catch (e){
                            // return  Reflect.apply(value, target, args[1])
                        }
                    }
                }

                // 处理代理对象的属性访问和设置(递归调用)
                if (value != null && (typeof value === 'object')) {
                    console.log(`访问: "${(String(key) + "\"属性").padEnd(30, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                    return new Proxy(value,createHandler(`${String(name)}.${String(key)}`));
                }

                if (typeof value === 'function'){
                    // 在Node上和windows有些差异,node有函数也有prototype,所以需要继续回调
                    return new Proxy(value,createHandler(`${String(name)}.${String(key)}`));
                }else{
                    // 不进行代理的属性或方法
                    console.log(`获取: "${(String(key) + "\"属性").padEnd(30, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                }
                return value;
            },
            set(target, key, value, receiver) {
                // 打印调用栈
                // console.log(new Error().stack);
                console.log(`设置对象: "${(String(key) + "\"").padEnd(28, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|值=`, truncateValue(serializeValue(value)));
                return Reflect.set(target, key, value, receiver);
            },
            apply(target, thisArg, args) {
                // 打印调用栈
                // console.log(new Error().stack);
                console.log(`调用了函数: ${(String(name)).padEnd(27, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${truncateValue(serializeValue(args))}`);
                return Reflect.apply(target, thisArg, args);
            },
            construct(target, args, newTarget) {
                // 打印调用栈
                // console.log(new Error().stack);
                console.log(`调用了构造函数: ${String(target.name).padEnd(23, " ")}|"${(truncateValue(serializeValue(name)) + "\"对象").padEnd(50, " ")}|参数= ${JSON.stringify(args)}`);
                return Reflect.construct(target, args, newTarget);
            },
        };
    }
    return new Proxy(window,createHandler('window'));
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/645871
推荐阅读
相关标签
  

闽ICP备14008679号