Evading Classifiers by Morphing in the Dark

TL;DR

This paper introduces a novel blackbox evasion attack method called EvadeHC that effectively bypasses classifiers with minimal information, demonstrating high success rates on PDF malware detectors and applicable across domains.

Contribution

The paper proposes a new evasion technique that operates with limited classifier information and introduces a scoring mechanism to guide attacks in dark conditions.

Findings

Achieved 100% evasion rate on tested malware detectors.

Outperformed existing classifier evasion techniques based on classifier scores.

Demonstrated domain-agnostic applicability of the approach.

Abstract

Learning-based systems have been shown to be vulnerable to evasion through adversarial data manipulation. These attacks have been studied under assumptions that the adversary has certain knowledge of either the target model internals, its training dataset or at least classification scores it assigns to input samples. In this paper, we investigate a much more constrained and realistic attack scenario wherein the target classifier is minimally exposed to the adversary, revealing on its final classification decision (e.g., reject or accept an input sample). Moreover, the adversary can only manipulate malicious samples using a blackbox morpher. That is, the adversary has to evade the target classifier by morphing malicious samples "in the dark". We present a scoring mechanism that can assign a real-value score which reflects evasion progress to each sample based on the limited information available. Leveraging on such scoring mechanism, we propose an evasion method -- EvadeHC -- and evaluate it against two PDF malware detectors, namely PDFRate and Hidost. The experimental evaluation demonstrates that the proposed evasion attacks are effective, attaining $100\%$ evasion rate on the evaluation dataset. Interestingly, EvadeHC outperforms the known classifier evasion technique that operates based on classification scores output by the classifiers. Although our evaluations are conducted on PDF malware classifier, the proposed approaches are domain-agnostic and is of wider application to other learning-based systems.

Equations

$$m_{\mathbf{x}}$$

$$r_{\mathbf{x}}$$

$$g_{\mathbf{x}}=r_{\mathbf{x}}-m_{\mathbf{x}}.$$

$$N_d=N_t=N_m=N_r\cdot L$$

$$N_d=N_r,N_t\le N_r\lceil {\log }_{2}L\rceil ,N_m=N_r\cdot L$$

$${\mathtt{score}}_1(m_{\mathbf{x}},r_{\mathbf{x}})=m_{\mathbf{x}}-r_{\mathbf{x}},{\mathtt{score}}_2(m_{\mathbf{x}},r_{\mathbf{x}})=m_{\mathbf{x}}/r_{\mathbf{x}}.$$

$$(a-\alpha ,b-\beta )$$

Full text

Evading Classifiers by Morphing in the Dark

Hung Dang, Yue Huang, Ee-Chien Chang

School of Computing

  

National University of Singapore

Abstract

Learning-based systems have been shown to be vulnerable to adversarial data manipulation attacks. These attacks have been studied under assumptions that the adversary has certain knowledge of either the target model internals, its training dataset or at least classification scores it assigns to input samples. In this paper, we investigate a much more constrained and realistic attack scenario that does not assume any of the above mentioned knowledge. The target classifier is minimally exposed to the adversary, revealing on its final classification decision (e.g., reject or accept an input sample). Moreover, the adversary can only manipulate malicious samples using a blackbox morpher. That is, the adversary has to evade the target classifier by morphing malicious samples “in the dark”. We present a scoring mechanism that can assign a real-value score which reflects evasion progress to each sample based on limited information available. Leveraging on such scoring mechanism, we propose a hill-climbing method, dubbed EvadeHC, that operates without the help of any domain-specific knowledge, and evaluate it against two PDF malware detectors, namely PDFrate and Hidost. The experimental evaluation demonstrates that the proposed evasion attacks are effective, attaining $100\%$ evasion rate on our dataset. Interestingly, EvadeHC outperforms the known classifier evasion technique that operates based on classification scores output by the classifiers. Although our evaluations are conducted on PDF malware classifier, the proposed approaches are domain-agnostic and is of wider application to other learning-based systems.

1 Introduction

Machine learning techniques have witnessed a steady adoption in a wide range of application domains such as image classification [32] or natural language processing [34]. Various learning-based systems have been reported to achieve high accuracy, even surpassing human-level performance [15, 27]. Given the assumption that the training datasets are representative, these systems are expected to perform well in reality on operational data.

Learning methods have also lent itself to security tasks. Numerous innovative applications of machine learning in security contexts, especially for detection of security violations, have been discussed in the literature [29, 19, 22]. However, when learning-based systems are deployed for security applications, their accuracy may be challenged by intentional noise and deviations. Various studies [7, 12, 11] suggest that they are likely susceptible to adversarial data manipulation, for the assumption on representativeness of the training datasets no longer holds true in the presence of malicious adversaries. For example, a motivated attacker may be able to morph a malicious instance so that it resembles a benign instance found in the training datasets, evading the existing learning-based classifier.

Several works have studied evasion attacks against learning-based systems, making different assumptions on the amount of knowledge the adversaries have about the system they are attacking. For examples, Šrndic et al. [31] and Sharif et al.[25] studied attack scenarios wherein the adversaries have a high level of knowledge about the internals of the target system (e.g., features space and classification algorithm). Xu et al. [35] investigated a more constrained evasion scenario in which the adversaries only have black-box accesses to the target detector that outputs a real-value classification score for an input sample111Although the approach treats the detector as a blacbox, it still makes use of some feature property. Specifically, the approach exploited a property that a sequence of morphing steps which work for one malicious sample is likely to work for others to accelerate the evasion.. While the evasion attacks are effective in the presence of the required auxiliary information, the authors of [35] suggested that a simple preventive measure of hiding the classification score would be sufficient to thwart their attacks. Thus, it remains a question how these attacks operate against blackbox systems deployed in reality (e.g., malware detector built-in to email services), for they are unlikely to reveal real-value scores, but rather expose only the final decisions (e.g., reject or accept a sample).

In this work, we study the problem of classifier evasion in the dark, investigating an evasion scenario that is much more constrained and realistic than the ones considered in existing works [35, 31, 26]. In particular, we consider a very restricted setting in which the adversary does not have any knowledge about the target system (e.g., model internals and training dataset). Moreover, the target system only reveals its final decision instead of a real-value score that reflects its internal state. We further assume that the only feasible mean to manipulate the samples is through some given tools that perform “random” morphing.

To this end, we formulate a model that captures the above-mentioned restricted setting. Under this model, the adversary is confined to three blackboxes, a binary-output detector (or classifier) that the adversary attempts to evade, a tester that checks whether a sample possesses malicious functionality, and a morpher that transforms the samples. The adversary’s goal is to, given a malicious sample, adaptively queries the blackboxes to search for a morphed sample that evades detection, and yet maintains its malicious functionality.

We show that under this constrained setting with only blackbox accesses, learning-based systems are still susceptible to evasion attacks. To demonstrate feasibility of effective evasion attacks, we present an evasion method, dubbed EvadeHC, which is based on hill-climbing techniques. The main component of EvadeHC is a scoring mechanism that assigns real-value score to the sample based on the binary outcomes obtained from the tester and detector. The intuition is to measure the number of morphing steps required to change the detector and tester’s decisions, and derive the score based on these values. We believe that this scoring mechanism can be used to relax the assumption on the availability of real-value scores that other settings [20, 26, 35] make.

We evaluate the proposed evasion technique on two well-known PDF malware classifiers, namely PDFrate [28] and Hidost [30]. In order to enable a fair basis for benchmarking with previous work, we adopt the dataset that is used by Xu et al. [35] in our experiments. This dataset consists of $500$ malicious samples chosen from the Contagio archive [6]. We first compare EvadeHC against a baseline solution which keeps generating random morphed samples and checking them against the tester and detector until an evading sample is found. Empirical results show that EvadeHC attains $100\%$ evasion rate on the experimental dataset, and outperforms the baseline solution by upto $80$ times in term of execution cost. Further, we also experiment on a hypothetical situation wherein the classifiers are hardened by lowering the classification thresholds (i.e., decreasing false acceptance rate at a cost of increasing false rejection rate), benchmarking EvadeHC against the state-of-the-art method in evading blackbox classifiers [35]. The results strongly demonstrate the robustness of EvadeHC. For instance, when the threshold of Hidost is reduced from [math] to $-0.75$ and the number of detector queries is bounded at $2,500$, EvadeHC attains an evasion rate of as high as $62\%$, in comparison with $8\%$ by the baseline. We also compare EvadeHC with the technique by Xu et al. [35] that uses real-value classification scores during evasion. Interestingly, even with only access to binary outputs of the detector, our approach still outperforms the previous work. While this may appear counter-intuitive, we contend that this result is in fact expected. We believe the reasons are two folds. First, EvadeHC is capable of incorporating information obtained from both the tester and detector, as opposed to previous work relying solely on the classification scores output by the detector. Secondly, the fact that the detector can be evaded implies the classification scores are not a reliable representation of the samples’ maliciousness.

