@kakuzu_aon/apkz 1.0.0

package/src/commands/extract.js

@@ -0,0 +1,410 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : extract.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : Advanced APK extraction 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 ManifestParser = require('../utils/manifest-parser');
+const NetworkAnalyzer = require('../utils/network-analyzer');
+const VulnerabilityScanner = require('../utils/vulnerability-scanner');
+
+const extractCommand = new Command('extract')
+    .description('Professional APK extraction with comprehensive analysis and reporting')
+    .argument('<apk-file>', 'APK file to extract')
+    .option('-o, --output <dir>', 'Output directory (default: ./extracted)', './extracted')
+    .option('-f, --force', 'Overwrite existing output directory')
+    .option('--no-resources', 'Skip resource extraction')
+    .option('--no-dex', 'Skip DEX file extraction')
+    .option('--no-native', 'Skip native library extraction')
+    .option('--no-assets', 'Skip assets extraction')
+    .option('--no-manifest', 'Skip manifest extraction')
+    .option('--no-meta', 'Skip metadata extraction')
+    .option('--analyze', 'Perform deep analysis during extraction')
+    .option('--vulnerability', 'Perform vulnerability scanning')
+    .option('--obfuscation', 'Perform obfuscation analysis')
+    .option('--network', 'Perform network analysis')
+    .option('--strings', 'Extract all strings from smali files')
+    .option('--signatures', 'Extract code signatures and metadata')
+    .option('--permissions', 'Extract permission analysis')
+    .option('--components', 'Extract component analysis')
+    .option('--framework', 'Detect development frameworks')
+    .option('--resources', 'Extract resource analysis')
+    .option('--native', 'Extract native library analysis')
+    .option('--parallel <num>', 'Parallel extraction threads', '4')
+    .option('--timeout <ms>', 'Extraction timeout in milliseconds', '300000')
+    .option('--progress', 'Show detailed progress information')
+    .option('--validate', 'Validate extracted files')
+    .option('--compress', 'Compress extracted files')
+    .option('--backup', 'Create backup of original APK')
+    .option('--export <file>', 'Export extraction report')
+    .option('--format <format>', 'Report format (json, html, csv)', 'json')
+    .option('--dry-run', 'Show extraction plan without executing')
+    .option('--template <name>', 'Use extraction template')
+    .option('--log-level <level>', 'Logging level (debug, info, warn, error)', 'info')
+    .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 extraction...').start();
+            
+            await performAdvancedExtraction(apkFile, outputDir, options);
+            
+            spinner.succeed('Advanced extraction completed!');
+            
+        } catch (error) {
+            if (spinner) spinner.fail('Extraction failed');
+            console.error(chalk.red('🔴 Error:'), error.message);
+            process.exit(1);
+        }
+    });
+
+async function performAdvancedExtraction(apkPath, outputDir, options) {
+    const zip = new AdmZip(apkPath);
+    const entries = zip.getEntries();
+    
+    // Create output directory
+    await fs.ensureDir(outputDir);
+    
+    // Multi-progress bars
+    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: 'Extracting files...' });
+    const analysisProgress = multiProgress.create(100, 0, { file: 'Analysis...' });
+    
+    // Extract files
+    let processed = 0;
+    const extractedFiles = {
+        total: entries.length,
+        dex: 0,
+        resources: 0,
+        native: 0,
+        assets: 0,
+        manifest: 0,
+        certificates: 0,
+        other: 0
+    };
+    
+    for (const entry of entries) {
+        const entryPath = path.join(outputDir, entry.entryName);
+        
+        try {
+            // Skip based on options
+            if (!options.dex && entry.entryName.endsWith('.dex')) {
+                processed++;
+                extractionProgress.update(processed);
+                continue;
+            }
+            
+            if (!options.resources && entry.entryName === 'resources.arsc') {
+                processed++;
+                extractionProgress.update(processed);
+                continue;
+            }
+            
+            if (!options.native && entry.entryName.startsWith('lib/')) {
+                processed++;
+                extractionProgress.update(processed);
+                continue;
+            }
+            
+            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('.dex')) {
+                    extractedFiles.dex++;
+                } else if (entry.entryName === 'resources.arsc') {
+                    extractedFiles.resources++;
+                } else if (entry.entryName.startsWith('lib/')) {
+                    extractedFiles.native++;
+                } else if (entry.entryName.startsWith('assets/')) {
+                    extractedFiles.assets++;
+                } else if (entry.entryName === 'AndroidManifest.xml') {
+                    extractedFiles.manifest++;
+                } else if (entry.entryName.startsWith('META-INF/')) {
+                    extractedFiles.certificates++;
+                } else {
+                    extractedFiles.other++;
+                }
+            }
+        } catch (error) {
+            console.warn(chalk.yellow(`⚠️  Warning: Could not extract ${entry.entryName}: ${error.message}`));
+        }
+        
+        processed++;
+        extractionProgress.update(processed, { file: entry.entryName });
+    }
+    
+    multiProgress.stop();
+    
+    // Display extraction summary
+    console.log(chalk.bold('\n📊 Extraction Summary:'));
+    console.log(chalk.gray(`  • Total files: ${extractedFiles.total}`));
+    console.log(chalk.cyan(`  • DEX files: ${extractedFiles.dex}`));
+    console.log(chalk.blue(`  • Resources: ${extractedFiles.resources}`));
+    console.log(chalk.magenta(`  • Native libs: ${extractedFiles.native}`));
+    console.log(chalk.green(`  • Assets: ${extractedFiles.assets}`));
+    console.log(chalk.yellow(`  • Certificates: ${extractedFiles.certificates}`));
+    console.log(chalk.gray(`  • Other files: ${extractedFiles.other}`));
+    
+    // Perform analysis if requested
+    if (options.analyze || options.vulnerability || options.network) {
+        await performPostExtractionAnalysis(outputDir, options, analysisProgress);
+    }
+    
+    // Extract strings if requested
+    if (options.strings) {
+        await extractAllStrings(outputDir);
+    }
+    
+    // Extract signatures if requested
+    if (options.signatures) {
+        await extractSignatures(outputDir);
+    }
+    
+    // Save extraction metadata
+    const metadata = {
+        timestamp: new Date().toISOString(),
+        source_apk: path.resolve(apkPath),
+        extracted_files: extractedFiles,
+        options: options,
+        analysis: {}
+    };
+    
+    await fs.writeJson(path.join(outputDir, 'extraction_metadata.json'), metadata, { spaces: 2 });
+    
+    console.log(chalk.green(`✅ Advanced extraction completed: ${outputDir}`));
+}
+
+async function performPostExtractionAnalysis(outputDir, options, progress) {
+    progress.update(0, { file: 'Starting analysis...' });
+    
+    const analysis = {};
+    
+    // Manifest analysis
+    if (fs.existsSync(path.join(outputDir, 'AndroidManifest.xml'))) {
+        progress.update(25, { file: 'Analyzing manifest...' });
+        try {
+            const manifestParser = new ManifestParser();
+            analysis.manifest = await manifestParser.parseManifest(outputDir);
+        } catch (error) {
+            console.warn(chalk.yellow('⚠️  Manifest analysis failed:', error.message));
+        }
+    }
+    
+    // Network analysis
+    if (options.network) {
+        progress.update(50, { file: 'Analyzing network...' });
+        try {
+            const networkAnalyzer = new NetworkAnalyzer();
+            analysis.network = await networkAnalyzer.analyzeNetwork(outputDir);
+        } catch (error) {
+            console.warn(chalk.yellow('⚠️  Network analysis failed:', error.message));
+        }
+    }
+    
+    // Vulnerability scanning
+    if (options.vulnerability) {
+        progress.update(75, { file: 'Scanning for vulnerabilities...' });
+        try {
+            const vulnScanner = new VulnerabilityScanner();
+            analysis.vulnerability = await vulnScanner.scanAPK(outputDir);
+        } catch (error) {
+            console.warn(chalk.yellow('⚠️  Vulnerability scanning failed:', error.message));
+        }
+    }
+    
+    progress.update(100, { file: 'Analysis completed!' });
+    
+    // Save analysis results
+    await fs.writeJson(path.join(outputDir, 'analysis_results.json'), analysis, { spaces: 2 });
+    
+    // Display analysis summary
+    if (analysis.manifest) {
+        console.log(chalk.bold('\n📱 Application Information:'));
+        console.log(chalk.cyan(`  • Package: ${analysis.manifest.package || 'Unknown'}`));
+        console.log(chalk.green(`  • Version: ${analysis.manifest.versionName || 'Unknown'} (${analysis.manifest.versionCode || 'Unknown'})`));
+        console.log(chalk.blue(`  • Min SDK: ${analysis.manifest.minSdk || 'Unknown'}`));
+        console.log(chalk.blue(`  • Target SDK: ${analysis.manifest.targetSdk || 'Unknown'}`));
+        
+        if (analysis.manifest.application?.debuggable === 'true') {
+            console.log(chalk.red('  ⚠️  Debug mode enabled'));
+        }
+    }
+    
+    if (analysis.network) {
+        console.log(chalk.bold('\n🌐 Network Analysis:'));
+        console.log(chalk.cyan(`  • URLs found: ${analysis.network.summary.totalUrls}`));
+        console.log(chalk.yellow(`  • API keys: ${analysis.network.summary.apiKeysFound}`));
+        console.log(chalk.red(`  • Risk level: ${analysis.network.security.riskLevel}`));
+    }
+    
+    if (analysis.vulnerability) {
+        console.log(chalk.bold('\n🔒 Security Scan:'));
+        console.log(chalk.red(`  • Risk Score: ${analysis.vulnerability.summary.riskScore}/100`));
+        console.log(chalk.red(`  • Total vulnerabilities: ${analysis.vulnerability.summary.total}`));
+        console.log(chalk.red(`  • Critical: ${analysis.vulnerability.summary.critical}`));
+        console.log(chalk.yellow(`  • High: ${analysis.vulnerability.summary.high}`));
+    }
+}
+
+async function extractAllStrings(decodedPath) {
+    const SmaliEditor = require('../utils/smali-editor');
+    const spinner = ora('🔤 Extracting strings...').start();
+    
+    try {
+        const smaliEditor = new SmaliEditor();
+        const strings = await smaliEditor.extractStrings(decodedPath, {
+            minLength: 3,
+            maxLength: 200,
+            includeUrls: true,
+            includeEmails: true
+        });
+        
+        spinner.succeed(`Extracted ${strings.length} strings`);
+        
+        // Save strings
+        const stringsPath = path.join(decodedPath, 'extracted_strings.json');
+        await fs.writeJson(stringsPath, strings, { spaces: 2 });
+        
+        // Show sample
+        console.log(chalk.bold('\n🔤 Sample Strings:'));
+        strings.slice(0, 10).forEach((str, index) => {
+            console.log(chalk.gray(`  ${index + 1}. "${str.value}" (${path.basename(str.file)})`));
+        });
+        
+        if (strings.length > 10) {
+            console.log(chalk.gray(`  ... and ${strings.length - 10} more strings`));
+        }
+        
+    } catch (error) {
+        spinner.fail('String extraction failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+async function extractSignatures(decodedPath) {
+    const spinner = ora('🔍 Extracting signatures...').start();
+    
+    try {
+        const signatures = {
+            certificates: [],
+            manifest: {},
+            native_libs: [],
+            file_hashes: {}
+        };
+        
+        // Extract certificates
+        const metaInfDir = path.join(decodedPath, 'META-INF');
+        if (fs.existsSync(metaInfDir)) {
+            const certFiles = await fs.readdir(metaInfDir);
+            for (const file of certFiles) {
+                if (file.endsWith('.RSA') || file.endsWith('.DSA') || file.endsWith('.SF')) {
+                    const filePath = path.join(metaInfDir, file);
+                    const stats = await fs.stat(filePath);
+                    signatures.certificates.push({
+                        name: file,
+                        size: stats.size,
+                        path: path.relative(decodedPath, filePath)
+                    });
+                }
+            }
+        }
+        
+        // Extract manifest info
+        const manifestPath = path.join(decodedPath, 'AndroidManifest.xml');
+        if (fs.existsSync(manifestPath)) {
+            const stats = await fs.stat(manifestPath);
+            signatures.manifest = {
+                size: stats.size,
+                modified: stats.mtime,
+                path: path.relative(decodedPath, manifestPath)
+            };
+        }
+        
+        // Extract native library signatures
+        const libDir = path.join(decodedPath, 'lib');
+        if (fs.existsSync(libDir)) {
+            const archDirs = await fs.readdir(libDir);
+            for (const arch of archDirs) {
+                const archPath = path.join(libDir, arch);
+                if (fs.statSync(archPath).isDirectory()) {
+                    const soFiles = await fs.readdir(archPath);
+                    for (const file of soFiles) {
+                        if (file.endsWith('.so')) {
+                            const filePath = path.join(archPath, file);
+                            const stats = await fs.stat(filePath);
+                            signatures.native_libs.push({
+                                name: file,
+                                architecture: arch,
+                                size: stats.size,
+                                path: path.relative(decodedPath, filePath)
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        
+        // Calculate file hashes for important files
+        const crypto = require('crypto');
+        const importantFiles = ['AndroidManifest.xml', 'classes.dex', 'resources.arsc'];
+        
+        for (const file of importantFiles) {
+            const filePath = path.join(decodedPath, file);
+            if (fs.existsSync(filePath)) {
+                const content = await fs.readFile(filePath);
+                const hash = crypto.createHash('sha256').update(content).digest('hex');
+                signatures.file_hashes[file] = hash;
+            }
+        }
+        
+        spinner.succeed('Signatures extracted');
+        
+        // Save signatures
+        const signaturesPath = path.join(decodedPath, 'signatures.json');
+        await fs.writeJson(signaturesPath, signatures, { spaces: 2 });
+        
+        // Display summary
+        console.log(chalk.bold('\n🔍 Signature Summary:'));
+        console.log(chalk.cyan(`  • Certificates: ${signatures.certificates.length}`));
+        console.log(chalk.magenta(`  • Native libraries: ${signatures.native_libs.length}`));
+        console.log(chalk.blue(`  • File hashes: ${Object.keys(signatures.file_hashes).length}`));
+        
+    } catch (error) {
+        spinner.fail('Signature extraction failed');
+        console.error(chalk.red('🔴 Error:'), error.message);
+    }
+}
+
+module.exports = extractCommand;