@kakuzu_aon/apkz 1.0.0

package/src/utils/config.json

@@ -0,0 +1,118 @@
+{
+  "version": "1.0.0",
+  "general": {
+    "logLevel": "info",
+    "outputDir": "./output",
+    "tempDir": "./temp",
+    "maxFileSize": 104857600,
+    "parallel": 4,
+    "timeout": 300000,
+    "autoCleanup": true,
+    "showBanner": true
+  },
+  "security": {
+    "defaultSeverity": "medium",
+    "scanNativeLibs": true,
+    "scanResources": true,
+    "scanManifest": true,
+    "checkKnownVulns": true,
+    "generateCVSS": true,
+    "complianceChecks": ["owasp-top10", "mobile-top10"],
+    "excludePatterns": [
+      "schemas.android.com",
+      "android:layout",
+      "android:drawable",
+      "android:color"
+    ]
+  },
+  "web": {
+    "port": 3000,
+    "host": "localhost",
+    "cors": true,
+    "maxUploadSize": 104857600,
+    "sessionTimeout": 3600000,
+    "enableAuth": false,
+    "authSecret": "apkz-secret-key",
+    "enableWebhook": false,
+    "webhookUrl": ""
+  },
+  "batch": {
+    "parallel": 4,
+    "recursive": true,
+    "includeSubdirs": true,
+    "filter": "*.apk",
+    "autoAnalyze": true,
+    "generateSummary": true,
+    "saveIndividualReports": true,
+    "cleanupTempFiles": true
+  },
+  "monitoring": {
+    "interval": 5000,
+    "autoAnalyze": true,
+    "enableWebhook": false,
+    "webhookUrl": "",
+    "logEvents": true,
+    "maxEvents": 1000,
+    "eventRetention": 86400000
+  },
+  "reports": {
+    "defaultFormat": "json",
+    "includeScreenshots": false,
+    "includeStrings": true,
+    "includeNetwork": true,
+    "includeObfuscation": true,
+    "template": "default",
+    "customTemplates": {},
+    "exportFormats": ["json", "html", "csv"],
+    "compression": false,
+    "encryption": false
+  },
+  "modification": {
+    "autoBackup": true,
+    "backupDir": "./backups",
+    "preserveOriginal": true,
+    "validateAfterModification": true,
+    "autoSign": false,
+    "debugKeystore": {
+      "path": "./debug.keystore",
+      "alias": "androiddebugkey",
+      "password": "android",
+      "keyPassword": "android"
+    }
+  },
+  "analysis": {
+    "deepScan": false,
+    "extractStrings": true,
+    "analyzeNetwork": true,
+    "detectObfuscation": true,
+    "scanNativeLibs": true,
+    "analyzeResources": true,
+    "extractSignatures": true,
+    "generateReport": true
+  },
+  "plugins": {
+    "enabled": true,
+    "autoLoad": true,
+    "pluginDir": "./plugins",
+    "maxPlugins": 50,
+    "allowRemote": false,
+    "trustedSources": []
+  },
+  "ui": {
+    "theme": "default",
+    "colors": true,
+    "progressBars": true,
+    "animations": true,
+    "compact": false,
+    "showTimestamps": false,
+    "showMemoryUsage": false
+  },
+  "performance": {
+    "cacheResults": true,
+    "cacheSize": 104857600,
+    "compressionLevel": 6,
+    "memoryLimit": 1073741824,
+    "cpuLimit": 80,
+    "enableProfiling": false
+  }
+}

package/src/utils/icon-manager.js