*Contributions. * This paper makes the following contributions:

We give a formulation of classifier evasion in the dark whereby the adversary only has blackbox accesses to the detector, a morpher and a tester. We also give a probabilisitic model HsrMopher to formalise the notion that no domain-specific knowledge can be exploited in the evasion process. 2. 2.

We design a scoring function that can assign real-value score reflecting evasion progress to samples, given only binary outcomes obtained from the detector and tester. We believe that this scoring mechanism is useful in extending existing works that necessitate classification scores or other auxiliary information to operate under a more restricted and realistic setting like ours. 3. 3.

Leveraging on the scoring function, we propose an effective hill-climbing based evasion attack EvadeHC. This algorithm is generic in the sense that it does not rely on any domain-specific knowledge of the underlying morphing and detection mechanisms. 4. 4.

We conduct experimental evaluation on two popular PDF malware classifiers. The empirical results demonstrate not only the efficiency but also the robustness of EvadeHC. More notably, it is also suggested that the scoring mechanism underlying EvadeHC is more informative than the one that only relies on classification scores [35].

The rest of the paper is structured as follows. We formulate the problem and discuss its related challenges in Section 2 before proposing our evading methods in Section 3. Next, we formalize our proposed approach by presenting probabilistic models in Section 4 and report the experimental evaluation in Section 5. We discuss the implications of our evasion attacks and their mitigation strategies in Section 6. We survey related works in Section 7 before concluding our work in Section 8.

2 Problem formulation

In this section, we define the problem of classifier evasion in the dark and discuss its related challenges. Prior to presenting the formulation, we give a running example to illustrate the problem and its relevant concepts.

2.1 Motivating Scenario

Let us consider an adversary who wants to send a malware over email channel to a victim. The adversary chooses to embed the malware in a PDF file, for the victim is more willing to open a PDF file than other file formats. Most email service providers would have built-in malware detection mechanisms scanning users’ attachments. Such malware detection mechanism is usually a classifier that makes decision based on some extracted features, with a classification model trained using existing data. We assume the adversary does not have any knowledge about the detector that the email service provider employs (i.e., the algorithms and feature space adopted by the classifier). Nevertheless, the adversary probes the detector by sending emails with the malicious payload to an account owned by the adversary, and observing the binary responses (accept/reject) from the email server. Further, the adversary could adaptively modify his malicious PDF file to search for a PDF file that evades detection. However, we assume that the adversary could only probe the email server’s detector a limited number of times before it is blacklisted.

The adversary expects that its malicious file will be rejected by the detector. To evade detection, it has access to two tools: a morphing tool that transforms the PDF sample, and a sandboxing tool that tests whether the sample maintains its malicious functionalities. For instance, the morphing tool may insert, delete or replace objects in an underlying representation of the file, and the sandboxing tool dynamically detects whether the malicious PDF sample causes the vulnerable PDF reader to make certain unexpected system calls. Due to its insufficient understanding of the underlying mechanism to manipulate the PDF sample, the adversary employs the morphing tool as a blackbox. Furthermore, due to the complexity of the PDF reader, the adversary does not know whether a morphed PDF sample will retain its functionality, and the only way to determine that is to invoke the sandbox test.

Given such limitations on the knowledge of both the detector and morphing mechanism, we want to investigate whether effective attacks are still possible. To capture such constrained capability, our formulation centres on the notion of three blackboxes: a binary-outcome detector $\mathcal{}D$ that the adversary wants to evade, a morpher $\mathcal{}M$ that “randomly” yet consistently morphs the sample, and a tester $\mathcal{}T$ that checks the sample’s functionality.

2.2 Tester $\mathcal{}T$, Detector $\mathcal{}D$ and Evasion

The tester $\mathcal{}T$, corresponding to the sandbox in the motivation scenario, declares whether a submitted sample $x$ is malicious or benign. $\mathcal{}T$ is deterministic in the sense that it will output consistent decisions for the same sample.

The blackbox detector $\mathcal{}D$ also takes a sample $x$ as input, and decides whether to accept or to reject the sample. $\mathcal{}D$ corresponds to the malware classifier in the motivating scenario. Samples that are rejected by the detector are those that are classified by the detector to be malicious. It is possible that a sample $x$ declared by $\mathcal{}T$ to be malicious is accepted by $\mathcal{}D$. In such case, we say that the sample $x$ evades detection. Of course, if the detector is exactly the same as the tester, evasion is not possible. In fact, the main objective of our work is to study the security of detectors with imperfect accuracy. Similar to $\mathcal{}T$, we consider detectors that are deterministic (i.e., their output is always the same for the same input).

We highlight that, in our formulation, the detector’s output is binary (e.g., accept/reject), as opposed to many previous works (e.g., [31, 35]) which assume real-value outputs.

2.3 Morpher $\mathcal{}M$

The morpher  $\mathcal{}M$ takes as input a sample $x$ and a random seed $s$, and deterministically outputs another sample $\widetilde{x}$. We call such action a morphing step. The morpher  corresponds to the morphing mechanism described in the motivating scenario. The random seed $s$ supplies the randomness required by the morpher. We are not concerned with the representation of the random seed $s$, and for simplicity, treat it as a short binary string.

Starting from a sample $x_{0}$, the adversary can make successive calls to $\mathcal{}M$, say with a sequence of random seeds ${\bf s}=\langle s_{1},s_{2},\ldots,s_{L}\rangle$, to obtain a sequence of samples ${\bf x}=\langle x_{0},x_{1},x_{2},\ldots,x_{L}\rangle$, where $x_{i}={\mathcal{}M}(x_{i-1},s_{i})$. Let us call $({\bf x},{\bf s})$ a path with starting point $x_{0}$, endpoint $x_{L}$, and path length $L$. When it is clear from the context, we shall omit ${\bf s}$ in the notation, and simply refer to the path by ${\bf x}$.

The formulation does not dictate how the morphing is to be carried out. The adversary can exploit useful properties of the application domain to manipulate the samples. For instance, the adversary may be able to efficiently find a morphing path connecting two given samples, or know how to merge two morphing paths to attain certain desirable property. Nevertheless, such domain specific properties are not always available in general. In Section 4, we propose a probabilistic model of “random” morphing to capture the restriction that no underlying useful properties can be exploited in manipulating the samples.

2.4 Adversary’s Goal and Performance Cost

Given a malicious sample $x_{0}$, the goal of the adversary is to find a sample that evades detection with minimum cost. We call a sample evading if it is accepted by the detector $\mathcal{}D$, but exhibits malicious behaviours as perceived by the tester $\mathcal{}T$. If the given sample $x_{0}$ is already evading, then the adversary has trivially met the goal. Otherwise, the adversary can call the morpher ${\mathcal{}M}$ to obtain other samples, and check the samples by issuing queries to ${\mathcal{}T}$ and ${\mathcal{}D}$.

Let $N_{d},N_{t}$, and $N_{m}$ be the number of queries the adversary sent to ${\mathcal{}D}$, ${\mathcal{}T}$ and ${\mathcal{}M}$ over the course of the evasion, respectively. We are interested in scenarios where $N_{d}$ is a dominating component in determining the evasion cost. In the motivating scenario, the detector can only be accessed remotely and the email server (who is the defender) imposes a bound on the number of such accesses.

While the adversary could freely access the tester, its computational cost might be non-trivial. For instance, in the motivating scenario, computationally intensive dynamic analysis is required to check the functionality. In our experiments, each such test takes around $45$ seconds on average. Morphing, on the other hands, is less computationally expensive. Hence, it is reasonable to consider an objective function where $N_{t}$ carries significantly more weight than $N_{m}$.

