☰

Greasy Fork is available in English.

DevTools Bypass

Bypass for website restrictions on DevTools with enhanced protection

  1. // ==UserScript==
  2. // @name         DevTools Bypass
  3. // @name:vi      Bỏ Qua Chặn DevTools
  4. // @name:zh-CN   开发工具限制绕过
  5. // @name:ru      Разблокировка DevTools
  6. // @namespace    https://greatest.deepsurf.us/vi/users/1195312-renji-yuusei
  7. // @version      2025.06.10.1
  8. // @description  Bypass for website restrictions on DevTools with enhanced protection
  9. // @description:vi Bỏ qua các hạn chế của trang web về DevTools với bảo vệ nâng cao
  10. // @description:zh-CN 绕过网站对开发工具的限制，具有增强的保护功能
  11. // @description:ru   Разблокировка DevTools с усиленной защитой
  12. // @author       Yuusei
  13. // @match        *://*/*
  14. // @grant        unsafeWindow
  15. // @run-at       document-start
  16. // @license      GPL-3.0-only
  17. // ==/UserScript==
  18.  
  19. (() => {
  20.   'use strict';
  21.  
  22.   // Constants
  23.   const CONSTANTS = {
  24.     PREFIX: '[DevTools Bypass]',
  25.     LOG_LEVELS: {
  26.       INFO: 'info',
  27.       WARN: 'warn', 
  28.       ERROR: 'error',
  29.       DEBUG: 'debug'
  30.     },
  31.     TIME_THRESHOLDS: {
  32.       DEBUGGER: 80,
  33.       CACHE: 30000
  34.     },
  35.     CACHE_TTL: {
  36.         DEBUGGER_CHECK: 500
  37.     }
  38.   };
  39.  
  40.   // Configuration
  41.   const config = {
  42.     antiDebugRegex: new RegExp([
  43.         // debugger, debug(), etc.
  44.         /[;\s]*(?:debugger|debug(?:ger)?|breakpoint)[\s;]*/,
  45.         // new Function('debugger')(), etc.
  46.         /(?:eval|Function|setTimeout|setInterval)\s*\(\s*['"`].*?debugger.*?['"`]\s*\)/,
  47.         // devtools checks
  48.         /(?:isDevTools?|devtools?|debugMode|debug_enabled)\s*[=:]\s*(?:true|1|!0|yes)/,
  49.         // console checks
  50.         /console\.(?:log|warn|error|info|debug|trace|dir|table)/,
  51.         // source map urls
  52.         /\/\/[#@]\s*source(?:Mapping)?URL\s*=.*/,
  53.         // Known anti-debug library patterns
  54.         /FuckDevTools|devtools-detector/
  55.     ].map(r => r.source).join('|'), 'gi'),
  56.  
  57.     consoleProps: ['log', 'warn', 'error', 'info', 'debug', 'trace', 'dir', 'dirxml', 'table', 'profile', 'group', 'groupEnd', 'time', 'timeEnd'],
  58.     cutoffs: {
  59.       debugger: { amount: 30, within: CONSTANTS.TIME_THRESHOLDS.CACHE },
  60.       debuggerThrow: { amount: 30, within: CONSTANTS.TIME_THRESHOLDS.CACHE }
  61.     },
  62.     bypassTriggers: {
  63.       timeThreshold: CONSTANTS.TIME_THRESHOLDS.DEBUGGER,
  64.       stackDepth: 30,
  65.       recursionLimit: 50
  66.     },
  67.     debuggerDetector: {
  68.         cacheTTL: CONSTANTS.CACHE_TTL.DEBUGGER_CHECK,
  69.         historyCleanupInterval: 60000 // 1 minute
  70.     },
  71.     logging: {
  72.       enabled: true,
  73.       prefix: CONSTANTS.PREFIX,
  74.       levels: Object.values(CONSTANTS.LOG_LEVELS),
  75.       detailedErrors: true,
  76.       monitorAPI: false,
  77.       monitorDOM: false
  78.     },
  79.     protection: {
  80.       preventDevToolsKeys: true,
  81.       hideStackTraces: true,
  82.       sanitizeErrors: true,
  83.       obfuscateTimers: true,
  84.       preventRightClick: true,
  85.       preventViewSource: true,
  86.       preventCopy: true,
  87.       preventPaste: true,
  88.       preventPrint: true,
  89.       preventSave: true
  90.     }
  91.   };
  92.  
  93.   // Logger class
  94.   class Logger {
  95.     static #instance;
  96.     #lastLog = 0;
  97.     #logCount = 0;
  98.     #logBuffer = [];
  99.  
  100.     constructor() {
  101.       if (Logger.#instance) {
  102.         return Logger.#instance;
  103.       }
  104.       Logger.#instance = this;
  105.       this.#setupBufferFlush();
  106.     }
  107.  
  108.     #setupBufferFlush() {
  109.       setInterval(() => {
  110.         if (this.#logBuffer.length) {
  111.           this.#flushBuffer();
  112.         }
  113.       }, 1000);
  114.     }
  115.  
  116.     #flushBuffer() {
  117.       this.#logBuffer.forEach(({level, args}) => {
  118.         console[level](config.logging.prefix, ...args);
  119.       });
  120.       this.#logBuffer = [];
  121.     }
  122.  
  123.     #shouldLog() {
  124.       const now = Date.now();
  125.       if (now - this.#lastLog > 1000) {
  126.         this.#logCount = 0;
  127.       }
  128.       this.#lastLog = now;
  129.       return ++this.#logCount <= 10;
  130.     }
  131.  
  132.     #log(level, ...args) {
  133.       if (!config.logging.enabled || !this.#shouldLog()) return;
  134.       this.#logBuffer.push({ level, args });
  135.     }
  136.  
  137.     info(...args) { this.#log(CONSTANTS.LOG_LEVELS.INFO, ...args); }
  138.     warn(...args) { this.#log(CONSTANTS.LOG_LEVELS.WARN, ...args); }
  139.     error(...args) { this.#log(CONSTANTS.LOG_LEVELS.ERROR, ...args); }
  140.     debug(...args) { this.#log(CONSTANTS.LOG_LEVELS.DEBUG, ...args); }
  141.   }
  142.  
  143.   // Original functions store
  144.   const OriginalFunctions = {
  145.     defineProperty: Object.defineProperty,
  146.     getOwnPropertyDescriptor: Object.getOwnPropertyDescriptor,
  147.     setTimeout: window.setTimeout,
  148.     setInterval: window.setInterval,
  149.     Date: window.Date,
  150.     now: Date.now,
  151.     performance: window.performance,
  152.     Function: window.Function,
  153.     eval: window.eval,
  154.     console: {},
  155.     toString: Function.prototype.toString,
  156.     preventDefault: Event.prototype.preventDefault,
  157.     getComputedStyle: window.getComputedStyle,
  158.     addEventListener: window.addEventListener,
  159.     removeEventListener: window.removeEventListener,
  160.     fetch: window.fetch,
  161.     XMLHttpRequest: window.XMLHttpRequest,
  162.  
  163.     initConsole() {
  164.       config.consoleProps.forEach(prop => {
  165.         if (console[prop]) {
  166.           this.console[prop] = console[prop].bind(console);
  167.         }
  168.       });
  169.     }
  170.   };
  171.  
  172.   OriginalFunctions.initConsole();
  173.  
  174.   // Debugger detector
  175.   class DebuggerDetector {
  176.     static #detectionCache = new Map();
  177.     static #detectionHistory = [];
  178.     static #historyCleanupTimer = null;
  179.  
  180.     static isPresent() {
  181.       try {
  182.         const cacheKey = 'debugger_check';
  183.         const cached = this.#detectionCache.get(cacheKey);
  184.         if (cached && Date.now() - cached.timestamp < config.debuggerDetector.cacheTTL) {
  185.           return cached.result;
  186.         }
  187.  
  188.         const startTime = OriginalFunctions.now.call(Date);
  189.         new Function('debugger;')();
  190.         const timeDiff = OriginalFunctions.now.call(Date) - startTime;
  191.  
  192.         const result = timeDiff > config.bypassTriggers.timeThreshold;
  193.         this.#detectionCache.set(cacheKey, {
  194.           result,
  195.           timestamp: Date.now()
  196.         });
  197.  
  198.         this.#detectionHistory.push({
  199.           timestamp: Date.now(),
  200.           result,
  201.           timeDiff
  202.         });
  203.  
  204.         // Keep history for 5 minutes
  205.         const fiveMinutesAgo = Date.now() - 300000;
  206.         this.#detectionHistory = this.#detectionHistory.filter(entry => entry.timestamp > fiveMinutesAgo);
  207.  
  208.         return result;
  209.       } catch {
  210.         return false;
  211.       }
  212.     }
  213.  
  214.     static analyzeStack() {
  215.       try {
  216.         const stack = new Error().stack;
  217.         if (!stack) return { depth: 0, hasDebugKeywords: false, isRecursive: false, suspiciousPatterns: [], stackHash: '' };
  218.         
  219.         const frames = stack.split('\n');
  220.         const uniqueFrames = new Set(frames);
  221.  
  222.         return {
  223.           depth: frames.length,
  224.           hasDebugKeywords: config.antiDebugRegex.test(stack),
  225.           isRecursive: uniqueFrames.size < frames.length,
  226.           suspiciousPatterns: this.#detectSuspiciousPatterns(stack),
  227.           stackHash: this.#generateStackHash(stack)
  228.         };
  229.       } catch {
  230.         return {
  231.           depth: 0,
  232.           hasDebugKeywords: false,
  233.           isRecursive: false,
  234.           suspiciousPatterns: [],
  235.           stackHash: ''
  236.         };
  237.       }
  238.     }
  239.  
  240.     static #detectSuspiciousPatterns(stack) {
  241.       const patterns = [
  242.         /eval.*?\(/g,
  243.         /Function.*?\(/g,
  244.         /debugger/g,
  245.         /debug/g,
  246.         /DevTools/g,
  247.         /console\./g,
  248.         /chrome-extension/g
  249.       ];
  250.       return patterns.filter(pattern => pattern.test(stack));
  251.     }
  252.  
  253.     static #generateStackHash(stack) {
  254.       return Array.from(stack).reduce((hash, char) => {
  255.         hash = ((hash << 5) - hash) + char.charCodeAt(0);
  256.         return hash & hash;
  257.       }, 0).toString(36);
  258.     }
  259.  
  260.     static getDetectionStats() {
  261.       const now = Date.now();
  262.       const recentDetections = this.#detectionHistory.filter(entry => 
  263.         entry.timestamp > now - 60000
  264.       );
  265.  
  266.       return {
  267.         total: recentDetections.length,
  268.         positive: recentDetections.filter(entry => entry.result).length,
  269.         averageTime: recentDetections.reduce((acc, curr) => 
  270.           acc + curr.timeDiff, 0) / (recentDetections.length || 1)
  271.       };
  272.     }
  273.  
  274.     static startHistoryCleanup() {
  275.         if (this.#historyCleanupTimer) return;
  276.         this.#historyCleanupTimer = setInterval(() => {
  277.             const fiveMinutesAgo = Date.now() - 300000;
  278.             this.#detectionHistory = this.#detectionHistory.filter(entry => entry.timestamp > fiveMinutesAgo);
  279.         }, config.debuggerDetector.historyCleanupInterval);
  280.     }
  281.   }
  282.  
  283.   // Protection class
  284.   class Protection {
  285.     static #combinedPattern = null;
  286.     
  287.     static applyAll() {
  288.       this.#patchGlobalDebugVariables();
  289.       this.#protectTimers();
  290.       this.#protectTiming();
  291.       this.#protectFunction();
  292.       this.#protectStack();
  293.       this.#protectEval();
  294.       this.#protectConsole();
  295.       this.#setupMutationObserver();
  296.       this.#protectDeveloperKeys();
  297.       this.#protectRightClick();
  298.       this.#protectNetwork();
  299.       this.#protectStorage();
  300.       this.#protectClipboard();
  301.       this.#protectPrinting();
  302.       this.#protectWebWorkers();
  303.       this.#applyDeveloperHelpers();
  304.     }
  305.  
  306.     static #protectTimers() {
  307.       const wrapTimer = original => {
  308.         return function(handler, timeout, ...args) {
  309.           if (typeof handler !== 'function') {
  310.             return original.apply(this, arguments);
  311.           }
  312.  
  313.           const wrappedHandler = function() {
  314.             try {
  315.               if (DebuggerDetector.isPresent()) return;
  316.               return handler.apply(this, arguments);
  317.             } catch (e) {
  318.               if (e.message?.includes('debugger')) return;
  319.               throw e;
  320.             }
  321.           };
  322.  
  323.           if (config.protection.obfuscateTimers) {
  324.             timeout = Math.max(1, timeout + (Math.random() * 20 - 10));
  325.           }
  326.  
  327.           return original.call(this, wrappedHandler, timeout, ...args);
  328.         };
  329.       };
  330.  
  331.       window.setTimeout = wrapTimer(OriginalFunctions.setTimeout);
  332.       window.setInterval = wrapTimer(OriginalFunctions.setInterval);
  333.     }
  334.  
  335.     static #protectTiming() {
  336.       const timeOffset = Math.random() * 25;
  337.       const safeNow = () => OriginalFunctions.now.call(Date) + timeOffset;
  338.  
  339.       Object.defineProperty(Date, 'now', {
  340.         value: safeNow,
  341.         configurable: false,
  342.         writable: false
  343.       });
  344.  
  345.       if (window.performance?.now) {
  346.         Object.defineProperty(window.performance, 'now', {
  347.           value: safeNow,
  348.           configurable: false,
  349.           writable: false
  350.         });
  351.       }
  352.     }
  353.  
  354.     static #protectFunction() {
  355.       const handler = {
  356.         apply(target, thisArg, args) {
  357.           if (typeof args[0] === 'string') {
  358.             args[0] = Protection.#cleanCode(args[0]);
  359.           }
  360.           return Reflect.apply(target, thisArg, args);
  361.         },
  362.         construct(target, args) {
  363.           if (typeof args[0] === 'string') {
  364.             args[0] = Protection.#cleanCode(args[0]);
  365.           }
  366.           return Reflect.construct(target, args);
  367.         }
  368.       };
  369.  
  370.       window.Function = new Proxy(OriginalFunctions.Function, handler);
  371.       if (typeof unsafeWindow !== 'undefined') {
  372.         unsafeWindow.Function = window.Function;
  373.       }
  374.     }
  375.  
  376.     static #protectStack() {
  377.       if (!config.protection.hideStackTraces) return;
  378.  
  379.       // V8-specific API for stack trace customization
  380.       if ('prepareStackTrace' in Error) {
  381.         Error.prepareStackTrace = (error, stack) => {
  382.           const stackString = [error.toString(), ...stack.map(frame => `    at ${frame}`)].join('\n');
  383.           return Protection.#cleanCode(stackString);
  384.         };
  385.         return;
  386.       }
  387.       
  388.       // Standard-based approach
  389.       try {
  390.         const originalStackDescriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
  391.         if (originalStackDescriptor?.get) {
  392.           Object.defineProperty(Error.prototype, 'stack', {
  393.             get() {
  394.               const originalStack = originalStackDescriptor.get.call(this);
  395.               return Protection.#cleanCode(originalStack);
  396.             },
  397.             configurable: true,
  398.           });
  399.         }
  400.       } catch (e) {
  401.         logger.error('Failed to protect stack traces:', e);
  402.       }
  403.     }
  404.  
  405.     static #protectEval() {
  406.       const safeEval = function(code) {
  407.         if (typeof code === 'string') {
  408.           if (DebuggerDetector.isPresent()) return;
  409.           return OriginalFunctions.eval.call(this, Protection.#cleanCode(code));
  410.         }
  411.         return OriginalFunctions.eval.apply(this, arguments);
  412.       };
  413.  
  414.       Object.defineProperty(window, 'eval', {
  415.         value: safeEval,
  416.         configurable: false,
  417.         writable: false
  418.       });
  419.  
  420.       if (typeof unsafeWindow !== 'undefined') {
  421.         unsafeWindow.eval = safeEval;
  422.       }
  423.     }
  424.  
  425.     static #protectConsole() {
  426.       const consoleHandler = {
  427.         get(target, prop) {
  428.           if (!config.consoleProps.includes(prop)) return target[prop];
  429.  
  430.           return function(...args) {
  431.             if (DebuggerDetector.isPresent()) return;
  432.             return OriginalFunctions.console[prop]?.apply(console, args);
  433.           };
  434.         },
  435.         set(target, prop, value) {
  436.           if (config.consoleProps.includes(prop)) return true;
  437.           target[prop] = value;
  438.           return true;
  439.         }
  440.       };
  441.  
  442.       window.console = new Proxy(console, consoleHandler);
  443.     }
  444.  
  445.     static #setupMutationObserver() {
  446.       new MutationObserver(mutations => {
  447.         mutations.forEach(mutation => {
  448.           mutation.addedNodes.forEach(node => {
  449.             if (node.nodeType === Node.ELEMENT_NODE) {
  450.               // Clean script content
  451.               if (node.tagName === 'SCRIPT') {
  452.                 const originalContent = node.textContent;
  453.                 const cleanedContent = Protection.#cleanCode(originalContent);
  454.                 if (originalContent !== cleanedContent) {
  455.                   node.textContent = cleanedContent;
  456.                 }
  457.               }
  458.               // Clean attributes
  459.               for (const attr of node.attributes) {
  460.                 if (attr.name.startsWith('on') && Protection.#cleanCode(attr.value) !== attr.value) {
  461.                     node.removeAttribute(attr.name);
  462.                 }
  463.               }
  464.             }
  465.           });
  466.         });
  467.       }).observe(document.documentElement, {
  468.         childList: true,
  469.         subtree: true,
  470.       });
  471.     }
  472.  
  473.     static #protectDeveloperKeys() {
  474.       if (!config.protection.preventDevToolsKeys && !config.protection.preventViewSource) return;
  475.  
  476.       const handler = e => {
  477.         const key = e.key.toUpperCase();
  478.         const ctrl = e.ctrlKey;
  479.         const shift = e.shiftKey;
  480.         const alt = e.altKey;
  481.  
  482.         const isDevToolsKey =
  483.           key === 'F12' ||
  484.           (ctrl && shift && (key === 'I' || key === 'J' || key === 'C')) ||
  485.           (ctrl && key === 'U');
  486.         
  487.         if (isDevToolsKey) {
  488.           e.preventDefault();
  489.           e.stopPropagation();
  490.         }
  491.       };
  492.  
  493.       window.addEventListener('keydown', handler, true);
  494.     }
  495.  
  496.     static #protectRightClick() {
  497.       if (!config.protection.preventRightClick) return;
  498.  
  499.       window.addEventListener('contextmenu', e => {
  500.         e.preventDefault();
  501.         e.stopPropagation();
  502.         return false;
  503.       }, true);
  504.     }
  505.  
  506.     static #protectNetwork() {
  507.       window.fetch = async function(...args) {
  508.         if (DebuggerDetector.isPresent()) {
  509.           throw new Error('Network request blocked');
  510.         }
  511.         return OriginalFunctions.fetch.apply(this, args);
  512.       };
  513.  
  514.       window.XMLHttpRequest = function() {
  515.         const xhr = new OriginalFunctions.XMLHttpRequest();
  516.         const originalOpen = xhr.open;
  517.         xhr.open = function(...args) {
  518.           if (DebuggerDetector.isPresent()) {
  519.             throw new Error('Network request blocked');
  520.           }
  521.           return originalOpen.apply(xhr, args);
  522.         };
  523.         return xhr;
  524.       };
  525.     }
  526.  
  527.     static #protectStorage() {
  528.       const storageHandler = {
  529.         get(target, prop) {
  530.           if (DebuggerDetector.isPresent()) return null;
  531.           return target[prop];
  532.         },
  533.         set(target, prop, value) {
  534.           if (DebuggerDetector.isPresent()) return true;
  535.           target[prop] = value;
  536.           return true;
  537.         }
  538.       };
  539.  
  540.       window.localStorage = new Proxy(window.localStorage, storageHandler);
  541.       window.sessionStorage = new Proxy(window.sessionStorage, storageHandler);
  542.     }
  543.  
  544.     static #protectClipboard() {
  545.       const events = [];
  546.       if (config.protection.preventCopy) events.push('copy', 'cut');
  547.       if (config.protection.preventPaste) events.push('paste');
  548.  
  549.       if (events.length) {
  550.         events.forEach(eventName => {
  551.           document.addEventListener(eventName, e => {
  552.             e.preventDefault();
  553.             e.stopPropagation();
  554.           }, true);
  555.         });
  556.       }
  557.     }
  558.  
  559.     static #protectPrinting() {
  560.       if (!config.protection.preventPrint) return;
  561.  
  562.       window.addEventListener('beforeprint', e => {
  563.         e.preventDefault();
  564.       }, true);
  565.  
  566.       window.addEventListener('afterprint', e => {
  567.         e.preventDefault();
  568.       }, true);
  569.     }
  570.  
  571.     static #protectWebWorkers() {
  572.       window.Worker = function(scriptURL, options) {
  573.         console.log('[Worker Created]', scriptURL);
  574.         return new OriginalFunctions.Worker(scriptURL, options);
  575.       };
  576.     }
  577.  
  578.     static #applyDeveloperHelpers() {
  579.       if (config.logging.monitorAPI) {
  580.         this.#monitorAPICalls();
  581.       }
  582.       if (config.logging.monitorDOM) {
  583.         this.#monitorDOMEvents();
  584.       }
  585.     }
  586.     
  587.     static #patchGlobalDebugVariables() {
  588.         const noop = () => {};
  589.         Object.defineProperties(window, {
  590.             'debug': { value: noop, configurable: false, writable: false },
  591.             'debugger': { value: noop, configurable: false, writable: false },
  592.             'isDebuggerEnabled': { value: false, configurable: false, writable: false }
  593.         });
  594.     }
  595.     
  596.     static #monitorAPICalls() {
  597.       const originalFetch = window.fetch;
  598.       window.fetch = async (...args) => {
  599.         logger.debug('[API Call]', ...args);
  600.         return originalFetch.apply(this, args);
  601.       };
  602.     }
  603.  
  604.     static #monitorDOMEvents() {
  605.       new MutationObserver(mutations => {
  606.         mutations.forEach(mutation => {
  607.           logger.debug('[DOM Change]', mutation);
  608.         });
  609.       }).observe(document.documentElement, {
  610.         childList: true,
  611.         subtree: true,
  612.         attributes: true,
  613.         characterData: true
  614.       });
  615.     }
  616.  
  617.     static #cleanCode(code) {
  618.       if (typeof code !== 'string') return code;
  619.       return code.replace(config.antiDebugRegex, '');
  620.     }
  621.   }
  622.   // Main class
  623.   class DevToolsBypass {
  624.     static init() {
  625.       try {
  626.         DebuggerDetector.startHistoryCleanup();
  627.         Protection.applyAll();
  628.         logger.info('DevTools Bypass initialized successfully');
  629.       } catch (e) {
  630.         logger.error('Failed to initialize DevTools Bypass:', e);
  631.       }
  632.     }
  633.   }
  634.  
  635.   // Initialize
  636.   DevToolsBypass.init();
  637. })();