@@ -0,0 +1,544 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : icon-manager.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : APK icon replacement utilities
+// ────────────────★─────────────────────────────────
+
+const fs = require('fs-extra');
+const path = require('path');
+const sharp = require('sharp');
+
+class IconManager {
+    constructor() {
+        this.iconSizes = {
+            // Android launcher icon sizes
+            mdpi: 48,
+            hdpi: 72,
+            xhdpi: 96,
+            xxhdpi: 144,
+            xxxhdpi: 192,
+            // Adaptive icon sizes
+            adaptive_mdpi: 80,
+            adaptive_hdpi: 120,
+            adaptive_xhdpi: 160,
+            adaptive_xxhdpi: 240,
+            adaptive_xxxhdpi: 320,
+            // Notification icons
+            notification_mdpi: 24,
+            notification_hdpi: 36,
+            notification_xhdpi: 48,
+            notification_xxhdpi: 72,
+            notification_xxxhdpi: 96
+        };
+    }
+
+    /**
+     * Replace app icons in decoded APK
+     */
+    async replaceIcons(decodedPath, iconPath, options = {}) {
+        const results = {
+            replaced: [],
+            errors: [],
+            generated: []
+        };
+
+        try {
+            // Validate input icon
+            if (!fs.existsSync(iconPath)) {
+                throw new Error(`Icon file not found: ${iconPath}`);
+            }
+
+            // Check if icon is valid image
+            const iconMetadata = await sharp(iconPath).metadata();
+            if (!['png', 'jpeg', 'jpg', 'webp'].includes(iconMetadata.format)) {
+                throw new Error(`Unsupported icon format: ${iconMetadata.format}`);
+            }
+
+            const resDir = path.join(decodedPath, 'res');
+            if (!fs.existsSync(resDir)) {
+                throw new Error('Resources directory not found in decoded APK');
+            }
+
+            // Generate different sizes
+            const tempDir = path.join(decodedPath, '.temp_icons');
+            await fs.ensureDir(tempDir);
+
+            try {
+                // Generate all required sizes
+                await this.generateIconSizes(iconPath, tempDir, options);
+
+                // Replace launcher icons
+                await this.replaceLauncherIcons(resDir, tempDir, results);
+
+                // Replace adaptive icons
+                await this.replaceAdaptiveIcons(resDir, tempDir, results);
+
+                // Replace notification icons if requested
+                if (options.includeNotifications) {
+                    await this.replaceNotificationIcons(resDir, tempDir, results);
+                }
+
+                // Update manifest if requested
+                if (options.updateManifest) {
+                    await this.updateManifestIcons(decodedPath, iconPath, results);
+                }
+
+            } finally {
+                // Clean up temp directory
+                await fs.remove(tempDir);
+            }
+
+        } catch (error) {
+            results.errors.push({
+                error: error.message,
+                step: 'icon_replacement'
+            });
+        }
+
+        return results;
+    }
+
+    /**
+     * Generate icon sizes from source image
+     */
+    async generateIconSizes(sourcePath, outputDir, options = {}) {
+        const { format = 'png', quality = 90, adaptive = true } = options;
+
+        for (const [sizeName, size] of Object.entries(this.iconSizes)) {
+            try {
+                let outputPath = path.join(outputDir, `${sizeName}.${format}`);
+                
+                const resizeOptions = {
+                    width: size,
+                    height: size,
+                    fit: 'cover',
+                    position: 'center'
+                };
+
+                // For adaptive icons, add padding
+                if (sizeName.startsWith('adaptive_')) {
+                    const adaptiveSize = parseInt(sizeName.split('_')[1]);
+                    const canvasSize = this.iconSizes[`adaptive_${sizeName.split('_')[1]}`];
+                    
+                    await sharp(sourcePath)
+                        .resize(adaptiveSize * 0.8, adaptiveSize * 0.8, { fit: 'cover', position: 'center' })
+                        .extend({
+                            top: adaptiveSize * 0.1,
+                            bottom: adaptiveSize * 0.1,
+                            left: adaptiveSize * 0.1,
+                            right: adaptiveSize * 0.1,
+                            background: { r: 0, g: 0, b: 0, alpha: 0 }
+                        })
+                        .toFile(outputPath);
+                } else {
+                    await sharp(sourcePath)
+                        .resize(resizeOptions)
+                        .toFormat(format, { quality })
+                        .toFile(outputPath);
+                }
+
+            } catch (error) {
+                console.warn(`Warning: Could not generate ${sizeName}: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Replace launcher icons
+     */
+    async replaceLauncherIcons(resDir, tempDir, results) {
+        const launcherDirs = [
+            'mipmap-mdpi', 'mipmap-hdpi', 'mipmap-xhdpi', 'mipmap-xxhdpi', 'mipmap-xxxhdpi',
+            'drawable-mdpi', 'drawable-hdpi', 'drawable-xhdpi', 'drawable-xxhdpi', 'drawable-xxxhdpi'
+        ];
+
+        const iconNames = ['ic_launcher.png', 'ic_launcher.webp', 'icon.png', 'icon.webp'];
+
+        for (const dir of launcherDirs) {
+            const dirPath = path.join(resDir, dir);
+            if (!fs.existsSync(dirPath)) continue;
+
+            const density = dir.split('-')[1];
+            const sizeName = density;
+
+            for (const iconName of iconNames) {
+                const iconPath = path.join(dirPath, iconName);
+                const sourceIcon = path.join(tempDir, `${sizeName}.png`);
+
+                if (fs.existsSync(iconPath) && fs.existsSync(sourceIcon)) {
+                    try {
+                        await fs.copy(sourceIcon, iconPath);
+                        results.replaced.push({
+                            type: 'launcher',
+                            file: path.relative(resDir, iconPath),
+                            size: this.iconSizes[sizeName]
+                        });
+                    } catch (error) {
+                        results.errors.push({
+                            error: error.message,
+                            file: path.relative(resDir, iconPath)
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Replace adaptive icons
+     */
+    async replaceAdaptiveIcons(resDir, tempDir, results) {
+        const adaptiveDirs = [
+            'mipmap-mdpi-v26', 'mipmap-hdpi-v26', 'mipmap-xhdpi-v26', 
+            'mipmap-xxhdpi-v26', 'mipmap-xxxhdpi-v26'
+        ];
+
+        for (const dir of adaptiveDirs) {
+            const dirPath = path.join(resDir, dir);
+            if (!fs.existsSync(dirPath)) continue;
+
+            const density = dir.split('-')[1];
+            const sizeName = `adaptive_${density}`;
+
+            // Replace foreground icons
+            const foregroundIcon = path.join(dirPath, 'ic_launcher_foreground.png');
+            const sourceForeground = path.join(tempDir, `${sizeName}.png`);
+
+            if (fs.existsSync(foregroundIcon) && fs.existsSync(sourceForeground)) {
+                try {
+                    await fs.copy(sourceForeground, foregroundIcon);
+                    results.replaced.push({
+                        type: 'adaptive_foreground',
+                        file: path.relative(resDir, foregroundIcon),
+                        size: this.iconSizes[sizeName]
+                    });
+                } catch (error) {
+                    results.errors.push({
+                        error: error.message,
+                        file: path.relative(resDir, foregroundIcon)
+                    });
+                }
+            }
+        }
+    }
+
+    /**
+     * Replace notification icons
+     */
+    async replaceNotificationIcons(resDir, tempDir, results) {
+        const notificationDirs = [
+            'drawable-mdpi', 'drawable-hdpi', 'drawable-xhdpi', 
+            'drawable-xxhdpi', 'drawable-xxxhdpi'
+        ];
+
+        for (const dir of notificationDirs) {
+            const dirPath = path.join(resDir, dir);
+            if (!fs.existsSync(dirPath)) continue;
+
+            const density = dir.split('-')[1];
+            const sizeName = `notification_${density}`;
+
+            const notificationIcon = path.join(dirPath, 'ic_notification.png');
+            const sourceIcon = path.join(tempDir, `${sizeName}.png`);
+
+            if (fs.existsSync(notificationIcon) && fs.existsSync(sourceIcon)) {
+                try {
+                    await fs.copy(sourceIcon, notificationIcon);
+                    results.replaced.push({
+                        type: 'notification',
+                        file: path.relative(resDir, notificationIcon),
+                        size: this.iconSizes[sizeName]
+                    });
+                } catch (error) {
+                    results.errors.push({
+                        error: error.message,
+                        file: path.relative(resDir, notificationIcon)
+                    });
+                }
+            }
+        }
+    }
+
+    /**
+     * Update manifest to reference new icons
+     */
+    async updateManifestIcons(decodedPath, iconPath, results) {
+        const manifestPath = path.join(decodedPath, 'AndroidManifest.xml');
+        
+        if (!fs.existsSync(manifestPath)) {
+            return;
+        }
+
+        try {
+            let manifestContent = await fs.readFile(manifestPath, 'utf8');
+            
+            // Update application icon if needed
+            if (manifestContent.includes('android:icon')) {
+                // This is a simplified approach - in reality, manifest might be binary
+                console.log('Manifest icon references detected - manual update may be required');
+                results.replaced.push({
+                    type: 'manifest_note',
+                    file: 'AndroidManifest.xml',
+                    message: 'Manual icon reference update may be needed'
+                });
+            }
+
+        } catch (error) {
+            results.errors.push({
+                error: error.message,
+                file: 'AndroidManifest.xml'
+            });
+        }
+    }
+
+    /**
+     * Extract existing icons from APK
+     */
+    async extractIcons(decodedPath, outputDir) {
+        const results = {
+            extracted: [],
+            errors: []
+        };
+
+        const resDir = path.join(decodedPath, 'res');
+        if (!fs.existsSync(resDir)) {
+            results.errors.push('Resources directory not found');
+            return results;
+        }
+
+        await fs.ensureDir(outputDir);
+
+        // Find all icon files
+        const iconPatterns = [
+            '**/ic_launcher.*',
+            '**/ic_launcher_foreground.*',
+            '**/ic_launcher_background.*',
+            '**/icon.*',
+            '**/ic_notification.*'
+        ];
+
+        for (const pattern of iconPatterns) {
+            try {
+                const files = await this.findFiles(resDir, pattern);
+                
+                for (const file of files) {
+                    const relativePath = path.relative(resDir, file);
+                    const outputPath = path.join(outputDir, relativePath.replace(/[\/\\]/g, '_'));
+                    
+                    await fs.ensureDir(path.dirname(outputPath));
+                    await fs.copy(file, outputPath);
+                    
+                    results.extracted.push({
+                        source: relativePath,
+                        output: path.basename(outputPath)
+                    });
+                }
+            } catch (error) {
+                results.errors.push({
+                    error: error.message,
+                    pattern
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Create adaptive icon from single image
+     */
+    async createAdaptiveIcon(iconPath, outputPath, options = {}) {
+        const { 
+            backgroundColor = '#FFFFFF', 
+            size = 108,
+            padding = 0.2 
+        } = options;
+
+        try {
+            const iconSize = Math.floor(size * (1 - padding));
+            
+            await sharp(iconPath)
+                .resize(iconSize, iconSize, { fit: 'cover', position: 'center' })
+                .extend({
+                    top: size * padding / 2,
+                    bottom: size * padding / 2,
+                    left: size * padding / 2,
+                    right: size * padding / 2,
+                    background: backgroundColor
+                })
+                .toFile(outputPath);
+
+            return { success: true, outputPath };
+
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Validate icon file
+     */
+    async validateIcon(iconPath) {
+        try {
+            if (!fs.existsSync(iconPath)) {
+                return { valid: false, error: 'File not found' };
+            }
+
+            const metadata = await sharp(iconPath).metadata();
+            
+            if (!['png', 'jpeg', 'jpg', 'webp'].includes(metadata.format)) {
+                return { valid: false, error: `Unsupported format: ${metadata.format}` };
+            }
+
+            if (metadata.width < 48 || metadata.height < 48) {
+                return { valid: false, error: 'Icon too small (minimum 48x48)' };
+            }
+
+            if (metadata.width > 2048 || metadata.height > 2048) {
+                return { valid: false, error: 'Icon too large (maximum 2048x2048)' };
+            }
+
+            if (Math.abs(metadata.width - metadata.height) > metadata.width * 0.1) {
+                return { valid: false, error: 'Icon should be roughly square' };
+            }
+
+            return { 
+                valid: true, 
+                metadata: {
+                    format: metadata.format,
+                    width: metadata.width,
+                    height: metadata.height,
+                    size: metadata.size
+                }
+            };
+
+        } catch (error) {
+            return { valid: false, error: error.message };
+        }
+    }
+
+    /**
+     * Find files matching pattern
+     */
+    async findFiles(dir, pattern) {
+        const files = [];
+        const items = await fs.readdir(dir);
+        
+        for (const item of items) {
+            const fullPath = path.join(dir, item);
+            const stat = await fs.stat(fullPath);
+            
+            if (stat.isDirectory()) {
+                const subFiles = await this.findFiles(fullPath, pattern);
+                files.push(...subFiles);
+            } else {
+                // Simple pattern matching
+                if (this.matchesPattern(item, pattern)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        
+        return files;
+    }
+
+    /**
+     * Simple pattern matching
+     */
+    matchesPattern(filename, pattern) {
+        const regex = new RegExp(
+            pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]'),
+            'i'
+        );
+        return regex.test(filename);
+    }
+
+    /**
+     * Get icon information from decoded APK
+     */
+    async getIconInfo(decodedPath) {
+        const info = {
+            launcherIcons: [],
+            adaptiveIcons: [],
+            notificationIcons: [],
+            totalIcons: 0
+        };
+
+        const resDir = path.join(decodedPath, 'res');
+        if (!fs.existsSync(resDir)) {
+            return info;
+        }
+
+        // Scan for icon files
+        const items = await fs.readdir(resDir, { withFileTypes: true });
+        
+        for (const item of items) {
+            if (!item.isDirectory()) continue;
+            
+            const dirPath = path.join(resDir, item.name);
+            const files = await fs.readdir(dirPath);
+            
+            for (const file of files) {
+                if (this.isIconFile(file)) {
+                    const filePath = path.join(dirPath, file);
+                    const stat = await fs.stat(filePath);
+                    
+                    const iconInfo = {
+                        path: path.relative(resDir, filePath),
+                        size: stat.size,
+                        type: this.getIconType(file),
+                        density: this.getDensityFromDir(item.name)
+                    };
+
+                    if (iconInfo.type === 'launcher') {
+                        info.launcherIcons.push(iconInfo);
+                    } else if (iconInfo.type === 'adaptive') {
+                        info.adaptiveIcons.push(iconInfo);
+                    } else if (iconInfo.type === 'notification') {
+                        info.notificationIcons.push(iconInfo);
+                    }
+                    
+                    info.totalIcons++;
+                }
+            }
+        }
+
+        return info;
+    }
+
+    /**
+     * Check if file is an icon
+     */
+    isIconFile(filename) {
+        const iconNames = [
+            'ic_launcher', 'ic_launcher_foreground', 'ic_launcher_background',
+            'icon', 'ic_notification', 'ic_stat_notify'
+        ];
+        
+        return iconNames.some(name => filename.toLowerCase().startsWith(name.toLowerCase()));
+    }
+
+    /**
+     * Get icon type from filename
+     */
+    getIconType(filename) {
+        if (filename.includes('launcher_foreground')) return 'adaptive';
+        if (filename.includes('launcher_background')) return 'adaptive';
+        if (filename.includes('launcher') || filename.includes('icon')) return 'launcher';
+        if (filename.includes('notification') || filename.includes('ic_stat_')) return 'notification';
+        return 'unknown';
+    }
+
+    /**
+     * Get density from directory name
+     */
+    getDensityFromDir(dirname) {
+        const densities = ['mdpi', 'hdpi', 'xhdpi', 'xxhdpi', 'xxxhdpi', 'nodpi', 'anydpi'];
+        return densities.find(d => dirname.includes(d)) || 'unknown';
+    }
+}
+
+module.exports = IconManager;