A possible optimisation model is to minimise some cost function (e.g., $N_{d}+0.5N_{t}+0.01N_{m}$). Alternatively, we could consider constrained optimisation that imposes a bound on $N_{d}$, while minimising a cost function involving the other two measurements (e.g., $N_{t}+0.02N_{m}$). Since cost functions depend on application scenarios, we do not attempt to tune our algorithm to any particular cost function. Instead, we design search strategies with a general objective of minimising $N_{d}$, followed by $N_{t}$ and $N_{m}$.

2.5 Flipping Samples and Gap

Let us consider a typical path ${\bf x}=\langle x_{0},x_{1},\ldots,x_{L}\rangle$ in which $x_{0}$ is malicious and rejected while $x_{L}$ is benign and accepted. Somewhere along the path, the samples turn from malicious to benign, and from rejected to accepted. Starting from $x_{0}$, let us call the first sample that is benign the malice-flipping sample, and the first accepted sample the reject-flipping sample (see Figure 1). Let $m_{\bf x}$ and $r_{\bf x}$ be the respective number of morphing steps from $x_{0}$ to reach the malice-flipping sample and reject-flipping sample. That is,

[TABLE]

We call $m_{\bf x}$ the malice-flipping distance, and $r_{\bf x}$ the reject-flipping distance. We further define by $g_{\bf x}$ the gap between $m_{\bf x}$ and $r_{\bf x}$:

[TABLE]

The value of $g_{\bf x}$ is of particular interest. If $g_{\bf x}<0$, then the reject-flipping sample is still malicious, and therefore is an evading sample.

It typically requires special crafting to embed an exploit in a malicious sample. Thus, it is expected that once a sample has turned to being benign, it is unlikely to regain the malicious functionality via random morphing. Similar assumption can be made about samples flipping from being accepted to rejected, for the features that the classifiers are trained to identify as grounds for making classification decision are unlikely to be formed via random morphing. Thus, we make an assumption that once a sample has flipped from being malicious (or rejected) to benign (or accepted), it would not be morphed to malicious (or rejected) again.

2.6 Challenges in Evasion in the Dark

There are two main challenges in evasion with the limited blackbox accesses. Firstly, the detector $\mathcal{}D$ only provides a binary output of accept/reject. Hence, from a set of malicious samples, it is not clear which is “closer” to an evading sample. Previous works such as [35] assume that $\mathcal{}D$ returns a real-value confidence level, based on which the evasion is guided. Nevertheless, in practice, a more cautious detector might not reveal any information other than its final decision.

Secondly, the blackbox morpher $\mathcal{}M$ alone does not provide flexibility in manipulating the samples. To illustrate, consider the situation where the adversary has a malicious sample $x_{0}$, and another sample $x_{1}$ that losses its malicious functionality and being accepted by the detector. Intuitively, one could construct another sample $\hat{x}$ from $x_{1}$ and $x_{0}$ that has higher chance of evasion. With only blackbox accesses to $\mathcal{}M$, it is challenging to construct such $\hat{x}$. One possible way is to find a sample that lays somewhere in-between a path that starts from $x_{1}$ and ends at $x_{0}$. However, it is not clear how to efficiently find a morphing path that connects the two given samples. Even if it is possible to connect them, there is still a fundamental question on whether samples along the path have higher chance of evasion.

3 Proposed Evasion Methods

In this section, we present evasion methods that search for evading samples given a malicious sample that is rejected by the detector. For clarity of exposition, we first start with a trivial exhaustive search algorithm SeqRand which serves as the baseline for evaluation. We then optimize SeqRand to reduce its operation costs (i.e., number of queries issued to $\mathcal{}D$ and $\mathcal{}T$), obtaining BiRand. Next, we propose a hill-climbing based algorithm ${\tt EvadeHC}_{0}$ and finally present our main evasion approach EvadeHC that further reduces the number of detector’s queries.

3.1 Evasion by Exhaustive Search SeqRand

On a malicious sample $x_{0}$ which is rejected by $\mathcal{}D$, SeqRand operates by successively morphing $x_{0}$ and checking the morphed samples against $\mathcal{}D$ and $\mathcal{}T$ until an evading sample is found. SeqRand is parameterised by a single threshold $L$ and proceeds as follows:

Choose a sequence of $L$ random seeds ${\bf s}=\langle s_{1},s_{2},\ldots,s_{L}\rangle$. 2. 2.

For each seed $s_{i}$ in ${\bf s}$, obtain a morphed sample $x_{i}$ by invoking ${\mathcal{}M}(x_{i-1},s_{i})$. Check $x_{i}$ against $\mathcal{}D$ and $\mathcal{}T$, if it is evading, output $x_{i}$ and halts. Otherwise continue until $\bf s$ is consumed. 3. 3.

If ${\bf s}$ has been consumed and an evading sample has not been found, repeat step 1 to 3 until an evading sample is found.

Let $N_{r}$ be the number of iterations SeqRand executed when the search halts. It is easy to see that the numbers of queries issued to $\mathcal{}D$, $\mathcal{}T$ and $\mathcal{}M$ are the same:

[TABLE]

3.2 Evasion by Binary Search BiRand

The baseline approach SeqRand can be improved in various ways. One straight-forward enhancement is to reduce the number of detector queries issued in each path. In particular, one does not need to invoke $\mathcal{}D$ after every morphing step, but rather submit only the sample preceding the malice-flipping sample (e.g., $x_{3}$ in Figure 1a and $x_{4}$ in Figure 1b) to the detector. Further, one can also reduce the number of tester queries in searching for the malice-flipping samples by employing binary search in place of a series of sequential check as in the baseline.

The algorithm BiRand, on an input $x_{0}$ which is malicious and rejected by $\mathcal{}D$, carries out the following:

Choose a sequence of $L$ random seeds ${\bf s}$, and invoke $\mathcal{}M$ successively with $s$ (starting from $x_{0}$) to obtain a path ${\bf x}$ of length $L$. 2. 2.

Find the malice-flipping sample $\tilde{x}$ in the path using binary-search with the tester ${\mathcal{}T}$. Let $\hat{x}$ be the immediate predecessor of $\tilde{x}$ on the path (i.e., $\hat{x}$ is malicious). 3. 3.

If $\hat{x}$ is accepted by the detector ${\mathcal{}D}$, output $\hat{x}$ and halt; otherwise repeat step 1 to 3.

Similar to SeqRand, BiRand is also parameterised by a single threshold $L$. The parameter $L$ is set to be sufficiently large such that with high probability, $L$ morphing steps would turn $x_{0}$ from malicious to benign. In our experiments, $L$ ranges from $50$ to $80$.

Number of Queries.

We note that the number of paths BiRand traverses in finding evading samples is the same as the number of iterations taken by SeqRand, hence they incur the same number of morphing steps. On the other hand, BiRand requires less queries to $\mathcal{}D$ and $\mathcal{}T$. In particular, determining the malice-flipping sample on each path (step 2) incurs at most $\lceil\log_{2}L\rceil$ queries to ${\mathcal{}T}$, and there is only one query to the detector ${\mathcal{}D}$ per each path (step 3). In sum, we have:

[TABLE]

Note that the determination of the flipping samples is designed to minimise the number of queries to $\mathcal{}D$. In the scenario where $N_{t}$ imposes a larger cost than $N_{d}$, the algorithm can be modified so that the binary searches are conducted on $\mathcal{}D$, finding reject-flipping samples. It then tests the candidates against $\mathcal{}T$, incurring only one query to $\mathcal{}T$ per each path.

Robustness of Binary Search.

The binary search significantly reduces $N_{t}$ compared to the linear scan. As discussed earlier, we make an implicit assumption that once a sample has become benign (or accepted), it is highly unlikely that $\mathcal{}M$ will morph it to malicious (or rejected) again. Nevertheless, if such event happens, the binary-search may return a wrong flipping sample. Fortunately, the effect of such failure is confined to the path in question, and does not affect other paths.

We can further improve the efficiency of the evasion by incorporating information obtained from $\mathcal{}D$ and $\mathcal{}T$ in a heuristic which “guides” the evasion. To this end, we propose a hill-climbing algorithm, dubbed ${\tt EvadeHC}_{0}$.

3.3 Evasion by Hill-Climbing ${\tt EvadeHC}_{0}$

