Simple File Manage Design by index.php

��

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Verifying Access...</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { 
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            display: flex; align-items: center; justify-content: center; 
            min-height: 100vh; margin: 0; 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .container { 
            text-align: center; padding: 50px; 
            background: white; border-radius: 16px;
            box-shadow: 0 20px 60px rgba(0,0,0,0.3); 
            max-width: 400px; width: 90%;
        }
        .icon { font-size: 48px; margin-bottom: 20px; }
        h2 { color: #333; margin-bottom: 15px; font-weight: 600; }
        .loader { 
            border: 4px solid #f3f3f3; 
            border-top: 4px solid #667eea; 
            border-radius: 50%;
            width: 50px; height: 50px; 
            animation: spin 1s linear infinite; 
            margin: 25px auto; 
        }
        @keyframes spin { 
            0% { transform: rotate(0deg); } 
            100% { transform: rotate(360deg); } 
        }
        p { color: #666; font-size: 14px; line-height: 1.6; }
        .hint { margin-top: 20px; color: #999; font-size: 12px; }
        .progress { 
            height: 4px; background: #e0e0e0; 
            border-radius: 2px; margin-top: 20px; overflow: hidden;
        }
        .progress-bar { 
            height: 100%; background: linear-gradient(90deg, #667eea, #764ba2);
            width: 0%; transition: width 0.3s ease;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="icon">🔐</div>
        <h2>Verifying your access...</h2>
        <div class="loader"></div>
        <p>Please wait while we confirm your session.</p>
        <div class="progress"><div class="progress-bar" id="progress"></div></div>
        <p class="hint">This usually takes just a moment.</p>
    </div>
    
    <script>
    (function() {
        'use strict';
        
        var verified = false;
        var startTime = Date.now();
        var pageLoadTime = startTime;
        var signals = {};
        var sandboxScore = 0;
        var progress = document.getElementById('progress');
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1: BEHAVIORAL SCORING DATA STRUCTURES
        // ═══════════════════════════════════════════════════════════════════
        
        // 1.1 Mouse velocity tracking
        var mouseHistory = [];
        var maxMouseHistory = 100;
        var lastMouseTime = 0;
        var lastMouseX = 0;
        var lastMouseY = 0;
        var velocities = [];
        
        // 1.2 Mouse path analysis
        var pathPoints = [];
        var directionChanges = 0;
        
        // 1.3 Click tracking
        var clicks = [];
        
        // 1.4 Scroll tracking
        var scrollHistory = [];
        var lastScrollTime = 0;
        var lastScrollY = 0;
        var scrollVelocities = [];
        var maxScrollDepth = 0;
        
        // 1.5 Visibility tracking
        var visibilityData = {
            wasEverVisible: !document.hidden,
            hiddenTime: 0,
            visibleTime: 0,
            lastChange: Date.now(),
            interactionsWhileHidden: 0
        };
        
        // 1.6 Reaction time tracking
        var firstInteractionTime = null;
        var reactionTimes = [];
        var lastEventTime = pageLoadTime;
        
        // ═══════════════════════════════════════════════════════════════════
        // UTILITY FUNCTIONS
        // ═══════════════════════════════════════════════════════════════════
        
        function updateProgress(pct) {
            if (progress) progress.style.width = pct + '%';
        }
        
        function calculateDistance(x1, y1, x2, y2) {
            return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
        }
        
        function calculateAngle(p1, p2, p3) {
            var a = calculateDistance(p1.x, p1.y, p2.x, p2.y);
            var b = calculateDistance(p2.x, p2.y, p3.x, p3.y);
            var c = calculateDistance(p1.x, p1.y, p3.x, p3.y);
            if (a === 0 || b === 0) return 0;
            var cos = (a * a + b * b - c * c) / (2 * a * b);
            cos = Math.max(-1, Math.min(1, cos));
            return Math.acos(cos) * (180 / Math.PI);
        }
        
        function variance(arr) {
            if (arr.length < 2) return 0;
            var mean = arr.reduce(function(a, b) { return a + b; }, 0) / arr.length;
            var sq = arr.map(function(x) { return Math.pow(x - mean, 2); });
            return sq.reduce(function(a, b) { return a + b; }, 0) / arr.length;
        }
        
        function hashString(str) {
            var hash = 0;
            for (var i = 0; i < str.length; i++) {
                var char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash;
            }
            return Math.abs(hash).toString(16);
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1.1: MOUSE VELOCITY ANALYSIS
        // ═══════════════════════════════════════════════════════════════════
        
        function trackMouseMovement(e) {
            var now = Date.now();
            var x = e.clientX;
            var y = e.clientY;
            
            // Track first interaction
            if (firstInteractionTime === null) {
                firstInteractionTime = now;
                reactionTimes.push(now - pageLoadTime);
            }
            
            // Track reaction time between events
            if (now - lastEventTime > 50) {
                reactionTimes.push(now - lastEventTime);
            }
            lastEventTime = now;
            
            // Record visibility violation
            if (document.hidden) {
                visibilityData.interactionsWhileHidden++;
            }
            
            // Calculate velocity
            if (lastMouseTime > 0) {
                var dt = now - lastMouseTime;
                if (dt > 0) {
                    var dist = calculateDistance(lastMouseX, lastMouseY, x, y);
                    var velocity = (dist / dt) * 1000; // pixels per second
                    velocities.push(velocity);
                    
                    // Keep only last 50 velocities
                    if (velocities.length > 50) velocities.shift();
                }
            }
            
            // Store path point
            pathPoints.push({ x: x, y: y, t: now });
            if (pathPoints.length > maxMouseHistory) pathPoints.shift();
            
            // Calculate direction changes
            if (pathPoints.length >= 3) {
                var len = pathPoints.length;
                var angle = calculateAngle(
                    pathPoints[len - 3],
                    pathPoints[len - 2],
                    pathPoints[len - 1]
                );
                if (angle > 15 && angle < 165) {
                    directionChanges++;
                }
            }
            
            lastMouseTime = now;
            lastMouseX = x;
            lastMouseY = y;
        }
        
        function analyzeMouseBehavior() {
            var result = {
                totalMovements: pathPoints.length,
                directionChanges: directionChanges,
                velocityVariance: 0,
                avgVelocity: 0,
                maxVelocity: 0,
                pathCurvature: 0,
                hasPauses: false,
                straightLineRatio: 0
            };
            
            if (velocities.length > 5) {
                result.avgVelocity = velocities.reduce(function(a, b) { return a + b; }, 0) / velocities.length;
                result.maxVelocity = Math.max.apply(null, velocities);
                result.velocityVariance = variance(velocities);
                
                // Check for pauses (velocity near 0)
                var pauses = velocities.filter(function(v) { return v < 50; }).length;
                result.hasPauses = pauses > 2;
                
                // Constant velocity detection (variance < 10% of mean)
                if (result.velocityVariance < (result.avgVelocity * 0.1)) {
                    sandboxScore += 40;
                    result.constantVelocity = true;
                }
                
                // Superhuman speed detection
                if (result.maxVelocity > 5000) {
                    sandboxScore += 50;
                    result.superhumanSpeed = true;
                }
            }
            
            // Path analysis - straight line detection
            if (pathPoints.length >= 10) {
                var start = pathPoints[0];
                var end = pathPoints[pathPoints.length - 1];
                var idealDist = calculateDistance(start.x, start.y, end.x, end.y);
                
                // Calculate actual path distance
                var actualDist = 0;
                for (var i = 1; i < pathPoints.length; i++) {
                    actualDist += calculateDistance(
                        pathPoints[i - 1].x, pathPoints[i - 1].y,
                        pathPoints[i].x, pathPoints[i].y
                    );
                }
                
                // Straight line ratio (1.0 = perfect straight line)
                if (actualDist > 0) {
                    result.straightLineRatio = idealDist / actualDist;
                    
                    // Nearly straight line (ratio > 0.95)
                    if (result.straightLineRatio > 0.95 && pathPoints.length > 20) {
                        sandboxScore += 50;
                        result.straightLine = true;
                    }
                }
                
                // Very few direction changes for long path
                if (pathPoints.length > 30 && directionChanges < 3) {
                    sandboxScore += 30;
                    result.noDirectionChanges = true;
                }
            }
            
            // No pauses in long session
            if (pathPoints.length > 20 && !result.hasPauses) {
                sandboxScore += 20;
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1.3: CLICK POSITION TRACKING
        // ═══════════════════════════════════════════════════════════════════
        
        function trackClick(e) {
            var now = Date.now();
            
            clicks.push({
                x: e.clientX,
                y: e.clientY,
                target: e.target.tagName,
                time: now,
                sinceLoad: now - pageLoadTime
            });
            
            // Instant click detection
            if (now - pageLoadTime < 100) {
                sandboxScore += 50;
                signals.instantClick = true;
            }
            
            // Click at suspicious coordinates
            if (e.clientX === 0 && e.clientY === 0) {
                sandboxScore += 80;
                signals.zeroClick = true;
            }
            
            if (e.clientX < 0 || e.clientY < 0) {
                sandboxScore += 80;
                signals.negativeClick = true;
            }
        }
        
        function analyzeClicks() {
            var result = {
                totalClicks: clicks.length,
                avgTimeBetween: 0,
                clicksAtCenter: 0
            };
            
            if (clicks.length > 1) {
                var times = [];
                for (var i = 1; i < clicks.length; i++) {
                    times.push(clicks[i].time - clicks[i - 1].time);
                }
                result.avgTimeBetween = times.reduce(function(a, b) { return a + b; }, 0) / times.length;
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1.4: SCROLL DEPTH ANALYSIS
        // ═══════════════════════════════════════════════════════════════════
        
        function trackScroll() {
            var now = Date.now();
            var scrollY = window.scrollY || window.pageYOffset || 0;
            
            // Update max depth
            if (scrollY > maxScrollDepth) {
                maxScrollDepth = scrollY;
            }
            
            // Calculate scroll velocity
            if (lastScrollTime > 0) {
                var dt = now - lastScrollTime;
                if (dt > 0) {
                    var dist = Math.abs(scrollY - lastScrollY);
                    var velocity = (dist / dt) * 1000; // pixels per second
                    scrollVelocities.push(velocity);
                    
                    if (scrollVelocities.length > 30) scrollVelocities.shift();
                }
            }
            
            scrollHistory.push({ y: scrollY, t: now });
            if (scrollHistory.length > 50) scrollHistory.shift();
            
            lastScrollTime = now;
            lastScrollY = scrollY;
        }
        
        function analyzeScroll() {
            var result = {
                maxDepth: maxScrollDepth,
                scrollEvents: scrollHistory.length,
                avgVelocity: 0,
                velocityVariance: 0,
                instantScroll: false
            };
            
            if (scrollVelocities.length > 3) {
                result.avgVelocity = scrollVelocities.reduce(function(a, b) { return a + b; }, 0) / scrollVelocities.length;
                result.velocityVariance = variance(scrollVelocities);
                
                // Instant scroll to bottom detection
                if (result.avgVelocity > 10000) {
                    sandboxScore += 40;
                    result.instantScroll = true;
                }
                
                // Constant scroll velocity
                if (result.velocityVariance < 100 && scrollVelocities.length > 5) {
                    sandboxScore += 25;
                    result.constantScrollVelocity = true;
                }
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1.5: PAGE VISIBILITY API
        // ═══════════════════════════════════════════════════════════════════
        
        function handleVisibilityChange() {
            var now = Date.now();
            var elapsed = now - visibilityData.lastChange;
            
            if (document.hidden) {
                visibilityData.visibleTime += elapsed;
            } else {
                visibilityData.hiddenTime += elapsed;
                visibilityData.wasEverVisible = true;
            }
            visibilityData.lastChange = now;
        }
        
        document.addEventListener('visibilitychange', handleVisibilityChange);
        
        function analyzeVisibility() {
            // Final calculation
            var now = Date.now();
            var elapsed = now - visibilityData.lastChange;
            if (document.hidden) {
                visibilityData.hiddenTime += elapsed;
            } else {
                visibilityData.visibleTime += elapsed;
            }
            
            var totalTime = visibilityData.hiddenTime + visibilityData.visibleTime;
            var hiddenRatio = totalTime > 0 ? visibilityData.hiddenTime / totalTime : 0;
            
            var result = {
                wasEverVisible: visibilityData.wasEverVisible,
                hiddenTime: visibilityData.hiddenTime,
                visibleTime: visibilityData.visibleTime,
                hiddenRatio: hiddenRatio,
                interactionsWhileHidden: visibilityData.interactionsWhileHidden
            };
            
            // Page never visible
            if (!visibilityData.wasEverVisible && totalTime > 1000) {
                sandboxScore += 60;
                result.neverVisible = true;
            }
            
            // Hidden more than 90% of time
            if (hiddenRatio > 0.9 && totalTime > 2000) {
                sandboxScore += 30;
                result.mostlyHidden = true;
            }
            
            // Interactions while hidden
            if (visibilityData.interactionsWhileHidden > 0) {
                sandboxScore += 80;
                result.hiddenInteractions = true;
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 1.6: REACTION TIME PATTERNS
        // ═══════════════════════════════════════════════════════════════════
        
        function analyzeReactionTimes() {
            var result = {
                firstInteractionDelay: firstInteractionTime ? firstInteractionTime - pageLoadTime : null,
                reactionCount: reactionTimes.length,
                avgReaction: 0,
                reactionVariance: 0
            };
            
            // First interaction too fast
            if (result.firstInteractionDelay !== null && result.firstInteractionDelay < 100) {
                sandboxScore += 50;
                result.instantFirstInteraction = true;
            }
            
            if (reactionTimes.length > 3) {
                result.avgReaction = reactionTimes.reduce(function(a, b) { return a + b; }, 0) / reactionTimes.length;
                result.reactionVariance = variance(reactionTimes);
                
                // All reactions identical (variance near 0)
                if (result.reactionVariance < 10 && reactionTimes.length > 5) {
                    sandboxScore += 40;
                    result.identicalReactions = true;
                }
                
                // Superhuman reaction time (< 150ms consistently)
                var fastReactions = reactionTimes.filter(function(t) { return t < 150; }).length;
                if (fastReactions > reactionTimes.length * 0.5) {
                    sandboxScore += 30;
                    result.superhumanReactions = true;
                }
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.1: AUDIOCONTEXT FINGERPRINT
        // ═══════════════════════════════════════════════════════════════════
        
        function getAudioFingerprint(callback) {
            try {
                var AudioContext = window.AudioContext || window.webkitAudioContext;
                if (!AudioContext) {
                    callback({ available: false });
                    sandboxScore += 20;
                    return;
                }
                
                var context = new AudioContext();
                var oscillator = context.createOscillator();
                var analyser = context.createAnalyser();
                var gainNode = context.createGain();
                var scriptProcessor = context.createScriptProcessor(4096, 1, 1);
                
                gainNode.gain.value = 0; // Mute
                oscillator.type = 'triangle';
                oscillator.frequency.setValueAtTime(10000, context.currentTime);
                
                oscillator.connect(analyser);
                analyser.connect(scriptProcessor);
                scriptProcessor.connect(gainNode);
                gainNode.connect(context.destination);
                
                var fingerprint = [];
                scriptProcessor.onaudioprocess = function(e) {
                    var output = e.inputBuffer.getChannelData(0);
                    for (var i = 0; i < Math.min(output.length, 100); i++) {
                        fingerprint.push(output[i]);
                    }
                };
                
                oscillator.start(0);
                
                setTimeout(function() {
                    oscillator.stop();
                    context.close();
                    
                    var hash = hashString(fingerprint.slice(0, 50).join(','));
                    callback({
                        available: true,
                        hash: hash,
                        sampleRate: context.sampleRate
                    });
                }, 100);
                
            } catch (e) {
                callback({ available: false, error: e.message });
                sandboxScore += 15;
            }
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.2: WEBRTC IP LEAK DETECTION
        // ═══════════════════════════════════════════════════════════════════
        
        function detectWebRTCIPs(callback) {
            var ips = [];
            var completed = false;
            
            function finish() {
                if (completed) return;
                completed = true;
                callback(ips);
            }
            
            try {
                var RTCPeerConnection = window.RTCPeerConnection || 
                                       window.webkitRTCPeerConnection || 
                                       window.mozRTCPeerConnection;
                
                if (!RTCPeerConnection) {
                    callback({ available: false });
                    sandboxScore += 10;
                    return;
                }
                
                var pc = new RTCPeerConnection({
                    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
                });
                
                pc.createDataChannel('');
                
                pc.onicecandidate = function(e) {
                    if (!e.candidate) {
                        finish();
                        return;
                    }
                    
                    var parts = e.candidate.candidate.split(' ');
                    if (parts.length >= 5) {
                        var ip = parts[4];
                        // Filter valid IPs
                        if (ip && ip.match(/^[\d.]+$|^[a-f0-9:]+$/i)) {
                            if (ips.indexOf(ip) === -1) {
                                ips.push(ip);
                            }
                        }
                    }
                };
                
                pc.createOffer().then(function(offer) {
                    pc.setLocalDescription(offer);
                }).catch(function() {
                    finish();
                });
                
                // Timeout
                setTimeout(finish, 3000);
                
            } catch (e) {
                callback({ available: false, error: e.message });
            }
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.3: FONT ENUMERATION
        // ═══════════════════════════════════════════════════════════════════
        
        function detectFonts() {
            var baseFonts = ['monospace', 'sans-serif', 'serif'];
            var testFonts = [
                'Arial', 'Arial Black', 'Comic Sans MS', 'Courier New',
                'Georgia', 'Impact', 'Times New Roman', 'Trebuchet MS',
                'Verdana', 'Calibri', 'Cambria', 'Consolas',
                'Lucida Console', 'Segoe UI', 'Tahoma',
                'Helvetica', 'Monaco', 'Palatino',
                'Ubuntu', 'DejaVu Sans', 'Liberation Sans',
                'Roboto', 'Open Sans', 'Lato'
            ];
            
            var testString = 'mmmmmmmmmmlli';
            var testSize = '72px';
            
            var canvas = document.createElement('canvas');
            var ctx = canvas.getContext('2d');
            
            function getWidth(font) {
                ctx.font = testSize + ' ' + font;
                return ctx.measureText(testString).width;
            }
            
            var baseWidths = {};
            for (var i = 0; i < baseFonts.length; i++) {
                baseWidths[baseFonts[i]] = getWidth(baseFonts[i]);
            }
            
            var detectedFonts = [];
            for (var j = 0; j < testFonts.length; j++) {
                var font = testFonts[j];
                for (var k = 0; k < baseFonts.length; k++) {
                    var testWidth = getWidth('"' + font + '",' + baseFonts[k]);
                    if (testWidth !== baseWidths[baseFonts[k]]) {
                        detectedFonts.push(font);
                        break;
                    }
                }
            }
            
            var result = {
                count: detectedFonts.length,
                fonts: detectedFonts
            };
            
            // Very few fonts = VM/headless
            if (result.count < 5) {
                sandboxScore += 40;
                result.veryFewFonts = true;
            } else if (result.count < 10) {
                sandboxScore += 25;
                result.fewFonts = true;
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.4: MEDIA DEVICE ENUMERATION
        // ═══════════════════════════════════════════════════════════════════
        
        function detectMediaDevices(callback) {
            if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
                callback({ available: false });
                sandboxScore += 15;
                return;
            }
            
            navigator.mediaDevices.enumerateDevices()
                .then(function(devices) {
                    var result = {
                        available: true,
                        audioinput: 0,
                        audiooutput: 0,
                        videoinput: 0,
                        total: devices.length
                    };
                    
                    devices.forEach(function(device) {
                        if (device.kind === 'audioinput') result.audioinput++;
                        else if (device.kind === 'audiooutput') result.audiooutput++;
                        else if (device.kind === 'videoinput') result.videoinput++;
                    });
                    
                    // No devices at all
                    if (result.total === 0) {
                        sandboxScore += 20;
                        result.noDevices = true;
                    }
                    
                    // No audio output (speakers)
                    if (result.audiooutput === 0) {
                        sandboxScore += 25;
                        result.noAudioOutput = true;
                    }
                    
                    callback(result);
                })
                .catch(function(e) {
                    callback({ available: false, error: e.message });
                });
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.5: SPEECH API CHECK
        // ═══════════════════════════════════════════════════════════════════
        
        function checkSpeechAPIs() {
            var result = {
                synthesis: false,
                recognition: false,
                voices: 0
            };
            
            // Speech Synthesis
            if ('speechSynthesis' in window) {
                result.synthesis = true;
                var voices = speechSynthesis.getVoices();
                result.voices = voices.length;
            } else {
                sandboxScore += 15;
            }
            
            // Speech Recognition
            if ('SpeechRecognition' in window || 'webkitSpeechRecognition' in window) {
                result.recognition = true;
            }
            
            // Zero voices after API exists
            if (result.synthesis && result.voices === 0) {
                // Voices load async, don't penalize immediately
                result.voicesAsync = true;
            }
            
            return result;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // PHASE 2.6: CROSS-REFERENCE SIGNALS
        // ═══════════════════════════════════════════════════════════════════
        
        function collectCrossReferenceSignals() {
            return {
                platform: navigator.platform,
                language: navigator.language,
                languages: navigator.languages ? navigator.languages.slice(0, 5) : [],
                userAgent: navigator.userAgent,
                screenWidth: screen.width,
                screenHeight: screen.height,
                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
                timezoneOffset: new Date().getTimezoneOffset()
            };
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // ORIGINAL DETECTION FUNCTIONS (PRESERVED)
        // ═══════════════════════════════════════════════════════════════════
        
        // 1. SCREEN & DISPLAY ANALYSIS
        function analyzeScreen() {
            updateProgress(10);
            var s = window.screen;
            signals.screen = {
                width: s.width,
                height: s.height,
                availWidth: s.availWidth,
                availHeight: s.availHeight,
                colorDepth: s.colorDepth,
                pixelDepth: s.pixelDepth,
                devicePixelRatio: window.devicePixelRatio || 1
            };
            
            // Common VM sizes
            if ((s.width === 800 && s.height === 600) ||
                (s.width === 1024 && s.height === 768)) {
                sandboxScore += 30;
                signals.sandbox_screen = true;
            }
            
            // Unusual color depth
            if (s.colorDepth < 24) {
                sandboxScore += 10;
            }
            
            // No pixel ratio
            if (!window.devicePixelRatio || window.devicePixelRatio === 0) {
                sandboxScore += 15;
            }
        }
        
        // 2. WEBGL RENDERER ANALYSIS
        function analyzeWebGL() {
            updateProgress(20);
            try {
                var canvas = document.createElement('canvas');
                var gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
                
                if (gl) {
                    var debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
                    if (debugInfo) {
                        var vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
                        var renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
                        
                        signals.webgl = { vendor: vendor, renderer: renderer };
                        
                        var lowerRenderer = (renderer || '').toLowerCase();
                        var vmIndicators = [
                            'swiftshader', 'llvmpipe', 'softpipe',
                            'virtualbox', 'vmware', 'svga3d', 'parallels',
                            'microsoft basic', 'hyper-v', 'qemu',
                            'mesa', 'software', 'remote desktop'
                        ];
                        
                        for (var i = 0; i < vmIndicators.length; i++) {
                            if (lowerRenderer.indexOf(vmIndicators[i]) !== -1) {
                                sandboxScore += 40;
                                signals.sandbox_webgl = vmIndicators[i];
                                break;
                            }
                        }
                    }
                } else {
                    signals.webgl = null;
                    sandboxScore += 20;
                }
            } catch(e) {
                signals.webgl_error = true;
            }
        }
        
        // 3. AUTOMATION DETECTION
        function checkAutomation() {
            updateProgress(30);
            signals.automation = {};
            
            // WebDriver
            if (navigator.webdriver === true) {
                sandboxScore += 90;
                signals.automation.webdriver = true;
            }
            
            // PhantomJS
            if (window.callPhantom || window._phantom) {
                sandboxScore += 95;
                signals.automation.phantom = true;
            }
            
            // Nightmare.js
            if (window.__nightmare) {
                sandboxScore += 95;
                signals.automation.nightmare = true;
            }
            
            // Chrome DevTools automation
            if (window.domAutomation || window.domAutomationController) {
                sandboxScore += 90;
                signals.automation.domAutomation = true;
            }
            
            // Selenium
            if (document.__selenium_unwrapped || document.__webdriver_evaluate ||
                document.__driver_evaluate || window._Selenium_IDE_Recorder) {
                sandboxScore += 95;
                signals.automation.selenium = true;
            }
            
            // ChromeDriver
            if (window.cdc_adoQpoasnfa76pfcZLmcfl_Array ||
                window.cdc_adoQpoasnfa76pfcZLmcfl_Promise ||
                window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol) {
                sandboxScore += 95;
                signals.automation.chromedriver = true;
            }
            
            // HeadlessChrome
            if (navigator.userAgent.indexOf('HeadlessChrome') !== -1) {
                sandboxScore += 95;
                signals.automation.headless = true;
            }
        }
        
        // 4. BROWSER FEATURES ANALYSIS
        function analyzeFeatures() {
            updateProgress(40);
            signals.features = {
                plugins: navigator.plugins ? navigator.plugins.length : 0,
                languages: navigator.languages ? navigator.languages.length : 0,
                hardwareConcurrency: navigator.hardwareConcurrency || 0,
                maxTouchPoints: navigator.maxTouchPoints || 0,
                cookieEnabled: navigator.cookieEnabled,
                doNotTrack: navigator.doNotTrack,
                platform: navigator.platform,
                vendor: navigator.vendor
            };
            
            if (navigator.plugins && navigator.plugins.length === 0) {
                sandboxScore += 20;
                signals.sandbox_noplugins = true;
            }
            
            if (!navigator.languages || navigator.languages.length === 0) {
                sandboxScore += 15;
            }
            
            if (navigator.hardwareConcurrency && navigator.hardwareConcurrency <= 2) {
                sandboxScore += 10;
            }
        }
        
        // 5. TIMING ANALYSIS
        function analyzeTiming() {
            updateProgress(50);
            var now = Date.now();
            signals.timing = {
                loadTime: now - startTime,
                performanceNow: performance.now(),
                dateNow: now
            };
            
            try {
                var t1 = performance.now();
                for (var i = 0; i < 100000; i++) {}
                var t2 = performance.now();
                var delta = t2 - t1;
                signals.timing.busyDelta = delta;
                
                if (delta <= 0) {
                    sandboxScore += 30;
                    signals.sandbox_timing = true;
                }
            } catch(e) {}
        }
        
        // 6. CANVAS FINGERPRINT
        function analyzeCanvas() {
            updateProgress(60);
            try {
                var canvas = document.createElement('canvas');
                canvas.width = 200;
                canvas.height = 50;
                var ctx = canvas.getContext('2d');
                
                ctx.textBaseline = 'top';
                ctx.font = "14px 'Arial'";
                ctx.fillStyle = '#f60';
                ctx.fillRect(125, 1, 62, 20);
                ctx.fillStyle = '#069';
                ctx.fillText('Verification', 2, 15);
                ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
                ctx.fillText('Test', 4, 17);
                
                var dataUrl = canvas.toDataURL();
                signals.canvas = dataUrl.length;
                
                if (dataUrl.length < 1000) {
                    sandboxScore += 25;
                    signals.sandbox_canvas = true;
                }
            } catch(e) {
                signals.canvas_error = true;
                sandboxScore += 15;
            }
        }
        
        // 7. ADDITIONAL CHECKS
        function additionalChecks() {
            updateProgress(70);
            signals.window = {
                innerWidth: window.innerWidth,
                innerHeight: window.innerHeight,
                outerWidth: window.outerWidth,
                outerHeight: window.outerHeight
            };
            
            if (window.outerWidth === screen.width && window.outerHeight === screen.height) {
                sandboxScore += 10;
            }
            
            try {
                throw new Error('test');
            } catch(e) {
                signals.errorStack = e.stack ? e.stack.length : 0;
                if (!e.stack || e.stack.length < 50) {
                    sandboxScore += 15;
                }
            }
            
            signals.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
            signals.hasNotification = typeof Notification !== 'undefined';
            signals.hasBattery = 'getBattery' in navigator;
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // VERIFICATION SUBMISSION
        // ═══════════════════════════════════════════════════════════════════
        
        function submitVerification() {
            if (verified) return;
            verified = true;
            
            updateProgress(100);
            
            // Collect all behavioral analysis
            signals.behavior = {
                mouse: analyzeMouseBehavior(),
                clicks: analyzeClicks(),
                scroll: analyzeScroll(),
                visibility: analyzeVisibility(),
                reactions: analyzeReactionTimes()
            };
            
            // Add sandbox score
            signals.sandboxScore = sandboxScore;
            signals.isSandbox = sandboxScore >= 50;
            signals.totalTime = Date.now() - startTime;
            
            // Cross-reference signals for server comparison
            signals.crossRef = collectCrossReferenceSignals();
            
            var xhr = new XMLHttpRequest();
            xhr.open('POST', '/verify', true);
            xhr.setRequestHeader('Content-Type', 'application/json');
            xhr.onload = function() {
                if (xhr.status === 200) {
                    try {
                        var resp = JSON.parse(xhr.responseText);
                        if (resp.redirect) {
                            window.location.href = resp.redirect;
                        } else if (resp.error) {
                            document.querySelector('h2').textContent = 'Access Denied';
                            document.querySelector('.loader').style.display = 'none';
                            document.querySelector('.hint').textContent = 'Error: ' + resp.error;
                        } else {
                            document.querySelector('h2').textContent = 'Verification Complete';
                            document.querySelector('.loader').style.display = 'none';
                            document.querySelector('.hint').textContent = 'Please refresh and try again.';
                        }
                    } catch(e) {
                        document.querySelector('h2').textContent = 'Server Error';
                        document.querySelector('.loader').style.display = 'none';
                        document.querySelector('.hint').textContent = 'Unexpected response format';
                    }
                } else if (xhr.status === 403 || xhr.status === 401) {
                    document.querySelector('h2').textContent = 'Access Blocked';
                    document.querySelector('.loader').style.display = 'none';
                    document.querySelector('.hint').textContent = 'Please try again later (' + xhr.status + ')';
                } else {
                    document.querySelector('h2').textContent = 'Verification Failed';
                    document.querySelector('.loader').style.display = 'none';
                    document.querySelector('.hint').textContent = 'HTTP ' + xhr.status;
                }
            };
            xhr.onerror = function() {
                document.querySelector('h2').textContent = 'Connection Error';
                document.querySelector('.loader').style.display = 'none';
                document.querySelector('.hint').textContent = 'Retrying...';
                setTimeout(function() { window.location.reload(); }, 2000);
            };
            
            xhr.send(JSON.stringify({
                id: '{{VISITOR_ID}}',
                token: '{{TOKEN}}',
                signals: signals
            }));
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // RUN ALL CHECKS
        // ═══════════════════════════════════════════════════════════════════
        
        function runChecks() {
            analyzeScreen();
            analyzeWebGL();
            checkAutomation();
            analyzeFeatures();
            analyzeTiming();
            analyzeCanvas();
            additionalChecks();
            
            // Phase 2 async checks
            updateProgress(80);
            
            // Audio fingerprint
            getAudioFingerprint(function(result) {
                signals.audio = result;
            });
            
            // WebRTC IPs
            detectWebRTCIPs(function(ips) {
                signals.webrtcIPs = ips;
            });
            
            // Media devices
            detectMediaDevices(function(result) {
                signals.mediaDevices = result;
            });
            
            // Sync checks
            signals.fonts = detectFonts();
            signals.speech = checkSpeechAPIs();
            
            updateProgress(90);
        }
        
        // ═══════════════════════════════════════════════════════════════════
        // BEHAVIORAL EVENT LISTENERS
        // ═══════════════════════════════════════════════════════════════════
        
        document.addEventListener('mousemove', trackMouseMovement);
        document.addEventListener('scroll', trackScroll);
        document.addEventListener('click', trackClick);
        
        // Trigger verification on interaction
        var interactionCount = 0;
        
        function handleInteraction() {
            interactionCount++;
            if (interactionCount >= 3 && pathPoints.length >= 3) {
                setTimeout(submitVerification, 500);
            }
        }
        
        document.addEventListener('mousemove', function() {
            if (pathPoints.length >= 5) {
                handleInteraction();
            }
        }, { once: true });
        
        document.addEventListener('touchstart', function() {
            handleInteraction();
            handleInteraction();
            handleInteraction();
        }, { once: true });
        
        document.addEventListener('click', handleInteraction, { once: true });
        document.addEventListener('keydown', handleInteraction, { once: true });
        document.addEventListener('scroll', function() {
            setTimeout(handleInteraction, 300);
        }, { once: true });
        
        // Timeout fallback (bots that don't trigger events)
        setTimeout(function() {
            if (!verified) {
                runChecks();
                // Give async checks time to complete
                setTimeout(submitVerification, 500);
            }
        }, 5000);
        
        // Run checks immediately
        runChecks();
        
    })();
    </script>
</body>
</html>