DySign: Dynamic Fingerprinting for the Automatic Detection of Android Malware

TL;DR

DySign introduces a novel dynamic analysis-based fingerprinting technique for Android malware, utilizing NLP methods to create resilient, behavior-based signatures that improve detection and family attribution of malware variants.

Contribution

This paper presents DySign, the first fingerprinting method that leverages dynamic analysis and NLP techniques for Android malware detection and family attribution.

Findings

DySign achieves high detection accuracy.

It provides resilience to behavioral variations.

Effective malware family attribution is demonstrated.

Abstract

The astonishing spread of Android OS, not only in smartphones and tablets but also in IoT devices, makes this operating system a very tempting target for malware threats. Indeed, the latter are expanding at a similar rate. In this respect, malware fingerprints, whether based on cryptographic or fuzzy-hashing, are the first defense line against such attacks. Fuzzy-hashing fingerprints are suitable for capturing malware static features. Moreover, they are more resilient to small changes in the actual static content of malware files. On the other hand, dynamic analysis is another technique for malware detection that uses emulation environments to extract behavioral features of Android malware. However, to the best of our knowledge, there is no such fingerprinting technique that leverages dynamic analysis and would act as the first defense against Android malware attacks. In this paper, we address the following question: could we generate effective fingerprints for Android malware through dynamic analysis? To this end, we propose DySign, a novel technique for fingerprinting Android malware's dynamic behaviors. This is achieved through the generation of a digest from the dynamic analysis of a malware sample on existing known malware. It is important to mention that: (i) DySign fingerprints are approximated of the observed behaviors during dynamic analysis so as to achieve resiliency to small changes in the behaviors of future malware variants; (ii) Fingerprint computation is agnostic to the analyzed malware sample or family. DySign leverages state-of-the-art Natural Language Processing (NLP) techniques to generate the aforementioned fingerprints, which are then leveraged to build an enhanced Android malware detection system with family attribution.

Figures

Tables

Table 1. TABLE I: Insight of DySign Android Malware Detection

#	App1	App2	TFIDF Cosine
1	00453ca8 (FakeInst)1	com.BigBawb.coin.apk	0.19
2	00453ca8 (FakeInst)	com.interestcalculator.apk	0.21
3	21262a59 (FakeInst)	com.sleggi.MiFreetime.apk	0.16
4	00453ca8 (FakeInst)	21262a59 (FakeInst)	0.42
5	00453ca8 (FakeInst)	com.sleggi.MiFreetime.apk	0.27

Table 2. TABLE II: Insight of DySign Android Malware Family Attribution

#	Malware1	Malware2	TFIDF Cosine
1	090b5be2 (Plankton)2	bedf51a5 (DroidKungFu)	0.56
2	149bde78 (Plankton)	bedf51a5 (DroidKungFu)	0.46
3	090b5be2 (Plankton)	149bde78 (Plankton)	0.71

Table 3. TABLE III: Android Dataset Description

	Drebin Dataset	Drebin Mixed With Benign
Total Size	3414	8639
Malware	3414	3414
Benign	/	5225

Table 4. TABLE IV: Dataset Description By Malware Family

	Malawre Family	Number of Samples
0	FakeInstaller	866
1	DroidKungFu	611
2	Opfake	566
3	Plankton	515
4	GinMaster	314
5	BaseBridge	295
6	Iconosys	127
7	FakeDoc	120
8	Benign Apps	5225

Table 5. TABLE V: Detection and Attribution Performance of DySign

	F1-Score	Precision	Recall	Time
Mixed (Detection)	85%	94%	78%	4min 45s
Drebin (Attribution)	80%	82%	79%	2min 20s

Equations

$$\text{mbox}tf-idf(w,d)=\text{mbox}tf(w,d)\times \text{mbox}idf(w)$$

$$\text{mbox}tf(w,d)=|w\in d,d=\{w_1,w_2,...w_n\}:w=w_i|$$

$$\text{mbox}idf(w)=log\frac{|D|}{1+|d:w\in d|}$$

$$\text{mbox}cosine-similarity(v_1,v_2)=\text{mbox}cos(\theta )=\frac{v_1\cdot v_2}{||v_1||||v_2||}$$

$$P=\frac{TP}{TP+FP},R=\frac{TP}{TP+FN},F1=2\times \frac{P\times R}{P+R}$$

Full text

I Introduction

