Avancerad skydd mot fingeravtryckning

#!/bin/bash
# Komplett anti-fingeravtryckningsinställningsskript

# 1. Installera Tor
sudo apt update
sudo apt install tor -y
sudo systemctl enable tor
sudo systemctl start tor

# 2. Konfigurera iptables för Tor
sudo iptables -t nat -A OUTPUT -p tcp --dport 80 -j REDIRECT --to-ports 9050
sudo iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-ports 9050

# 3. Installera och konfigurera DNScrypt
sudo apt install dnscrypt-proxy -y
sudo systemctl enable dnscrypt-proxy
sudo systemctl start dnscrypt-proxy

# 4. Inaktivera IPv6 (förebygger läckor)
sudo sysctl -w net.ipv6.conf.all.disable_ipv6=1
sudo sysctl -w net.ipv6.conf.default.disable_ipv6=1

# 5. MAC-adressrandomisering
sudo apt install macchanger -y
sudo macchanger -r eth0

# 6. Installera integritetsskyddade webbläsare
# Tor Browser
wget https://www.torproject.org/dist/torbrowser/latest/tor-browser-linux64.tar.xz
tar -xf tor-browser-linux64.tar.xz

# Brave Browser
sudo curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg \
  https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/brave-browser-archive-keyring.gpg] \
  https://brave-browser-apt-release.s3.brave.com/ stable main" | \
  sudo tee /etc/apt/sources.list.d/brave-browser-release.list
sudo apt update
sudo apt install brave-browser -y

#!/usr/bin/env python3
"""
Anti-fingeravtryckningstestpaket
Testar din webbläsares motståndskraft mot olika fingeravtryckningstekniker
"""

import asyncio
from playwright.async_api import async_playwright
import json

async def test_fingerprint_resistance():
    results = {}

    async with async_playwright() as p:
        # Test med integritetsskyddad Firefox
        browser = await p.firefox.launch(
            args=[
                '--private',
                '--disable-webgl',
                '--disable-canvas-aa',
            ]
        )

        context = await browser.new_context(
            viewport={'width': 1280, 'height': 720},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0)',
            locale='en-US',
            timezone_id='America/New_York'
        )

        page = await context.new_page()

        # Test 1: Canvas-fingeravtryckning
        await page.goto('https://browserleaks.com/canvas')
        results['canvas'] = await page.evaluate('''() => {
            const canvas = document.createElement('canvas');
            const ctx = canvas.getContext('2d');
            ctx.fillText('Test', 0, 0);
            return canvas.toDataURL();
        }''')

        # Test 2: WebGL-fingeravtryckning
        await page.goto('https://browserleaks.com/webgl')
        results['webgl'] = await page.evaluate('''() => {
            const canvas = document.createElement('canvas');
            const gl = canvas.getContext('webgl');
            if (!gl) return 'blocked';
            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
            return {
                vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
                renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
            };
        }''')

        # Test 3: Teckensnittsfingeravtryckning
        results['fonts'] = await page.evaluate('''() => {
            const testFonts = ['Arial', 'Courier', 'Times'];
            return testFonts.map(font => {
                return document.fonts.check('12px ' + font);
            });
        }''')

        # Test 4: Ljudfingeravtryckning
        results['audio'] = await page.evaluate('''() => {
            const audioContext = new AudioContext();
            const oscillator = audioContext.createOscillator();
            const analyser = audioContext.createAnalyser();
            oscillator.connect(analyser);
            const data = new Float32Array(analyser.frequencyBinCount);
            analyser.getFloatFrequencyData(data);
            return Array.from(data).slice(0, 10);
        }''')

        await browser.close()

    # Analysera resultat
    print("Fingeravtryckningsmotståndstestresultat:")
    print("=" * 50)
    print(json.dumps(results, indent=2))

    # Beräkna unikhetspoäng
    uniqueness = calculate_uniqueness(results)
    print(f"\nUnihetspoäng: {uniqueness}/100")
    print(f"Lägre är bättre. Poäng < 20 = Bra skydd")

def calculate_uniqueness(results):
    score = 0
    if results.get('canvas'): score += 25
    if results.get('webgl') != 'blocked': score += 30
    if len(results.get('fonts', [])) > 5: score += 25
    if results.get('audio'): score += 20
    return score

if __name__ == '__main__':
    asyncio.run(test_fingerprint_resistance())

// Detektera anti-fingeravtryckningsåtgärder (etisk användning)
function detectPrivacyTools() {
  const indicators = {
    canvasProtection: false,
    webglBlocked: false,
    fontsRestricted: false
  };

  // Försök inte att kringgå - respektera användarens val
  // Använd endast för analys/kompatibilitetsvarningar

  return indicators;
}

// Ge smidiga alternativlösningar
function privacyFriendlyFeatureDetection() {
  // Istället för fingeravtryckning, använd progressiv förbättring
  if (!supportsWebGL()) {
    loadCanvasFallback();
  }
}

# Automatiserat testskript
#!/bin/bash
echo "Testar fingeravtryckningsskydd..."

# Test 1: IP-läcktest
curl -s https://icanhazip.com
echo "IP bör vara VPN/Tor-IP"

# Test 2: DNS-läcktest
nslookup whoami.akamai.net
echo "DNS bör vara VPN/krypterad DNS"

# Test 3: WebRTC-läcktest
firefox --private-window https://browserleaks.com/webrtc &
echo "WebRTC bör vara blockerad eller visa endast VPN-IP"

# Test 4: Canvas-fingeravtryckning
firefox --private-window https://browserleaks.com/canvas &
echo "Canvas bör visa randomisering eller blockering"

class FingerprintRotator:
    """Rotera webbläsarfingeravtryck för varje session"""

    def __init__(self):
        self.profiles = self.load_profiles()

    def load_profiles(self):
        return [
            {
                'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...',
                'screen_resolution': '1920x1080',
                'timezone': 'America/New_York',
                'languages': ['en-US', 'en'],
                'platform': 'Win32'
            },
            # Fler profiler...
        ]

    def get_random_profile(self):
        import random
        return random.choice(self.profiles)

    def apply_profile(self, browser_context, profile):
        browser_context.set_user_agent(profile['user_agent'])
        browser_context.set_viewport_size(
            *map(int, profile['screen_resolution'].split('x'))
        )
        browser_context.set_timezone_id(profile['timezone'])
        browser_context.set_locale(profile['languages'][0])

# Docker-container med förkonfigurerat anti-fingeravtryckning
docker run -it \
  --name privacy-browser \
  --shm-size=2gb \
  -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  jess/firefox \
  --private-window