apk.py

from db_manager import insert_apk, insert_features
import os
import re


class APK:
    def __init__(self, path: str, dataset: str, malignity: int = None):
        self.manifest_features = ManifestFeatures()
        self.dex_features = DexFeatures()
        self.malignity = malignity
        self.name = self.get_apk_name(path)
        self.path = path
        self.dataset = dataset
        self.score = None

    def set_manifest_features(self, manifest_features):
        if type(manifest_features) == ManifestFeatures:
            self.manifest_features = manifest_features

    def set_dex_features(self, dex_features):
        if type(dex_features) == DexFeatures:
            self.dex_features = dex_features

    def get_apk_name(self, path: str) -> str:
        basename = os.path.basename(path)
        match = re.search(r'([\w.]+)\.apk', path)
        if match:
            return match.group(1)
        return basename

    def save_apk_to_db(self):
        row_id = insert_apk(self)
        if row_id:
            insert_features(self.get_features(row_id))
            pass
        else:
            raise Exception('apk not saved : row_id == None')

    def get_features(self, row_id=None) -> list:
        features = self.get_dex_features().get_features()
        features.extend(self.get_manifest_features().get_features())
        return [
            {'apk_id': row_id,
             'name': feature['feature_name'],
             'type': feature['feature_type']}
            for feature in features
            ]

    @staticmethod
    def get_feature_types():
        feature_types = ManifestFeatures.get_feature_types()
        feature_types.extend(DexFeatures.get_feature_types())
        return feature_types

    def get_dataset(self):
        return self.dataset

    def get_manifest_features(self):
        return self.manifest_features

    def get_dex_features(self):
        return self.dex_features

    def get_name(self):
        return self.name

    def get_malignity(self):
        return self.malignity

    def add_restricted_api(self, api_call):
        self.dex_features.add_restricted_api(api_call)

    def add_suspicious_api(self, api_call):
        self.dex_features.add_suspicious_api(api_call)

    def add_used_permissions(self, permissions):
        self.dex_features.add_used_permissions(permissions)

    def add_url(self, url):
        self.dex_features.add_url(url)

    def add_defined_permissions(self, permissions):
        self.manifest_features.add_permissions(permissions)

    def add_activities(self, activities):
        self.manifest_features.add_activities(activities)

    def add_receivers(self, receivers):
        self.manifest_features.add_receivers(receivers)

    def add_services(self, services):
        self.manifest_features.add_services(services)

    def add_providers(self, providers):
        self.manifest_features.add_providers(providers)

    def add_hardwares(self, hardwares):
        self.manifest_features.add_hardwares(hardwares)

    def add_intents(self, intents):
        self.manifest_features.add_intents(intents)

    def get_path(self):
        return self.path


class DexFeatures:
    RESTRICTED_API = 'restricted_api'
    USED_PERM = 'used_perm'
    SUSPICIOUS_API = 'suspicious_api'
    URL = 'url'

    def __init__(self):
        self.restricted_apis = set()
        self.used_permissions = set()
        self.suspicious_apis = set()
        self.urls = set()
        self.features = {DexFeatures.RESTRICTED_API: self.restricted_apis,
                         DexFeatures.USED_PERM: self.used_permissions,
                         DexFeatures.SUSPICIOUS_API: self.suspicious_apis,
                         DexFeatures.URL: self.urls}

    def get_features(self):
        return [{'feature_type': feature_type,
                 'feature_name': feature_name} for feature_type, feature_set in self.features.items()
                for feature_name in feature_set if len(feature_set) != 0]

    @staticmethod
    def get_feature_types():
        return [DexFeatures.RESTRICTED_API,
                DexFeatures.USED_PERM,
                DexFeatures.SUSPICIOUS_API,
                DexFeatures.URL]

    def get_restricted_apis(self):
        return self.restricted_apis

    def get_used_permissions(self):
        return self.used_permissions

    def get_suspicious_apis(self):
        return self.suspicious_apis

    def get_url(self):
        return self.urls

    def add_restricted_api(self, api: str):
        self.restricted_apis.add(api)

    def add_used_permissions(self, permissions: list):
        self.used_permissions.update(permissions)

    def add_suspicious_api(self, api: str):
        self.suspicious_apis.add(api)

    def add_url(self, url: str):
        self.urls.add(url)


class ManifestFeatures:
    DEFINED_PERM = 'defined_perm'
    HARDWARE = 'hardware'
    INTENT = 'intent'
    ACTIVITY = 'activity'
    RECEIVER = 'receiver'
    SERVICE = 'service'
    PROVIDER = 'provider'

    def __init__(self):
        self.permissions = set()
        self.hardware = set()
        self.intents = set()
        # app components
        self.activities = set()
        self.receivers = set()
        self.services = set()
        self.providers = set()

        self.features = {ManifestFeatures.DEFINED_PERM: self.permissions,
                         ManifestFeatures.HARDWARE: self.hardware,
                         ManifestFeatures.INTENT: self.intents,
                         ManifestFeatures.ACTIVITY: self.activities,
                         ManifestFeatures.RECEIVER: self.receivers,
                         ManifestFeatures.SERVICE: self.services,
                         ManifestFeatures.PROVIDER: self.providers}

    def get_features(self):
        return [{'feature_type': feature_type,
                 'feature_name': feature_name} for feature_type, feature_set in self.features.items()
                for feature_name in feature_set if len(feature_set) != 0]

    @staticmethod
    def get_feature_types():
        return [ManifestFeatures.DEFINED_PERM, ManifestFeatures.HARDWARE, ManifestFeatures.INTENT,
                ManifestFeatures.ACTIVITY, ManifestFeatures.RECEIVER,
                ManifestFeatures.SERVICE, ManifestFeatures.PROVIDER]

    def get_activities(self):
        return self.activities

    def get_receivers(self):
        return self.receivers

    def get_services(self):
        return self.services

    def get_providers(self):
        return self.providers

    def get_hardware(self):
        return self.hardware

    def get_intents(self):
        return self.intents

    def get_permissions(self):
        return self.permissions

    def add_permissions(self, permissions):
        self.permissions.update(permissions)

    def add_hardwares(self, hardwares):
        self.hardware.update(hardwares)

    def add_intents(self, intents):
        self.intents.update(intents)

    def add_activities(self, activities):
        self.activities.update(activities)

    def add_receivers(self, receivers):
        self.receivers.update(receivers)

    def add_services(self, services):
        self.services.update(services)

    def add_providers(self, providers):
        self.providers.update(providers)