The rapid growth in technologies triggers the development and evolvement of mobile devices to enhance both economic and social interactions. Hence, mobile applications (referred to as apps henceforth) running on smart devices are gaining ubiquity due to their convenience. For instance, nowadays users purchase products online and in retail stores at their fingertips using such apps like Apple pay app. However, the growth of the mobile market apps has increased the concerns about apps’ security. Android[1] is one of the most adopted mobile OS in smart devices, especially in the emerging Internet of Things (IoT) world through Brillo [8], an Android-based IoT system. However, this IoT mega-trend makes Android security more crucial than ever before. This is due to the fact that IoT devices are everywhere and control important services in cars[2], TVs[6], watches[7], etc. Consequently, this has motivated malware writers to launch attacks against mobile apps. These attacks may cause direct financial losses or sensitive data leakages since some apps perform monetary transactions using sensitive information such as credit card numbers and passwords. Malware attacks targeting smart devices may also harm IoT devices. This deployment coverage made Android more tempting for cyber-attackers. For example, according to G DATA [10], $1,548,129$ and $2,333,777$ new Android malware were discovered in 2014 and 2015, which represents approximately an average of $4,250$ and $6,400$ new malware per day respectively. Furthermore, about $53$% of malware are SMS Trojans designed to steal funds and personal information from Android-based mobile devices [22].

In this context, it is a desideratum to develop a scalable, efficient, and accurate framework that tackles two distinct problems: (i) Malware detection - distinguishing malicious from benign applications, and (ii) malware family attribution - assigning malware samples to known families.

Problem Statement: In the literature, malware analysis may be categorized into static and dynamic analyses. In static analysis, fingerprints are the first defense line against malware attacks. Two common static analysis techniques are used for fingerprinting Android malware, namely, cryptographic and fuzzy/approximate hashing techniques. Using cryptographic hashes may be easily defeated by the tiniest change in malware Android packaging (APK). The Fuzzy/approximate hashing technique is more resilient to small changes. Moreover, it has the possibility of detecting malware variants produced by APK repacking. On the other hand, dynamic analysis misses a fuzzy fingerprint, similarly to APK file fuzzy fingerprint, that could effectively capture Android malware run-time behaviors instead of APK static content. Dynamic analysis is commonly used to obtain dynamic features that are fed to a classifier to detect Android malware or cluster them according to their families. However, this dynamic analysis process suffers from the following main drawbacks: i) The detection needs an intermediate, which is the learning model, between the dynamic analysis of malicious Android APK and the new app to check its similarity; ii) in most cases, the extracted dynamic features are driven by the malware dataset. Accordingly, we choose features that give the most accurate model. Although these features could fingerprint the malware family of the dataset, it is hard to predict if extracting the same features from other Android malicious apps could fingerprint them. As such, malware or family-agnostic features are needed in order to have a resilient fingerprinting technique; iii) directly using dynamic analysis output to compare between malware dynamic behaviors lacks portability due to the inconsistent sizes of the output. Moreover, there is no defined approach for similarity computation.

The aforementioned drawbacks induce the need for a dynamic analysis based fingerprint with a fixed size to achieve portability and compute similarity between malware dynamic behaviors. Such fingerprint should be agnostic to the malware sample or family. Hence, the fingerprint extraction approach needs to be general enough to cover most of the essential information of the dynamic analysis output in most Android malware. In addition, it needs to be scalable to compute a digest relatively to the known malware and achieve a fast detection decision. To the best of our knowledge, there is no such a fingerprinting technique that abstracts the dynamic analysis in one digest for the purpose of Android malware detection.

Approach Overview: In this paper, we propose a novel fingerprinting approach, namely DySign, which aims at generating a signature that is based on the dynamic analysis of Android malware apps. In particular, the proposed approach aims at achieving the following properties: (i) DySign fingerprints are approximates of the observed behaviors during dynamic analysis so as to achieve resiliency to small changes in the behaviors of future malware variants; (ii) fingerprint computation is agnostic to the analyzed malware sample or family. We choose these properties since they allow our proposed approach DynSign to efficiently detect malware variants and other samples of the same family efficiently. The key idea of DySign lies in the fact that Android malicious apps, such as SMS Trojans, tend to have similar overall dynamic behaviors, which are distinguishable from the behaviors of benign apps. In addition, apps targeted by a given malware tend to share similar behaviors than apps that are targeted by different malware families. In a sandboxing environment, malware runtime behaviors are translated into an analysis report. Therefore, malicious apps with similar behaviors would produce similar analysis reports. In the context of DySign, we leverage the output of Android malware dynamic analysis using sandboxing environments to generate relative fingerprints from the known Android malware apps analysis reports. More precisely, DySign leverages state-of-the-art Natural Language Processing (NLP) techniques to produce the aforementioned fingerprints using the bag of words model in the DySign generation from the analysis reports. Considering the latter as a word makes DySign completely agnostic to the malware sample or family. Furthermore, we leverage DySign to build an enhanced Android malware detection system with family attribution. DySign is evaluated on both real-life malware and benign apps and the obtained results demonstrate high detection and attribution performances.