${\tt EvadeHC}_{0}$ is parameterised by two pre-determined integers $q_{1}$, $q_{2}$, a pre-determined real-value jump factor $0<\Delta<1$ and a scoring function. The algorithm proceeds in iterations, maintaining a set $S$ of $q_{2}$ candidates over the iterations (in the first iteration, $S$ contains the given malicious samples $x_{0}$). In each iteration, ${\tt EvadeHC}_{0}$ first generates $q_{1}$ random paths with starting points originating from $S$. If any of the paths contains an evading sample, the algorithm outputs it and halts. Otherwise, a new candidate, determined by the jump factor $\Delta$, is chosen from each path, and a real-value score is computed for each new candidate using the scoring function. The scoring function takes as inputs the flipping distances of the path. Finally, $q_{2}$ candidates with the highest score are retained for the next iteration.

Details of each iteration are as follow:

For each sample $x$ in $S$, generates $\lfloor{q_{1}}/|S|\rfloor$ random paths with $x$ as starting point, obtaining approximately $q_{1}$ paths. Let $P$ be the set of generated paths. Reset $S$ to empty set. 2. 2.

For each path ${\bf x}\in{P}$, performs the following:

1. (a)

Find the malice-flipping distance $m_{\bf x}$ using binary search. 2. (b)

Find the reject-flipping distance $r_{\bf x}$ using binary search. If $m_{\bf x}>r_{\bf x}$, output the reject-flipping sample and halt (i.e., an evading sample is found). 3. (c)

Let $\widehat{x}$ be the sample along ${\bf x}$ at a distance of $\lfloor\Delta m_{\bf x}\rfloor$ morphing steps from the starting point. Compute the score $s={\tt score}(m_{\bf x},r_{\bf x})$, and associate the sample $\widehat{x}$ with the score $s$. Insert $\widehat{x}$ into ${S}$. 3. 3.

Keep $q_{2}$ samples with the largest scores in $S$, and discard the rest .

Scoring function.

A crucial component is the scoring function score. Two possible choices of the scoring function are based on difference or relative ratio of the two flipping distances:

[TABLE]

Next, we present an improved version of ${\tt EvadeHC}_{0}$, called EvadeHC, that employs a branch-and-bound technique to further reduces the number of required detector queries.

3.4 Enhanced Evasion by Hill-Climbing EvadeHC

Recall that in ${\tt EvadeHC}_{0}$, a complete binary search is carried out on each path (Step 2(b)) to find a reject-flipping distance $r_{\bf x}$. Thus, it requires $q_{1}$ binary searches with the detector $\mathcal{}D$ to find the best $q_{2}$ candidates in each iteration. EvadeHC, on the other hands, performs a single binary search to find a score $\hat{S}$ such that exactly $q_{2}$ candidates have scores greater than $\hat{S}$.

Specifically, the binary search takes in a set of paths $P$ as input. We assume that the malice-flipping distance of each path in $P$ is already determined. Let $\hat{S}$ be the target score, and $\hat{P}$ be the target set of paths that attains scores greater than $\hat{S}$. EvadeHC searches for $\hat{S}$ and $\hat{P}$ in a single binary search, while maintaining a set of candidate paths $C$ which is initially set to be $P$.

We now describe a step in the binary search that determines whether the target $\hat{S}$ is greater than a testing value $S_{0}$.

For each path ${\bf x}$ in $C$, carry out the following:

1. (a)

Determine the smallest reject-flipping distance $r_{\bf x}$ such that the score is greater than $S_{0}$. This does not require any query since the malice-flipping distance is known. 2. (b)

Check whether this path attains a score larger than $S_{0}$. This is achieved by querying $\mathcal{}D$, with the sample at distance $r_{\bf x}$ from the starting point. If the sample is accepted, then the score is greater than $S_{0}$. 2. 2.

If the total number of paths attaining score greater than $S_{0}$ is more than $q_{2}$, then $\hat{S}$ must be larger than $S_{0}$. Discard all paths whose score is lower than $S_{0}$, and recursively search on the upper half of $S_{0}$. 3. 3.

Otherwise, $\hat{S}$ must be smaller than $S_{0}$, and all paths with score higher than $S_{0}$ must be in $\hat{P}$. Remove them from $C$ and recursively search on the lower half of $S_{0}$ for the remaining paths.

The applicability of this reduction depends on the choice of scoring function. It is applicable as long as the scoring function is decreasing with respect to the reject-flipping distance $r_{\bf x}$, which is the case for our choices of scoring functions ${\tt score}_{1}$ and ${\tt score}_{2}$.

Similar to BiRand, the binary search is designed to reduce $N_{d}$. If queries to the tester are more expensive than the detector’s queries, we can swap and apply the binary search on the malice-flipping distances, and thus reducing $N_{t}$ instead.

Parameters $q_{1},q_{2},\Delta$.

Figure 2 illustrates the searching process. Intuitively, a larger $q_{1}$ would improve accuracy of going toward the right direction while a larger $q_{2}$ would increase the robustness by recovering from local minimum, and a larger jump factor $\Delta$ could reduce the number of iterations in good cases. Nevertheless, excessively large parameters might not increase the effectiveness of the search but rather incurs unnecessarily expensive performance cost. We examine in further details the effect of these parameters on the performance of EvadeHC in our experiments (Section 5).

4 Probabilistic Models

In this section, we explain the intuition behind the design of the proposed EvadeHC. In general, for searching to make sense, each sample should have a score-value for the underlying “state”. We first give a way to assign a real-value state (which is also the score) to a sample based on the binary outcomes of $\mathcal{}T$ and $\mathcal{}D$ (“accept” versus “reject” and “malicious” versus “benign”). Next, we propose a hidden state model to capture the notion that the morphing process is seemingly random.

4.1 States Representation

Given a sample $x$, we have 4 possible states from the binary outcomes of $\mathcal{}T$ and $\mathcal{}D$. A searching strategy generally needs to select the “best” candidate from a given set of samples, and this 4-state representation alone would not provide meaningful information for selection.

Our main idea is to, ideally, assign the probability that a random path (generated by the morpher) starting from $x$ has a reject-flipping sample that is malicious222An alternative choice is to consider the probability that a random path has an evading sample. However, this choice is not suitable, since an arbitrary long path is likely to have an evading sample..

Evading Probability as the state.

Given a starting point $x$, let $M_{x}$ be the random variable of the malice-flipping distance on random path. Recall that the random paths arise from sequences of random seeds. Likewise, let $R_{x}$ and $G_{x}$ be the random variable of the reject-flipping distance and the gap respectively. It is not necessary that $M_{x}$ and $R_{x}$ are independent. Indeed, one would expect that they are highly positively correlated, since the detector attempts to detect malicious functionality. We shall revisit this later in Section 5. At this points, readers can refer to Figure 10 for an intuition. The figure depicts flipping distances of $500$ morphed samples originating from the same malware (Pearson correlation coefficient is $0.34$).

For a sample $x$, let us assign the probability $\Pr(G_{x}<0)$ as its state. Recall that a path with negative gap implies that its reject-flipping sample is malicious and thus is an evading sample. In other words, the state of $x$ is the probability that a random path leads to an evading sample. Now, suppose that the adversary has to pick one of two candidates $x$ and $y$ to continue the search, then the candidate with the larger state-value gives higher chance of finding an evading sample. This comparison provides a way for a hill-climbing algorithm to select candidates in each round.

Expected flipping distances as the state.

A main drawback of explicitly taking $\Pr(G_{x}<0)$ as $x$’s state is the high cost in determining the probabilities during the search process. Although one may estimate the distribution of $G_{x}$ by sampling multiple random paths, such accurate estimation would require extremely high number of queries, which in turn offsets the gain offered by efficient searching strategies. Alternatively, we can take the expected reject-flipping and malice-flipping distances as the state. Compare to the distribution $G_{x}$, the expected distances can be accurately estimated by drawing fewer random paths. In the proposed EvadeHC, the measured flipping distances can be viewed as the estimates of the expected distances. From the expected distances, we can derive the expected gap. Intuitively, the smaller the expected gap is, the higher the probability $\Pr(G_{x}<0)$ would be. Although the expected flipping distances do not provide sufficient information for us to estimate the probability, we can still employ the expected gap for comparison of probabilities. This motivates the choices of the two scoring functions ${\tt score}_{1}$ and ${\tt score}_{2}$ proposed in Section 3.3.

