// Name: Edgenuity Script Key Cracker
// Description: Cracks keys for other Edgenuity scripts that require authentication
// Author: JayJ122

import "@johnlindquist/kit"

// Generate a comprehensive key cracking script for Tampermonkey
const tampermonkeyScript = `// ==UserScript==
// @name         Edgenuity Script Key Cracker
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  Cracks keys for other Edgenuity scripts that require authentication
// @author       JayJ122
// @match        *://*.edgenuity.com/*
// @match        *://*.core.learn.edgenuity.com/*
// @icon         data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDJDMTMuMSAyIDE0IDIuOSAxNCA0VjhIMTZWNEMxNiAxLjc5IDE0LjIxIDAgMTIgMEM5Ljc5IDAgOCAxLjc5IDggNFY4SDEwVjRDMTAgMi45IDEwLjkgMiAxMiAyWiIgZmlsbD0iIzRDQUY1MCIvPgo8cGF0aCBkPSJNMTggOEg2QzQuOSA4IDQgOC45IDQgMTBWMjBDNCAyMS4xIDQuOSAyMiA2IDIySDIwQzIxLjEgMjIgMjIgMjEuMSAyMiAyMFYxMEMyMiA4LjkgMjEuMSA4IDIwIDhIMThaTTEyIDE4QzEwLjkgMTggMTAgMTcuMSAxMCAxNkMxMCAxNC45IDEwLjkgMTQgMTIgMTRDMTMuMSAxNCAxNCAxNC45IDE0IDE2QzE0IDE3LjEgMTMuMSAxOCAxMiAxOFoiIGZpbGw9IiM0Q0FGNTASCZ8L3N2Zz4K
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_listValues
// @grant        GM_notification
// @grant        GM_openInTab
// @grant        GM_setClipboard
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// ==/UserScript==

(function() {
    'use strict';
    
    // Common key patterns used in Edgenuity scripts
    const commonKeys = [
        'edgenuity_bypass',
        'auto_answer_key',
        'skip_videos_key',
        'test_bypass_key',
        'assignment_key',
        'lesson_skip_key',
        'edg_unlock',
        'bypass_2023',
        'student_helper',
        'auto_complete'
    ];
    
    // Key generation algorithms
    function generateTimeBasedKey() {
        const now = new Date();
        const timestamp = Math.floor(now.getTime() / 1000);
        return btoa(timestamp.toString()).substring(0, 16);
    }
    
    function generateHashKey(input) {
        let hash = 0;
        for (let i = 0; i < input.length; i++) {
            const char = input.charCodeAt(i);
            hash = ((hash << 5) - hash) + char;
            hash = hash & hash;
        }
        return Math.abs(hash).toString(36);
    }
    
    function generateSessionKey() {
        const session = document.cookie.match(/session[^;]*/);
        if (session) {
            return generateHashKey(session[0]);
        }
        return generateHashKey(window.location.href);
    }
    
    // Key cracking functions
    function crackSimpleKeys() {
        const crackedKeys = [];
        
        // Try common keys
        commonKeys.forEach(key => {
            crackedKeys.push({
                type: 'common',
                key: key,
                hash: generateHashKey(key)
            });
        });
        
        return crackedKeys;
    }
    
    function crackAdvancedKeys() {
        const crackedKeys = [];
        
        // Time-based keys
        for (let i = -5; i <= 5; i++) {
            const timeKey = generateTimeBasedKey();
            crackedKeys.push({
                type: 'time_based',
                key: timeKey,
                offset: i
            });
        }
        
        // Session-based keys
        const sessionKey = generateSessionKey();
        crackedKeys.push({
            type: 'session_based',
            key: sessionKey
        });
        
        // URL-based keys
        const urlKey = generateHashKey(window.location.pathname);
        crackedKeys.push({
            type: 'url_based',
            key: urlKey
        });
        
        return crackedKeys;
    }
    
    // Key injection system
    function injectKeys() {
        const allKeys = [...crackSimpleKeys(), ...crackAdvancedKeys()];
        
        // Store keys using Tampermonkey storage
        GM_setValue('crackedKeys', JSON.stringify(allKeys));
        
        // Create global key store
        unsafeWindow.edgenuityKeys = {
            keys: allKeys,
            getKey: function(type) {
                return this.keys.filter(k => k.type === type);
            },
            getAllKeys: function() {
                return this.keys.map(k => k.key);
            },
            validateKey: function(key) {
                return this.keys.some(k => k.key === key);
            }
        };
        
        // Inject into common script locations
        const keyVariables = [
            'scriptKey',
            'authKey',
            'bypassKey',
            'unlockKey',
            'accessKey',
            'validationKey'
        ];
        
        keyVariables.forEach(varName => {
            allKeys.forEach(keyObj => {
                try {
                    unsafeWindow[varName] = keyObj.key;
                    unsafeWindow[varName + '_hash'] = keyObj.hash || generateHashKey(keyObj.key);
                } catch (e) {
                    console.log('Key injection failed for:', varName);
                }
            });
        });
        
        console.log('Edgenuity Key Cracker: Injected', allKeys.length, 'keys');
        
        // Show notification
        GM_notification({
            text: \`Injected \${allKeys.length} keys successfully\`,
            title: 'Key Cracker Active',
            timeout: 3000
        });
        
        return allKeys;
    }
    
    // Monitor for script key requests
    function monitorKeyRequests() {
        const originalFetch = unsafeWindow.fetch;
        unsafeWindow.fetch = function(...args) {
            const url = args[0];
            if (typeof url === 'string' && url.includes('key')) {
                console.log('Key request detected:', url);
                // Inject keys into request headers
                if (args[1]) {
                    args[1].headers = args[1].headers || {};
                    unsafeWindow.edgenuityKeys.getAllKeys().forEach((key, index) => {
                        args[1].headers['X-Script-Key-' + index] = key;
                    });
                }
            }
            return originalFetch.apply(this, args);
        };
        
        // Also monitor XMLHttpRequest
        const originalXHR = unsafeWindow.XMLHttpRequest;
        unsafeWindow.XMLHttpRequest = function() {
            const xhr = new originalXHR();
            const originalOpen = xhr.open;
            xhr.open = function(method, url, ...args) {
                if (url.includes('key')) {
                    console.log('XHR Key request detected:', url);
                }
                return originalOpen.apply(this, [method, url, ...args]);
            };
            return xhr;
        };
    }
    
    // Override common authentication functions
    function overrideAuthFunctions() {
        // Override key validation functions
        unsafeWindow.validateScriptKey = function(key) {
            return unsafeWindow.edgenuityKeys.validateKey(key) || true;
        };
        
        unsafeWindow.checkAuth = function() {
            return true;
        };
        
        unsafeWindow.isValidKey = function(key) {
            return true;
        };
        
        // Override localStorage key checks
        const originalGetItem = localStorage.getItem;
        localStorage.getItem = function(key) {
            if (key.includes('key') || key.includes('auth')) {
                const crackedKey = unsafeWindow.edgenuityKeys.getAllKeys()[0];
                return crackedKey || originalGetItem.call(this, key);
            }
            return originalGetItem.call(this, key);
        };
    }
    
    // Create advanced UI panel
    function createControlPanel() {
        const panel = document.createElement('div');
        panel.id = 'keycracker-panel';
        panel.innerHTML = \`
            <div style="background: linear-gradient(135deg, #4CAF50, #45a049); color: white; padding: 10px; border-radius: 8px; font-family: Arial, sans-serif; box-shadow: 0 4px 8px rgba(0,0,0,0.3);">
                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
                    <span style="font-weight: bold;">🔓 Key Cracker</span>
                    <button id="toggle-panel" style="background: rgba(255,255,255,0.2); border: none; color: white; padding: 2px 6px; border-radius: 3px; cursor: pointer;">−</button>
                </div>
                <div id="panel-content">
                    <div style="font-size: 12px; margin-bottom: 5px;">Keys Active: <span id="key-count">0</span></div>
                    <div style="display: flex; gap: 5px;">
                        <button id="refresh-keys" style="background: rgba(255,255,255,0.2); border: none; color: white; padding: 3px 8px; border-radius: 3px; cursor: pointer; font-size: 11px;">Refresh</button>
                        <button id="copy-keys" style="background: rgba(255,255,255,0.2); border: none; color: white; padding: 3px 8px; border-radius: 3px; cursor: pointer; font-size: 11px;">Copy Keys</button>
                        <button id="export-keys" style="background: rgba(255,255,255,0.2); border: none; color: white; padding: 3px 8px; border-radius: 3px; cursor: pointer; font-size: 11px;">Export</button>
                    </div>
                </div>
            </div>
        \`;
        
        panel.style.cssText = \`
            position: fixed;
            top: 10px;
            right: 10px;
            z-index: 10000;
            min-width: 200px;
            transition: all 0.3s ease;
        \`;
        
        document.body.appendChild(panel);
        
        // Add event listeners
        document.getElementById('toggle-panel').onclick = function() {
            const content = document.getElementById('panel-content');
            const button = this;
            if (content.style.display === 'none') {
                content.style.display = 'block';
                button.textContent = '−';
            } else {
                content.style.display = 'none';
                button.textContent = '+';
            }
        };
        
        document.getElementById('refresh-keys').onclick = function() {
            const newKeys = injectKeys();
            document.getElementById('key-count').textContent = newKeys.length;
        };
        
        document.getElementById('copy-keys').onclick = function() {
            const keys = unsafeWindow.edgenuityKeys.getAllKeys().join('\\n');
            GM_setClipboard(keys);
            GM_notification({
                text: 'Keys copied to clipboard!',
                title: 'Key Cracker',
                timeout: 2000
            });
        };
        
        document.getElementById('export-keys').onclick = function() {
            const keys = GM_getValue('crackedKeys', '[]');
            const blob = new Blob([keys], {type: 'application/json'});
            const url = URL.createObjectURL(blob);
            GM_openInTab(url);
        };
        
        return panel;
    }
    
    // Main execution
    function initialize() {
        console.log('Edgenuity Script Key Cracker - Initializing...');
        
        // Wait for page to load
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', initialize);
            return;
        }
        
        // Inject keys
        const crackedKeys = injectKeys();
        
        // Monitor requests
        monitorKeyRequests();
        
        // Override auth functions
        overrideAuthFunctions();
        
        // Create UI panel
        const panel = createControlPanel();
        document.getElementById('key-count').textContent = crackedKeys.length;
        
        // Auto-minimize after 5 seconds
        setTimeout(() => {
            document.getElementById('panel-content').style.display = 'none';
            document.getElementById('toggle-panel').textContent = '+';
        }, 5000);
        
        console.log('Edgenuity Script Key Cracker - Ready!');
        console.log('Available keys:', unsafeWindow.edgenuityKeys.getAllKeys());
        
        // Load previously saved keys
        const savedKeys = GM_getValue('crackedKeys', null);
        if (savedKeys) {
            try {
                const parsedKeys = JSON.parse(savedKeys);
                console.log('Loaded', parsedKeys.length, 'saved keys');
            } catch (e) {
                console.log('Failed to load saved keys');
            }
        }
    }
    
    // Start the cracker
    initialize();
    
    // Periodic key refresh
    setInterval(() => {
        injectKeys();
        const keyCount = document.getElementById('key-count');
        if (keyCount) {
            keyCount.textContent = unsafeWindow.edgenuityKeys.keys.length;
        }
    }, 30000); // Refresh every 30 seconds
    
})();`

// Save the script to a file
const scriptPath = home("Downloads", "edgenuity-key-cracker.user.js")
await writeFile(scriptPath, tampermonkeyScript)

await div(md(`
# Enhanced Edgenuity Script Key Cracker Generated! 🔓

## New Features Added:

### 🔧 **Enhanced Grants**
- \`GM_setValue/GM_getValue\` - Persistent key storage
- \`GM_notification\` - Success notifications
- \`GM_setClipboard\` - Copy keys to clipboard
- \`GM_openInTab\` - Export functionality
- \`unsafeWindow\` - Better page integration

### 🎨 **Custom Icon**
- Green lock icon for easy identification
- SVG-based for crisp display