Contributions: In summary, this paper makes the following contributions:

We introduce DySign, a novel fingerprinting system for automatically generating dynamic fingerprints for dynamic analysis of Android malware apps. 2. 2.

We leverage state-of-the-art of Natural Language Processing (NLP) techniques in order to propose an approach that is resilient to change in the dynamic behaviors of Android malicious apps. 3. 3.

We conduct a large-scale evaluation of DySign using $8,639$ malicious and benign apps. Our evaluation demonstrates that DySign achieves a good detection performance with high scalability.

The remainder of this paper is organized as follows: Section II presents some usage scenarios of DySign. Section III gives a light background on Android OS. Section IV details our methodology. We evaluate DySign in Section V. In Section VI, we discuss the related work. In Section VII, we provide some concluding remarks on this research together with a discussion of future research.

II Usage Scenarios

The main aim of DySign is to generate an approximate fingerprint from the dynamic analysis of malicious apps. The fingerprint is generated with respect to a database of known apps analysis. Our main concern after accuracy is scalability of the fingerprinting since DySign is intended to be the first fingerprint’s defense line, along with static file fuzzy fingerprint, to tackle the overwhelming volume of malicious apps on a daily basis. DySign has two main usage scenarios: i) Mobile OS monitoring: In this scenario, we have a set of installed apps that run in a given smart device (the number of apps could be fixed in the case of an IoT device since it is mono-task with a deterministic goal). Having a runtime report database of the these apps would help DySign to periodically fingerprint the behaviors of these apps in order to check for the existence of abnormal behaviors. In this scenario, DySign could raise an exception of behavior change after a suspicious update or a hack; ii) Cloud service analyzer: In this scenario, DySign is used as a core of cloud checking service of the received analysis reports, either automatically or by user submission, from the Android device of suspicious apps. The goal is to match the runtime analysis against malicious apps. These scenarios are general applications of DySign. However, we believe that it can be extended to many other usages due to the simplicity and scalability of DySign.

III Background

III-A Android Architecture

Android has been settled by Android Open Source Project (AOSP) team, maintained by Google and supported by the Open Handset Alliance (OHA) [13]. It encompasses the Original Equipment Manufacturers (OEMs), chip-makers, carriers and application developers. Android apps are written in Java. However, the native code and shared libraries are generally developed in C/C++ [4]. The typical Android architecture consists of Linux kernel, which is designed for an embedded environment consisting of limited resources. On top of Linux kernel, the native libraries developed in C/C++ support high-performance third-party reusable shared libraries. Moreover, Android apps written in Java are translated into Dalvik bytecode. It is specifically optimized for resource-constrained mobile OS platforms.

III-B Android Threats

Once the app is installed, it may create undesirable consequences for the device security. Following are some examples of malicious activities that have been reported: i) Personal-information leakage occurs when users give dangerous permissions to malicious apps and unknowingly allow access to sensitive data and its exfiltration without user knowledge or consent; ii) malicious apps can also spy on the users by monitoring their voice calls, SMS/MMS, recording audio/video without user knowledge or consent; iii) compromising the device to act as a bot and remotely control it through a server by sending various commands to perform malicious activities.

IV DYSIGN Methodology

IV-A Fingerprint Computation

Our ultimate goal is to automatically fingerprint Android malware based on dynamic analysis. To this end, we use natural language processing techniques, where we consider the output of the dynamic analysis as a plaintext file and model it as a bag of words. The latter treats the text document as a set of words separated by predefined delimiters such as spaces and curly-brackets. Given a set of analysis report bag of words, we compute a relative fingerprint for each report based on the word frequency in one document and the rest. In other words, we distinguish between the reports by giving a high weight to the words with a high frequency in the given report and low frequency in the others. The result is a vector of words’ weights for each analysis report. To compute DySign’s vector, we leverage the so-called Term Frequency-Inverse Document Frequency tf-idf [14], a well-known technique adopted in the fields of information retrieval and natural language processing. The latter computes vectors of inputted text documents by considering both the frequency in the individual documents and in the whole set. Let $D=\{d_{1},d_{2},\ldots,d_{n}\}$ be a set of text documents, where $n$ is the number of documents, and let $d=\{w_{1},w_{2},\ldots,w_{m}\}$ be a document, where $m$ is the number of words in $d$. The tf-idf of a word $w$ and document $d$ is the product of term frequency of $w$ in $d$ and the inverse document frequency of $w$, as shown in Formula 1. The term frequency (Formula 2) is the occurrence number of $w$ in $d$. Finally, the inverse document frequency of $w$ (Formula 3) represents the number of documents $n$ divided by the number of documents that contain $w$ in the logarithmic form. The computation of tf-idf is very scalable, which suites our needs (Section V).