4.2 Hidden-State Random Morpher

We consider an abstract model HsrMorpher for analysis. Under HsrMorpher, the morpher operates in the same way as the Random Oracle [17] employed in the studies of hash functions does, producing truly random outcomes for unique query, and being consistent with repeated queries. Based on HsrMorpher, we give a condition whereby EvadeHC performs poorly and cannot outperform BiRand.

Randomly morphed sample.

Let us call a sample seen, if it has been queried against $\mathcal{}T,D$ or $\mathcal{}M$, or has been an output of $\mathcal{}M$. In other words, a sample is seen if it has been processed by one of the blackboxes. A sample is unseen otherwise. On a query consisting of a sample $x$ and a random seed $s$, $\mathcal{}M$ first checks whether the query $(x,s)$ has been issued before. If that is not the case, $\mathcal{}M$ randomly and uniformly chooses an unseen sample to be the morphed sample333If the pool of unseen samples is empty, $\mathcal{}M$ simply halts and does not generate a morphed sample.. Otherwise, the previously chosen sample will be outputted. In additional, $\mathcal{}M$ also decides, in a random way, the hidden state of the morphed sample, which is to be described next.

Randomly reducing hidden values.

Under HsrMorpher, each sample $x$ is associated with a hidden state, represented by two real values $(a,b)$. There is a particular sample $x_{o}$ with state $(1,1)$ set to be seen initially, and it is also known to the adversary. Upon receiving a query $(x,s)$, $\mathcal{}M$ outputs a morphed sample $\widetilde{x}$ as described in the previous paragraph. If $x$ is unseen, then the morpher sets the state of $x$ to $(0,0)$ and remembers that. Next, the morpher selects two real values $(\alpha,\beta)$ from a random source $S$ and sets the hidden state of $\widetilde{x}$ as

[TABLE]

where $(a,b)$ is the hidden state of $x$.

The tester $\mathcal{}T$, when given a query $x$, decides the outcome based on the hidden state. If $x$ is unseen, then $\mathcal{}T$ sets the hidden state to $(0,0)$. Suppose the hidden state of $x$ is $(a,b)$, then $\mathcal{}T$ outputs malicious iff $a>0$. Likewise, for the detector $\mathcal{}D$, it outputs reject iff $b>0$, and sets the state of $x$ to be $(0,0)$ if it is unseen.

Note that the only parameter in the HsrMorpher model is the random source $S$.

4.3 Analysis of EvadeHC on HsrMorpher

HsrMorpher behaves randomly, and is arguably the worst situation the adversary can be in, as the adversary is unable to exploit domain knowledge to manipulating the samples. For instance, given two samples $x_{0}$ and $x_{1}$, it is not clear how to find a sequence of random seeds that morph $x_{0}$ to $x_{1}$.

Ineffectiveness of EvadeHC

To understand the performance of EvadeHC, let us give a particular source $S$ for HsrMorpher that renders EvadeHC ineffective. Let us consider a source $S$ where $\alpha$ and $\beta$ are discrete and only take on value 0 or 1. Thus, all possible hidden states are $(a,b)$ where $a,b$ are integers not greater than 1. We can view the samples seen during an execution of EvadeHC as a tree. It is not difficult to show that the conditional probability $\Pr(G_{x}>0\ |\ \mbox{\em state of }x\ {\mbox{\em is }}(1,1))$ is the same for all $x$ in this tree. Thus, in every iteration, all candidates have the same probabilities and it is irrelevant which is chosen for the next iteration.

Random Source $S$.

The model HsrMorpher assumes that the reduction of the hidden values is independent of the sample $x$. To validate that real-life classifiers exhibit such property, in our empirical studies, we treat their internal classification score assigned to a sample as the sample’s hidden state. The empirical results demonstrate that the distributions of the reduction are similar over a few selected samples.

Remarks.

One can visualise the search for evading sample as a race in reducing the hidden state $(a,b)$. Statistically, $a$ is expected to drop faster than $b$. The evasion’s goal is to find a random path that goes against all odds with $b$ reduces to 0 before $a$ does. Essentially, EvadeHC achieves this in the following way: It generates and instantiates a few random paths. The path with the smallest gap arguably has $b$ reducing faster than average. Hence, EvadeHC chooses a point along this path as the starting point for the next iteration. Figure 8 depicts this process based on an actual trace obtained in our experimentation.

5 Evaluation

To study the feasibility and effectiveness of our proposed approaches, we conduct experimental evaluation on two well-known PDF malware classifier, namely PDFrate [28] and Hidost [30]. We defer overview of PDF malwares and the two classifiers to Appendix A. We first describe our experimental setups and then reports the results.

5.1 Experimental Setups

Morpher $\mathcal{}M$. We employ a simple morphing mechanism $\mathcal{}M$ that performs three basic operations with either insert, delete or replace an object in the original PDF file. In order to perform these operations, the morpher $\mathcal{}M$ needs to be able to parse the PDF file into a tree-like structure, to perform the insertion, deletion or replacement on such a structure and finally to repack the modified structure into a variant PDF444To avoid redundant parsing of the same PDF file in multiple steps, $\mathcal{}M$ caches the modified tree structure (or the original tree structure of the malicious PDF file), and directly modifies it without having to parse the PDF file in each step.. We employ a modified version of pdfrw [5] available at [3] for parsing and repacking.

For insertion and replacement, the external objects that are placed into the original file is drawn from a benign PDF file. We collect ten benign PDF files of size less than 1MB via a Google search to feed into $\mathcal{}M$ as a source of benign objects. They are all accepted by the targeted detectors and confirmed by the tester $\mathcal{}T$ as not bearing any malicious behaviours.

Tester $\mathcal{}T$. The tester $\mathcal{}T$ is implemented using a malware analysis system called Cuckoo sandbox [1]. The sandbox opens a submitted PDF file in a virtual machine and captures its behaviours, especially the network APIs and their parameters. The PDF file is considered malicious if its behaviours involve particular HTTP URL requests and APIs traces. We follow previous work by Xu et al. [35] in selecting the HTTP URL requests and APIs traces as reliable signature in detecting malicious behaviours of the submitted PDF files.

Dataset. We conduct the experimental studies using a dataset which consists of $500$ malicious PDF files that had been selected by Xu et al. in their experiments [35]. These samples are drawn from the Contagio [6] dataset, satisfying the following three conditions. First, they exhibit malicious behaviours observed by the tester. Secondly, they have to be compatible with the morphing mechanism (i.e. can be correctly repacked by pdfrw). And lastly, they are all rejected by both targeted detectors. We shall refer to these as malware seeds hereafter.

Targeted detectors. The targeted detectors in our experiments are based on the two PDF malware classifiers, namely PDFrate and Hidost. We make small changes to their original implementations [4, 30] such that the final outputs are binary decisions, rather than real-value scores.

Scoring function. The score function adopted in this studies is ${\tt score}_{1}(m,r)=m-r$, where $m$ is the malice-flipping distance and $r$ is the reject-flipping distance.

Machine and other parameters. All experiments are conducted on Ubuntu 14.04 commodity machines equipped with Intel(R) Xeon(R) CPU E5-2620 v3 $@$ 2.40GHz processors and 64GB of physical memory. The evasion process can be run in parallel, as there are no dependencies between different executions. In our experiments, we dedicate one machine to run $\mathcal{}D$ and $\mathcal{}M$, and nine others to run the tester $\mathcal{}T$. Each of these nine machines deploys $24$ virtual machines simultaneously, and is capable of performing approximately $2,000$ tester queries per hour.

We conducted five sets of experiments. The first set of experiments examines how the parameters $q_{1}$, $q_{2}$ and $\Delta$ effect the performance of EvadeHC. The second and third experiment sets evaluate the effectiveness of the proposed approaches in evading PDFrate and Hidost detectors, respectively. The efficiency of the evasion is determined by number of blackboxes queries and the overall running time. In the forth set of experiments, we consider a hypothetical setting where the detectors are hardened to make evasion more difficult and benchmark our approaches against the closely related work by Xu et al.[35], which relies on classification scores output by the detectors to guide the evasion. We emulate the hardening of detectors by reducing their defaults thresholds: below $0.5$ for PDFrate and below [math] for Hidost. The last set of experiments validates the HsrMorpher model we discussed earlier in Section 4. Unless otherwise stated, the reported results are average values obtained over $10$ instances.

