☰

Safari Fingerprint blocker

Hide browser fingerprint. Derived from "No Fingerprint"

  1. // ==UserScript==
  2. // @name         Safari Fingerprint blocker
  3. // @version      1.0
  4. // @description  Hide browser fingerprint. Derived from "No Fingerprint"
  5. // @match        *://*/*
  6. // @grant        none
  7. // @run-at       document-start
  8. // @noframes     false
  9. // @license      The Unlicense
  10. // @namespace https://greasyfork.org/users/1405117
  11. // ==/UserScript==
  12.  
  13. let script = document.createElement("script");
  14. script.textContent = "(" + (function() {
  15.     "use strict";
  16.  
  17.     let debug = function(topOnly) {
  18.         if (!topOnly || window === window.top) {
  19.             // debugger;
  20.         }
  21.     };
  22.  
  23.     (function() {
  24.         document.documentElement.dataset.fbscriptallow = true;
  25.     })();
  26.  
  27.     let randomChange = function(n, m) {
  28.         if (!m) {
  29.             m = 0.1;
  30.         }
  31.         return Math.round(n + ((Math.random() - 0.5) * 2 * n * 0.3));
  32.     };
  33.  
  34.     let setValue = function(object, propertyName, value, writable) {
  35.         if (!writable) {
  36.             writable = false;
  37.         }
  38.         Object.defineProperty(object, propertyName, {
  39.             value: value,
  40.             writable: writable,
  41.             enumerable: true
  42.         });
  43.     };
  44.  
  45.     (function() { // Date
  46.         window.Date.prototype.getDate = window.Date.prototype.getUTCDate;
  47.         window.Date.prototype.getDay = window.Date.prototype.getUTCDay;
  48.         window.Date.prototype.getFullYear = window.Date.prototype.getUTCFullYear;
  49.         window.Date.prototype.getHours = window.Date.prototype.getUTCHours;
  50.         window.Date.prototype.getMilliseconds = window.Date.prototype.getUTCMilliseconds;
  51.         window.Date.prototype.getMinutes = window.Date.prototype.getUTCMinutes;
  52.         window.Date.prototype.getMonth = window.Date.prototype.getUTCMonth;
  53.         window.Date.prototype.getSeconds = window.Date.prototype.getUTCSeconds;
  54.         window.Date.prototype.getTimezoneOffset = function() { return 0; }; // -480
  55.         window.Date.prototype.getYear = function() { return this.getFullYear() - 1900; };
  56.         window.Date.prototype.setDate = window.Date.prototype.setUTCDate;
  57.         window.Date.prototype.setFullYear = window.Date.prototype.setUTCFullYear;
  58.         window.Date.prototype.setHours = window.Date.prototype.setUTCHours;
  59.         window.Date.prototype.setMilliseconds = window.Date.prototype.setUTCMilliseconds;
  60.         window.Date.prototype.setMinutes = window.Date.prototype.setUTCMinutes;
  61.         window.Date.prototype.setMonth = window.Date.prototype.setUTCMonth;
  62.         window.Date.prototype.setSeconds = window.Date.prototype.setUTCSeconds;
  63.         window.Date.prototype.setYear = function(n) { return this.setFullYear(n + 1900); };
  64.         window.Date.prototype.toLocaleDateString = function() { return ""; };
  65.         window.Date.prototype.toLocaleString = function() { return ""; }; //America/Los_Angeles
  66.         window.Date.prototype.toLocaleTimeString = function() { return ""; };
  67.         window.Date.prototype.toString = function() { return ""; };
  68.         window.Date.prototype.toTimeString = function() { return ""; };
  69.     })();
  70.  
  71.     (function() {
  72.         let fakeNavigator = {
  73.             appCodeName: "",
  74.             appName: "",
  75.             appVersion: "",
  76.             product: "",
  77.             productSub: "",
  78.             vendor: "",
  79.             vendorSub: "",
  80.             deviceMemory: Math.floor((Math.random() * 8) + 1),
  81.             hardwareConcurrency: Math.floor((Math.random() * 8) + 1),
  82.             maxTouchPoints: Math.floor((Math.random() * 8) + 1),
  83.             bluetooth: undefined,
  84.             clipboard: undefined,
  85.             connection: undefined,
  86.             credentials: undefined,
  87.             doNotTrack: "false",
  88.             geolocation: undefined,
  89.             //globalPrivacyControl: 1,
  90.             keyboard: undefined,
  91.             language: "en-US",
  92.             languages: "en-US",
  93.             locks: undefined,
  94.             mediaCapabilities: undefined,
  95.             mediaDevices: undefined,
  96.             mediaSession: undefined,
  97.             onLine: undefined,
  98.             permissions: undefined,
  99.             presentation: undefined,
  100.             scheduling: undefined,
  101.             serviceWorker: undefined,
  102.             usb: undefined,
  103.             userActivation: undefined,
  104.             userAgentData: "",
  105.             wakeLock: undefined,
  106.             webkitPersistentStorage: undefined,
  107.             webkitTemporaryStorage: undefined,
  108.             xr: undefined,
  109.             getBattery: "",
  110.             platform: "",
  111.         };
  112.  
  113.         // Define getters for the properties in window.navigator
  114.         for (let prop in window.navigator) {
  115.             if (fakeNavigator[prop] !== undefined) {
  116.                 try {
  117.                     Object.defineProperty(window.navigator, prop, {
  118.                         get: function() {
  119.                             if (fakeNavigator[prop] === "undefined") {
  120.                                 return undefined;
  121.                             }
  122.                             return fakeNavigator[prop];
  123.                         },
  124.                     });
  125.                 } catch (e) {}
  126.             }
  127.         }
  128.     })();
  129.  
  130.     // Randomized Plugins
  131.     (function() {
  132.         function generateRandomString(length) {
  133.             const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  134.             let result = '';
  135.             for (let i = 0; i < length; i++) {
  136.                 const randomIndex = Math.floor(Math.random() * characters.length);
  137.                 result += characters.charAt(randomIndex);
  138.             }
  139.             return result;
  140.         }
  141.  
  142.         const numPlugins = Math.floor(Math.random() * 5) + 1;
  143.         const customPlugins = [];
  144.  
  145.         // Generate random plugins
  146.         for (let i = 0; i < numPlugins; i++) {
  147.             const pluginName = generateRandomString(10);
  148.             const pluginDescription = generateRandomString(20);
  149.             customPlugins.push({
  150.                 name: pluginName,
  151.                 description: pluginDescription,
  152.             });
  153.         }
  154.  
  155.         // Override navigator.plugins with the custom plugins
  156.         Object.defineProperty(navigator, 'plugins', {
  157.             get: function() {
  158.                 return customPlugins;
  159.             },
  160.         });
  161.     })();
  162.  
  163.     (function() { // Screen size
  164.  
  165.         var choice2 = Math.floor(Math.random() * 4);
  166.  
  167.             switch(choice2){
  168.     
  169.     case 0:
  170.             var screenSize = [360,800];   
  171.              break;
  172.  
  173.     case 1:
  174.             var screenSize = [1920,1080];
  175.             break;
  176.  
  177.     case 2:
  178.             var screenSize = [1366,768];
  179.             break;
  180.    
  181.     
  182.     case 3:
  183.             var screenSize = [1536,864];
  184.             
  185.  };
  186.         //let screenSize = [1920, 1080];
  187.         screen.availWidth && setValue(screen, "availWidth", screenSize[0]);
  188.         screen.availHeight && setValue(screen, "availHeight", screenSize[1] - 40);
  189.         screen.availLeft && setValue(screen, "availLeft", undefined, true);
  190.         screen.availTop && setValue(screen, "availTop", undefined, true);
  191.         screen.width && setValue(screen, "width", screenSize[0]);
  192.         screen.height && setValue(screen, "height", screenSize[1]);
  193.         screen.Brightness && setValue(screen, "Brightness", randomChange(screen.Brightness));
  194.         screen.mozBrightness && setValue(screen, "mozBrightness", randomChange(screen.mozBrightness));
  195.         screen.left && setValue(screen, "left", undefined, true);
  196.         screen.top && setValue(screen, "top", undefined, true);
  197.         screen.enabled && setValue(screen, "enabled", undefined);
  198.         screen.mozEnabled && setValue(screen, "mozEnabled", undefined);
  199.         screen.pixelDepth && setValue(screen, "pixelDepth", 32);
  200.         screen.colorDepth && setValue(screen, "colorDepth", 32);
  201.     })();
  202.  
  203.     (function() { // Debugger panel size
  204.         let n = Math.round(71.5 + (Math.random() * 15)), wChanged = false, wValue, hChanged = false, hValue;
  205.         Object.defineProperty(window, "outerWidth", {
  206.             get: function() {
  207.                 if (!wChanged) {
  208.                     return window.innerWidth;
  209.                 }
  210.                 return wValue;
  211.             },
  212.             set: function(value) {
  213.                 wChanged = true;
  214.                 wValue = value;
  215.             }
  216.         });
  217.         Object.defineProperty(window, "outerHeight", {
  218.             get: function() {
  219.                 if (!hChanged) {
  220.                     return window.innerHeight + n;
  221.                 }
  222.                 return hValue;
  223.             },
  224.             set: function(value) {
  225.                 hChanged = true;
  226.                 hValue = value;
  227.             }
  228.         });
  229.     })();
  230.  
  231.     (function() { // AudioContext
  232.         let origGetFloatFrequencyData = window.AnalyserNode.prototype.getFloatFrequencyData;
  233.         window.AnalyserNode.prototype.getFloatFrequencyData = function getFloatFrequencyData(array) {
  234.             let ret = origGetFloatFrequencyData.apply(this, arguments);
  235.             for (let i = 0; i < array.length; i++) {
  236.                 array[i] = array[i] + Math.random() * 0.2;
  237.             }
  238.             return ret;
  239.         };
  240.         window.AnalyserNode.prototype.getFloatFrequencyData.toString = origGetFloatFrequencyData.toString.bind(origGetFloatFrequencyData);
  241.  
  242.         let origGetChannelData = window.AudioBuffer.prototype.getChannelData;
  243.         window.AudioBuffer.prototype.getChannelData = function getChannelData() {
  244.             let ret = origGetChannelData.apply(this, arguments);
  245.             for (let i = 0; i < ret.length; i++) {
  246.                 ret[i] = ret[i] + Math.random() * 0.0001;
  247.             }
  248.             return ret;
  249.         };
  250.         window.AudioBuffer.prototype.getChannelData.toString = origGetChannelData.toString.bind(origGetChannelData);
  251.     })();
  252.  
  253.    (function() { // Canvas
  254.     // Save original methods
  255.     let origGetContext = HTMLCanvasElement.prototype.getContext;
  256.     let origGetImageData = CanvasRenderingContext2D.prototype.getImageData;
  257.     let origToDataURL = HTMLCanvasElement.prototype.toDataURL;
  258.  
  259.     // Function to randomize image data
  260.     let randomizeImageData = function(imageData) {
  261.         let data = imageData.data;
  262.         for (let i = 0; i < data.length; i += 4) {
  263.             // Modify pixel data to include random variations
  264.             data[i] = (data[i] + Math.random() * 10) % 256;       // Red
  265.             data[i + 1] = (data[i + 1] + Math.random() * 10) % 256; // Green
  266.             data[i + 2] = (data[i + 2] + Math.random() * 10) % 256; // Blue
  267.             // Alpha remains the same
  268.         }
  269.     };
  270.  
  271.     // Override the getImageData method to randomize image data
  272.     CanvasRenderingContext2D.prototype.getImageData = function() {
  273.         let imageData = origGetImageData.apply(this, arguments);
  274.         randomizeImageData(imageData);
  275.         return imageData;
  276.     };
  277.  
  278.     // Function to randomize canvas data URL
  279.     let randomizeDataURL = function(dataURL) {
  280.         // Append random query string to data URL to prevent caching
  281.         return dataURL + '?random=' + Math.random();
  282.     };
  283.  
  284.     // Override the toDataURL method to randomize data URL
  285.     HTMLCanvasElement.prototype.toDataURL = function() {
  286.         let dataURL = origToDataURL.apply(this, arguments);
  287.         return randomizeDataURL(dataURL);
  288.     };
  289.  
  290.     // Override getContext to ensure modifications are applied
  291.     HTMLCanvasElement.prototype.getContext = function() {
  292.         let context = origGetContext.apply(this, arguments);
  293.         if (arguments[0] === '2d' && typeof context.getImageData === 'function') {
  294.             context.getImageData = CanvasRenderingContext2D.prototype.getImageData;
  295.         }
  296.         return context;
  297.     };
  298. })();
  299.  
  300.    // Randomize WebGL Rendering Context attributes
  301.     const originalGetExtension = WebGLRenderingContext.prototype.getExtension;
  302.     WebGLRenderingContext.prototype.getExtension = function(name) {
  303.         if (name === 'WEBGL_debug_renderer_info') {
  304.             return null;
  305.         }
  306.         return originalGetExtension.call(this, name);
  307.     };
  308.  
  309.     const originalGetSupportedExtensions = WebGLRenderingContext.prototype.getSupportedExtensions;
  310.     WebGLRenderingContext.prototype.getSupportedExtensions = function() {
  311.         return (originalGetSupportedExtensions.call(this) || []).filter(ext => ext !== 'WEBGL_debug_renderer_info');
  312.     };
  313.  
  314.     // Local storage noise
  315.     (function() {
  316.         let originalSetItem = localStorage.setItem;
  317.         let originalGetItem = localStorage.getItem;
  318.  
  319.         localStorage.setItem = function(key, value) {
  320.             let noise = (Math.random() * 0.0001).toString();
  321.             originalSetItem.call(this, key, value + noise);
  322.         };
  323.  
  324.         localStorage.getItem = function(key) {
  325.             let value = originalGetItem.call(this, key);
  326.             if (value) {
  327.                 return value.replace(/0\.\d+$/, "");
  328.             }
  329.             return value;
  330.         };
  331.     })();
  332.  
  333.     // WebGL noise
  334.     (function() {
  335.         let originalGetParameter = WebGLRenderingContext.prototype.getParameter;
  336.  
  337.         WebGLRenderingContext.prototype.getParameter = function(parameter) {
  338.             let value = originalGetParameter.call(this, parameter);
  339.             if (typeof value === "number") {
  340.                 return value + Math.random() * 0.01;
  341.             }
  342.             return value;
  343.         };
  344.     })();
  345. }).toString() + ")();";
  346.  
  347.  
  348.  
  349.  
  350. Object.defineProperty(navigator, 'userAgent', {
  351.            get: function () { return ''; }
  352.         });
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360. (function () { // Intl
  361. 		window.Intl = undefined;
  362. 	})();
  363.  
  364.  
  365. function hideRefer(c){var b=c.target;if(b&&b.tagName!=="A"){b=b.parentNode}if(b&&b.tagName==="A"){b.rel="noreferrer"}}window.addEventListener("click",hideRefer,true);window.addEventListener("contextmenu",hideRefer,true);
  366.  
  367.  
  368.  
  369. (function() {
  370.     
  371.  
  372.     // Override the getVoices method
  373.     const originalGetVoices = window.speechSynthesis.getVoices;
  374.  
  375.     window.speechSynthesis.getVoices = function() {
  376.         return []; // Return an empty array
  377.     };
  378.  
  379.     // Optionally, you can also override the voices property
  380.     Object.defineProperty(window.speechSynthesis, 'voices', {
  381.         get: function() {
  382.             return []; // Return an empty array
  383.         }
  384.     });
  385.  
  386. })();
  387.  
  388.  
  389.  
  390.  
  391.  
  392. (function() {
  393.     
  394.  
  395.     // Override the getBoundingClientRect method for spans
  396.     const originalGetBoundingClientRect = HTMLElement.prototype.getBoundingClientRect;
  397.     HTMLElement.prototype.getBoundingClientRect = function() {
  398.         // Check if the element is a span
  399.         if (this.tagName.toLowerCase() === 'span') {
  400.             // Return a fixed rectangle to prevent accurate width measurement
  401.             return {
  402.                 width: 100, // Fixed width
  403.                 height: 20, // Fixed height
  404.                 top: 0,
  405.                 right: 100,
  406.                 bottom: 20,
  407.                 left: 0,
  408.                 // Include other properties as needed
  409.             };
  410.         }
  411.         // Call the original method for other elements
  412.         return originalGetBoundingClientRect.call(this);
  413.     };
  414.  
  415.     // Optionally, override the offsetWidth property for spans
  416.     Object.defineProperty(HTMLElement.prototype, 'offsetWidth', {
  417.         get: function() {
  418.             if (this.tagName.toLowerCase() === 'span') {
  419.                 return 100; // Fixed width
  420.             }
  421.             return originalGetBoundingClientRect.call(this).width;
  422.         }
  423.     });
  424.  
  425.     // Optionally, override the offsetHeight property for spans
  426.     Object.defineProperty(HTMLElement.prototype, 'offsetHeight', {
  427.         get: function() {
  428.             if (this.tagName.toLowerCase() === 'span') {
  429.                 return 20; // Fixed height
  430.             }
  431.             return originalGetBoundingClientRect.call(this).height;
  432.         }
  433.     });
  434. })();
  435.  
  436.  
  437. document.documentElement.appendChild(script);