utils.py

import os
import subprocess
import xml.etree.ElementTree as ET
import numpy as np
import tempfile
import shutil
from dotenv import load_dotenv

load_dotenv()
apktool_jar_path = os.getenv("APKTOOL_JAR_PATH")

def decompile_apk(apk_path, output_dir):
    """
    Decompile an APK file using apktool
    
    Parameters:
    apk_path (str): Path to the APK file
    output_dir (str): Directory where the decompiled APK will be stored
    
    Returns:
    bool: True if decompilation was successful, False otherwise
    """
    try:
        os.makedirs(output_dir, exist_ok=True)
        result = subprocess.run(
            ["java", "-jar", apktool_jar_path, "d", apk_path, "-o", output_dir, "-f"],
            capture_output=True,
            text=True,
            check=True
        )
        return True
    except subprocess.CalledProcessError as e:
        print(f"Error decompiling APK: {e}")
        print(f"Output: {e.stdout}")
        print(f"Error: {e.stderr}")
        return False
    except Exception as e:
        print(f"Unexpected error: {e}")
        return False

def extract_permissions(decompiled_dir):
    """
    Extract permissions from the AndroidManifest.xml file
    
    Parameters:
    decompiled_dir (str): Directory containing the decompiled APK
    
    Returns:
    list: List of Android permissions found in the manifest
    """
    manifest_path = os.path.join(decompiled_dir, "AndroidManifest.xml")
    permissions = []
    
    try:
        # Parse XML structure of AndroidManifest.xml
        tree = ET.parse(manifest_path)
        root = tree.getroot()
        
        # Define the Android namespace
        android_ns = '{http://schemas.android.com/apk/res/android}'
        
        # Find all permission elements
        for permission_elem in root.findall(".//uses-permission"):
            permission_name = permission_elem.get(f'{android_ns}name')
            if permission_name:
                permissions.append(permission_name)
                
        return permissions
    except Exception as e:
        print(f"Error extracting permissions: {e}")
        return []

def permissions_to_features(permissions, all_permissions):
    """
    Convert a list of permissions to a feature vector
    
    Parameters:
    permissions (list): List of permissions extracted from the APK
    all_permissions (list): List of all possible permissions from the training data
    
    Returns:
    numpy.ndarray: Feature vector with 1 for permissions present, 0 for permissions absent
    """
    # Create a feature vector initialized with zeros then set 1 for permissions that are present
    features = np.zeros(len(all_permissions))
    for i, permission in enumerate(all_permissions):
        if permission in permissions:
            features[i] = 1         
    return features

def process_apk(apk_path, all_permissions):
    """
    Process an APK file to extract features for prediction
    
    Parameters:
    apk_path (str): Path to the APK file
    all_permissions (list): List of all possible permissions from the training data
    
    Returns:
    numpy.ndarray: Feature vector for the APK, or None if processing failed
    """
    temp_dir = tempfile.mkdtemp()    # Create a temporary director to store decompiled APK
    
    try:
        if not decompile_apk(apk_path, temp_dir):
            return None
        
        permissions = extract_permissions(temp_dir)
        features = permissions_to_features(permissions, all_permissions)
        return features
    except Exception as e:
        print(f"Error processing APK: {e}")
        return None
    finally:
        # Clean up the temporary directory
        shutil.rmtree(temp_dir, ignore_errors=True)