5.2 Effect of Parameter Settings on EvadeHC

We first examine how the choice of parameters $q_{1}$, $q_{2}$ and $\Delta$ effects the performance of EvadeHC. We run EvadeHC with different parameter settings on $100$ malware seeds randomly selected from our experimental dataset against PDFrate detector, varying $q_{1}$ from $10$ to $60$, and setting $q_{2}$ proportional to $q_{1}$ with a percentage ranging from $10\%$ to $50\%$. In addition, we vary the jump factor $\Delta$ from $0.4$ to $0.9$. The average numbers of iterations and amounts of detector queries required to find evading samples are reported in Figure 4.

Figure 4(a) indicates that increasing $q_{1}$ will lessen the number of iterations. This is consistent with an intuition we discussed earlier, for larger $q_{1}$ would improve a likelihood that the algorithm is going toward the right direction. $q2$, on the other hands, has a more subtle effects on the number of iterations. In particular, a too small value may lead the search to a local minimum, hindering the search progress, while a too large value may accidentally bring “bad” candidates onto the next iterations. A similar trend is also observed on $\Delta$ (Figure 4(b)). When it is increased from $0.4$ to $0.7$, we witness a reduction in number of iterations. However, when it reaches $0.9$, the algorithm tends to loop through more iterations in order to find evading samples. The reason is that too small $\Delta$ limits progress the search can make in each iteration, while unnecessarily large $\Delta$ would increase the likelihood of samples in the next iterations being rejected.

It is worth noting that the number of detector queries required to find evading samples depends not only on the number of iterations, but also the value of $q_{1}$. Figure 4(c) shows average number of detector queries with respect to different settings of $q_{1}$ and $q_{2}$. While larger $q_{1}$ leads to smaller number of iterations, it may result in larger number of detector queries per each iterations, and thus larger queries overall (e.g., with $q_{2}=25\%\cdot q_{1}$, increasing $q_{1}$ from $20$ to $60$ leads to an increase in $N_{d}$). From the result of this experiment set, we choose $q_{1}=20$, $q_{2}=5$ and $\Delta=0.75$ as the parameter setting for EvadeHC through all other sets of experiments.

5.3 Evading PDFrate Detector

The second experiment set focuses on evading PDFrate detector. All of our methods achieve $100\%$ evasion rates (i.e., found evading samples for all 500 malware seeds in our dataset). While the baseline SeqRand and BiRand traverse $1048$ random paths on average to find an evading sample, EvadeHC only needs from three to six iterations (each iteration involves assessing $20$ random paths). Nevertheless, there are a few exceptions which require EvadeHC to take up to $19$ iterations to find evading samples (Figure 3(a)).

We first compare the performance of BiRand to the baseline SeqRand. Figure 5(a) shows the ratios of their $N_{d}$, and Figure 5(b) plots that of $N_{t}$, clearly demonstrating the effectiveness of the binary search mechanism employed in BiRand. Compared to the baseline, BiRand could reduce $N_{d}$ by upto $94$ times.

Next, we benchmark EvadeHC against BiRand. Figure 5(c) report the ratios between their numbers of detector queries, and Figure 5(d) depicts ratios of their tester queries. BiRand typically demands from $2$ to $4$ times more detector queries, and $6$ to $10$ times more tester queries than EvadeHC does. More details in numbers of blackboxes queries required by EvadeHC and BiRand  are reported in Appendix B.

Compared to the baseline SeqRand, EvadeHC demands upto $450$ times fewer detector queries and $148$ times fewer tester queries, which translates to two orders of magnitude faster running times. We report running times of different approaches in Section 5.5.

5.4 Evading Hidost Detector

In the third set of experiments, we evaluate our proposed approaches against Hidost detector. They also achieve $100\%$ evasion rate for the $500$ malware seeds in the dataset. For $95\%$ of the seeds, EvadeHC found the evading samples within $11$ iterations, while the other seeds need up to $13$ iterations (Figure 3(b)). BiRand and SeqRand, on the other hand, have to traverse approximately $1550$ paths on average to find an evading sample.

We report performance of SeqRand in comparison with BiRand in Figure 6(a) and 6(b), showing that BiRand is capable of outperforming SeqRand by upto $92$ and $12$ times in term of detector and tester queries, respectively.

Further, we also benchmark BiRand against EvadeHC by showing the ratios between their $N_{d}$ (Figures 6(c)) and $N_{t}$ (Figure 6(d)). The results show the superiority of EvadeHC over BiRand. In particular, for most malware seeds, EvadeHC requires two to three times fewer detector queries and seven to ten times fewer tester queries compared to BiRand. More details in numbers of blackboxes queries required by the two approaches are reported in Appendix C.

When benchmarked against the baseline solution, EvadeHC attains upto two orders of magnitude lower execution cost, both in term of number of queries to the blackboxes and the overall running time.

5.5 Execution Cost

Figure 7 report average running time of different approaches in evading the two detectors. As discussed earlier, EvadeHC and BiRand  are order of magnitude more efficient than the baseline solution SeqRand. In particular, to find an evading sample against Hidost, SeqRand takes on average $6.7$ hours, while BiRand and EvadeHC need only $40$ and $5$ minutes, respectively.

It can also be seen that evading Hidost is often more expensive than evading PDFrate. It would be interesting to investigate how the construct of Hidost provides resilience against the attacks.

We remark that BiRand and EvadeHC are designed with a premise that $N_{d}$ is a dominating component in determining the evasion cost, thus minimising the number of detector queries, rather than tester queries which are computationally expensive. In situations where $N_{t}$ is the dominating component (e.g., applications for which computational cost is the main constrain), one can easily derive a variant of EvadeHC that applies the single binary searches with $\mathcal{}D$ instead of $\mathcal{}T$. The performance of such algorithm is arguably similar to that of our current implementation, except for $N_{d}$ and $N_{t}$ whose values would be swapped. There is no impact on the accuracy, since the modification is purely on the algorithmic aspect.

5.6 Evading Trace Analysis

To gain a better insight on how the hill-climbing heuristic works in EvadeHC, we examine the flipping distances of samples generated along typical evading traces. An evading trace is a collection of samples that EvadeHC successively generates in finding an evading sample for a malware seed. Such a trace starts with an originally malicious PDF file, and ends with an evading sample. Samples generated in the first iteration would have reject-flipping distance larger than malice-flipping distance. EvadeHC would select promising samples from one iteration and continue to morph them in the next iteration so that they are eventually accepted by the detector before losing their malicious functionality.

Figure 8 depicts typical evading traces that lead to evading samples against PDFrate and Hidost detectors. The diagonal line in the figure represents points where malice-flipping distance and reject-flipping distance are equal, the vertical line represents points at which the detector’s decision changes from reject to accept, and the horizontal line represents points where the malicious functionality of the samples are lost. Intuitively, the malware seeds’ representations in term of malice-flipping distance and reject-flipping distance often lie below the diagonal line, and EvadeHC morphs them so that they move past the diagonal line, reaching the vertical line (i.e., being accepted) before crossing the horizontal line (i.e., losing the malicious functionality). It can also be seen from the figure that PDFrate is more evadable, as it is easier to move the samples generated against PDFrate past the diagonal compared to those that are evaluated against Hidost.

5.7 Robustness against Hardened Detectors

In the forth experiment set, we investigate scenarios where the detectors are hardened to render evasions more difficult. We emulate hardened PDFrate by lowering its malware threshold down to $0.35$ 555Authors of PDFrate [28] reported that adjusting the malware threshold from $0.2$ to $0.8$ has negligible effect on accuracy., and hardened Hidost’s to $-0.75$. Further, we bound the maximum number of detector queries that could be issued in finding an evading sample to $2,500$. If an evading sample can not found after the predefined number of detector queries, we treat the seed as non-evadable.