[TABLE]

[TABLE]

[TABLE]

The result of tf-idf is a set of vectors $V=\{v_{1},v_{2},\ldots,v_{n}\}$ (DySign fingerprints) of word weights for each document $d\in D$. Computing the similarity using DySign is straightforward using the cosine similarity as shown in Formula 4.

[TABLE]

How DySign could be used for Android malware detection and family attribution? We answer this question through an illustrating example, in which we compute DySign fingerprints from the analysis reports of malware samples from Drebin malware dataset [17, 40] along with benign apps downloaded from Google Play [11]. The example is summarized in Table I and Table II. How DySign is used for malware detection is illustrated in Table I, where we compute the similarity between malware analysis reports and benign ones. This example shows the potential of DySign in distinguishing between malware and benign apps.

As shown in Table II, DySign could be used to segregate between Android malware families by requiring a higher similarity between the fingerprints of the same malware family. Based on these insights, we generalize and build a system on top of DySign for Android malware detection and family attribution.

How DySign is agnostic to malware samples and families? DySign is agnostic by design since no features are extracted specifically for a given malware family or sample. In other words, DySign considers the analysis report as a bag of words. It only considers the frequency of the word in a document relatively to the other ones. This ensures that the extracted DySign information is broad enough to cover most malware samples and without relying on specific features.

IV-B Architecture Overview

In this section, we present the architecture of DySign framework for Android malware detection, built on top of DySign’s fingerprint. There are two main processes in DySign framework, as depicted in Section 1. i) The first process is building the analysis report database. The initial phase of this process consists of a bulk sandboxing and reports insertion into a database of known Android malware (Algorithm 1). Afterwards, the process proceeds as a continuous task of updating the report’s database with new apps (Algorithm. 2).

ii) The second process is the detection process, in which we check the runtime behaviors of newly received apps against known malware behaviors. First, the new app is executed in a sandboxing environment during a time $T$ to get the analysis report. The latter will be used along with the database reports to compute the DySign fingerprint using tf-idf. Finally, we compute the similarity between the DySign fingerprint of the new app and the existing fingerprints to identify whether it is malicious or not and its family in case it is malicious. The complete DySign process is presented in Algorithm 3. Using DySing’s fingerprint, we do not only detect malware but also attribute the unknown samples to their Android malware families. Further, we can also ascribe a family to the unknown samples if we already have samples of this family in DySign’s dynamic analysis database. Algorithm 3 describes the process of generating a dynamic fingerprint.

A cornerstone in DySign framework is the sandboxing system, which heavily influences the produced analysis reports. We use DroidBox [9], a well-established sandboxing environment based on the Android software emulator [3] provided by Google Android SDK [5]. Running the app may not lead to a sufficient coverage of the executed app. As such, to simulate the user interaction with the apps, we leverage MonkeyRunner [12], which produces random UI actions aiming for a broader execution coverage. However, this makes the app execution non-deterministic since MonkeyRunner generates random actions. Therefore, this yields different analysis reports for every execution, where the accuracy of the results may vary. To tackle this issue, we run the app in a sandboxing environment for a long time $T$ in order to assure the maximum of information in the resulting report. However, a long time $T$ could lead to execution bottleneck since DroidBox can only handle one app at a time. In this context, executing the dataset apps in a sandboxing environment during the initial setup of a reports database is a computation bottleneck in DySign. This is because of the defined time $T$, during which the app needs to run in order to get the analysis report. Hence, the initialization phase could take a very long time (may reach few days). To overcome this challenge, we develop a multi-worker sandboxing environment to exploit the maximum available resources and boost the initialization setup.Another problem is the similarity computation, which could be a bottleneck for the DySign framework and could lead to inefficient matching against new unknown apps. To address this issue, we resort to LSH K-Nearest Neighbor (KNN) [19]. Similarity computation needs to be conducted in an efficient way that is much faster than the brute-force computation. To this end, we leverage Locality Sensitive Hashing (LSH) techniques, and more precisely LSH Forest [19], a tunable high-performance algorithm for similarity computation. The key idea behind LSH Forest is that similar items hashed using LSH are most likely to be in the same bucket (collide) and dissimilar items in different ones as we will explain it in the next Section.

