@kakuzu_aon/apkz 1.0.0

package/src/commands/decompile.js

@@ -0,0 +1,444 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : decompile.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : Advanced APK decompilation command
+// ────────────────★─────────────────────────────────
+
+const { Command } = require('commander');
+const chalk = require('chalk').default;
+const { default: ora } = require('ora');
+const fs = require('fs-extra');
+const path = require('path');
+const AdmZip = require('adm-zip');
+const cliProgress = require('cli-progress');
+const SmaliEditor = require('../utils/smali-editor');
+const ObfuscationDetector = require('../utils/obfuscation-detector');
+
+const decompileCommand = new Command('decompile')
+    .description('Professional APK decompilation with advanced smali analysis and optimization')
+    .argument('<apk-file>', 'APK file to decompile')
+    .option('-o, --output <dir>', 'Output directory (default: ./decompiled)', './decompiled')
+    .option('-f, --force', 'Overwrite existing output directory')
+    .option('--level <level>', 'Decompilation level (basic, intermediate, advanced, expert)', 'advanced')
+    .option('--deobfuscate', 'Attempt to deobfuscate code')
+    .option('--analyze-strings', 'Analyze and categorize strings')
+    .option('--find-patterns', 'Search for specific patterns in smali')
+    .option('--optimize', 'Optimize decompiled code')
+    .option('--parallel <num>', 'Parallel processing threads', '4')
+    .option('--timeout <ms>', 'Decompilation timeout in milliseconds', '300000')
+    .option('--progress', 'Show detailed progress information')
+    .option('--validate', 'Validate decompiled code')
+    .option('--backup', 'Create backup before decompilation')
+    .option('--export <file>', 'Export decompilation report')
+    .option('--format <format>', 'Report format (json, html, csv)', 'json')
+    .option('--dry-run', 'Show decompilation plan without executing')
+    .option('--log-level <level>', 'Logging level (debug, info, warn, error)', 'info')
+    .option('--template <name>', 'Use decompilation template')
+    .option('--interactive', 'Interactive decompilation mode')
+    .option('--batch', 'Batch decompilation mode')
+    .option('--preserve-debug', 'Preserve debug information')
+    .option('--remove-debug', 'Remove debug information')
+    .option('--inline-constants', 'Inline constant values')
+    .option('--remove-logging', 'Remove logging statements')
+    .option('--simplify-control', 'Simplify control flow')
+    .option('--rename-classes', 'Rename obfuscated classes')
+    .option('--restructure', 'Restructure code organization')
+    .option('--annotations', 'Add helpful annotations')
+    .option('--comments', 'Add explanatory comments')
+    .option('--format-code', 'Format decompiled code')
+    .option('--minify', 'Minify decompiled code')
+    .option('--pretty-print', 'Pretty print decompiled code')
+    .option('--custom-rules <file>', 'Apply custom decompilation rules')
+    .option('--plugins', 'Enable decompilation plugins')
+    .option('--metrics', 'Generate decompilation metrics')
+    .option('--benchmark', 'Benchmark decompilation performance')
+    .action(async (apkFile, options) => {
+        let spinner;
+        try {
+            if (!fs.existsSync(apkFile)) {
+                console.error(chalk.red(`🔴 Error: APK file not found: ${apkFile}`));
+                process.exit(1);
+            }
+
+            const outputDir = path.resolve(options.output);
+            
+            if (fs.existsSync(outputDir) && !options.force) {
+                console.error(chalk.red(`🔴 Error: Output directory exists: ${outputDir}`));
+                console.error(chalk.yellow('💡 Use --force to overwrite'));
+                process.exit(1);
+            }
+
+            spinner = ora('🔧 Starting advanced decompilation...').start();
+            
+            await performAdvancedDecompilation(apkFile, outputDir, options);
+            
+            spinner.succeed('Advanced decompilation completed!');
+            
+        } catch (error) {
+            if (spinner) spinner.fail('Decompilation failed');
+            console.error(chalk.red('🔴 Error:'), error.message);
+            process.exit(1);
+        }
+    });
+
+async function performAdvancedDecompilation(apkPath, outputDir, options) {
+    const zip = new AdmZip(apkPath);
+    const entries = zip.getEntries();
+    
+    // Create output directory
+    await fs.ensureDir(outputDir);
+    
+    // Setup progress tracking
+    const multiProgress = new cliProgress.MultiBar({
+        format: chalk.cyan('📦 {bar}') + ' | {percentage}% | {value}/{total} {file}',
+        barCompleteChar: '█',
+        barIncompleteChar: '░',
+        hideCursor: true
+    }, cliProgress.Presets.shades_grey);
+    
+    const extractionProgress = multiProgress.create(entries.length, 0, { file: 'Decompiling...' });
+    const analysisProgress = multiProgress.create(100, 0, { file: 'Analysis...' });
+    
+    // Extract all files first
+    let processed = 0;
+    const decompilationData = {
+        files: {
+            total: entries.length,
+            smali: 0,
+            resources: 0,
+            native: 0,
+            assets: 0,
+            other: 0
+        },
+        analysis: {
+            strings: { total: 0, categories: {} },
+            patterns: [],
+            obfuscation: null,
+            optimization: null
+        }
+    };
+    
+    for (const entry of entries) {
+        const entryPath = path.join(outputDir, entry.entryName);
+        
+        try {
+            if (entry.isDirectory) {
+                await fs.ensureDir(entryPath);
+            } else {
+                await fs.ensureDir(path.dirname(entryPath));
+                await fs.writeFile(entryPath, entry.getData());
+                
+                // Categorize files
+                if (entry.entryName.endsWith('.smali')) {
+                    decompilationData.files.smali++;
+                } else if (entry.entryName.startsWith('res/')) {
+                    decompilationData.files.resources++;
+                } else if (entry.entryName.startsWith('lib/')) {
+                    decompilationData.files.native++;
+                } else if (entry.entryName.startsWith('assets/')) {
+                    decompilationData.files.assets++;
+                } else {
+                    decompilationData.files.other++;
+                }
+            }
+        } catch (error) {
+            console.warn(chalk.yellow(`⚠️  Warning: Could not extract ${entry.entryName}: ${error.message}`));
+        }
+        
+        processed++;
+        extractionProgress.update(processed, { file: entry.entryName });
+    }
+    
+    multiProgress.stop();
+    
+    console.log(chalk.bold('\n📊 Decompilation Summary:'));
+    console.log(chalk.cyan(`  • Smali files: ${decompilationData.files.smali}`));
+    console.log(chalk.blue(`  • Resources: ${decompilationData.files.resources}`));
+    console.log(chalk.magenta(`  • Native libs: ${decompilationData.files.native}`));
+    console.log(chalk.green(`  • Assets: ${decompilationData.files.assets}`));
+    console.log(chalk.gray(`  • Other files: ${decompilationData.files.other}`));
+    
+    // Perform advanced analysis based on level
+    await performDecompilationAnalysis(outputDir, options, analysisProgress, decompilationData);
+    
+    // Save decompilation metadata
+    const metadata = {
+        timestamp: new Date().toISOString(),
+        source_apk: path.resolve(apkPath),
+        decompilation_level: options.level,
+        files: decompilationData.files,
+        analysis: decompilationData.analysis,
+        options: options
+    };
+    
+    await fs.writeJson(path.join(outputDir, 'decompilation_metadata.json'), metadata, { spaces: 2 });
+    
+    console.log(chalk.green(`✅ Advanced decompilation completed: ${outputDir}`));
+}
+
+async function performDecompilationAnalysis(outputDir, options, progress, data) {
+    progress.update(0, { file: 'Starting analysis...' });
+    
+    const smaliDir = path.join(outputDir, 'smali');
+    if (!fs.existsSync(smaliDir)) {
+        console.log(chalk.yellow('⚠️  No smali directory found - skipping analysis'));
+        return;
+    }
+    
+    const smaliEditor = new SmaliEditor();
+    
+    // String analysis
+    if (options.analyzeStrings) {
+        progress.update(25, { file: 'Analyzing strings...' });
+        await analyzeSmaliStrings(smaliDir, smaliEditor, data);
+    }
+    
+    // Pattern searching
+    if (options.findPatterns) {
+        progress.update(50, { file: 'Finding patterns...' });
+        await searchSmaliPatterns(smaliDir, smaliEditor, data);
+    }
+    
+    // Obfuscation analysis
+    if (options.deobfuscate) {
+        progress.update(75, { file: 'Analyzing obfuscation...' });
+        await analyzeObfuscation(outputDir, data);
+    }
+    
+    // Optimization
+    if (options.optimize) {
+        progress.update(90, { file: 'Optimizing code...' });
+        await optimizeSmaliCode(smaliDir, smaliEditor, data);
+    }
+    
+    progress.update(100, { file: 'Analysis completed!' });
+    
+    // Display analysis results
+    displayAnalysisResults(data);
+}
+
+async function analyzeSmaliStrings(smaliDir, smaliEditor, data) {
+    const spinner = ora('🔤 Analyzing strings...').start();
+    
+    try {
+        const strings = await smaliEditor.extractStrings(smaliDir, {
+            minLength: 1,
+            maxLength: 500,
+            includeUrls: true,
+            includeEmails: true
+        });
+        
+        // Categorize strings
+        const categories = {
+            urls: [],
+            emails: [],
+            api_keys: [],
+            file_paths: [],
+            class_names: [],
+            method_names: [],
+            package_names: [],
+            other: []
+        };
+        
+        for (const str of strings) {
+            const value = str.value.toLowerCase();
+            
+            if (value.includes('http://') || value.includes('https://')) {
+                categories.urls.push(str);
+            } else if (value.includes('@') && value.includes('.')) {
+                categories.emails.push(str);
+            } else if (value.includes('api') || value.includes('key') || value.includes('token')) {
+                categories.api_keys.push(str);
+            } else if (value.includes('/') || value.includes('\\')) {
+                categories.file_paths.push(str);
+            } else if (value.includes('class') || value.includes('activity') || value.includes('service')) {
+                categories.class_names.push(str);
+            } else if (value.includes('method') || value.includes('function')) {
+                categories.method_names.push(str);
+            } else if (value.includes('com.') || value.includes('org.')) {
+                categories.package_names.push(str);
+            } else {
+                categories.other.push(str);
+            }
+        }
+        
+        data.analysis.strings.total = strings.length;
+        data.analysis.strings.categories = categories;
+        
+        spinner.succeed(`Analyzed ${strings.length} strings`);
+        
+        // Display summary
+        console.log(chalk.bold('\n🔤 String Analysis:'));
+        console.log(chalk.cyan(`  • Total strings: ${strings.length}`));
+        console.log(chalk.blue(`  • URLs: ${categories.urls.length}`));
+        console.log(chalk.yellow(`  • Emails: ${categories.emails.length}`));
+        console.log(chalk.red(`  • API keys: ${categories.api_keys.length}`));
+        console.log(chalk.magenta(`  • File paths: ${categories.file_paths.length}`));
+        
+        // Save detailed strings
+        await fs.writeJson(path.join(smaliDir, '..', 'string_analysis.json'), categories, { spaces: 2 });
+        
+    } catch (error) {
+        spinner.fail('String analysis failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+async function searchSmaliPatterns(smaliDir, smaliEditor, data) {
+    const spinner = ora('🔍 Searching patterns...').start();
+    
+    try {
+        const patterns = [
+            {
+                name: 'HTTP Requests',
+                regex: /invoke-(virtual|static|direct).*http.*url/gi,
+                description: 'HTTP URL usage'
+            },
+            {
+                name: 'SQL Queries',
+                regex: /SELECT|INSERT|UPDATE|DELETE|FROM.*WHERE/gi,
+                description: 'SQL query patterns'
+            },
+            {
+                name: 'Crypto Operations',
+                regex: /Cipher|MessageDigest|Signature|KeyGenerator/gi,
+                description: 'Cryptographic operations'
+            },
+            {
+                name: 'File Operations',
+                regex: /File\(|FileInputStream|FileOutputStream/gi,
+                description: 'File I/O operations'
+            },
+            {
+                name: 'Network Operations',
+                regex: /Socket|HttpURLConnection|OkHttpClient/gi,
+                description: 'Network communication'
+            }
+        ];
+        
+        const results = await smaliEditor.searchPatterns(smaliDir, patterns);
+        
+        data.analysis.patterns = results;
+        
+        spinner.succeed(`Found ${results.length} pattern matches`);
+        
+        // Display summary
+        console.log(chalk.bold('\n🔍 Pattern Search Results:'));
+        for (const result of results) {
+            console.log(chalk.cyan(`  • ${result.pattern}: ${result.count} matches`));
+        }
+        
+        // Save results
+        await fs.writeJson(path.join(smaliDir, '..', 'pattern_search.json'), results, { spaces: 2 });
+        
+    } catch (error) {
+        spinner.fail('Pattern search failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+async function analyzeObfuscation(outputDir, data) {
+    const spinner = ora('🔍 Analyzing obfuscation...').start();
+    
+    try {
+        const ObfuscationDetector = require('../utils/obfuscation-detector');
+        const detector = new ObfuscationDetector();
+        
+        const analysis = await detector.analyzeObfuscation(outputDir);
+        
+        data.analysis.obfuscation = analysis;
+        
+        spinner.succeed('Obfuscation analysis completed');
+        
+        // Display summary
+        console.log(chalk.bold('\n🔍 Obfuscation Analysis:'));
+        console.log(chalk.cyan(`  • Obfuscation level: ${analysis.obfuscationLevel}`));
+        console.log(chalk.blue(`  • Score: ${analysis.overallScore}%`));
+        console.log(chalk.magenta(`  • Confidence: ${analysis.confidence}%`));
+        
+        if (analysis.antiTampering.techniques.length > 0) {
+            console.log(chalk.red(`  • Anti-tampering: ${analysis.antiTampering.techniques.join(', ')}`));
+        }
+        
+        // Save analysis
+        await fs.writeJson(path.join(outputDir, 'obfuscation_analysis.json'), analysis, { spaces: 2 });
+        
+    } catch (error) {
+        spinner.fail('Obfuscation analysis failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+async function optimizeSmaliCode(smaliDir, smaliEditor, data) {
+    const spinner = ora('⚡ Optimizing code...').start();
+    
+    try {
+        // Remove debug code
+        const debugReplacements = [
+            { from: /Log\.d\(.+?\)/g, to: '// Debug removed', regex: true },
+            { from: /System\.out\.print/g, to: '// System.out removed', regex: true },
+            { from: /android\.util\.Log/g, to: '// Log removed', regex: true }
+        ];
+        
+        const debugResults = await smaliEditor.replaceStrings(smaliDir, debugReplacements);
+        
+        // Remove dead code
+        const deadCodeReplacements = [
+            { from: /if\s*\(false\s*\)\s*\{[^}]*\}/g, to: '', regex: true },
+            { from: /if\s*\(true\s*\)\s*\{[^}]*\}/g, to: '', regex: true }
+        ];
+        
+        const deadCodeResults = await smaliEditor.replaceStrings(smaliDir, deadCodeReplacements);
+        
+        data.analysis.optimization = {
+            debug_code_removed: debugResults.modified.length,
+            dead_code_removed: deadCodeResults.modified.length,
+            total_files_modified: debugResults.modified.length + deadCodeResults.modified.length
+        };
+        
+        spinner.succeed('Code optimization completed');
+        
+        // Display summary
+        console.log(chalk.bold('\n⚡ Optimization Results:'));
+        console.log(chalk.cyan(`  • Debug code removed from: ${data.analysis.optimization.debug_code_removed} files`));
+        console.log(chalk.yellow(`  • Dead code removed from: ${data.analysis.optimization.dead_code_removed} files`));
+        console.log(chalk.green(`  • Total files modified: ${data.analysis.optimization.total_files_modified}`));
+        
+        // Save optimization results
+        await fs.writeJson(path.join(smaliDir, '..', 'optimization_results.json'), data.analysis.optimization, { spaces: 2 });
+        
+    } catch (error) {
+        spinner.fail('Code optimization failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+function displayAnalysisResults(data) {
+    console.log(chalk.bold('\n📊 Decompilation Analysis Summary:'));
+    
+    if (data.analysis.strings) {
+        console.log(chalk.cyan(`🔤 Strings: ${data.analysis.strings.total} total`));
+        for (const [category, items] of Object.entries(data.analysis.strings.categories)) {
+            if (items.length > 0) {
+                console.log(chalk.gray(`  • ${category}: ${items.length}`));
+            }
+        }
+    }
+    
+    if (data.analysis.patterns && data.analysis.patterns.length > 0) {
+        console.log(chalk.cyan(`🔍 Patterns: ${data.analysis.patterns.length} types found`));
+    }
+    
+    if (data.analysis.obfuscation) {
+        console.log(chalk.cyan(`🔍 Obfuscation: ${data.analysis.obfuscation.obfuscationLevel} level`));
+    }
+    
+    if (data.analysis.optimization) {
+        console.log(chalk.cyan(`⚡ Optimization: ${data.analysis.optimization.total_files_modified} files optimized`));
+    }
+}
+
+module.exports = decompileCommand;