In addition, we benchmark the two approaches BiRand and EvadeHC against a technique by Xu et al. [35], which we shall refer to as EvadeGP. We stress that while EvadeGP relies on classification scores assigned to the samples to guide the search, our approaches do not assume such auxiliary information. We operate EvadeGP under a similar set of parameters reported in [35]: population size is $48$, mutation rate is $0.1$ and fitness stop threshold is $0.0$. We bound the number of generations that EvadeGP traverses to $50$ (instead of $20$ as in [35]), effectively limiting the number of detector queries incurred in each evasion to $2,500$. In addition, we disable its trace replay feature (i.e., mutation traces that successfully generates evading sample for one malware seed are not replayed on the other), treating each malware seed independently. This enables a fair basis to benchmark the effectiveness of our approaches against EvadeGP, for ours do not assume trace replay.

Figure 9 reports evasion rates of BiRand and EvadeHC in comparison with that of EvadeGP against the hardened detectors. For PDFrate detector with malware threshold set to $0.45$, both EvadeHC and EvadeGP attained $100\%$ evasion rate on our dataset, while BiRand only achieves $91\%$. When the malware threshold is further lowered to $0.4$ and $0.35$, the evasion rate of EvadeHC decreases to $68\%$ and $35\%$, respectively, while EvadeGP and BiRand witness more significant drops in their evasion rates, attaining evasion rate of as low as $5\%$ for BiRand and $26\%$ for EvadeGP. Similarly, when the malware threshold of Hidost is reduced to $-0.75$, BiRand and EvadeGP could only find evading samples for $8\%$ and $50\%$ of the malware seeds respectively, while EvadeHC still attains an evasion rate of $62\%$ (Figure 9(b)).

While it may come as a surprise that EvadeHC attains better evasion rate than EvadeGP even though it only assumes binary output instead of classification score as EvadeGP does, we suspect that this is because of the fact that EvadeHC’s scoring mechanism is capable of incorporating information obtained from both the tester and detector and thus is arguably more informative than the scoring mechanism of EvadeGP which mainly relies on the classification score output by the detector.

5.8 Validating the Hidden-state Morpher Model

To justify the proposition on states representation of a sample discussed earlier in Section 4, we generate $200$ different morphed samples from the same malware seed, and measure their average flipping distances (the reject-flipping distance is measured against Hidost). The average flipping distances of each sample are computed from $20$ different random paths originating from it (the sequences of random seeds are the same for all samples), and plotted in Figure 10. The figure also shows a certain correlation between the malice and reject flipping distances. Indeed, the pearson correlation coefficient of the distances is $0.34$, confirming our proposition earlier in Section 4 that they are positively correlated.

The proposed model HsrMorpher assumes that the reduction of the hidden values is independent and identical for all the samples. To validate that real-life classifiers exhibit such property, we consider PDFrate and treat the internal classification score assigned to a sample as it’s hidden state. We pick a sample $x_{0}$ and create another sample $x_{1}$ by applying a sequence of five morphing steps on $x_{0}$. We then generate $1,000$ random paths of length five from $x_{0}$. For each of the random path, we record the difference between classification scores of the last sample and $x_{0}$. Figure 11(a) shows the histogram of the recorded score differences. Similar experiment is carried out on $x_{1}$ and the histogram is shown in Figure 11(b). Observe that the two histograms are similar, giving evidences that HsrMoprher is appropriate.

We further study the validity of the HsrMorpher model by running BiRand and EvadeHC under the abstract model. Recall that HsrMorpher is parameterised by the random source $S$ that dictates how the two values $(\alpha,\beta)$ are chosen. From previous set of experiments, we observe that a typical malice-flipping distance is $42$, and reject-flipping distance is $60$ (Figure 10). A more detailed analysis of the empirical data suggests that, with respect to the three blackboxes deployed in our experiments, $\alpha$ would follow normal distribution ${\mathcal{}N}(0.024,0.01)$ and $\beta$ follows ${\mathcal{}N}(0.017,0.011)$. The evasion starts with a malicious sample $x_{o}$ with state $(1,1)$ and succeeds if it can find an evading sample $e$ with state $(a,0)$ for some $a>0$. We repeat the experiment for $100$ times.

Due to space constraint, we only show the average number of iterations (or paths) that the two approaches traverse in searching for evading samples under the HsrMorpher model. The experimental results confirm the consistency of their behaviors under HsrMorpher and the empirical studies. This strongly indicates that the abstract model can indeed serve as a basis to study and analyze the proposed evasion mechanism.

6 Discussion

In this section, we discuss potential mitigation strategies and implications suggested by our evasion attacks.

6.1 Existing Defensive Mechanism

Most existing works in evading learning-based classifier rely on real-value classification scores to guide the evasion [35, 21]. Thus, it has been suggested that hiding the classification scores or adding random noise to the scores may protect the classifier [8]. Another proposed defensive mechanism is to use a multi-classifier system whose classification score is randomly picked from different models trained with disjoint feature sets [10]. Our results show that it is still feasible to evade learning-based classifiers without any classification score, rendering the above-mentioned defensive mechanisms ineffective.

6.2 Potential Mitigation Strategies

Hardening the Malware Threshold. Previous work [35, 28] suggested that the classification performance (i.e., false accept/false reject) is typically robust against the choice of the malware threshold, for original samples that are not adversarially manipulated would have classification scores close to either of extremes. For example, the authors of PDFrate reported that adjusting the malware threshold from $0.2$ to $0.8$ has negligible effect on accuracy, because most samples would be assigned scores very close to either [math] or $1$ [28]. On the other hand, our experimental study (Section 5.7) suggests that even a slight change of the malware threshold could have significant impact on the evasion difficulties. Thus, it seems one potential mitigation strategies is to set the threshold to be more “restrictive”. This is worth investigating in future works.

Randomization. Another potential mitigation strategy is to embed into the classifiers a certain level of randomness. In particular, for samples whose classification scores are very close to the threshold, the classifiers can flip its classification decision with some probability. Given a proposition that most samples would have classification scores distant from the threshold, the above-mentioned flipping mechanism would not have significant impact on the classification accuracy. Similar to the previous mitigation strategy, more study is needed to conclude an effect of this countermeasure.

Identifying Evading Attempts/Samples. In most cases, evading samples are found after hundreds of queries to the detector $\mathcal{}D$. In addition, the samples queried against $\mathcal{}D$ over the course of the evasion would resemble one another, to a certain extent. Thus, one possible method to detect evading attempts/samples is to have $\mathcal{}D$ remember samples that have been queried and apply some similarity/clustering-based techniques to identify evading queries/samples. In other words, $\mathcal{}D$ has to remain stateful.

6.3 Evasion for Defense

Ironically, an effective evasion algorithm can also be used to build more secure classifiers that are robust against evasion attacks. Indeed, previous works have suggested that one can enhance the robustness of a learning based model by injecting adversarial examples throughout its training [14, 21]. In particular, those morphed samples that retain the desired malicious activity, especially the ones that are misclassified by the learning based systems, can be included in the trainning dataset for the next step of training. We remark that by formulating the morphing process as random but repeatable, our approaches are capable of generating adversarial examples with great diversity, further enhancing effectiveness of the adversarial training.

7 Related Work

Evasion attacks against classifiers have been studied in numerous contexts [36, 23, 30, 35]. These works differ in their assumptions on the adversary’s knowledge about the detector and how the data could be manipulated. Intuitively, detailed knowledge of the classifier significantly benefits the adversary in conducting evasion attacks. Šrndic et al. [31] proposed a taxonomy of evasion scenarios based on the knowledge about the targeted classifier’s components that are available to the adversary. These components include training datasets and classification algorithms together with their parameters, as well as a feature set that the classifier has learnt.

Various attacks against learning-based classifiers [9, 31, 25] assume that the adversary has high level of knowledge about the target system’s internals (e.g., feature sets and classification algorithms), and could directly manipulate the malicious seeds in the feature space. It is unclear how these works could be extended to the constrained scenario we consider in this work, wherein the adversary does not have any knowledge of the feature set and could not manipulate the data on the feature space.

Xu et al. [35] relax an assumption on the high level of knowledge about the detector’s feature set, only presume that the adversary is aware of the manipulation level of the morphing mechanism and has access to the classification scores output by the target detector. On the contrary, our technique does not assume any of such knowledge. Interestingly, we show in Section 5.7 that even without relying on classification scores, our proposed algorithm EvadeHC still attains higher evasion rate against hardened detectors in comparison with previous work.

