def get_apk_info(self):
apk = APK(self.apk_file)
app_icon_file = apk.get_app_icon()
app_icon_data = apk.get_file(app_icon_file)
size = (256, 256)
buffered = BytesIO()
im = Image.open(BytesIO(app_icon_data))
im = im.resize(size, Image.ANTIALIAS)
im.save(buffered, "PNG")
app_icon_b64 = "data:image/png;base64," + base64.b64encode(
buffered.getvalue()).decode('utf-8')
self.package_name = apk.get_package()
self.app_name = apk.get_app_name()
self.report_saver.package_name = self.package_name
self.report_saver.app_name = self.app_name
self.report_saver.version = apk.get_androidversion_code()
self.report_saver.app_icon = app_icon_b64
permission_parser = PermissionParser(mode='groups')
permission_values = permission_parser.transform(
apk.get_permissions()).flatten().tolist()
permission_labels = permission_parser.labels()
self.report_saver.permissions_actual = {
permission_labels[i]: bool(v)
for i, v in enumerate(permission_values)
}
def permission_class_weights(package_names):
permission_parser = PermissionParser('groups')
db = SamplesDatabase.get()
count = np.zeros(shape=permission_parser.count())
for p in package_names:
count += permission_parser.transform(db.read(p, 'permissions'))
weights = len(package_names)/(permission_parser.count() * count)
weights = {i: w for i, w in enumerate(weights)}
return weights
class Generator(keras.utils.Sequence):
def __init__(self,
packages,
shuffle=True,
at_once=False,
verbose=True,
batch_size=None):
self.log = logging.getLogger()
self.batch_size = batch_size or config.Text2PermissionClassifier.batch_size
self.packages = packages
self.at_once = at_once # for validation: no batches, calculate at once
self.permissions_parser = PermissionParser(mode='groups')
self.num_permissions = self.permissions_parser.count()
self.shuffle = shuffle
self.indexes = []
self.db = SamplesDatabase.get()
if verbose:
print("Generator loaded: %d files" % len(self.packages))
self.embedded_samples = EmbeddedSamples.get()
self.on_epoch_end()
def __len__(self):
if self.at_once:
return 1
return int(np.floor(len(self.packages) / self.batch_size))
def __getitem__(self, index):
X, y, _ = self.get_item_and_package(index)
return X, y
def get_item_and_package(self, index):
if self.at_once:
packages_temp = self.packages
else:
indexes = self.indexes[index * self.batch_size:(index + 1) *
self.batch_size]
packages_temp = [self.packages[k] for k in indexes]
X, y, metas = self.__data_generation(packages_temp, True)
return X, y, metas
def __data_generation(self, packages_temp, return_packages=False):
embedding_idx_unknown = PreTrainedEmbeddings.get().get_unknown_idx()
# Initialization
num_samples = len(self.packages) if self.at_once else self.batch_size
X = np.full(
(num_samples,
config.Text2PermissionClassifier.max_description_embeddings),
fill_value=embedding_idx_unknown,
dtype=np.int32)
y = np.empty((num_samples, self.num_permissions), dtype=np.uint8)
packages = []
# Generate data
for i, package in enumerate(packages_temp):
embedding_indices = self.embedded_samples.get_embedded_indices(
package)
X[i, :len(embedding_indices)] = embedding_indices
y[i] = self.permissions_parser.transform(
self.db.read(package, 'permissions'))
packages.append(package)
if return_packages:
return X, y, packages
else:
return X, y
def on_epoch_end(self):
self.indexes = np.arange(len(self.packages))
if self.shuffle:
np.random.shuffle(self.indexes)
self.embedded_samples.on_epoch_end()