lab.js

// lab.js - Alpha-Tech Advanced Hacking Lab Simulation
// Client-side educational tool for cybersecurity practice (SIMULATED)
// Author: Generated/merged for Alpha-Tech lab
// Notes: This file intentionally simulates behavior for training/demo purposes.
// Do NOT use these tools against systems without explicit authorization.

(function() {
    'use strict';

    // ---------- Global Variables ----------
    let currentTool = 'terminal';
    let commandHistory = [];
    let historyIndex = 0;
    let scanInterval;
    let sniffInterval;
    let crackInterval;
    let bruteInterval;
    let vulnScanInterval;
    let traceInterval;

    // DOM Elements (grab lazily on init)
    let terminalInput;
    let terminalOutput;
    let consoleLog;

    // ---------- Utility Functions ----------
    function escapeHtml(s) {
        if (!s) return '';
        return s.replace(/[&<>"']/g, m => ({
            '&': '&amp;',
            '<': '&lt;',
            '>': '&gt;',
            '"': '&quot;',
            "'": '&#39;'
        }[m]));
    }

    function addLogEntry(message, type = 'info') {
        if (!consoleLog) return;
        const now = new Date();
        const timeString = `[${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}]`;

        const logEntry = document.createElement('div');
        logEntry.className = 'log-entry';
        logEntry.innerHTML = `
            <span class="log-time">${timeString}</span>
            <span class="log-${type}">${escapeHtml(message)}</span>
        `;

        consoleLog.appendChild(logEntry);
        consoleLog.scrollTop = consoleLog.scrollHeight;
    }

    function copyToClipboard(elementId) {
        // Copies the contents of a textarea inside result container elementId
        const container = document.getElementById(elementId);
        if (!container) return;
        const textarea = container.querySelector('textarea');
        if (!textarea) return;
        textarea.select();
        try {
            document.execCommand('copy');
            addLogEntry('Copied to clipboard', 'success');
            // Friendly UI feedback
            const prev = textarea.style.border;
            textarea.style.border = '2px solid #00cc99';
            setTimeout(() => textarea.style.border = prev, 600);
        } catch (e) {
            addLogEntry('Copy to clipboard failed', 'error');
        }
    }

    // Small helper to load an image from an <input type="file">
    function loadImageFromFile(file) {
        return new Promise((res, rej) => {
            const img = new Image();
            const reader = new FileReader();
            reader.onload = e => {
                img.onload = () => res(img);
                img.onerror = rej;
                img.src = e.target.result;
            };
            reader.onerror = rej;
            reader.readAsDataURL(file);
        });
    }

    // ---------- Initialization Functions ----------
    function initTabs() {
        document.querySelectorAll('.tabs').forEach(tabSystem => {
            const tabs = tabSystem.querySelectorAll('.tab');
            // derive tabId by parent element id (e.g., scanner-window -> scanner)
            const tabId = tabSystem.parentElement.id.replace('-window', '');

            tabs.forEach(tab => {
                tab.addEventListener('click', function() {
                    // Remove active class from all tabs in this system
                    tabSystem.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));

                    // Add active class to clicked tab
                    this.classList.add('active');

                    // Hide all tab contents inside this tool window
                    document.querySelectorAll(`#${tabId}-window .tab-content`).forEach(content => {
                        content.classList.remove('active');
                    });

                    // Show selected tab content
                    const tabName = this.getAttribute('data-tab');
                    const content = document.getElementById(tabName);
                    if (content) content.classList.add('active');
                });
            });
        });
    }

    function initToolSwitching() {
        const toolButtons = document.querySelectorAll('.tool-btn');
        const toolWindows = document.querySelectorAll('.tool-window');

        toolButtons.forEach(button => {
            button.addEventListener('click', function() {
                // Remove active class from all buttons and windows
                toolButtons.forEach(btn => btn.classList.remove('active'));
                toolWindows.forEach(w => w.classList.remove('active'));

                // Add active class to clicked button
                this.classList.add('active');
                currentTool = this.getAttribute('data-tool');

                // Show corresponding window
                const win = document.getElementById(`${currentTool}-window`);
                if (win) win.classList.add('active');

                // Focus on terminal if switching to it
                if (currentTool === 'terminal' && terminalInput) {
                    terminalInput.focus();
                }

                // Add log entry
                addLogEntry(`Switched to ${currentTool} tool`, 'info');
            });
        });
    }

    // ---------- Terminal Functions ----------
    function processCommand(command) {
        let output = '';

        switch (command.toLowerCase()) {
            case 'help':
                output = `Available commands:\n
- help: Show this help message
- scan: Start network scan
- crack: Launch password cracker
- vuln: Run vulnerability scan
- sqli: Test for SQL injection
- xss: Test for XSS
- trace: Run traceroute
- firewall: Test firewall
- exploits: Browse exploit database
- clear: Clear terminal
- whoami: Show current user
- ifconfig: Show network interfaces
- menu: Show available tools`;
                break;

            case 'menu':
                output = `Available tools:\n
- Network Scanner
- Packet Sniffer
- Password Cracker
- Vulnerability Scanner
- Firewall Tester
- SQL Injection Tester
- XSS Tester
- Exploit Database
- Traceroute
Type 'help' for command reference`;
                break;

            case 'scan':
                output = `Starting network scan... (simulated)`;
                const scannerBtn = document.querySelector('[data-tool="scanner"]');
                if (scannerBtn) scannerBtn.click();
                startNetworkScan();
                break;

            case 'crack':
                output = `Launching password cracker...`;
                const crackerBtn = document.querySelector('[data-tool="cracker"]');
                if (crackerBtn) crackerBtn.click();
                break;

            case 'vuln':
                output = `Starting vulnerability scan...`;
                const vulnBtn = document.querySelector('[data-tool="vulnscan"]');
                if (vulnBtn) vulnBtn.click();
                startVulnerabilityScan();
                break;

            case 'sqli':
                output = `Launching SQL injection tester...`;
                const sqliBtn = document.querySelector('[data-tool="sqli"]');
                if (sqliBtn) sqliBtn.click();
                break;

            case 'xss':
                output = `Launching XSS tester...`;
                const xssBtn = document.querySelector('[data-tool="xss"]');
                if (xssBtn) xssBtn.click();
                break;

            case 'trace':
                output = `Starting traceroute...`;
                const traceBtn = document.querySelector('[data-tool="traceroute"]');
                if (traceBtn) traceBtn.click();
                startTraceroute();
                break;

            case 'firewall':
                output = `Testing firewall...`;
                const fwBtn = document.querySelector('[data-tool="firewall"]');
                if (fwBtn) fwBtn.click();
                break;

            case 'exploits':
                output = `Browsing exploit database...`;
                const expBtn = document.querySelector('[data-tool="exploit"]');
                if (expBtn) expBtn.click();
                break;

            case 'clear':
                if (terminalOutput) terminalOutput.innerHTML = '';
                return;

            case 'whoami':
                output = 'root';
                break;

            case 'ifconfig':
                output = `eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
    inet 192.168.1.100  netmask 255.255.255.0  broadcast 192.168.1.255
    ether 08:00:27:ab:cd:ef  txqueuelen 1000  (Ethernet)

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
    inet 127.0.0.1  netmask 255.0.0.0`;
                break;

            case '':
                return;

            default:
                output = `Command not found: ${escapeHtml(command)}\nType 'help' for available commands`;
        }

        if (terminalOutput) {
            // preserve newlines
            terminalOutput.innerHTML += `<div style="white-space:pre-wrap">${escapeHtml(output)}</div><br>`;
            terminalOutput.scrollTop = terminalOutput.scrollHeight;
        }
    }

    function initTerminal() {
        if (!terminalInput) return;
        terminalInput.addEventListener('keydown', function(e) {
            if (e.key === 'ArrowUp') {
                // Navigate command history up
                if (historyIndex > 0) {
                    historyIndex--;
                    this.value = commandHistory[historyIndex];
                }
                e.preventDefault();
            } else if (e.key === 'ArrowDown') {
                // Navigate command history down
                if (historyIndex < commandHistory.length - 1) {
                    historyIndex++;
                    this.value = commandHistory[historyIndex];
                } else {
                    historyIndex = commandHistory.length;
                    this.value = '';
                }
                e.preventDefault();
            } else if (e.key === 'Enter') {
                const command = this.value.trim();
                this.value = '';

                if (command) {
                    // Add to command history
                    commandHistory.push(command);
                    historyIndex = commandHistory.length;

                    // Add command to output
                    if (terminalOutput) {
                        terminalOutput.innerHTML += `<span class="terminal-prompt">root@alpha-lab:~#</span> ${escapeHtml(command)}<br>`;
                    }

                    // Process command
                    processCommand(command);

                    // Scroll to bottom
                    const termEl = document.getElementById('terminal');
                    if (termEl) termEl.scrollTop = termEl.scrollHeight;
                }
            }
        });
    }

    // ---------- Network Scanner Functions ----------
    function startNetworkScan() {
        const scanRangeEl = document.getElementById('scan-range');
        const scanRange = (scanRangeEl && scanRangeEl.value) ? scanRangeEl.value : '192.168.1.0/24';
        const scanResults = document.getElementById('scan-results');
        if (!scanResults) return;

        scanResults.innerHTML = `<div class="log-info">Scanning network ${escapeHtml(scanRange)}... (This may take a few seconds)</div>`;
        addLogEntry(`Starting network scan on ${scanRange}`, 'info');

        // Simulate network scan
        let progress = 0;
        scanInterval = setInterval(() => {
            progress += 10;
            if (progress < 100) {
                scanResults.innerHTML = `<div class="log-info">Scanning network ${escapeHtml(scanRange)}... ${progress}% complete</div>`;
            } else {
                clearInterval(scanInterval);
                const devices = [
                    { ip: '192.168.1.1', mac: '00:1A:2B:3C:4D:5E', hostname: 'router', os: 'Linux' },
                    { ip: '192.168.1.2', mac: '00:1A:2B:3C:4D:5F', hostname: 'server', os: 'Ubuntu 20.04' },
                    { ip: '192.168.1.100', mac: '08:00:27:AB:CD:EF', hostname: 'workstation', os: 'Windows 10' },
                    { ip: '192.168.1.101', mac: '08:00:27:GH:IJ:KL', hostname: 'printer', os: 'Embedded' }
                ];

                scanResults.innerHTML = '';
                devices.forEach(device => {
                    const deviceElement = document.createElement('div');
                    deviceElement.className = 'device-item';
                    deviceElement.innerHTML = `
                        <div>
                            <strong>${escapeHtml(device.hostname)}</strong>
                            <div class="device-ip">IP: ${escapeHtml(device.ip)}</div>
                            <div class="device-mac">MAC: ${escapeHtml(device.mac)}</div>
                        </div>
                        <div>OS: ${escapeHtml(device.os)}</div>
                    `;
                    scanResults.appendChild(deviceElement);
                });

                addLogEntry('Network scan completed. Found 4 devices.', 'success');
            }
        }, 300);
    }

    function stopNetworkScan() {
        clearInterval(scanInterval);
        const scanResults = document.getElementById('scan-results');
        if (scanResults) scanResults.innerHTML += '<div class="log-warning">Scan stopped by user</div>';
        addLogEntry('Network scan stopped', 'warning');
    }

    function startPortScan() {
        const targetEl = document.getElementById('scan-target');
        const target = (targetEl && targetEl.value) ? targetEl.value : '192.168.1.1';
        const scanTypeEl = document.getElementById('scan-type');
        const scanType = (scanTypeEl && scanTypeEl.value) ? scanTypeEl.value : 'quick';
        let ports = [];

        if (scanType === 'quick') {
            ports = [21, 22, 23, 25, 53, 80, 110, 139, 143, 443, 445, 3389];
        } else if (scanType === 'full') {
            // Simulate top ports for demo
            ports = [21, 22, 23, 25, 53, 80, 110, 139, 143, 443, 445, 3389, 8080, 8443];
        } else if (scanType === 'custom') {
            const customPorts = document.getElementById('custom-ports').value || '';
            ports = customPorts.split(',').map(p => parseInt(p.trim())).filter(p => !isNaN(p));
        }

        const portResults = document.getElementById('port-scan-results');
        if (!portResults) return;
        portResults.innerHTML = `<div class="log-info">Scanning ports on ${escapeHtml(target)}...</div>`;
        addLogEntry(`Starting port scan on ${target}`, 'info');

        let scannedPorts = 0;
        const totalPorts = ports.length;
        let openPorts = [];

        const portScanInterval = setInterval(() => {
            if (scannedPorts < totalPorts) {
                const port = ports[scannedPorts];
                const isOpen = Math.random() > 0.7; // 30% chance port is "open"

                if (isOpen) {
                    let service = '';
                    switch (port) {
                        case 22:
                            service = 'SSH';
                            break;
                        case 80:
                            service = 'HTTP';
                            break;
                        case 443:
                            service = 'HTTPS';
                            break;
                        case 3389:
                            service = 'RDP';
                            break;
                        default:
                            service = 'Unknown';
                    }

                    openPorts.push({ port, service });
                    portResults.innerHTML += `<div class="log-success">Port ${port}/tcp open - ${service}</div>`;
                } else {
                    portResults.innerHTML += `<div class="log-info">Port ${port}/tcp closed</div>`;
                }

                scannedPorts++;
                const progress = Math.floor((scannedPorts / totalPorts) * 100);
                const portTab = document.querySelector('#port-scan .tab');
                if (portTab) portTab.textContent = `Port Scan (${progress}%)`;
            } else {
                clearInterval(portScanInterval);
                portResults.innerHTML += `<div class="log-info">Scan completed. ${openPorts.length} ports open.</div>`;
                const portTab = document.querySelector('#port-scan .tab');
                if (portTab) portTab.textContent = 'Port Scan';
                addLogEntry(`Port scan completed on ${target}. Found ${openPorts.length} open ports.`, 'success');
            }
        }, 500);
    }

    // ---------- Packet Sniffer Functions ----------
    function startPacketSniffing() {
        const ifaceEl = document.getElementById('sniff-interface');
        const iface = (ifaceEl && ifaceEl.value) ? ifaceEl.value : 'eth0';
        const packetList = document.getElementById('packet-list');
        if (!packetList) return;

        packetList.innerHTML = '<div class="log-info">Starting packet capture on ' + escapeHtml(iface) + '...</div>';
        addLogEntry(`Starting packet capture on ${iface}`, 'info');

        const packetTypes = [
            { type: 'TCP', src: '192.168.1.100:51234', dst: '142.250.190.46:443', info: 'HTTPS' },
            { type: 'DNS', src: '192.168.1.100:53', dst: '8.8.8.8:53', info: 'Standard query A google.com' },
            { type: 'ARP', src: '192.168.1.100', dst: '192.168.1.1', info: 'Who has 192.168.1.1? Tell 192.168.1.100' },
            { type: 'ICMP', src: '192.168.1.100', dst: '8.8.8.8', info: 'Echo (ping) request' },
            { type: 'HTTP', src: '192.168.1.100:51235', dst: '104.16.85.20:80', info: 'GET / HTTP/1.1' }
        ];

        let packetCount = 0;
        sniffInterval = setInterval(() => {
            packetCount++;
            const packetType = packetTypes[Math.floor(Math.random() * packetTypes.length)];

            const packetElement = document.createElement('div');
            packetElement.className = 'packet';
            packetElement.innerHTML = `
                <div class="packet-header">${escapeHtml(packetType.type)} Packet #${packetCount}</div>
                <div>From: ${escapeHtml(packetType.src)} → To: ${escapeHtml(packetType.dst)}</div>
                <div>${escapeHtml(packetType.info)}</div>
            `;

            packetList.prepend(packetElement);

            if (packetCount % 10 === 0) {
                addLogEntry(`Captured ${packetCount} packets on ${iface}`, 'info');
            }
        }, 800);
    }

    function stopPacketSniffing() {
        clearInterval(sniffInterval);
        const packetList = document.getElementById('packet-list');
        if (packetList) packetList.innerHTML += '<div class="log-warning">Packet capture stopped</div>';
        addLogEntry('Packet capture stopped', 'warning');
    }

    function clearPackets() {
        const packetList = document.getElementById('packet-list');
        if (packetList) packetList.innerHTML = '';
        addLogEntry('Cleared packet list', 'info');
    }

    function analyzeTraffic() {
        const analysisDiv = document.getElementById('traffic-analysis');
        if (!analysisDiv) return;
        analysisDiv.innerHTML = '<div class="log-info">Analyzing captured traffic...</div>';

        setTimeout(() => {
            analysisDiv.innerHTML = `
                <div class="log-success">Traffic Analysis Results:</div>
                <div>Total packets: 42</div>
                <div>Protocol distribution:</div>
                <div>- TCP: 28 (66.7%)</div>
                <div>- UDP: 8 (19.0%)</div>
                <div>- ICMP: 4 (9.5%)</div>
                <div>- Other: 2 (4.8%)</div>
                <div class="log-warning">Potential issues detected:</div>
                <div>- Unencrypted HTTP traffic found</div>
                <div>- Suspicious port scanning activity detected</div>
            `;
            addLogEntry('Traffic analysis completed', 'success');
        }, 1500);
    }

    // ---------- Password Cracker Functions ----------
    function startHashCracking() {
        const hashInputEl = document.getElementById('hash-input');
        const hashInput = (hashInputEl && hashInputEl.value) ? hashInputEl.value.trim() : '';
        const hashType = document.getElementById('hash-type').value;
        const attackMode = document.getElementById('attack-mode').value;
        const crackResults = document.getElementById('crack-results');
        if (!crackResults) return;

        if (!hashInput) {
            crackResults.innerHTML = '<div class="log-error">Please enter a hash to crack</div>';
            addLogEntry('Hash cracking failed - no hash provided', 'error');
            return;
        }

        crackResults.innerHTML = '<div class="log-info">Attempting to crack hash using ' + escapeHtml(attackMode) + ' attack...</div>';
        addLogEntry(`Starting ${attackMode} attack on ${hashType} hash`, 'info');

        const commonPasswords = {
            '5f4dcc3b5aa765d61d8327deb882cf99': 'password',
            '7c6a180b36896a0a8c02787eeafb0e4c': 'password1',
            '6cb75f652a9b52798eb6cf2201057c73': 'password123',
            'd8578edf8458ce06fbc5bb76a58c5ca4': 'qwerty',
            '5a105e8b9d40e1329780d62ea2265d8a': 'test',
            'b1b3773a05c0ed0176787a4f1574ff0075f7521e': 'letmein',
            '7110eda4d09e062aa5e4a390b0a572ac0d2c0220': '1234',
            'b0399d2029f64d445bd131ffaa399a42d2f8e7dc': 'admin'
        };

        let attempts = 0;
        crackInterval = setInterval(() => {
            attempts++;
            crackResults.innerHTML = `<div class="log-info">Attempt ${attempts}: Testing password candidate...</div>`;

            if (attempts % 10 === 0) {
                addLogEntry(`Hash cracking in progress - attempt ${attempts}`, 'info');
            }

            if (commonPasswords[hashInput.toLowerCase()]) {
                clearInterval(crackInterval);
                const password = commonPasswords[hashInput.toLowerCase()];
                crackResults.innerHTML = `
                    <div class="log-success">Hash cracked successfully after ${attempts} attempts!</div>
                    <div>Hash: ${escapeHtml(hashInput)}</div>
                    <div>Type: ${escapeHtml(hashType.toUpperCase())}</div>
                    <div class="log-warning">Password: ${escapeHtml(password)}</div>
                    <div class="log-info">This password is extremely weak and commonly used</div>
                    <button class="btn" id="show-security-tips">
                        <i class="fas fa-shield-alt"></i> View Security Recommendations
                    </button>
                `;
                addLogEntry(`Successfully cracked ${hashType} hash: ${password}`, 'success');

                // attach security tips handler
                document.getElementById('show-security-tips').addEventListener('click', showPasswordSecurityTips);
            } else if (attempts > 30) {
                clearInterval(crackInterval);
                crackResults.innerHTML = `
                    <div class="log-error">Failed to crack hash after ${attempts} attempts</div>
                    <div>Hash: ${escapeHtml(hashInput)}</div>
                    <div>Type: ${escapeHtml(hashType.toUpperCase())}</div>
                    <div>This hash is not in our dictionary database</div>
                    <div class="log-info">The password may be stronger or use a different algorithm</div>
                `;
                addLogEntry(`Failed to crack ${hashType} hash after ${attempts} attempts`, 'warning');
            }
        }, 200);
    }

    function stopHashCracking() {
        clearInterval(crackInterval);
        const crackResults = document.getElementById('crack-results');
        if (crackResults) crackResults.innerHTML += '<div class="log-warning">Hash cracking stopped by user</div>';
        addLogEntry('Hash cracking stopped', 'warning');
    }

    function showPasswordSecurityTips() {
        const tips = [
            'Use a password manager to generate and store unique passwords.',
            'Use long passphrases (12+ characters) with mixed character sets.',
            'Enable multi-factor authentication (MFA) wherever possible.',
            'Salt and slow-hash user passwords on the server using bcrypt/argon2.',
            'Monitor for reused passwords and exposed credentials.'
        ].join('\n\n');
        alert('Security Recommendations:\n\n' + tips);
    }

    function generateWordlist() {
        const baseWord = document.getElementById('base-word').value.trim() || 'password';
        // rules are not interpreted in this simulation beyond being present
        const wordlistOutput = document.getElementById('wordlist-output');

        if (!wordlistOutput) return;
        wordlistOutput.innerHTML = '<div class="log-info">Generating wordlist based on rules...</div>';
        addLogEntry('Generating wordlist', 'info');

        setTimeout(() => {
            const variations = [
                baseWord,
                baseWord + '123',
                baseWord + '!',
                baseWord + '2020',
                baseWord + '2021',
                baseWord.charAt(0).toUpperCase() + baseWord.slice(1),
                baseWord + '@',
                baseWord + '1',
                baseWord + '2',
                baseWord + '3',
                baseWord + '123!',
                baseWord + '123@',
                baseWord + '123#',
                baseWord.toUpperCase(),
                baseWord.split('').reverse().join(''), // Reverse the word
                baseWord + baseWord, // Duplicate
                baseWord + 'abc',
                baseWord + 'xyz'
            ];

            const uniqueVariations = [...new Set(variations)];

            wordlistOutput.innerHTML = `
                <div class="log-success">Generated wordlist with ${uniqueVariations.length} unique entries:</div>
                <div style="max-height: 300px; overflow-y: auto; border: 1px solid #444; padding: 10px; margin-top: 10px;">
            `;

            uniqueVariations.forEach(word => {
                wordlistOutput.innerHTML += `<div>${escapeHtml(word)}</div>`;
            });

            wordlistOutput.innerHTML += `</div>`;
            addLogEntry(`Generated wordlist with ${uniqueVariations.length} variations`, 'success');
        }, 1000);
    }

    function startBruteForce() {
        const charset = document.getElementById('charset').value || 'abcdefghijklmnopqrstuvwxyz';
        const minLength = parseInt(document.getElementById('min-length').value) || 4;
        const maxLength = parseInt(document.getElementById('max-length').value) || 6;
        const bruteResults = document.getElementById('brute-results');
        if (!bruteResults) return;

        bruteResults.innerHTML = '<div class="log-info">Starting brute force attack...</div>';
        addLogEntry(`Starting brute force attack with charset: ${charset}`, 'info');

        let attempts = 0;
        bruteInterval = setInterval(() => {
            attempts++;
            // Generate a random attempt for simulation
            let currentAttempt = '';
            const currentLength = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
            for (let i = 0; i < currentLength; i++) {
                currentAttempt += charset.charAt(Math.floor(Math.random() * charset.length));
            }

            bruteResults.innerHTML = `<div class="log-info">Attempt ${attempts}: Testing "${escapeHtml(currentAttempt)}"</div>`;

            if (attempts % 10 === 0) {
                addLogEntry(`Brute force in progress - attempt ${attempts}`, 'info');
            }

            if (charset.includes('t') && charset.includes('e') && charset.includes('s') &&
                currentAttempt === 'test' && attempts > 5) {
                clearInterval(bruteInterval);
                bruteResults.innerHTML += `
                    <div class="log-success">Password found after ${attempts} attempts!</div>
                    <div class="log-warning">Password: test</div>
                    <div class="log-info">This is a very weak password</div>
                `;
                addLogEntry('Brute force attack successful! Password: test', 'success');
            } else if (attempts > 100) {
                clearInterval(bruteInterval);
                bruteResults.innerHTML += `
                    <div class="log-error">Stopped after ${attempts} attempts</div>
                    <div>No password found with current parameters</div>
                    <div class="log-info">This suggests the password may be longer or uses characters not in the selected charset</div>
                `;
                addLogEntry(`Brute force stopped after ${attempts} attempts`, 'warning');
            }
        }, 300);
    }

    function stopBruteForce() {
        clearInterval(bruteInterval);
        const bruteResults = document.getElementById('brute-results');
        if (bruteResults) bruteResults.innerHTML += '<div class="log-warning">Brute force attack stopped by user</div>';
        addLogEntry('Brute force attack stopped', 'warning');
    }

    // ---------- Vulnerability Scanner Functions ----------
    function startVulnerabilityScan() {
        const target = document.getElementById('vuln-target').value || 'http://testphp.vulnweb.com';
        const scanProfile = document.getElementById('vuln-scan-profile').value;
        const vulnResults = document.getElementById('vuln-scan-results');
        if (!vulnResults) return;

        vulnResults.innerHTML = `<div class="log-info">Starting ${escapeHtml(scanProfile)} scan on ${escapeHtml(target)}...</div>`;
        addLogEntry(`Starting ${scanProfile} vulnerability scan on ${target}`, 'info');

        let progress = 0;
        vulnScanInterval = setInterval(() => {
            progress += 5;
            if (progress < 100) {
                vulnResults.innerHTML = `<div class="log-info">Scanning ${escapeHtml(target)}... ${progress}% complete</div>`;
            } else {
                clearInterval(vulnScanInterval);

                const vulnerabilities = [
                    { title: 'SQL Injection Vulnerability', severity: 'High', description: 'The application appears vulnerable to SQL injection attacks in the login form.', solution: 'Use prepared statements and parameterized queries.', cvss: '9.8', reference: 'CWE-89' },
                    { title: 'Cross-Site Scripting (XSS)', severity: 'Medium', description: 'Reflected XSS vulnerability found in search parameter.', solution: 'Implement proper output encoding and input validation.', cvss: '6.1', reference: 'CWE-79' },
                    { title: 'Outdated Software', severity: 'Medium', description: 'Apache 2.2.15 detected (End of Life). Multiple known vulnerabilities.', solution: 'Upgrade to a supported version of Apache.', cvss: '5.9', reference: 'CVE-2017-3169' },
                    { title: 'Missing Security Headers', severity: 'Low', description: 'Missing X-XSS-Protection and Content-Security-Policy headers.', solution: 'Implement proper security headers in web server configuration.', cvss: '3.7', reference: 'OWASP-ASVS' },
                    { title: 'Information Disclosure', severity: 'Low', description: 'Server version information disclosed in HTTP headers.', solution: 'Configure server to not disclose version information.', cvss: '3.5', reference: 'CWE-200' }
                ];

                vulnResults.innerHTML = `
                    <div class="log-success">Scan completed. Found ${vulnerabilities.length} vulnerabilities.</div>
                    <div class="log-info">Scan duration: ~2 minutes (simulated)</div>
                    <div class="log-warning">Vulnerabilities found:</div>
                `;

                vulnerabilities.forEach(vuln => {
                    const vulnElement = document.createElement('div');
                    vulnElement.className = 'vulnerability-item';
                    vulnElement.innerHTML = `
                        <div class="vuln-title">[${escapeHtml(vuln.severity)}] ${escapeHtml(vuln.title)}</div>
                        <div class="vuln-desc">${escapeHtml(vuln.description)}</div>
                        <div><strong>CVSS Score:</strong> ${escapeHtml(vuln.cvss)}/10</div>
                        <div><strong>Reference:</strong> ${escapeHtml(vuln.reference)}</div>
                        <div><strong>Solution:</strong> ${escapeHtml(vuln.solution)}</div>
                    `;
                    vulnResults.appendChild(vulnElement);
                });

                vulnResults.innerHTML += `
                    <div class="log-info">Remediation Summary:</div>
                    <div class="result-box">
                        <strong>Critical Actions:</strong><br>
                        - Fix SQL injection vulnerability immediately<br>
                        - Implement XSS protection<br>
                        - Update Apache server<br><br>
                        <strong>Recommended Actions:</strong><br>
                        - Add security headers<br>
                        - Disable server version disclosure<br>
                        - Implement WAF protection<br>
                        - Regular security scanning
                    </div>
                    <button class="btn" id="export-vuln-report">
                        <i class="fas fa-file-pdf"></i> Export Vulnerability Report
                    </button>
                `;

                // Add export functionality (simulated)
                const exportBtn = document.getElementById('export-vuln-report');
                if (exportBtn) {
                    exportBtn.addEventListener('click', function() {
                        addLogEntry('Exported vulnerability report', 'success');
                        alert('Vulnerability report exported successfully (simulated)\n\nFile: vulnerability_report.pdf');
                    });
                }

                addLogEntry(`Vulnerability scan completed. Found ${vulnerabilities.length} issues.`, 'success');
            }
        }, 300);
    }

    function stopVulnerabilityScan() {
        clearInterval(vulnScanInterval);
        const vulnResults = document.getElementById('vuln-scan-results');
        if (vulnResults) vulnResults.innerHTML += '<div class="log-warning">Vulnerability scan stopped by user</div>';
        addLogEntry('Vulnerability scan stopped', 'warning');
    }

    // ---------- SQL Injection Functions (SIMULATED) ----------
    function testSQLInjection() {
        const url = document.getElementById('sqli-url').value || 'http://testphp.vulnweb.com/artists.php?artist=1';
        const technique = document.getElementById('sqli-technique').value;
        const sqliResults = document.getElementById('sqli-results');
        if (!sqliResults) return;

        sqliResults.innerHTML = '<div class="log-info">Testing for SQL injection using ' + escapeHtml(technique) + ' technique...</div>';
        addLogEntry(`Testing for SQL injection at ${url} using ${technique} technique`, 'info');

        setTimeout(() => {
            let isVulnerable = false;
            let payload = '';

            switch (technique) {
                case 'error-based':
                    isVulnerable = true;
                    payload = "artist=1'";
                    break;
                case 'boolean':
                    isVulnerable = true;
                    payload = "artist=1 AND 1=1";
                    break;
                case 'time':
                    isVulnerable = false;
                    payload = "artist=1; WAITFOR DELAY '0:0:5'--";
                    break;
                case 'union':
                    isVulnerable = true;
                    payload = "artist=1 UNION SELECT 1,2,3,4,5,6,7,8--";
                    break;
            }

            if (isVulnerable) {
                sqliResults.innerHTML = `
                    <div class="log-success">Vulnerability found (simulated)!</div>
                    <div>URL: ${escapeHtml(url)}</div>
                    <div>Technique: ${escapeHtml(technique)}</div>
                    <div class="log-warning">Successful payload: ${escapeHtml(payload)}</div>
                    <div>The application appears vulnerable to ${escapeHtml(technique)} SQL injection (simulated).</div>
                `;
                addLogEntry(`SQL injection vulnerability found using ${technique} technique`, 'success');
            } else {
                sqliResults.innerHTML = `
                    <div class="log-error">No vulnerability detected</div>
                    <div>URL: ${escapeHtml(url)}</div>
                    <div>Technique: ${escapeHtml(technique)}</div>
                    <div>The application does not appear vulnerable to ${escapeHtml(technique)} SQL injection (simulated).</div>
                `;
                addLogEntry(`No SQL injection vulnerability found using ${technique} technique`, 'warning');
            }
        }, 1500);
    }

    function exploitSQLInjection() {
        const url = document.getElementById('sqli-url').value || 'http://testphp.vulnweb.com/artists.php?artist=1';
        const sqliResults = document.getElementById('sqli-results');
        if (!sqliResults) return;

        sqliResults.innerHTML = '<div class="log-info">Attempting to exploit SQL injection (simulated)...</div>';
        addLogEntry(`Attempting to exploit SQL injection at ${url}`, 'info');

        setTimeout(() => {
            sqliResults.innerHTML = `
                <div class="log-success">Exploit successful (simulated)!</div>
                <div>Database type: MySQL</div>
                <div>Current user: root@localhost</div>
                <div>Current database: acuart</div>
                <div class="log-warning">Use the 'Dump Data' button to extract database contents (simulated)</div>
            `;
            addLogEntry('SQL injection exploit successful (simulated)', 'success');
        }, 2000);
    }

    function dumpDatabase() {
        const sqliResults = document.getElementById('sqli-results');
        if (!sqliResults) return;

        sqliResults.innerHTML = '<div class="log-info">Dumping database contents (simulated)...</div>';
        addLogEntry('Starting database dump (simulated)', 'info');

        setTimeout(() => {
            sqliResults.innerHTML = `
                <div class="log-success">Database dump complete (simulated)</div>
                <div>Tables found:</div>
                <div>- artists</div>
                <div>- carts</div>
                <div>- categories</div>
                <div>- featured</div>
                <div>- guestbook</div>
                <div>- pictures</div>
                <div>- users</div>
                <div class="log-warning">Sample data from users table (simulated):</div>
                <table class="table">
                    <tr><th>id</th><th>uname</th><th>pass</th><th>email</th><th>address</th><th>country</th></tr>
                    <tr><td>1</td><td>test</td><td>test</td><td>test@test.com</td><td>123 Test St</td><td>US</td></tr>
                    <tr><td>2</td><td>admin</td><td>5f4dcc3b5aa765d61d8327deb882cf99</td><td>admin@test.com</td><td>456 Admin Ave</td><td>UK</td></tr>
                    <tr><td>3</td><td>john</td><td>7c6a180b36896a0a8c02787eeafb0e4c</td><td>john@example.com</td><td>789 User Rd</td><td>CA</td></tr>
                    <tr><td>4</td><td>jane</td><td>6cb75f652a9b52798eb6cf2201057c73</td><td>jane@example.com</td><td>321 Customer Ln</td><td>AU</td></tr>
                </table>
                <div class="log-info">Total records: 4 (simulated)</div>
                <div class="log-warning">Sensitive data detected: Password hashes should be properly hashed with salt</div>
                <button class="btn" id="export-data">
                    <i class="fas fa-download"></i> Export Data as CSV
                </button>
            `;
            addLogEntry('Database dump completed (simulated)', 'success');

            // Add export functionality (simulated)
            const exportBtn = document.getElementById('export-data');
            if (exportBtn) {
                exportBtn.addEventListener('click', function() {
                    addLogEntry('Exported database data as CSV (simulated)', 'success');
                    alert('Data exported successfully (simulated)\n\nIn a real environment, this would download a CSV file containing the database contents.');
                });
            }
        }, 2500);
    }

    // ---------- XSS Tester (SIMULATED) ----------
    function testXSS() {
        const url = document.getElementById('xss-url').value || 'http://testphp.vulnweb.com/search.php?test=query';
        const payloads = (document.getElementById('xss-payloads').value || '').split('\n').filter(p => p.trim());
        const xssResults = document.getElementById('xss-results');
        if (!xssResults) return;

        xssResults.innerHTML = '<div class="log-info">Testing for XSS vulnerabilities (simulated)...</div>';
        addLogEntry(`Testing for XSS at ${url} with ${payloads.length} payloads`, 'info');

        setTimeout(() => {
            let vulnerablePayloads = [];

            payloads.forEach(payload => {
                if (payload.includes('script') || payload.includes('onerror') || payload.includes('onload')) {
                    vulnerablePayloads.push(payload);
                }
            });

            if (vulnerablePayloads.length > 0) {
                xssResults.innerHTML = `
                    <div class="log-success">XSS vulnerabilities found (simulated)!</div>
                    <div>URL: ${escapeHtml(url)}</div>
                    <div>Vulnerable payloads:</div>
                `;

                vulnerablePayloads.forEach(payload => {
                    xssResults.innerHTML += `<div class="log-warning">- ${escapeHtml(payload)}</div>`;
                });

                xssResults.innerHTML += `<div>The application appears vulnerable to XSS attacks (simulated).</div>`;
                addLogEntry(`Found ${vulnerablePayloads.length} XSS vulnerabilities`, 'success');
            } else {
                xssResults.innerHTML = `
                    <div class="log-error">No XSS vulnerabilities detected</div>
                    <div>URL: ${escapeHtml(url)}</div>
                    <div>The application does not appear vulnerable to the tested XSS payloads (simulated).</div>
                `;
                addLogEntry('No XSS vulnerabilities found', 'warning');
            }
        }, 2000);
    }

    function scanDOM() {
        const xssResults = document.getElementById('xss-results');
        if (!xssResults) return;

        xssResults.innerHTML = '<div class="log-info">Analyzing DOM for potential XSS vectors (simulated)...</div>';
        addLogEntry('Starting DOM analysis for XSS', 'info');

        setTimeout(() => {
            xssResults.innerHTML = `
                <div class="log-success">DOM analysis complete</div>
                <div>Potential XSS vectors found:</div>
                <div class="log-warning">- document.write() with user input</div>
                <div class="log-warning">- innerHTML with user input</div>
                <div class="log-warning">- jQuery.html() with user input</div>
                <div>Recommendations:</div>
                <div>- Use textContent instead of innerHTML</div>
                <div>- Implement proper output encoding</div>
                <div>- Use Content Security Policy (CSP)</div>
            `;
            addLogEntry('DOM analysis completed', 'success');
        }, 1800);
    }

    // ---------- Traceroute (SIMULATED) ----------
    function startTraceroute() {
        const target = document.getElementById('trace-target').value || 'google.com';
        const traceResults = document.getElementById('trace-results');
        if (!traceResults) return;

        traceResults.innerHTML = '<div class="log-info">Tracing route to ' + escapeHtml(target) + '...</div>';
        addLogEntry(`Starting traceroute to ${target}`, 'info');

        const hops = [
            { ip: '192.168.1.1', time1: '1.2 ms', time2: '1.5 ms', time3: '1.3 ms', host: 'router.home' },
            { ip: '10.20.30.1', time1: '12.5 ms', time2: '11.8 ms', time3: '12.1 ms', host: 'gateway.isp.net' },
            { ip: '203.0.113.45', time1: '15.3 ms', time2: '14.9 ms', time3: '15.7 ms', host: 'core-router.isp.net' },
            { ip: '198.51.100.22', time1: '20.1 ms', time2: '19.8 ms', time3: '20.5 ms', host: 'border-router.google.com' },
            { ip: '172.217.16.14', time1: '22.5 ms', time2: '21.9 ms', time3: '22.3 ms', host: 'google.com' }
        ];

        let hopIndex = 0;
        traceInterval = setInterval(() => {
            if (hopIndex < hops.length) {
                const hop = hops[hopIndex];
                const hopElement = document.createElement('div');
                hopElement.className = 'hop-item';
                hopElement.innerHTML = `
                    <span class="hop-number">${hopIndex + 1}</span>
                    <span>${escapeHtml(hop.host)} [${escapeHtml(hop.ip)}]</span>
                    <span>${escapeHtml(hop.time1)} ${escapeHtml(hop.time2)} ${escapeHtml(hop.time3)}</span>
                `;
                traceResults.appendChild(hopElement);
                hopIndex++;
            } else {
                clearInterval(traceInterval);
                traceResults.innerHTML += '<div class="log-success">Trace complete.</div>';
                addLogEntry(`Traceroute to ${target} completed`, 'success');
            }
        }, 1000);
    }

    function stopTraceroute() {
        clearInterval(traceInterval);
        const traceResults = document.getElementById('trace-results');
        if (traceResults) traceResults.innerHTML += '<div class="log-warning">Trace stopped by user</div>';
        addLogEntry('Traceroute stopped', 'warning');
    }

    // ---------- Firewall Tester (SIMULATED) ----------
    function testFirewall() {
        const target = document.getElementById('firewall-target').value || '192.168.1.1';
        const portsField = document.getElementById('test-ports').value || '22,80,443';
        const ports = portsField.split(',').map(p => p.trim()).filter(Boolean);
        const firewallResults = document.getElementById('firewall-results');
        if (!firewallResults) return;

        firewallResults.innerHTML = `<div class="log-info">Testing firewall on ${escapeHtml(target)}...</div>`;
        addLogEntry(`Testing firewall on ${target}`, 'info');

        setTimeout(() => {
            firewallResults.innerHTML = '<div class="log-success">Firewall test results (simulated):</div>';
            ports.forEach(port => {
                // 70% chance blocked, 30% open (simulated)
                const isOpen = Math.random() > 0.7;
                firewallResults.innerHTML += `
                    <div>Port ${escapeHtml(port)}: ${isOpen ? '<span class="log-success">Open</span>' : '<span class="log-error">Blocked</span>'}</div>
                `;
            });
            addLogEntry('Firewall test completed (simulated)', 'success');
        }, 1600);
    }

    function testBypass() {
        const technique = document.getElementById('bypass-technique').value;
        const bypassResults = document.getElementById('bypass-results');
        if (!bypassResults) return;

        bypassResults.innerHTML = `<div class="log-info">Testing firewall bypass using ${escapeHtml(technique)} technique (simulated)...</div>`;
        addLogEntry(`Testing firewall bypass using ${technique}`, 'info');

        setTimeout(() => {
            const success = Math.random() > 0.5;
            bypassResults.innerHTML = success ?
                `<div class="log-success">Bypass successful (simulated)! Firewall circumvented using ${escapeHtml(technique)} technique.</div>` :
                `<div class="log-error">Bypass failed (simulated). Firewall detected and blocked the attempt.</div>`;
            addLogEntry(`Firewall bypass ${success ? 'succeeded' : 'failed'} using ${technique}`, success ? 'success' : 'warning');
        }, 1500);
    }

    // ---------- CSRF Generator (client-side simulated payload preview) ----------
    function generateFormCsrf() {
        const targetUrl = document.getElementById('target-url').value || '';
        const params = document.getElementById('form-params').value || '';
        const method = document.getElementById('csrf-method').value || 'POST';
        const out = document.getElementById('csrf-payload');
        if (!out) return;

        // Build a minimal HTML payload that submits a form automatically (for testing/educational preview only)
        const inputs = params.split('&').filter(Boolean).map(kv => {
            const parts = kv.split('=');
            const k = encodeURIComponent(parts[0] || '');
            const v = encodeURIComponent(parts.slice(1).join('=') || '');
            return `<input type="hidden" name="${k}" value="${v}">`;
        }).join('\n');

        const payload = `
<!doctype html>
<html>
  <body onload="document.forms[0].submit()">
    <form action="${escapeHtml(targetUrl)}" method="${escapeHtml(method)}">
      ${inputs}
      <noscript><button type="submit">Submit</button></noscript>
    </form>
  </body>
</html>
`.trim();

        out.innerHTML = `
            <div class="log-success">Form CSRF Payload (preview)</div>
            <textarea class="input-field" rows="10" readonly>${escapeHtml(payload)}</textarea>
            <button class="btn" onclick="(function(){ const t=document.querySelector('#csrf-payload textarea'); t.select(); document.execCommand('copy'); alert('Payload copied to clipboard (preview)'); })();">
                <i class="fas fa-copy"></i> Copy Payload
            </button>
        `;
        addLogEntry('Generated form-based CSRF payload (preview)', 'success');
    }

    function generateJsonCsrf() {
        const url = document.getElementById('json-url').value || '';
        let body = document.getElementById('json-body').value || '{}';
        const out = document.getElementById('json-csrf-payload');
        if (!out) return;

        // sanitize for display (not executing)
        const safeBody = body.replace(/<\/script>/ig, '<\\/script>'); // prevent naive closing tag
        const payload = `
<!doctype html>
<html>
  <body>
    <script>
      // This is a preview of a JSON API CSRF payload (educational only)
      fetch("${escapeHtml(url)}", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: ${safeBody},
          credentials: "include"
      }).catch(e => console.warn(e));
    </script>
  </body>
</html>
`.trim();

        out.innerHTML = `
            <div class="log-success">JSON CSRF Payload (preview)</div>
            <textarea class="input-field" rows="10" readonly>${escapeHtml(payload)}</textarea>
            <button class="btn" onclick="(function(){ const t=document.querySelector('#json-csrf-payload textarea'); t.select(); document.execCommand('copy'); alert('Payload copied to clipboard (preview)'); })();">
                <i class="fas fa-copy"></i> Copy Payload
            </button>
        `;
        addLogEntry('Generated JSON API CSRF payload (preview)', 'success');
    }

    // ---------- Steganography (LSB on blue channel) ----------
    // This implementation hides message length (32 bits) then message bytes into blue-channel LSB of pixels.
    // Works with RGBA ImageData and produces a PNG blob for download.

    let lastStegoBlobUrl = null;

    async function hideMessageLSB() {
        const coverInput = document.getElementById('cover-image');
        const secretInput = document.getElementById('secret-message');
        const stegResult = document.getElementById('steg-result');
        const canvas = document.createElement('canvas');

        if (!coverInput || !coverInput.files[0]) {
            if (stegResult) stegResult.innerHTML = '<div class="log-error">Please select a cover image</div>';
            addLogEntry('Steganography hide failed - no image selected', 'error');
            return;
        }
        const file = coverInput.files[0];
        const msg = (secretInput && secretInput.value) ? secretInput.value : '';

        if (!msg) {
            if (stegResult) stegResult.innerHTML = '<div class="log-error">Please enter a secret message</div>';
            addLogEntry('Steganography hide failed - no message', 'error');
            return;
        }

        if (stegResult) {
            stegResult.style.display = 'block';
            stegResult.innerHTML = `<div class="log-info">Hiding message (LSB)...</div>`;
        }

        try {
            const img = await loadImageFromFile(file);
            canvas.width = img.width;
            canvas.height = img.height;
            const ctx = canvas.getContext('2d');
            ctx.drawImage(img, 0, 0);

            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
            const pixels = imageData.data; // RGBA

            const pixelCount = pixels.length / 4;
            const maxChars = Math.floor((pixelCount - 32) / 8);
            if (msg.length > maxChars) {
                if (stegResult) stegResult.innerHTML = `<div class="log-error">Message too long for this image. Max chars ≈ ${maxChars}</div>`;
                addLogEntry('Steganography hide failed - message too long', 'error');
                return;
            }

            // build bit array: 32-bit length then message bytes
            const bits = [];
            const len = msg.length;
            for (let i = 31; i >= 0; i--) bits.push((len >> i) & 1);
            for (let i = 0; i < msg.length; i++) {
                const code = msg.charCodeAt(i);
                for (let b = 7; b >= 0; b--) bits.push((code >> b) & 1);
            }

            // write bits into blue-channel LSB
            let bitIndex = 0;
            for (let p = 0; p < pixels.length && bitIndex < bits.length; p += 4) {
                // pixels[p] = R, [p+1] = G, [p+2] = B, [p+3] = A
                pixels[p + 2] = (pixels[p + 2] & 0xFE) | bits[bitIndex++];
            }

            // put data back and export PNG
            ctx.putImageData(imageData, 0, 0);
            canvas.toBlob(blob => {
                if (!blob) {
                    if (stegResult) stegResult.innerHTML = '<div class="log-error">Failed to create stego image</div>';
                    addLogEntry('Steganography hide failed - blob creation error', 'error');
                    return;
                }
                if (lastStegoBlobUrl) URL.revokeObjectURL(lastStegoBlobUrl);
                lastStegoBlobUrl = URL.createObjectURL(blob);

                if (stegResult) {
                    stegResult.innerHTML = `
                        <div class="log-success">Message hidden successfully!</div>
                        <div>Download your steganographic image:</div>
                        <a class="btn" id="download-steg" href="${lastStegoBlobUrl}" download="stego.png"><i class="fas fa-download"></i> Download Image</a>
                        <div style="margin-top:10px;">Preview (may not display in some browsers):</div>
                        <img src="${lastStegoBlobUrl}" style="max-width:100%; margin-top:10px; border:1px solid #333;">
                    `;
                }
                addLogEntry('Message successfully hidden in image (LSB)', 'success');
            }, 'image/png');
        } catch (err) {
            if (stegResult) stegResult.innerHTML = `<div class="log-error">Error: ${escapeHtml(String(err))}</div>`;
            addLogEntry('Steganography hide failed - exception', 'error');
        }
    }

    async function extractMessageLSB() {
        const stegImage = document.getElementById('steg-image');
        const stegResult = document.getElementById('extracted-message');
        const canvas = document.createElement('canvas');

        if (!stegImage || !stegImage.files[0]) {
            if (stegResult) stegResult.innerHTML = '<div class="log-error">Please select a stego image</div>';
            addLogEntry('Steganography extract failed - no image selected', 'error');
            return;
        }

        try {
            const img = await loadImageFromFile(stegImage.files[0]);
            canvas.width = img.width;
            canvas.height = img.height;
            const ctx = canvas.getContext('2d');
            ctx.drawImage(img, 0, 0);
            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height).data;

            // read first 32 bits => length
            let len = 0;
            for (let p = 0; p < 32; p++) {
                const idx = p * 4 + 2;
                len = (len << 1) | (imageData[idx] & 1);
            }

            if (len <= 0 || len > 500000) {
                if (stegResult) stegResult.innerHTML = `<div class="log-error">Extracted message length invalid (${len}) — maybe image is not encoded with this tool.</div>`;
                addLogEntry('Steganography extract failed - invalid length', 'error');
                return;
            }

            const totalBits = len * 8;
            const msgBits = [];
            for (let p = 32; p < 32 + totalBits; p++) {
                const idx = p * 4 + 2;
                msgBits.push(imageData[idx] & 1);
            }

            let message = '';
            for (let i = 0; i < msgBits.length; i += 8) {
                let code = 0;
                for (let b = 0; b < 8; b++) {
                    code = (code << 1) | msgBits[i + b];
                }
                message += String.fromCharCode(code);
            }

            if (stegResult) {
                stegResult.innerHTML = `
                    <div class="log-success">Hidden message extracted!</div>
                    <div class="result-box">${escapeHtml(message)}</div>
                `;
            }
            addLogEntry('Successfully extracted hidden message (LSB)', 'success');
        } catch (err) {
            if (stegResult) stegResult.innerHTML = `<div class="log-error">Error: ${escapeHtml(String(err))}</div>`;
            addLogEntry('Steganography extract failed - exception', 'error');
        }
    }

    // ---------- Memory Analysis (SIMULATED) ----------
    function analyzeMemoryDump() {
        const fileInput = document.getElementById('memory-dump');
        const out = document.getElementById('dump-analysis');
        if (!out) return;

        if (!fileInput || !fileInput.files[0]) {
            out.innerHTML = '<div class="log-error">Please select a memory dump file</div>';
            addLogEntry('Memory analysis failed - no file selected', 'error');
            return;
        }

        out.innerHTML = '<div class="log-info">Analyzing memory dump (simulated)...</div>';
        addLogEntry('Starting memory dump analysis', 'info');

        setTimeout(() => {
            out.innerHTML = `
                <div class="log-success">Memory dump analysis complete (simulated)</div>
                <div>OS: Windows 10 (Build 19044)</div>
                <div>Architecture: x64</div>
                <div>Processes: 128</div>
                <div>Kernel modules: 89</div>
                <div>Last crash: No crash dump detected</div>
            `;
            addLogEntry('Memory dump analysis completed', 'success');
        }, 2000);
    }

    function scanProcesses() {
        const out = document.getElementById('process-list');
        if (!out) return;
        out.innerHTML = '<div class="log-info">Scanning running processes (simulated)...</div>';
        addLogEntry('Scanning processes in memory dump (simulated)', 'info');

        setTimeout(() => {
            const maliciousProcesses = Math.random() > 0.7 ? 1 : 0;
            out.innerHTML = `
                <div class="log-success">Found 42 processes</div>
                ${maliciousProcesses ? '<div class="log-error">1 potentially malicious process found</div>' : '<div class="log-success">No obvious malicious processes detected</div>'}
                <table class="table">
                    <tr><th>PID</th><th>Name</th><th>Path</th></tr>
                    <tr><td>1244</td><td>explorer.exe</td><td>C:\\Windows\\explorer.exe</td></tr>
                    <tr><td>1456</td><td>chrome.exe</td><td>C:\\Program Files\\Google\\Chrome\\chrome.exe</td></tr>
                    <tr><td>1588</td><td>svchost.exe</td><td>C:\\Windows\\System32\\svchost.exe</td></tr>
                    ${maliciousProcesses ? '<tr class="log-error"><td>1999</td><td>malware.exe</td><td>C:\\Temp\\malware.exe</td></tr>' : ''}
                </table>
            `;
            addLogEntry(`Process scan completed. ${maliciousProcesses ? 'Malicious process detected!' : 'No threats found.'}`, maliciousProcesses ? 'error' : 'success');
        }, 1200);
    }

    function scanConnections() {
        const out = document.getElementById('connection-list');
        if (!out) return;
        out.innerHTML = '<div class="log-info">Scanning network connections (simulated)...</div>';
        addLogEntry('Scanning network connections in memory dump (simulated)', 'info');

        setTimeout(() => {
            out.innerHTML = `
                <div class="log-success">Found 8 network connections</div>
                <table class="table">
                    <tr><th>Protocol</th><th>Local</th><th>Remote</th><th>State</th></tr>
                    <tr><td>TCP</td><td>192.168.1.100:51234</td><td>142.250.190.46:443</td><td>ESTABLISHED</td></tr>
                    <tr><td>TCP</td><td>192.168.1.100:51235</td><td>104.16.85.20:80</td><td>ESTABLISHED</td></tr>
                    <tr><td>UDP</td><td>192.168.1.100:53</td><td>8.8.8.8:53</td><td>N/A</td></tr>
                </table>
            `;
            addLogEntry('Network connection scan completed (simulated)', 'success');
        }, 1300);
    }

    function scanRegistry() {
        const out = document.getElementById('registry-data');
        if (!out) return;
        out.innerHTML = '<div class="log-info">Scanning registry artifacts (simulated)...</div>';
        addLogEntry('Scanning registry in memory dump (simulated)', 'info');

        setTimeout(() => {
            const suspiciousEntries = Math.random() > 0.5 ? 2 : 0;
            out.innerHTML = `
                <div class="log-success">Registry scan complete</div>
                ${suspiciousEntries ? '<div class="log-error">Found 2 suspicious registry entries</div>' : '<div class="log-success">No suspicious registry entries found</div>'}
                <div>Autostart entries:</div>
                <ul>
                    <li>HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Run - Explorer</li>
                    ${suspiciousEntries ? '<li class="log-error">HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Run - Malware</li>' : ''}
                </ul>
            `;
            addLogEntry(`Registry scan completed. ${suspiciousEntries ? 'Suspicious entries found!' : 'No issues detected.'}`, suspiciousEntries ? 'error' : 'success');
        }, 1400);
    }

    // ---------- Lab Controls ----------
    function newLab() {
        if (!confirm('Are you sure you want to start a new lab? All unsaved progress will be lost.')) return;
        document.querySelectorAll('.result-box').forEach(box => box.innerHTML = '');
        if (terminalOutput) terminalOutput.innerHTML = 'Welcome to Alpha-Tech Advanced Hacking Lab\nType \'help\' to see available commands\n\n';
        addLogEntry('New lab session started', 'info');
    }

    function saveLab() {
        addLogEntry('Lab progress saved (simulated)', 'success');
        alert('Lab progress saved successfully (simulated)');
    }

    function resetLab() {
        if (!confirm('Are you sure you want to reset the lab? This will clear all results and data.')) return;
        document.querySelectorAll('.result-box').forEach(box => box.innerHTML = '');
        if (terminalOutput) terminalOutput.innerHTML = 'Welcome to Alpha-Tech Advanced Hacking Lab\nType \'help\' to see available commands\n\n';
        if (consoleLog) consoleLog.innerHTML = `
            <div class="log-entry">
                <span class="log-time">[00:00:00]</span>
                <span class="log-info">SYSTEM: Lab environment initialized</span>
            </div>
            <div class="log-entry">
                <span class="log-time">[00:00:01]</span>
                <span class="log-info">NETWORK: Virtual lab network ready</span>
            </div>
        `;
        addLogEntry('Lab has been reset', 'info');
    }

    // ---------- Wiring & Initialization ----------
    function wireEventHandlers() {
        // Terminal elements
        terminalInput = document.getElementById('terminal-input');
        terminalOutput = document.querySelector('.terminal-output');
        consoleLog = document.getElementById('console-log');

        initTabs();
        initToolSwitching();
        initTerminal();

        // Network scanner
        const startScanBtn = document.getElementById('start-scan');
        if (startScanBtn) startScanBtn.addEventListener('click', startNetworkScan);
        const stopScanBtn = document.getElementById('stop-scan');
        if (stopScanBtn) stopScanBtn.addEventListener('click', stopNetworkScan);
        const startPortScanBtn = document.getElementById('start-port-scan');
        if (startPortScanBtn) startPortScanBtn.addEventListener('click', startPortScan);
        const scanTypeSel = document.getElementById('scan-type');
        if (scanTypeSel) {
            scanTypeSel.addEventListener('change', function() {
                const container = document.getElementById('custom-ports-container');
                if (container) container.style.display = this.value === 'custom' ? 'block' : 'none';
            });
        }

        // Packet sniffer
        const startSniffBtn = document.getElementById('start-sniffing');
        if (startSniffBtn) startSniffBtn.addEventListener('click', startPacketSniffing);
        const stopSniffBtn = document.getElementById('stop-sniffing');
        if (stopSniffBtn) stopSniffBtn.addEventListener('click', stopPacketSniffing);
        const clearPacketsBtn = document.getElementById('clear-packets');
        if (clearPacketsBtn) clearPacketsBtn.addEventListener('click', clearPackets);
        const analyzeTrafficBtn = document.getElementById('analyze-traffic');
        if (analyzeTrafficBtn) analyzeTrafficBtn.addEventListener('click', analyzeTraffic);

        // Password cracker
        const crackBtn = document.getElementById('crack-btn');
        if (crackBtn) crackBtn.addEventListener('click', startHashCracking);
        const stopCrackBtn = document.getElementById('stop-crack');
        if (stopCrackBtn) stopCrackBtn.addEventListener('click', stopHashCracking);
        const genWordlistBtn = document.getElementById('generate-wordlist');
        if (genWordlistBtn) genWordlistBtn.addEventListener('click', generateWordlist);
        const startBruteBtn = document.getElementById('start-brute');
        if (startBruteBtn) startBruteBtn.addEventListener('click', startBruteForce);
        const stopBruteBtn = document.getElementById('stop-brute');
        if (stopBruteBtn) stopBruteBtn.addEventListener('click', stopBruteForce);

        // Vulnerability scanner
        const startVulnBtn = document.getElementById('start-vuln-scan');
        if (startVulnBtn) startVulnBtn.addEventListener('click', startVulnerabilityScan);
        const stopVulnBtn = document.getElementById('stop-vuln-scan');
        if (stopVulnBtn) stopVulnBtn.addEventListener('click', stopVulnerabilityScan);

        // SQLi
        const testSqliBtn = document.getElementById('test-sqli');
        if (testSqliBtn) testSqliBtn.addEventListener('click', testSQLInjection);
        const exploitSqliBtn = document.getElementById('exploit-sqli');
        if (exploitSqliBtn) exploitSqliBtn.addEventListener('click', exploitSQLInjection);
        const dumpDataBtn = document.getElementById('dump-data');
        if (dumpDataBtn) dumpDataBtn.addEventListener('click', dumpDatabase);

        // XSS
        const testXssBtn = document.getElementById('test-xss');
        if (testXssBtn) testXssBtn.addEventListener('click', testXSS);
        const scanDomBtn = document.getElementById('scan-dom');
        if (scanDomBtn) scanDomBtn.addEventListener('click', scanDOM);

        // Traceroute
        const startTraceBtn = document.getElementById('start-trace');
        if (startTraceBtn) startTraceBtn.addEventListener('click', startTraceroute);
        const stopTraceBtn = document.getElementById('stop-trace');
        if (stopTraceBtn) stopTraceBtn.addEventListener('click', stopTraceroute);

        // Firewall
        const testFirewallBtn = document.getElementById('test-firewall');
        if (testFirewallBtn) testFirewallBtn.addEventListener('click', testFirewall);
        const testBypassBtn = document.getElementById('test-bypass');
        if (testBypassBtn) testBypassBtn.addEventListener('click', testBypass);

        // Exploit DB quick handlers (download/view)
        document.querySelectorAll('.exploit-card .btn').forEach(btn => {
            btn.addEventListener('click', function() {
                const exploitTitleEl = this.closest('.exploit-card') && this.closest('.exploit-card').querySelector('.exploit-title');
                const exploitTitle = exploitTitleEl ? exploitTitleEl.textContent.trim() : 'Unknown';
                if (this.classList.contains('btn-danger')) {
                    addLogEntry(`Downloaded exploit: ${exploitTitle} (simulated)`, 'success');
                    alert(`Exploit downloaded successfully (simulated): ${exploitTitle}`);
                } else {
                    addLogEntry(`Viewed details for: ${exploitTitle}`, 'info');
                    alert(`Showing details for: ${exploitTitle} (simulated)`);
                }
            });
        });

        // Lab controls
        const newLabBtn = document.getElementById('new-lab');
        if (newLabBtn) newLabBtn.addEventListener('click', newLab);
        const saveLabBtn = document.getElementById('save-lab');
        if (saveLabBtn) saveLabBtn.addEventListener('click', saveLab);
        const resetLabBtn = document.getElementById('reset-lab');
        if (resetLabBtn) resetLabBtn.addEventListener('click', resetLab);
        const backHomeBtn = document.getElementById('back-to-home');
        if (backHomeBtn) backHomeBtn.addEventListener('click', () => window.location.href = 'index.html');

        // CSRF generator
        const genCsrfBtn = document.getElementById('generate-csrf');
        if (genCsrfBtn) genCsrfBtn.addEventListener('click', generateFormCsrf);
        const genJsonCsrfBtn = document.getElementById('generate-json-csrf');
        if (genJsonCsrfBtn) genJsonCsrfBtn.addEventListener('click', generateJsonCsrf);

        // Steganography hide/extract
        const hideBtn = document.getElementById('hide-message');
        if (hideBtn) hideBtn.addEventListener('click', hideMessageLSB);
        const extractBtn = document.getElementById('extract-message');
        if (extractBtn) extractBtn.addEventListener('click', extractMessageLSB);

        // Memory analysis
        const analyzeDumpBtn = document.getElementById('analyze-dump');
        if (analyzeDumpBtn) analyzeDumpBtn.addEventListener('click', analyzeMemoryDump);
        const scanProcsBtn = document.getElementById('scan-processes');
        if (scanProcsBtn) scanProcsBtn.addEventListener('click', scanProcesses);
        const scanConnsBtn = document.getElementById('scan-connections');
        if (scanConnsBtn) scanConnsBtn.addEventListener('click', scanConnections);
        const scanRegBtn = document.getElementById('scan-registry');
        if (scanRegBtn) scanRegBtn.addEventListener('click', scanRegistry);

        // Help button (if present)
        const helpBtn = document.getElementById('helpBtn');
        if (helpBtn) helpBtn.addEventListener('click', () => {
            alert('Alpha-Tech Lab (simulated)\n\nThis lab is client-side & educational. To make tools functional for real networks you must implement secure server-side services with containerized sandboxing, authorization, usage logging, and strict rate limits.\n\nI can help scaffold server endpoints (Flask + Docker) if you want to extend any tool.');
        });
    }

    // ---------- Boot ----------
    // Wait for DOM loaded before wiring handlers
    document.addEventListener('DOMContentLoaded', function() {
        wireEventHandlers();

        // Initial messages
        setTimeout(() => addLogEntry('SYSTEM: All tools loaded successfully', 'info'), 500);
        setTimeout(() => addLogEntry('NETWORK: Virtual lab network ready', 'info'), 1000);

        // Show terminal by default
        const termBtn = document.querySelector('[data-tool="terminal"]');
        if (termBtn) termBtn.classList.add('active');
        const termWin = document.getElementById('terminal-window');
        if (termWin) termWin.classList.add('active');
        const termInput = document.getElementById('terminal-input');
        if (termInput) termInput.focus();
    });

    // Expose a very small safe API on window for debugging (non destructive)
    window.alphaTechLab = {
        addLog: addLogEntry,
        generateFormCsrfPreview: generateFormCsrf,
        generateJsonCsrfPreview: generateJsonCsrf
    };

})();