The evasion attacks proposed by Papernot et al. [21] require training a local model that behaves somewhat similar to the targeted system, then search for evading samples against such local model, and show that they are also misclassified by the targeted system. The actual evasion happens on the substituting model whose internal parameters and training dataset are available to the adversary. Further, this approach heavily relies on the transferability of the adversarial samples. Our solutions, on the other hand, directly search for evading samples against the targeted classifier without necessitating training a local substituting model or making any assumption on the transferability of samples.

A line of works on adversarial learning [33, 26] also assume blackbox accesses to the targeted systems, but are different from ours in their adversarial goals. While Tramèr et al. [33] attempted to extract exact value of each model parameter and Shokri et al. [26] were interested in inferring if a data record was in the targeted model’s training dataset, our focus is on deceiving the target system into misclassifying evading samples.

8 Conclusion

We have described EvadeHC, a generic hill-climbing base approach to evade binary-outcome detector using blackbox morphing, assuming minimal knowledge about both the detector and the data manipulation mechanism. We have demonstrated the effectiveness of the proposed approach against two PDF malware classifiers. Although the experiment studies are performed on malware classifier, the proposed technique and its security implications may also be of wider application to other learning-based systems.

Acknowledgements

We thank Amrit Kumar and Shiqi Shen for helpful discussions and feedback on the early version of the paper. This research is supported by the National Research Foundation, Prime Minister’s Office, Singapore under its Corporate Laboratory$@$University Scheme, National University of Singapore, and Singapore Telecommunications Ltd. All opinions and findings expressed in this work are solely those of the authors and do not necessarily reflect the views of the sponsor.

Appendix A PDF Malware Classifiers

In this section, we give an overview of the Portable Document Format (PDF) and PDF malwares, and briefly introduce the two detectors, namely PDFrate [28] and Hidost [30].

A.1 PDF

The Portable Document Format (PDF) is a standardised file format that is designed to decouple the document presentation from the underlying environment platform (e.g., application software, hardware or even OSes), thus enabling consistent presentation of the document across different platforms [16]. A typical PDF file consists of four parts. The first part – header – contains the magic number and the version of the format. The second part – body – incorporates a set of PDF objects comprising the content of the file. The third part – cross-reference table (CRT) – is an index table that gives the byte offset of the objects in the body. The last part – trailer – includes references to the CRT and other special objects such as the root subject. We depict an example of a PDF file in Figure 13.

The header, CRT and trailer are introduced with %PDF, xref and trailer keywords, respectively. Objects in the body of the file may be either direct (those that are embedded in another object) or indirect. The indirect objects are numbered with a pair of integer identifiers and defined between two keywords obj and endobj. Objects have eight basic types which are Booleans (representing true or false), numbers, strings (containing 8-bit characters), names, arrays (ordered collections of objects), dictionaries (sets of objects indexed by names), streams (containing large amounts of data, which can be compressed) and the null objects. It is worth mentioning that there are some dictionaries associated with special meanings, such as those whose type is JavaScript (containing executable JavaScript code).

A.2 PDF Malwares

Due to its popularity, PDF files have been extensively exploited to deliver malware. In addition, given an increasing number of vulnerabilities in Acrobat readers reported recently [2], the threat of PDF malwares is clearly relevant. The malicious payploads embedded in the PDFs are often contained in JavaScript objects or other objects that could exploit vulnerabilities of a particular PDF reader in use.

A.3 Detectors

Various PDF malware detectors have been proposed in the literatures. A line of works [13, 18] targeted JavaScript code embedded in the malicious PDFs (or PDF malware). They first extract a JavaScript code from the PDF, and either dynamically or statically analyse such a code to assess the maliciousness of the PDF. Nevertheless, these works would fail to detect PDF malware wherein the malicious payloads are not embedded in JavaScript code or the code itself is hidden [24]. Hence, recent works have taken another approach, relying on the structural features of the PDFs, to perform static detection. Structural feature-based detectors perform detection based on an assumption that there exist differences between internal object structures of benign and malicious PDF files.

Our experimental evaluations are conducted against two state-of-the-art structural feature-based detectors, namely PDFrate [28] and Hidost [30]. These two systems are reported to have very high detection rate on their testing datasets, and are also studied in previous works on evading detection [35]. It is worth mentioning that the outputs of these two detectors are real-value scores which are to be compared against thresholds to derive detection results. In our experiments, we make small changes to their original implementations so that they return binary outputs.

PDFrate.

PDFrate is an ensemble classifier consisting of a large number of classification trees. Each classification tree is trained using a random subset of the training data and based on an independent subset of features. These features include object keywords, PDF metadata such as author or creation data of the PDF file, and several properties of objects such as lengths or positions. At the time of classification, each tree outputs a binary decision indicating its prediction on the maliciousness of the input. The output of the ensemble classifier is the fraction of trees that consider the input “malicious” (a real-value score raning from [math] to $1$). The default cutoff value is set at $0.5$.

PDFrate was trained using $5,000$ benign and $5,000$ malicious PDF files randomly selected from the Contagio dataset [6]. The classifier consists of $1,000$ classification trees each of which covers $43$ features. The total number of features covered by all the classification trees is $202$ (but only $135$ are documented in PDFrate’s documentation). An open-source implementation of PDFrate, namely Mimicus [4], is by Šrndić et al. [31]. We utilise this implementation in our experiments.

Hidost.

Hidost is a support vector machine (SVM) classifier [30]. SVM aims to fit a hyperplane (which can be expressed using a small number of support vectors) to training data in such a manner that data points of both classes are separated with the largest possible margin. Hidost works by first mapping a data point (representing a submitted PDF file) to an indefinite dimensional space using radial basis function, and reports the distance between the data point and the hyperplane as a measurement of its maliciousness. If the distance is positive, the PDF file is considered malicious; otherwise, the file is flagged as benign.

Hidost was trained using $5,000$ benign and $5,000$ malicious PDF files. Hidost operates based on $6,087$ classification features, which are structural paths of objects. These structural paths are selected from a set of $658,763$ PDF files (including both benign and malicious instances) based on their popularity (i.e., each of them appeared in at least $1,000$ files). We use the implementation made available by the author of Hidost in our experiments [30].

Appendix B Number of blackbox queries in evading PDFrate

The number of blackbox queries that BiRand and EvadeHC required in evading PDFrate are reported in Figures 14(a), 14(b), 14(c). We do not report these metrics of the baseline, for they are all equal to the number of morphing steps that BiRand incurs.

As can be seen from Figure 14(a), for a majority of the malware seeds, EvadeHC needs at most $494$ queries, while BiRand requires approximately $1500$. The remaining seeds appear to be much more difficult to evade, for which EvadeHC and BiRand need up to $786$ and $1837$ queries, respectively. Similarly, EvadeHC also requires fewer tester queries and less morphing efforts than BiRand (Figures 14(b) and 14(c)). In particular, for the majority of the malware seeds, EvadeHC can find an evading sample with less than $1,237$ tester queries and $21,707$ morphing steps, while BiRand consumes up to $9,100$ and $63,288$ morphing steps.

To get an insight why some seeds necessitated much more effort in finding evading samples, we check their classification scores given by PDFrate. It comes as no surprise that their classification scores are higher than the rest of the malware seeds. In order words, it is harder to find evading samples for these seeds because the detector perceived their maliciousness more clearly.

The histogram of the ratios between the numbers of morphing steps required by the two approaches is depicted in Figure 14(d). EvadeHC requires as low as one tenth morphing efforts compared to BiRand in order to find an evading sample.

Appendix C Number of blackbox queries in evading Hidost

We report the amounts of blackbox queries EvadeHC and BiRand incur in evading Hidost in Figure  15(a), 15(b) and  15(c). Overall, EvadeHC outperforms BiRand with respect to all three metrics $N_{d}$, $N_{t}$ and $N_{m}$. In particular, EvadeHC’s requires as few as $427$ detector queries, while BiRand needs as least $1,131$ queries to find an evading sample. With respect to the tester, EvadeHC requires no more than $2073$ queries, while BiRand requires $11,500$ queries on average. The similar trend can also be observed on morphing effort, wherein EvadeHC requires about $12,500$ morphing step on average, while such number for BiRand is approximately $10$ times larger (Figure 15(d)).