IV-C Locality-Sensitive Hashing

Our system employs Locality-Sensitive Hashing (LSH) for feature reduction [26, 19]. The main idea in LSH is to define a hash function h such that h(s1) = h(s2) if the two sets of chains $s_{1}$ and $s_{2}$ are similar [16]. The hash is calculated over all sets of traces, and only those with similar hash values are clustered (hashed) to the same bucket. In the case of similarity, similar traces will be hashed to the same bucket. In our case, we assume that most dissimilar pairs will never hash to the same bucket, and therefore will never be checked. Once all traces have been hashed to a corresponding bucket, any bucket containing more than one hash value is identified and a list of candidate traces is extracted. Finally, similarity analysis is performed to rank the candidate pairs obtained from the previous steps. To create the signature from traces, we must use one of the hash function pairs. We choose $minhash$ due to its efficiency. When using $minhash$ (with $N$ unique hash functions) as signatures to represent the register chains, LSH can be used by splitting the minhash values into a signature matrix with $b$ bands consisting of $r$ rows each. Depending on the number of used bands, the number of minhash values for a given band will be the number of minhashes divided by the number of bands $(N/\#bands)$. The number of rows will be equal to the number of register chain minhash signatures. Finally, for each band $b$, the minhash values (the portion of one column within that band) are hashed to one bucket of a larger number of buckets.

V Experimental Results

In this section, we present the evaluation results of our proposed system. The implementation subsection shows the setup of our experiments. To evaluate the performance of malware detection using DySign, we use a mixed dataset, i.e., malware and benign apps. As for the evaluation of the attribution performance, we use a malware-only dataset.

V-A Implementation

For modularity purposes, DySign is implemented using separate Python scripts, which altogether form our analytical system. The scripts are used for parsing, cleaning, and tf-idf computation. We develop a multi-sandboxing system on top of DroidBox to be able to execute multiple Android apps simultaneously by leveraging the multicore CPUs to have numerous instances of DroidBox. We also use MonkeyRunner to simulate UI interaction with the user. SQLite has been used to store the features due to its efficiency and ease of use.

V-B DataSet

The first step towards the evaluation of DySign is to select appropriate datasets that can be utilized for Android malware fingerprinting. Obtaining representative datasets is a fundamental challenge, and there is certainly a strong need for standard ones. Hence, the utilized dataset consists of: i) malware-only dataset using the well-known Drebin dataset [17, 40], and ii) mixed dataset using Drebin dataset along with benign apps downloaded from Google Play [11]. Statistics about the dataset are presented in Table  III and Table IV. In TableIII, we use a subset of $3,414$ Android malware samples, from Drebin dataset, distributed on $8$ families IV. From this dataset, we exclude all malware families with only few samples due to the high skewness of the dataset. This would prevent having, for instance, a family with $800$ samples and other families with only 1, 2, or even 20 samples.

V-C Results

To evaluate our approach using the previous datasets, we split the training data into ten sets, reserving one set as a testing set and using nine sets as training sets. We repeat this process numerous times. We use precision (P) and recall (R):

[TABLE]

Detection Performance: Since the application domain targeted by DySign is much more sensitive to false-positives than false-negatives, we employ the F-measure, where the results of $F_{1}$ measure are summarized in Table V. We use two types of datasets: (i) The mixed dataset, used for detection performance assessment, and (ii) the malware-only dataset, used to assess DySign’s family attribution, as shown in Table V. The obtained results show that our approach achieves good detection and attribution performance in short time.

Attribution Performance: Figure 2 presents the confusion matrix for a more granular view of DySign’s family attribution. The darker, in the matrix, is the diagonal, the more accurate is the attribution. However, due to the unbalanced malware families (Table IV), there are some cells in the diagonal that are more darker because of the high number of samples in that family in the testing set. For this reason, we apply the log function on the original confusion matrix to have clearer results. Notice that all the produced results are based on the sandboxing reports of only $T=15s$ for each app whether it is a malware sample or a benign app. Therefore, the accuracy could be significantly improved by having a longer time $T$.

