# 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