Initial commit
Dieser Commit ist enthalten in:
Claude Project Manager
721
browser/fingerprint_protection.py
Normale Datei
721
browser/fingerprint_protection.py
Normale Datei
@ -0,0 +1,721 @@
|
||||
# browser/fingerprint_protection.py
|
||||
|
||||
"""
|
||||
Schutz vor Browser-Fingerprinting - Erweiterte Methoden zum Schutz vor verschiedenen Fingerprinting-Techniken
|
||||
"""
|
||||
|
||||
import random
|
||||
import logging
|
||||
import json
|
||||
from typing import Dict, List, Any, Optional, Tuple
|
||||
|
||||
logger = logging.getLogger("fingerprint_protection")
|
||||
|
||||
class FingerprintProtection:
|
||||
"""
|
||||
Bietet erweiterte Schutzmaßnahmen gegen verschiedene Browser-Fingerprinting-Techniken.
|
||||
Kann mit dem PlaywrightManager integriert werden, um die Anonymität zu verbessern.
|
||||
"""
|
||||
|
||||
def __init__(self, context=None, stealth_config=None):
|
||||
"""
|
||||
Initialisiert den Fingerprint-Schutz.
|
||||
|
||||
Args:
|
||||
context: Der Browser-Kontext, auf den die Schutzmaßnahmen angewendet werden sollen
|
||||
stealth_config: Konfigurationseinstellungen für das Stealth-Verhalten
|
||||
"""
|
||||
self.context = context
|
||||
self.stealth_config = stealth_config or {}
|
||||
self.scripts = []
|
||||
self.noise_level = self.stealth_config.get("noise_level", 0.5) # 0.0-1.0
|
||||
|
||||
# Standardwerte für Fingerprinting-Schutz
|
||||
self.defaults = {
|
||||
"webgl_vendor": "Google Inc. (Intel)",
|
||||
"webgl_renderer": "Intel Iris OpenGL Engine",
|
||||
"canvas_noise": True,
|
||||
"audio_noise": True,
|
||||
"webgl_noise": True,
|
||||
"hardware_concurrency": 8,
|
||||
"device_memory": 8,
|
||||
"timezone_id": "Europe/Berlin"
|
||||
}
|
||||
|
||||
# Einstellungen mit benutzerdefinierten Werten überschreiben
|
||||
for key, value in self.stealth_config.items():
|
||||
if key in self.defaults:
|
||||
self.defaults[key] = value
|
||||
|
||||
# Schutzmaßnahmen initialisieren
|
||||
self._init_protections()
|
||||
|
||||
def set_context(self, context):
|
||||
"""Setzt den Browser-Kontext nach der Initialisierung."""
|
||||
self.context = context
|
||||
|
||||
def _init_protections(self):
|
||||
"""Initialisiert alle Fingerprint-Schutzmaßnahmen."""
|
||||
self._init_canvas_protection()
|
||||
self._init_webgl_protection()
|
||||
self._init_audio_protection()
|
||||
self._init_navigator_protection()
|
||||
self._init_misc_protections()
|
||||
|
||||
def _init_canvas_protection(self):
|
||||
"""
|
||||
Initialisiert den Schutz gegen Canvas-Fingerprinting.
|
||||
Dies modifiziert das Canvas-Element, um leicht abweichende Werte zurückzugeben.
|
||||
"""
|
||||
script = """
|
||||
() => {
|
||||
// Originalmethoden speichern
|
||||
const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
|
||||
const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
|
||||
const originalToBlob = HTMLCanvasElement.prototype.toBlob;
|
||||
|
||||
// Funktion zum Hinzufügen von Rauschen zu Bilddaten
|
||||
const addNoise = (data, noise) => {
|
||||
const noiseFactor = noise || 0.03; // Standardwert für das Rauschlevel
|
||||
|
||||
// Nur auf Canvas über Mindestgröße anwenden, um normale Canvas nicht zu stören
|
||||
if (data.width > 16 && data.height > 16) {
|
||||
const pixelCount = data.width * data.height * 4; // RGBA-Kanäle
|
||||
|
||||
// Präzise, aber wenig wahrnehmbare Änderungen
|
||||
const minPixels = Math.max(10, Math.floor(pixelCount * 0.005)); // Mindestens 10 Pixel
|
||||
const maxPixels = Math.min(100, Math.floor(pixelCount * 0.01)); // Höchstens 100 Pixel
|
||||
|
||||
// Zufällige Anzahl an Pixeln auswählen
|
||||
const pixelsToModify = Math.floor(Math.random() * (maxPixels - minPixels)) + minPixels;
|
||||
|
||||
// Pixel modifizieren
|
||||
for (let i = 0; i < pixelsToModify; i++) {
|
||||
// Zufälligen Pixel auswählen
|
||||
const offset = Math.floor(Math.random() * pixelCount / 4) * 4;
|
||||
|
||||
// Nur RGB modifizieren, Alpha-Kanal unverändert lassen
|
||||
for (let j = 0; j < 3; j++) {
|
||||
// Subtile Änderungen hinzufügen (±1-2)
|
||||
const mod = Math.floor(Math.random() * 3) - 1;
|
||||
data.data[offset + j] = Math.max(0, Math.min(255, data.data[offset + j] + mod));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
// getImageData überschreiben
|
||||
CanvasRenderingContext2D.prototype.getImageData = function() {
|
||||
const imageData = originalGetImageData.apply(this, arguments);
|
||||
return addNoise(imageData, NOISE_LEVEL);
|
||||
};
|
||||
|
||||
// toDataURL überschreiben
|
||||
HTMLCanvasElement.prototype.toDataURL = function() {
|
||||
// Temporäre Modifikation für getImageData
|
||||
const tempGetImageData = CanvasRenderingContext2D.prototype.getImageData;
|
||||
CanvasRenderingContext2D.prototype.getImageData = originalGetImageData;
|
||||
|
||||
// toDataURL aufrufen
|
||||
let dataURL = originalToDataURL.apply(this, arguments);
|
||||
|
||||
// Wenn das Canvas groß genug ist und nicht von kritischen Anwendungen verwendet wird
|
||||
if (this.width > 16 && this.height > 16 && !this.hasAttribute('data-fingerprint-protect-ignore')) {
|
||||
// Rauschen in binären Teil des DataURL einfügen
|
||||
const parts = dataURL.split(',');
|
||||
if (parts.length === 2) {
|
||||
// Binäre Daten dekodieren
|
||||
const binary = atob(parts[1]);
|
||||
// Geringfügige Änderungen bei etwa 0,1% der Bytes
|
||||
let modifiedBinary = '';
|
||||
for (let i = 0; i < binary.length; i++) {
|
||||
if (Math.random() < 0.001 * NOISE_LEVEL) {
|
||||
// Byte leicht ändern
|
||||
const byte = binary.charCodeAt(i);
|
||||
const mod = Math.floor(Math.random() * 3) - 1;
|
||||
modifiedBinary += String.fromCharCode(Math.max(0, Math.min(255, byte + mod)));
|
||||
} else {
|
||||
modifiedBinary += binary[i];
|
||||
}
|
||||
}
|
||||
// Binäre Daten wieder kodieren
|
||||
dataURL = parts[0] + ',' + btoa(modifiedBinary);
|
||||
}
|
||||
}
|
||||
|
||||
// getImageData wiederherstellen
|
||||
CanvasRenderingContext2D.prototype.getImageData = tempGetImageData;
|
||||
|
||||
return dataURL;
|
||||
};
|
||||
|
||||
// toBlob überschreiben
|
||||
HTMLCanvasElement.prototype.toBlob = function(callback) {
|
||||
// Original toBlob aufrufen
|
||||
originalToBlob.apply(this, [function(blob) {
|
||||
// Wenn das Canvas groß genug ist und nicht von kritischen Anwendungen verwendet wird
|
||||
if (this.width > 16 && this.height > 16 && !this.hasAttribute('data-fingerprint-protect-ignore')) {
|
||||
// Blob zu ArrayBuffer konvertieren
|
||||
const reader = new FileReader();
|
||||
reader.onload = function() {
|
||||
const arrayBuffer = reader.result;
|
||||
const array = new Uint8Array(arrayBuffer);
|
||||
|
||||
// Geringfügige Änderungen bei etwa 0,1% der Bytes
|
||||
for (let i = 0; i < array.length; i++) {
|
||||
if (Math.random() < 0.001 * NOISE_LEVEL) {
|
||||
// Byte leicht ändern
|
||||
const mod = Math.floor(Math.random() * 3) - 1;
|
||||
array[i] = Math.max(0, Math.min(255, array[i] + mod));
|
||||
}
|
||||
}
|
||||
|
||||
// Neuen Blob erstellen
|
||||
const modifiedBlob = new Blob([array], {type: blob.type});
|
||||
callback(modifiedBlob);
|
||||
};
|
||||
reader.readAsArrayBuffer(blob);
|
||||
} else {
|
||||
// Unveränderten Blob zurückgeben
|
||||
callback(blob);
|
||||
}
|
||||
}.bind(this)]);
|
||||
};
|
||||
}
|
||||
""".replace("NOISE_LEVEL", str(self.noise_level))
|
||||
|
||||
self.scripts.append(script)
|
||||
|
||||
def _init_webgl_protection(self):
|
||||
"""
|
||||
Initialisiert den Schutz gegen WebGL-Fingerprinting.
|
||||
Dies modifiziert WebGL-spezifische Werte, die für Fingerprinting verwendet werden.
|
||||
"""
|
||||
webgl_vendor = self.defaults["webgl_vendor"]
|
||||
webgl_renderer = self.defaults["webgl_renderer"]
|
||||
|
||||
script = f"""
|
||||
() => {{
|
||||
// WebGL Vendor und Renderer spoofen
|
||||
const getParameterProxies = [
|
||||
WebGLRenderingContext.prototype,
|
||||
WebGL2RenderingContext.prototype
|
||||
];
|
||||
|
||||
getParameterProxies.forEach(contextPrototype => {{
|
||||
if (!contextPrototype) return;
|
||||
|
||||
const originalGetParameter = contextPrototype.getParameter;
|
||||
contextPrototype.getParameter = function(parameter) {{
|
||||
// WebGL Vendor (VENDOR)
|
||||
if (parameter === 0x1F00) {{
|
||||
return "{webgl_vendor}";
|
||||
}}
|
||||
|
||||
// WebGL Renderer (RENDERER)
|
||||
if (parameter === 0x1F01) {{
|
||||
return "{webgl_renderer}";
|
||||
}}
|
||||
|
||||
// Unshaded Language Version (SHADING_LANGUAGE_VERSION)
|
||||
if (parameter === 0x8B8C) {{
|
||||
const originalValue = originalGetParameter.call(this, parameter);
|
||||
|
||||
// Subtile Änderungen an der Version
|
||||
const versionMatch = originalValue.match(/^WebGL GLSL ES ([0-9]\\.[0-9][0-9])/);
|
||||
if (versionMatch) {{
|
||||
return originalValue.replace(versionMatch[1],
|
||||
(parseFloat(versionMatch[1]) + (Math.random() * 0.01 - 0.005)).toFixed(2));
|
||||
}}
|
||||
}}
|
||||
|
||||
// VERSION
|
||||
if (parameter === 0x1F02) {{
|
||||
const originalValue = originalGetParameter.call(this, parameter);
|
||||
|
||||
// Subtile Änderungen an der Version
|
||||
const versionMatch = originalValue.match(/^WebGL ([0-9]\\.[0-9])/);
|
||||
if (versionMatch) {{
|
||||
return originalValue.replace(versionMatch[1],
|
||||
(parseFloat(versionMatch[1]) + (Math.random() * 0.01 - 0.005)).toFixed(1));
|
||||
}}
|
||||
}}
|
||||
|
||||
return originalGetParameter.apply(this, arguments);
|
||||
}};
|
||||
}});
|
||||
|
||||
// WebGL Vertex und Fragment Shader spoofen
|
||||
const shaderSourceProxies = [
|
||||
WebGLRenderingContext.prototype,
|
||||
WebGL2RenderingContext.prototype
|
||||
];
|
||||
|
||||
shaderSourceProxies.forEach(contextPrototype => {{
|
||||
if (!contextPrototype) return;
|
||||
|
||||
const originalShaderSource = contextPrototype.shaderSource;
|
||||
contextPrototype.shaderSource = function(shader, source) {{
|
||||
// Füge geringfügige Unterschiede in Kommentaren ein, ohne die Funktionalität zu beeinträchtigen
|
||||
if (source.indexOf('//') !== -1) {{
|
||||
// Zufälligen Kommentar leicht modifizieren
|
||||
source = source.replace(/\\/\\/(.*?)\\n/g, (match, comment) => {{
|
||||
if (Math.random() < 0.1) {{
|
||||
// Füge ein Leerzeichen oder einen Bindestrich hinzu oder entferne eines
|
||||
const modifications = [
|
||||
' ', '-', '', ' '
|
||||
];
|
||||
const mod = modifications[Math.floor(Math.random() * modifications.length)];
|
||||
return `//` + comment + mod + `\\n`;
|
||||
}}
|
||||
return match;
|
||||
}});
|
||||
}}
|
||||
|
||||
// Ersetze bestimmte Whitespace-Muster
|
||||
source = source.replace(/\\s{2,}/g, match => {{
|
||||
if (Math.random() < 0.05) {{
|
||||
return ' '.repeat(match.length + (Math.random() < 0.5 ? 1 : -1));
|
||||
}}
|
||||
return match;
|
||||
}});
|
||||
|
||||
return originalShaderSource.call(this, shader, source);
|
||||
}};
|
||||
}});
|
||||
|
||||
// Canvas-Kontext spoofen
|
||||
const getContextProxies = [
|
||||
HTMLCanvasElement.prototype
|
||||
];
|
||||
|
||||
getContextProxies.forEach(canvasPrototype => {{
|
||||
const originalGetContext = canvasPrototype.getContext;
|
||||
canvasPrototype.getContext = function(contextType, contextAttributes) {{
|
||||
const context = originalGetContext.apply(this, arguments);
|
||||
|
||||
if (context && (contextType === 'webgl' || contextType === 'experimental-webgl' || contextType === 'webgl2')) {{
|
||||
// Zufällige Werte für verschiedene Parameter einführen
|
||||
if ({str(self.defaults["webgl_noise"]).lower()}) {{
|
||||
// Zufällige Modifikation für MAX_VERTEX_UNIFORM_VECTORS
|
||||
const MAX_VERTEX_UNIFORM_VECTORS = context.getParameter(context.MAX_VERTEX_UNIFORM_VECTORS);
|
||||
Object.defineProperty(context, 'MAX_VERTEX_UNIFORM_VECTORS', {{
|
||||
get: () => MAX_VERTEX_UNIFORM_VECTORS + Math.floor(Math.random() * 3) - 1
|
||||
}});
|
||||
|
||||
// Zufällige Modifikation für MAX_FRAGMENT_UNIFORM_VECTORS
|
||||
const MAX_FRAGMENT_UNIFORM_VECTORS = context.getParameter(context.MAX_FRAGMENT_UNIFORM_VECTORS);
|
||||
Object.defineProperty(context, 'MAX_FRAGMENT_UNIFORM_VECTORS', {{
|
||||
get: () => MAX_FRAGMENT_UNIFORM_VECTORS + Math.floor(Math.random() * 3) - 1
|
||||
}});
|
||||
}}
|
||||
}}
|
||||
|
||||
return context;
|
||||
}};
|
||||
}});
|
||||
}}
|
||||
"""
|
||||
|
||||
self.scripts.append(script)
|
||||
|
||||
def _init_audio_protection(self):
|
||||
"""
|
||||
Initialisiert den Schutz gegen Audio-Fingerprinting.
|
||||
Dies modifiziert die Audio-API-Funktionen, die für Fingerprinting verwendet werden.
|
||||
"""
|
||||
script = f"""
|
||||
() => {{
|
||||
// Audio-Kontext spoofen
|
||||
if (window.AudioContext || window.webkitAudioContext) {{
|
||||
const AudioContextProxy = window.AudioContext || window.webkitAudioContext;
|
||||
const originalAudioContext = AudioContextProxy;
|
||||
|
||||
// AudioContext überschreiben
|
||||
window.AudioContext = window.webkitAudioContext = function() {{
|
||||
const context = new originalAudioContext();
|
||||
|
||||
// createOscillator überschreiben
|
||||
const originalCreateOscillator = context.createOscillator;
|
||||
context.createOscillator = function() {{
|
||||
const oscillator = originalCreateOscillator.apply(this, arguments);
|
||||
|
||||
// Frequenz leicht modifizieren
|
||||
const originalFrequency = oscillator.frequency;
|
||||
Object.defineProperty(oscillator, 'frequency', {{
|
||||
get: function() {{
|
||||
return originalFrequency;
|
||||
}},
|
||||
set: function(value) {{
|
||||
if (typeof value === 'number') {{
|
||||
// Leichte Änderung hinzufügen
|
||||
const noise = (Math.random() * 0.02 - 0.01) * value;
|
||||
originalFrequency.value = value + noise;
|
||||
}} else {{
|
||||
originalFrequency.value = value;
|
||||
}}
|
||||
}}
|
||||
}});
|
||||
|
||||
return oscillator;
|
||||
}};
|
||||
|
||||
// getChannelData überschreiben
|
||||
const originalGetChannelData = context.createBuffer.prototype?.getChannelData || OfflineAudioContext.prototype?.getChannelData;
|
||||
if (originalGetChannelData) {{
|
||||
context.createBuffer.prototype.getChannelData = function(channel) {{
|
||||
const array = originalGetChannelData.call(this, channel);
|
||||
|
||||
if ({str(self.defaults["audio_noise"]).lower()} && this.length > 20) {{
|
||||
// Sehr subtiles Rauschen hinzufügen (bei etwa 0,1% der Samples)
|
||||
const noise = {self.noise_level} * 0.0001;
|
||||
|
||||
// Effiziente Implementierung
|
||||
const samples = Math.min(200, Math.floor(array.length * 0.001));
|
||||
for (let i = 0; i < samples; i++) {{
|
||||
const idx = Math.floor(Math.random() * array.length);
|
||||
array[idx] += (Math.random() * 2 - 1) * noise;
|
||||
}}
|
||||
}}
|
||||
|
||||
return array;
|
||||
}};
|
||||
}}
|
||||
|
||||
// AnalyserNode.getFloatFrequencyData überschreiben
|
||||
if (context.createAnalyser) {{
|
||||
const originalCreateAnalyser = context.createAnalyser;
|
||||
context.createAnalyser = function() {{
|
||||
const analyser = originalCreateAnalyser.apply(this, arguments);
|
||||
const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
|
||||
|
||||
analyser.getFloatFrequencyData = function(array) {{
|
||||
originalGetFloatFrequencyData.call(this, array);
|
||||
|
||||
if ({str(self.defaults["audio_noise"]).lower()} && array.length > 20) {{
|
||||
// Sehr subtiles Rauschen hinzufügen
|
||||
const noise = {self.noise_level} * 0.001;
|
||||
|
||||
// Effiziente Implementierung für große Arrays
|
||||
const samples = Math.min(20, Math.floor(array.length * 0.01));
|
||||
for (let i = 0; i < samples; i++) {{
|
||||
const idx = Math.floor(Math.random() * array.length);
|
||||
array[idx] += (Math.random() * 2 - 1) * noise;
|
||||
}}
|
||||
}}
|
||||
|
||||
return array;
|
||||
}};
|
||||
|
||||
return analyser;
|
||||
}};
|
||||
}}
|
||||
|
||||
return context;
|
||||
}};
|
||||
}}
|
||||
}}
|
||||
"""
|
||||
|
||||
self.scripts.append(script)
|
||||
|
||||
def _init_navigator_protection(self):
|
||||
"""
|
||||
Initialisiert den Schutz gegen Navigator-Objekt-Fingerprinting.
|
||||
Dies modifiziert verschiedene Navigator-Eigenschaften, die für Fingerprinting verwendet werden.
|
||||
"""
|
||||
hardware_concurrency = self.defaults["hardware_concurrency"]
|
||||
device_memory = self.defaults["device_memory"]
|
||||
|
||||
script = f"""
|
||||
() => {{
|
||||
// Navigator-Eigenschaften überschreiben
|
||||
|
||||
// hardwareConcurrency (CPU-Kerne)
|
||||
if (navigator.hardwareConcurrency) {{
|
||||
Object.defineProperty(navigator, 'hardwareConcurrency', {{
|
||||
get: () => {hardware_concurrency}
|
||||
}});
|
||||
}}
|
||||
|
||||
// deviceMemory (RAM)
|
||||
if (navigator.deviceMemory) {{
|
||||
Object.defineProperty(navigator, 'deviceMemory', {{
|
||||
get: () => {device_memory}
|
||||
}});
|
||||
}}
|
||||
|
||||
// language und languages
|
||||
if (navigator.language) {{
|
||||
const originalLanguage = navigator.language;
|
||||
const originalLanguages = navigator.languages;
|
||||
|
||||
Object.defineProperty(navigator, 'language', {{
|
||||
get: () => originalLanguage
|
||||
}});
|
||||
|
||||
Object.defineProperty(navigator, 'languages', {{
|
||||
get: () => originalLanguages
|
||||
}});
|
||||
}}
|
||||
|
||||
// userAgent-Konsistenz sicherstellen
|
||||
if (navigator.userAgent) {{
|
||||
const userAgent = navigator.userAgent;
|
||||
|
||||
// Wenn der userAgent bereits überschrieben wurde, stellen wir
|
||||
// sicher, dass die appVersion und platform konsistent sind
|
||||
const browserInfo = {{
|
||||
chrome: /Chrome\\/(\\d+)/.exec(userAgent),
|
||||
firefox: /Firefox\\/(\\d+)/.exec(userAgent),
|
||||
safari: /Safari\\/(\\d+)/.exec(userAgent),
|
||||
edge: /Edg(e|)\\/(\\d+)/.exec(userAgent)
|
||||
}};
|
||||
|
||||
// Platform basierend auf userAgent bestimmen
|
||||
let platform = '{self.defaults.get("platform", "Win32")}';
|
||||
if (/Windows/.test(userAgent)) platform = 'Win32';
|
||||
else if (/Macintosh/.test(userAgent)) platform = 'MacIntel';
|
||||
else if (/Linux/.test(userAgent)) platform = 'Linux x86_64';
|
||||
else if (/Android/.test(userAgent)) platform = 'Linux armv8l';
|
||||
else if (/iPhone|iPad/.test(userAgent)) platform = 'iPhone';
|
||||
|
||||
Object.defineProperty(navigator, 'platform', {{
|
||||
get: () => platform
|
||||
}});
|
||||
|
||||
// appVersion konsistent machen
|
||||
if (navigator.appVersion) {{
|
||||
Object.defineProperty(navigator, 'appVersion', {{
|
||||
get: () => userAgent.substring(8)
|
||||
}});
|
||||
}}
|
||||
|
||||
// vendor basierend auf Browser setzen
|
||||
let vendor = '{self.defaults.get("vendor", "Google Inc.")}';
|
||||
if (browserInfo.safari) vendor = 'Apple Computer, Inc.';
|
||||
else if (browserInfo.firefox) vendor = '';
|
||||
|
||||
Object.defineProperty(navigator, 'vendor', {{
|
||||
get: () => vendor
|
||||
}});
|
||||
}}
|
||||
|
||||
"""
|
||||
self.scripts.append(script)
|
||||
|
||||
def _init_misc_protections(self):
|
||||
"""
|
||||
Initialisiert verschiedene weitere Schutzmaßnahmen gegen Fingerprinting.
|
||||
"""
|
||||
timezone_id = self.defaults["timezone_id"]
|
||||
|
||||
script = f"""
|
||||
() => {{
|
||||
// Date.prototype.getTimezoneOffset überschreiben
|
||||
const originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
|
||||
Date.prototype.getTimezoneOffset = function() {{
|
||||
// Zeitzonendaten für '{timezone_id}'
|
||||
// Mitteleuropäische Zeit (CET/CEST): UTC+1 / UTC+2 (Sommerzeit)
|
||||
const date = new Date(this);
|
||||
|
||||
// Prüfen, ob Sommerzeit
|
||||
const jan = new Date(date.getFullYear(), 0, 1);
|
||||
const jul = new Date(date.getFullYear(), 6, 1);
|
||||
const standardOffset = Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
|
||||
|
||||
// Sommerzeit in Europa: Ende März bis Ende Oktober
|
||||
const isDST = date.getMonth() > 2 && date.getMonth() < 10;
|
||||
|
||||
// Offset in Minuten: CET = -60, CEST = -120
|
||||
return isDST ? -120 : -60;
|
||||
}};
|
||||
|
||||
// Plugins und MimeTypes Schutz
|
||||
if (navigator.plugins) {{
|
||||
// Leere oder gefälschte Plugins
|
||||
Object.defineProperty(navigator, 'plugins', {{
|
||||
get: () => {{
|
||||
// Plugins-Array-Eigenschaften simulieren
|
||||
const plugins = {{
|
||||
length: 0,
|
||||
item: () => null,
|
||||
namedItem: () => null,
|
||||
refresh: () => {{}},
|
||||
[Symbol.iterator]: function* () {{}}
|
||||
}};
|
||||
|
||||
return plugins;
|
||||
}}
|
||||
}});
|
||||
|
||||
// MimeTypes ebenfalls leeren
|
||||
if (navigator.mimeTypes) {{
|
||||
Object.defineProperty(navigator, 'mimeTypes', {{
|
||||
get: () => {{
|
||||
// MimeTypes-Array-Eigenschaften simulieren
|
||||
const mimeTypes = {{
|
||||
length: 0,
|
||||
item: () => null,
|
||||
namedItem: () => null,
|
||||
[Symbol.iterator]: function* () {{}}
|
||||
}};
|
||||
|
||||
return mimeTypes;
|
||||
}}
|
||||
}});
|
||||
}}
|
||||
}}
|
||||
|
||||
// Performance.now() und Date.now() - Schutz gegen Timing-Angriffe
|
||||
if (window.performance && performance.now) {{
|
||||
const originalNow = performance.now;
|
||||
|
||||
performance.now = function() {{
|
||||
const value = originalNow.call(performance);
|
||||
// Subtile Abweichung hinzufügen
|
||||
return value + (Math.random() * 0.01);
|
||||
}};
|
||||
}}
|
||||
|
||||
// Date.now() ebenfalls mit subtiler Abweichung
|
||||
const originalDateNow = Date.now;
|
||||
Date.now = function() {{
|
||||
const value = originalDateNow.call(Date);
|
||||
// Subtile Abweichung hinzufügen (±1ms)
|
||||
return value + (Math.random() < 0.5 ? 1 : 0);
|
||||
}};
|
||||
|
||||
// screen-Eigenschaften konsistent machen
|
||||
if (window.screen) {{
|
||||
const originalWidth = screen.width;
|
||||
const originalHeight = screen.height;
|
||||
const originalColorDepth = screen.colorDepth;
|
||||
const originalPixelDepth = screen.pixelDepth;
|
||||
|
||||
// Abweichungen verhindern - konsistente Werte liefern
|
||||
Object.defineProperties(screen, {{
|
||||
'width': {{ get: () => originalWidth }},
|
||||
'height': {{ get: () => originalHeight }},
|
||||
'availWidth': {{ get: () => originalWidth }},
|
||||
'availHeight': {{ get: () => originalHeight - 40 }}, // Taskleiste simulieren
|
||||
'colorDepth': {{ get: () => originalColorDepth }},
|
||||
'pixelDepth': {{ get: () => originalPixelDepth }}
|
||||
}});
|
||||
}}
|
||||
}}
|
||||
"""
|
||||
|
||||
self.scripts.append(script)
|
||||
|
||||
def apply_to_context(self, context=None):
|
||||
"""
|
||||
Wendet alle Skripte auf den Browser-Kontext an.
|
||||
|
||||
Args:
|
||||
context: Der Browser-Kontext, falls er noch nicht gesetzt wurde
|
||||
"""
|
||||
if context:
|
||||
self.context = context
|
||||
|
||||
if not self.context:
|
||||
logger.warning("Kein Browser-Kontext zum Anwenden der Fingerprint-Schutzmaßnahmen")
|
||||
return
|
||||
|
||||
for script in self.scripts:
|
||||
self.context.add_init_script(script)
|
||||
|
||||
logger.info(f"Fingerprint-Schutzmaßnahmen auf Browser-Kontext angewendet ({len(self.scripts)} Skripte)")
|
||||
|
||||
def get_fingerprint_status(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Gibt den aktuellen Status der Fingerprint-Schutzmaßnahmen zurück.
|
||||
|
||||
Returns:
|
||||
Dict[str, Any]: Status der Fingerprint-Schutzmaßnahmen
|
||||
"""
|
||||
status = {
|
||||
"active": self.context is not None,
|
||||
"script_count": len(self.scripts),
|
||||
"protections": {
|
||||
"canvas": self.defaults["canvas_noise"],
|
||||
"webgl": self.defaults["webgl_noise"],
|
||||
"audio": self.defaults["audio_noise"],
|
||||
"navigator": True,
|
||||
"battery": "getBattery" in self.scripts[-1],
|
||||
"timing": "performance.now" in self.scripts[-1]
|
||||
},
|
||||
"noise_level": self.noise_level,
|
||||
"custom_values": {
|
||||
"webgl_vendor": self.defaults["webgl_vendor"],
|
||||
"webgl_renderer": self.defaults["webgl_renderer"],
|
||||
"hardware_concurrency": self.defaults["hardware_concurrency"],
|
||||
"device_memory": self.defaults["device_memory"],
|
||||
"timezone_id": self.defaults["timezone_id"]
|
||||
}
|
||||
}
|
||||
|
||||
return status
|
||||
|
||||
def rotate_fingerprint(self, noise_level: Optional[float] = None):
|
||||
"""
|
||||
Rotiert den Fingerprint durch Neugenerierung der Schutzmaßnahmen.
|
||||
|
||||
Args:
|
||||
noise_level: Optionales neues Rauschniveau (0.0-1.0)
|
||||
|
||||
Returns:
|
||||
bool: True bei Erfolg, False bei Fehler
|
||||
"""
|
||||
if noise_level is not None:
|
||||
self.noise_level = max(0.0, min(1.0, noise_level))
|
||||
|
||||
try:
|
||||
# Skripte zurücksetzen
|
||||
self.scripts = []
|
||||
|
||||
# Neues WebGL-Vendor/Renderer-Paar generieren
|
||||
webgl_vendors = [
|
||||
"Google Inc.",
|
||||
"Google Inc. (Intel)",
|
||||
"Google Inc. (NVIDIA)",
|
||||
"Google Inc. (AMD)",
|
||||
"Intel Inc.",
|
||||
"NVIDIA Corporation",
|
||||
"AMD"
|
||||
]
|
||||
|
||||
webgl_renderers = [
|
||||
"ANGLE (Intel, Intel(R) HD Graphics 620 Direct3D11 vs_5_0 ps_5_0)",
|
||||
"ANGLE (NVIDIA, NVIDIA GeForce GTX 1060 Direct3D11 vs_5_0 ps_5_0)",
|
||||
"ANGLE (AMD, AMD Radeon RX 580 Direct3D11 vs_5_0 ps_5_0)",
|
||||
"Intel Iris OpenGL Engine",
|
||||
"NVIDIA GeForce GTX 980 OpenGL Engine",
|
||||
"AMD Radeon Pro 560 OpenGL Engine",
|
||||
"Mesa DRI Intel(R) UHD Graphics 620 (KBL GT2)",
|
||||
"Mesa DRI NVIDIA GeForce GTX 1650"
|
||||
]
|
||||
|
||||
# Zufällige Werte wählen
|
||||
self.defaults["webgl_vendor"] = random.choice(webgl_vendors)
|
||||
self.defaults["webgl_renderer"] = random.choice(webgl_renderers)
|
||||
|
||||
# Hardware-Concurrency und Device-Memory variieren
|
||||
self.defaults["hardware_concurrency"] = random.choice([2, 4, 6, 8, 12, 16])
|
||||
self.defaults["device_memory"] = random.choice([2, 4, 8, 16])
|
||||
|
||||
# Schutzmaßnahmen neu initialisieren
|
||||
self._init_protections()
|
||||
|
||||
# Auf Kontext anwenden, falls vorhanden
|
||||
if self.context:
|
||||
self.apply_to_context()
|
||||
|
||||
logger.info(f"Fingerprint erfolgreich rotiert (Noise-Level: {self.noise_level:.2f})")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei der Rotation des Fingerprints: {e}")
|
||||
return False
|
||||
In neuem Issue referenzieren
Einen Benutzer sperren