Reports Size Analysis: Figure 3 shows the size distribution of the analysis reports. Figures 3(a) and 3(c) show the size distribution in bytes for benign and malware reports respectively. To enhance the readability of the results, we apply the log function on the byte distributions. The results are shown in Figures 3(b) and 3(d) for benign and malware reports. The most noticeable is the size of the malware comparing with benign reports. Malware reports tend to be bigger than benign ones. This difference happens in a very short time since we execute the apps for only $T=15s$. Our observations show that: i) Malicious apps tend to have similar behaviors and are generally eager to access the resources to perform their malicious tasks as soon as they are executed. ii) Malware apps tend to be self-driving, i.e., in most cases, they do not need UI interaction emulator. Instead, for example, they try to connect to a given IP address with a specific payload .

Accuracy Performance and Dataset Size: Figure 4 shows the effect of the dataset size on the detection and family attribution. It also shows the direct relation between the number of samples in the dataset and the accuracy. The bigger is the dataset, the more accurate are the results. However, we could not test for higher scalability since we are limited by the size of Drebin dataset after excluding small families. According to the obtained results with our limited dataset, we conclude that by having a bigger dataset, DySign framework could achieve more accurate results. We let the validation of such conclusion as future work with much larger datasets.

Scalability Analysis: DySign shows high scalability, as summarized in Figure 5. First, DySign computation time is very fast and linearly scalable with the number of reports. Our system could compute tf-idf from $100,000$ analysis reports in about $200s$, as shown in Figure 5(c). Notice that we over-sample from our dataset in order to get $100,000$ analysis reports used in the scalability evaluation. Figure 5(b) shows the linearity of LSH matching time with the number of reports. Notice that for a $100,000$-report dataset, we match $10,000$ testing reports against $90,000$ reports in the training dataset.

VI Related Work

In this section, we briefly introduce the existing works on Android malware analysis. They are categorized into static [17, 32], dynamic  [15, 23], and hybrid [20, 41].

Static Analysis Approaches: Static analysis techniques perform code disassembling and decompilation without actually running it. This approach is undermined by the use of various code transformation techniques [30]. We may divide static analysis based techniques into the following categories: i) Signature-based analysis: This analysis deals with extracted syntactic pattern features [32, 36, 35], and create a unique signature matching for a particular malware. However, such signature cannot handle new variants of existing known malware. Moreover, the signature database should be updated to handle new variants. AndroSimilar [31] has been proposed to detect zero-day variants of the known malware. It is an automated statistical feature signature-based method. However, it is sensitive due to code transformation methods. ii) Resource-based analysis: The Manifest file contains important meta-data about the components (i.e., activities, services, receivers, etc.) and required permissions. There are some methods that have been proposed to extract such information and subject it to analysis [24, 33]. iii) Permission-based analysis: Discovering the dangerous permission request is not adequate to proclaim a malware app, but nevertheless, permissions mapping requested and used permissions are an important risk identification technique [38, 18].

Dynamic Analysis Approaches. Dynamic analysis techniques allow us to learn malicious activities. Android app execution is event-based with asynchronous multiple entry points. It is important to trigger those events. Dynamic techniques are divided into the following two categories: i) Resources usage based: Some malicious apps may cause Denial of Service (DoS) attacks by over-utilizing the constrained hardware resources. Range of parameters such as CPU usage, memory utilization statistics, network traffic pattern, battery usage and system-calls for benign and malware apps are gathered from the Android subsystem. Automatic analysis techniques along with machine learning techniques are used [39, 37, 25]. ii) Malicious behavior based: It is related to abnormal behaviors such as sensitive data leakage and sending SMS/emails [28, 21, 27, 34].

VII Limitations and Concluding Remarks

We have reported, in this paper, the first investigation of the possibility of using dynamic features for Android malware fingerprinting. DySign leveraged state-of-the-art machine learning and Natural Language Processing (NLP) techniques to produce agnostic fingerprints. The evaluation of DySign on both real-life malware and benign apps demonstrated a good detection and attribution performances with high scalability. Our work has a few limitations though. First, DySign fingerprinting approach is not deterministic, i.e., multiple executions could lead to slightly different fingerprints. However, the core information captured by such fingerprints is the same. Second, DySign detection is limited by the Android malware families in the analysis database, and therefore, it cannot detect malware belonging to new families. We plan to address these limitations in future work. In addition, we suggest exploring the applicability of a hybrid model in our detection system.

Acknowledgements

The authors would like to thank the anonymous reviewers for their insightful comments that allowed us to improve this paper.