1
//通用阻止切屏检测
2
// ==UserScript==
3
// @name         通用阻止切屏检测
4
// @namespace    http://tampermonkey.net/
5
// @version      0.1.0
6
// @description  尝试阻止各类网站的切屏、焦点丢失等检测
7
// @author       nodeseek@小号 && Gemini
8
// @match        http://*/*
9
// @match        https://*/*
10
// @run-at       document-start
11
// @grant        unsafeWindow
12
// @license      GPL-3.0
13
// ==/UserScript==
14

15
(function () {
16
    'use strict';
17
    const window = unsafeWindow; // 使用原始 window 对象
18

19
    // 黑名单事件，这些事件的监听器将被阻止
20
    const blackListedEvents = new Set([
21
        "visibilitychange", // 页面可见性改变
22
        "blur",             // 元素或窗口失去焦点
23
        "focus",            // 元素或窗口获得焦点 (某些检测可能反向利用focus)
24
        "pagehide",         // 页面隐藏（例如导航到其他页面）
25
        "freeze",           // 页面被冻结 (较新的事件)
26
        "resume",           // 页面从冻结状态恢复 (较新的事件)
27
        "mouseleave",       // 鼠标移出元素（通常是 document 或 body）
28
        "mouseout",         // 鼠标移出元素（更通用的移出，但要小心副作用）
29
        // "focusout",      // 元素将要失去焦点（与blur类似，但更通用，看情况添加）
30
        // "focusin",       // 元素将要获得焦点（与focus类似，看情况添加）
31
    ]);
32

33
    // 白名单属性，这些属性在 document 对象上将被伪造
34
    const spoofedDocumentProperties = {
35
        hidden: { value: false, configurable: true },
36
        mozHidden: { value: false, configurable: true }, // Firefox (旧版)
37
        msHidden: { value: false, configurable: true },  // Internet Explorer
38
        webkitHidden: { value: false, configurable: true }, // Chrome, Safari, Opera (旧版 Blink/WebKit)
39
        visibilityState: { value: "visible", configurable: true },
40
        hasFocus: { value: () => true, configurable: true }
41
    };
42

43
    // 需要清空/置空的事件处理器属性 (on-event handlers)
44
    const eventHandlersToNullifyDocument = [
45
        "onvisibilitychange",
46
        "onblur",
47
        "onfocus",
48
        "onmouseleave",
49
        "onmouseout",
50
        // "onfocusout",
51
        // "onfocusin",
52
        "onpagehide",
53
        "onfreeze",
54
        "onresume"
55
    ];
56

57
    const eventHandlersToNullifyWindow = [
58
        "onblur",
59
        "onfocus",
60
        "onpagehide",
61
        "onpageshow", // 有些检测可能通过 pageshow 结合 persisted 属性判断
62
        "onfreeze",
63
        "onresume",
64
        "onmouseleave", // window 也有 onmouseleave
65
        "onmouseout"
66
    ];
67

68
    const isDebug = false; // 设置为 true 以启用调试日志
69
    const scriptPrefix = "[通用阻止切屏检测]";
70
    const log = console.log.bind(console, `%c${scriptPrefix}`, 'color: #4CAF50; font-weight: bold;');
71
    const warn = console.warn.bind(console, `%c${scriptPrefix}`, 'color: #FFC107; font-weight: bold;');
72
    const error = console.error.bind(console, `%c${scriptPrefix}`, 'color: #F44336; font-weight: bold;');
73
    const debug = isDebug ? log : () => { };
74

75
    /**
76
     * 伪装函数的 toString 方法，使其看起来像原始函数。
77
     * @param {Function} modifiedFunction 被修改的函数
78
     * @param {Function} originalFunction 原始函数
79
     */
80
    function patchToString(modifiedFunction, originalFunction) {
81
        if (typeof modifiedFunction !== 'function' || typeof originalFunction !== 'function') {
82
            warn("patchToString: 传入的参数不是函数。", modifiedFunction, originalFunction);
83
            return;
84
        }
85
        try {
86
            const originalToStringSource = Function.prototype.toString.call(originalFunction);
87
            modifiedFunction.toString = () => originalToStringSource;
88

89
            // 进一步伪装 toString.toString
90
            const originalToStringToStringSource = Function.prototype.toString.call(originalFunction.toString);
91
            Object.defineProperty(modifiedFunction.toString, 'toString', {
92
                value: () => originalToStringToStringSource,
93
                enumerable: false,
94
                configurable: true, // 保持可配置，以防万一
95
                writable: false
96
            });
97
            debug(`patchToString applied for: ${originalFunction.name || 'anonymous function'}`);
98
        } catch (e) {
99
            error("patchToString failed:", e, "for function:", originalFunction.name);
100
        }
101
    }
102

103

104
    /**
105
     * 劫持并修改对象的 addEventListener 方法。
106
     * @param {EventTarget} targetObject 要劫持的对象 (window, document, Element)
107
     * @param {string} objectName 用于日志记录的对象名称
108
     */
109
    function patchAddEventListener(targetObject, objectName) {
110
        if (!targetObject || typeof targetObject.addEventListener !== 'function') {
111
            warn(`Cannot patch addEventListener for invalid target: ${objectName}`);
112
            return;
113
        }
114
        const originalAddEventListener = targetObject.addEventListener;
115

116
        targetObject.addEventListener = function (type, listener, optionsOrCapture) {
117
            if (blackListedEvents.has(type.toLowerCase())) {
118
                log(`BLOCKED ${objectName}.addEventListener: ${type}`);
119
                return undefined; // 阻止添加黑名单中的事件监听器
120
            }
121
            debug(`ALLOWED ${objectName}.addEventListener: ${type}`, listener, optionsOrCapture);
122
            return originalAddEventListener.call(this, type, listener, optionsOrCapture);
123
        };
124

125
        patchToString(targetObject.addEventListener, originalAddEventListener);
126
        log(`${objectName}.addEventListener patched.`);
127
    }
128

129
    /**
130
     * 劫持并修改对象的 removeEventListener 方法 (可选，但建议一起修改)。
131
     * @param {EventTarget} targetObject 要劫持的对象
132
     * @param {string} objectName 用于日志记录的对象名称
133
     */
134
    function patchRemoveEventListener(targetObject, objectName) {
135
        if (!targetObject || typeof targetObject.removeEventListener !== 'function') {
136
            warn(`Cannot patch removeEventListener for invalid target: ${objectName}`);
137
            return;
138
        }
139
        const originalRemoveEventListener = targetObject.removeEventListener;
140

141
        targetObject.removeEventListener = function (type, listener, optionsOrCapture) {
142
            if (blackListedEvents.has(type.toLowerCase())) {
143
                log(`Original call to ${objectName}.removeEventListener for blacklisted event '${type}' would have been ignored by our addEventListener patch anyway. Allowing native call if needed.`);
144
                // 即使我们阻止了 addEventListener，原始的 removeEventListener 仍然应该能安全调用
145
                // 因为如果监听器从未被添加，调用 remove 也无害。
146
            }
147
            debug(`PASSTHROUGH ${objectName}.removeEventListener: ${type}`, listener, optionsOrCapture);
148
            return originalRemoveEventListener.call(this, type, listener, optionsOrCapture);
149
        };
150
        patchToString(targetObject.removeEventListener, originalRemoveEventListener);
151
        log(`${objectName}.removeEventListener patched.`);
152
    }
153

154

155
    /**
156
     * 修改对象上的属性，使其返回伪造的值。
157
     * @param {object} targetObject 目标对象 (e.g., document)
158
     * @param {object} propertiesToSpoof 属性描述对象
159
     * @param {string} objectName 对象名称
160
     */
161
    function spoofProperties(targetObject, propertiesToSpoof, objectName) {
162
        if (!targetObject) {
163
            warn(`Cannot spoof properties for invalid target: ${objectName}`);
164
            return;
165
        }
166
        for (const prop in propertiesToSpoof) {
167
            if (Object.prototype.hasOwnProperty.call(propertiesToSpoof, prop)) {
168
                try {
169
                    Object.defineProperty(targetObject, prop, propertiesToSpoof[prop]);
170
                    debug(`Spoofed ${objectName}.${prop}`);
171
                } catch (e) {
172
                    error(`Failed to spoof ${objectName}.${prop}:`, e);
173
                }
174
            }
175
        }
176
        log(`${objectName} properties spoofed.`);
177
    }
178

179
    /**
180
     * 清空或置空对象上的事件处理器属性。
181
     * @param {object} targetObject 目标对象
182
     * @param {string[]} eventHandlerNames 事件处理器名称数组
183
     * @param {string} objectName 对象名称
184
     */
185
    function nullifyEventHandlers(targetObject, eventHandlerNames, objectName) {
186
        if (!targetObject) {
187
            warn(`Cannot nullify event handlers for invalid target: ${objectName}`);
188
            return;
189
        }
190
        eventHandlerNames.forEach(handlerName => {
191
            try {
192
                Object.defineProperty(targetObject, handlerName, {
193
                    get: () => {
194
                        debug(`Access to ${objectName}.${handlerName} (get), returning undefined.`);
195
                        return undefined;
196
                    },
197
                    set: (newHandler) => {
198
                        log(`Attempt to set ${objectName}.${handlerName} blocked.`);
199
                        if (typeof newHandler === 'function') {
200
                             // 可以选择性地调用 newHandler，或者完全阻止
201
                             // debug(`(Blocked) Handler function was:`, newHandler);
202
                        }
203
                    },
204
                    configurable: true // 保持可配置，以便脚本可以多次运行或被其他脚本修改
205
                });
206
                debug(`Nullified ${objectName}.${handlerName}`);
207
            } catch (e) {
208
                error(`Failed to nullify ${objectName}.${handlerName}:`, e);
209
            }
210
        });
211
        log(`${objectName} on-event handlers nullified.`);
212
    }
213

214
    // --- 开始执行 ---
215

216
    log("Script starting...");
217

218
    // 1. 劫持 window 和 document 的 addEventListener/removeEventListener
219
    patchAddEventListener(window, "window");
220
    patchRemoveEventListener(window, "window"); // 也 patch removeEventListener 以保持一致性
221
    patchAddEventListener(document, "document");
222
    patchRemoveEventListener(document, "document");
223

224
    // 2. 修改 document 的属性
225
    spoofProperties(document, spoofedDocumentProperties, "document");
226

227
    // 3. 置空 document 和 window 上的事件处理器
228
    nullifyEventHandlers(document, eventHandlersToNullifyDocument, "document");
229
    nullifyEventHandlers(window, eventHandlersToNullifyWindow, "window");
230

231
    // 4. 对于 document.body，需要等待 DOMContentLoaded
232
    // 使用 MutationObserver 确保 body 存在时立即 patch，比 DOMContentLoaded 更早且更可靠
233
    const observer = new MutationObserver((mutations, obs) => {
234
        if (document.body) {
235
            patchAddEventListener(document.body, "document.body");
236
            patchRemoveEventListener(document.body, "document.body");
237
            // 对于 document.body，也可以考虑 nullify onmouseleave, onmouseout 等
238
            nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");
239
            log("document.body patched via MutationObserver.");
240
            obs.disconnect(); // 完成任务后断开观察者
241
        }
242
    });
243

244
    if (document.body) { // 如果 body 已经存在 (不太可能在 document-start，但以防万一)
245
        patchAddEventListener(document.body, "document.body");
246
        patchRemoveEventListener(document.body, "document.body");
247
        nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");
248
        log("document.body patched directly.");
249
    } else {
250
        observer.observe(document.documentElement || document, { childList: true, subtree: true });
251
    }
252

253

254
    // 5. 调试：劫持计时器 (如果 isDebug 为 true)
255
    if (isDebug) {
256
        const originalSetInterval = window.setInterval;
257
        window.setInterval = function(...args) {
258
            const id = originalSetInterval.apply(this, args);
259
            debug("calling window.setInterval", id, args);
260
            return id;
261
        };
262
        patchToString(window.setInterval, originalSetInterval);
263

264
        const originalSetTimeout = window.setTimeout;
265
        window.setTimeout = function(...args) {
266
            const id = originalSetTimeout.apply(this, args);
267
            debug("calling window.setTimeout", id, args);
268
            return id;
269
        };
270
        patchToString(window.setTimeout, originalSetTimeout);
271
        log("Timer functions (setInterval, setTimeout) wrapped for debugging.");
272
    }
273

274
    log("Script execution finished. Monitoring active.");
275

276
})();