Generation & Evaluation of Adversarial Examples for Malware Obfuscation

TL;DR

This paper introduces a generative model for creating adversarial malware examples through obfuscation, achieving high evasion rates against classifiers while maintaining functionality.

Contribution

It presents a novel generative approach for malware obfuscation that effectively evades neural network classifiers in both white-box and black-box scenarios.

Findings

Achieves up to 100% misclassification in white-box settings.

Achieves up to 98% misclassification in black-box settings.

Demonstrates transferability of adversarial examples across models.

Abstract

There has been an increased interest in the application of convolutional neural networks for image based malware classification, but the susceptibility of neural networks to adversarial examples allows malicious actors to evade classifiers. Adversarial examples are usually generated by adding small perturbations to the input that are unrecognizable to humans, but the same approach is not effective with malware. In general, these perturbations cause changes in the byte sequences that change the initial functionality or result in un-executable binaries. We present a generative model for executable adversarial malware examples using obfuscation that achieves a high misclassification rate, up to 100% and 98% in white-box and black-box settings respectively, and demonstrates transferability. We further evaluate the effectiveness of the proposed method by reporting insignificant change in the evasion rate of our adversarial examples against popular defense strategies.

Figures

Tables

Table 1. TABLE I: Classification accuracies during the white-box and black-box setting experiments when using different obfuscation methods before input. We report accuracies using no obfuscation, one loop (AMAO 1 ) of the proposed method, the full proposed method (AMAO f f {}_{\mbox{f}} ), and randomly inserted semantic nops . For the randomized insertions, we record the range over 10 experiments. The top half of the table report results using white-box attacks and the lower half report results using black-box attacks.

Model	None	AMAO1	AMAO${}_{\text{f}}$	Random
Simple CNN	85.1%	44.4%	0.0%	20-30%
LeNet5	86.55%	46.0%	0.0%	20-30%
Boosted Trees	99.0%	1.98%	0.0%	80-85%
InceptionV3	86.1%	50.0%	26.95%	40-50%
MalConv	99.0%	57.89%	0.0%	80-90%

Table 2. TABLE II: This table contains the classification accuracy of three convolutional neural networks when classifying true malware binaries, adversarial examples generated using [ 26 ] , and our proposed method. To keep the experiments consistent, we use the [ 5 ] dataset. We also generate untargeted attacks using AMAO because the method proposed in [ 26 ] was designed for a binary detection problem. Attacks on InceptionV3 were black-box attacks while those on LeNet and Simple CNN were white-box.

Model and Data	None	Adversarial Training	Distillation
Simple CNN & True	85.10%	84.40%	86.50%
Simple CNN & [27]	83.24%	83.90%	83.10%
Simple CNN & AMAO	6.50%	7.78%	7.45%
LeNet & True	86.55%	86.00%	87.20%
LeNet & [27]	85.40%	83.75%	85.43%
LeNet & AMAO	6.80%	8.19%	7.30%
InceptionV3 & True	88.45%	79.80%	89.10%
InceptionV3 & [27]	86.91%	65.0%	66.34%
InceptionV3 & AMAO	26.95%	6.20%	6.14%

Table 3. TABLE III: This table compares accuracy scores of the top scoring Microsoft malware challenge [ 5 ] model trained on the competition malware training dataset and tested on malware data that has undergone different obfuscation.

Obfuscation	Classification Accuracy
No Obfuscation	$98.62\pm 0.21\%$
Instruction Sub.	$97.36\%\pm 0.36\%$
Subroutine Reorder	$98.45\pm 0.61\%$
Static Value Obf.	$97.52\pm 0.29\%$
Dummy Code	$87.98\pm 3.49\%$
Mixing Flow	$39.46\pm 3.70\%$
AMAO	$0.0\%$

Equations

$$x^{\prime }=x+\delta$$

$$||x^{\prime }-x|{|}_2<ϵ$$

$$O[i][j]=\min\left\{\begin{array}[]{l}O[i-1][j-1]\\ minCode\end{array}\right.+D(B1[i],B2[j])$$

$$\begin{gathered} minCode=\underset{c\in L_{\text{mbox}nops}}{\min }\{O[i][j-len(c)-1]+ \\ D(B1[i-len(c):i],c)\} \end{gathered}$$

$$D(x_{1},x_{2})=\sum_{i=0}^{n}\left\{\begin{array}[]{ll}0&\quad x_{1}[i]=x_{2}[i]\\ 1&\quad x_{1}[i]\ \neq\ x_{2}[i]\end{array}\right.$$

Full text

††This research was done while H. Khan was a graduate student at Rensselaer Polytechnic Institute. D. Park is supported by the US Department of Defense’s Science, Mathematics and Research for Transformation (SMART) Scholarship for Service Program.

I Introduction

With the growth of the Internet, the number of malware has been rapidly increasing. Machine learning has significantly improved existing solutions in malware detection, classification, and network intrusion detection and prevention. Static and dynamic analysis have been the cornerstone of malware detection and classification, but are increasingly being replaced by rule based and machine learning models trained on features extracted from analysis, such as $n$-grams [1]. This led to work, such as that of [2] and [3], in extracting richer sets of features and representations directly from malware.

It has been proposed to use the image representation of malware as input, allowing use of image processing and classification techniques for malware classification [4]. Features extracted from malware images were popularly used during a 2015 competition [5], resulting in significant improvement for the top performing classifier [6]. The methods proposed by [7] and [8] only used malware image features and achieved high classification accuracy.

However, [9] found that neural networks are vulnerable to adversarial examples. Adversarial examples are crafted by perturbing valid inputs such that they are indistinguishable from the valid inputs when viewed by humans but are confidently misclassified by a machine learning classifier. As the concept of adversarial examples has mostly been explored in the domain of natural images, interest has shifted to further research and understanding of adversarial examples in the malware domain [10, 11]. This immediately led us to question the effectiveness of adversarial examples for image representations of malware.

In this paper, we are interested in the application of machine learning to malware classification and the effect that adversarial examples have in this regard. Similar to adversarial examples in the natural image domain, an adversarial example of malware is an executable binary file that is crafted from an existing malware sample with the purpose of fooling a machine learning based classifier. However, adversarial malware examples must also preserve the original functionality while being executable. This paper presents a novel approach to creating executable adversarial examples by minimally modifying malicious raw binaries using a dynamic programming based insertion algorithm that obfuscates the .text section of a binary with executable byte sequences.

We report the misclassification rate of our adversarial malware examples against popular machine learning classifiers. We also test the effectiveness of the examples by strengthening the classifiers using popular defensive techniques, adversarial training and distillation, while comparing our proposed method with the current literature. We also show that dummy code insertion patterns can be learned and used as heuristics for obfuscation without use of machine learning based approaches.

I-A Contributions

The main contributions of this paper are as follows:

• •

We present a novel approach for generating adversarial malware executables and obfuscation using malware images.

• •

We show transferability of our generated adversarial examples to other classifiers.

• •

We evaluate the proposed method and related work against defended neural networks using adversarial training and distillation.

• •

We compare obfuscation generated using the proposed method to other common obfuscation techniques.

I-B Organization

This paper is organized as follows. Section II gives a brief background on malware classification and adversarial examples. Section III describes the mechanisms used in the proposed method for generating executable adversarial malware examples. Section IV reports results under white-box and black-box settings. It also reports the results after strengthening neural networks using adversarial training and distillation. In Section V, we discuss interesting aspects of the work, as well as possible extensions of the proposed method. Section VI presents related work in adversarial example generation for malware and obfuscation. We conclude the paper in Section VII.

II Background

In this section, we describe the relevant background and malware classification setup. We also discuss the nature of adversarial examples in the malware image domain.

II-A Convolutional neural networks

Convolutional neural networks (CNN) are often the model of choice when the input data contains spatial or temporal relationships, such as pixels in an image or samples in a time series. The learnable filters in a CNN are designed to explicitly capture the spatial or temporal invariances in the data. This, combined with the layered representation learning of deep neural networks allows CNN to effectively model many different types of data.

A typical CNN consists of multiple convolutional layers with pooling layers interspersed in between. The intuition behind this architecture is that the layers learn specialized representations of the input data for the task of interest.

CNN’s use in natural image classification has led to their use in malware classification. In the following section, we discuss an image representation of malware that can be used as input to a CNN.

II-B Data representation

In this work, we represent Windows malware binaries as grayscale images generated from the bytecode.

A whole malware binary is read into a 2-dimensional array as 8-bit unsigned integers. Because each of these 8-bit unsigned integers are between 0 and 255, they can be visualized as a grey-scale image where 0 is black and 255 is white.

Previous work has shown that this image representation of malware can be used to see shared repeated patterns and distinct characteristics between binaries in the same class [4].

In this work, we used the Malimg dataset introduced in [4]. In addition to the Malimg dataset, this work also uses the Microsoft malware challenge dataset [5]. For this dataset, the width of the image was fixed according to the recommended width for the largest malware sample.

II-C Adversarial examples & malware

The popularity of the image representation of malware has led to increased usage of deep learning techniques for classifying malware at high accuracies [12, 13].

Adversarial examples of malware images, generated using Fast Gradient Signed Method (FGSM) or the Carlini and Wagner (C&W) method can be used to evade classification [14, 15]. However, adversarial malware examples must also be executable and have the same effective program logic. A perturbation on a malware image does not necessarily ensure these properties. For example, let $x=[137,200]$, two pixels representing a binary sequence. When converted to hexadecimal and then to x86 instructions, we get $89c8$ and mov eax, ecx, respectively. Consider a small perturbation on the image which results in $x^{\prime}=[137,201]$. When $x^{\prime}$ is converted into assembly instructions, we get mov ecx, ecx, which does not produce the same results as $x$.

II-C1 Generating adversarial examples and noise

Adversarial examples are generally natural images, where a perturbation of the original image causes it to be misclassified even though it appears to be a copy of the original. We define adversarial examples and the methods used to generate them below before introducing the proposed method for generating executable adversarial examples.

Given an input binary file $x$, an adversarial example generated using $x$ is a perturbed version of $x$, $x^{\prime}$, such that

[TABLE]

where $\delta$ is some additive perturbation, which causes a classifier to incorrectly label the binary file while preserving the functionality of the original file. $x^{\prime}$ can be generated using various attack techniques. In this work, we use the FGSM [14] and C&W attacks [15].

In a non-targeted attack as explained in Section III-A, the goal is to cause misclassification. The task for the adversary is to generate an $l_{2}$-bounded perturbation of a binary $x$ with true class $y$ such that

[TABLE]

where $x^{\prime}$ is the modified binary, $||\cdot||_{2}$ is the $l_{2}$-norm, and $x^{\prime}$ is executable and preserves the functionality of $x$ while having a $l_{2}$ distance of less than a hyper-parameter $\epsilon$.

In a targeted attack, Equation 2 still applies. The only additional requirement is that the adversarial example is misclassified as a target class $y^{\prime}$ chosen by the adversary.

II-D Defensive techniques

In this section, we provide a brief summary of the defensive techniques against adversarial examples that will be used later to assess our method’s effectiveness.

II-D1 Adversarial training

Reference [16] showed that training on a combination of discovered adversarial examples and clean examples somewhat regularizes the neural network. The goal of adversarial training is to learn to correctly classify future inputs that have undergone adversarial perturbations. Reference [14] showed that adversarial training on the MNIST dataset reduced the original adversarial examples’ misclassification rates from $89.4\%$ to $17.9\%$. Adversarial examples generated using the adversarially trained model had an evasion rate of $40.9\%$.

II-D2 Distillation

Distillation was originally introduced by [17] as a method to reduce the size of deep neural network architectures while preserving knowledge acquired during training and extended by [18] to defend against adversarial examples. Intuitively, neural network distillation is the process of extracting class probability vectors from a first deep neural network to train a second deep neural networks of reduced dimensionality. This is based on the notion that knowledge is encoded in a model’s output probability vector in addition to its weights.

II-E Obfuscation

The main goal of obfuscation is to make a program difficult to understand while preserving the logic of the original program. In this preliminary work, we focus on generating adversarial examples using an obfuscation technique called dummy code insertion.

Dummy code insertion introduces code sequences that do not affect the program logic. These sequences are named after the nop or no operation. There are multiple ways to insert nops into a program, in addition to simply inserting the nop instruction as seen in Figure 1. These are called semantic nops and are instructions or sequences of instructions that do not affect program logic.

III Methodology

In this section, we will formally define our problem and threat model. We also describe how the Fast Gradient Sign Method and the Carlini & Wagner method can be applied to generate non-executable adversarial examples from malware images. We introduce a dynamic programming based algorithm, Adversarial Malware Alignment Obfuscation (AMAO), to achieve this goal. A general block diagram of the full method is given in Figure 2.

III-A Threat model

In this section, we define the adversary’s goal, capabilities, and attack surface.

III-A1 Adversarial Goal

In this work, the goal of the adversary is to generate malware samples that evade classification by deep neural network classification models. In an untargeted attack, the adversary adjusts the malware sample to be classified as any class but the true class. In a targeted attack, the adversary adjusts the malware sample to be classified as a chosen false class.

III-A2 Adversarial Capabilities

The adversary does not have any training phase capabilities, e.g, data injection and data modification, and limits the attack surface to the testing phase. We consider two separate types of adversaries, a white-box and a strict black-box adversary. The white-box adversary has total knowledge about the target model’s architecture, weights, training algorithm, and training data distribution. The strict black-box adversary only has the ability to collect input-output pairs $(\mbox{malware},\mbox{class}^{\prime})$ where $\mbox{class}^{\prime}$ is the label assigned the the sample by the target classifier.

III-B Semantic nops

We compiled a list of 23 semantic nops that are used in the dynamic programming algorithm introduced in Section III-C to create our executable adversarial examples. The semantic nops are inserted into a malware sample to create executable adversarial malware examples using a dynamic programming algorithm.

III-C Generating executable adversarial malware examples

The Adversarial Malware Alignment Obfuscation (AMAO) algorithm follows a standard dynamic programming structure and resembles string matching algorithms. The algorithm takes two binary strings, $B1$ and $B2$, and a list of insertion points as inputs. The binary string $B1$ has a length of $n$ (in bits) and is the binary representation of the non-executable adversarial example generated by a standard adversarial example generation attack (such as C&W). $B2$ has length $m$ (in bits) and is the binary representation of the original malware sample. Insertion points are address locations within $B2$ where an insertion of a semantic nop would not split an existing opcode and its operands. The goal of AMAO is to insert semantic nops at $B2$’s insertion points such that $B2$ matches $B1$ as closely as possible. Note that $m<n$ as we are only interested in inserting semantic nops in the original malware and are not modifying the non-executable adversarial example. The output of the algorithm is an adversarial malware example that follows the original sample’s program logic.

We define an $n\times m$ table $O$ for memoization. $O[i][j]$ is defined as the minimum distance between $B1[1:i]$ and $B2[1:j]$ with $B1[i]$ matched with $B2[j]$. We observe that the following recurrence holds:

[TABLE]

where

[TABLE]

for some distance function $D$ between binary strings and a list of semantic nops $L_{\mbox{nops}}$. At each step, the algorithm chooses between inserting a semantic nop and not inserting anything. We complete our description of the algorithm by noting that the base cases are trivial; $O[i][1]$ for all $i=1\ldots n$ is equal to $D(B1[i],B2[1])$. After the base cases are computed, we complete the rest of the table using the sub-problem defined in Equation 3 and Algorithm 1. Note that table $O$ is lower triangular as we assume $j\geq i$.

The distance metric was the sum over all bit differences, or

[TABLE]

where $x_{1}$ and $x_{2}$ are the adversarial example and malware sample, respectively, read in as a binary string. The binary strings are assumed to have the same length. In the case that $x_{1}$ and $x_{2}$ have different lengths, we pad the front of the shorter binary string with 0’s.

At the completion of the algorithm, the optimal solution’s distance from the adversarial example is located in $O[n][m]$. From this, we can trace-back to the binary string that the optimal solution represents.

It is important to note that adding semantic nops is much easier given the source code as the obfuscation can be added in the form of LLVM bitcode [19]. Without the source, we rely on the analysis and patching techniques laid out in [20] and [21].

III-D Closed loop model

Because our method obfuscates a malware sample to match an adversarial example as much as possible, it is possible that the output executable may not fool the classifier. Thus, we propose a closed loop model, in which we continue to train the adversarial noise until a 0% classification accuracy is achieved.

Our initial adversarial examples are generated using the architecture shown previously in Figure 3 with FGSM. Initially, the adversarial noise is generalized over the test set and may not create adversarial examples when added to a malware sample. In subsequent loops, we begin to apply more computationally expensive adversarial example generation algorithms by generating adversarial noise specific to each malware sample and creating adversarial examples using the C&W attack. The initial generalized approach reduces computational cost, however, any adversarial example generation algorithm can be used before input to the proposed AMAO algorithm.

III-E Binary string distance metric

There are multiple choices for the closeness measure used between the image adversarial example and the executable adversarial malware example. We experimented with two measures, $L_{2}$ and $L_{0}$ distance. In measuring the distance between two byte-sequences, the $L_{2}$ distance is the standard Euclidean distance between the image representations of the two byte-sequences. The $L_{0}$ distance counts how many bytes differ between the two sequences. For example, let $B_{1}$ = 0x9000 and let $B_{2}$ = 0x9100. The first bytes of $B_{1}$ and $B_{2}$ differ, resulting in a distance of 1. Comparatively, the $L_{2}$ distance is calculated using pixel values and the distance between bytes 0x90 and 0x91 is shorter than between bytes 0x90 and 0xFF. A distance metric using the $L_{\infty}$ norm was not considered due to its behavior in insertion problems. This is because minimizing the maximum change to a byte between two byte-sequences does not guarantee minimal insertions between the two sequences. For example, let $B_{1}$ from the previous example be our goal sequence. This means that we will be inserting semantic nops to $B_{2}$ such that the distance between $B_{1}$ and $B_{2}$ is minimized. Using the $L_{\infty}$ distance, consider the following cases. 1) $B_{2}$ = 0x9090; In this case the $L_{\infty}$ distance is 90. 2) $B_{2}$ = 0x90908585; the $L_{\infty}$ distance is also 90. If 0x85 was a semantic nop, this byte can be inserted to a sequence an infinite number of times without affecting the distance.

Using the $L_{2}$ distance resulted in executable malware examples with a higher misclassification rate compared to those created using the $L_{0}$ distance. The $L_{2}$ distance measure allows AMAO to minimize perturbations to pixel values, which is the input to our target classifiers. The $L_{0}$ distance does not capture important differences between two byte-sequences, i.e., given two semantic nops of the same length, the $L_{0}$ distance does not capture the difference between inserting one semantic nop or the other.

IV Experimental results

In this section, we will outline and discuss the experimental results of our method on different classifiers in a white-box and black-box setting.

IV-A Dataset

We evaluated the effectiveness of our method using the Malimg dataset [4] and the MMBIG dataset [5]. The Malimg dataset is already in the necessary black and white image representation and contains 25 unique classes. We transformed the MMBIG dataset into the correct format by parsing the given hex dumps. The MMBIG dataset consists of 9 unique classes.

To compare against random obfuscation, We used random nop insertion as there is no algorithmic approach to dummy code insertion, to the best of our knowledge.

IV-B White-box setting

In this section, we consider the results of our method with access to the classifier’s computational graph and weights.

We trained a simple convolutional neural network, depicted in Figure 4 to classify the Malimg dataset with a classification accuracy of $90\%$ on the training validation set. This translated to an $85\%$ accuracy rate on the test set. We optimized adversarial noise for each of the 25 classes using the gradients of the trained model in a closed loop, which consists of FGSM and C&W. In addition to the simple convolutional neural network, we also trained LeNet5 [22] because it was originally designed to be used with black and white characters such as MNIST. LeNet5 was trained and achieved $92\%$ classification accuracy on the training validation set and $87\%$ classification accuracy on the test set. The same procedure was used to generate white-box executable adversarial malware examples targeting LeNet5.

Our method was designed to terminate at a $0\%$ accuracy rate, or after some number $k$ iterations. As expected, our generated adversarial examples were all misclassified by the previously trained classifiers.

IV-C Black-box setting

There will always be cases when adversarial examples must be crafted without uninhibited access to the model and its weights. To evaluate or method in these circumstances, we first trained two models on the Malimg dataset. 1.) The first is InceptionV3, which is Google’s convolutional neural network architecture for image recognition introduced in [23]. InceptionV3 was trained using transfer learning to classify the Malimg dataset. 2.) The second is a gradient boosted tree classifier, using XGBoost, based on top MMBIG Kaggle competition submissions, using popular op-codes, the top 500 4-grams, and features extracted from the image representations of the malware [24]. We then fed the same adversarial examples generated during our white-box setting attack, to these two classifiers without any further optimization or alteration. We also repeat this process against MalConv, a deep neural network classifier that takes raw byte sequences as input [25].

IV-D Attack analysis

The results of both black-box and white-box experiments are given in Table I. It is interesting to note that one loop of AMAO resulted in malware samples of which only around 50% were able to successfully fool the InceptionV3 and MalConv. However, the same samples were much more effective against our boosted trees classifier, achieving  98% misclassification rate. Our method also consistently outperformed randomized dummy code obfuscation.

It is also interesting to note that the initial highest performing classifier is not necessarily the most robust against adversarial examples. InceptionV3 was marginally better than our simple CNN with respect to classification accuracy, but proved to be much more robust against our executable adversarial examples, maintaining a 50% and 27% classification accuracy against single-loop and full AMAO, respectively.

IV-E Effectiveness against defense strategies

To further analyze the effectiveness of our proposed method, we present experimental results of generated adversarial malware examples against popular adversarial defense strategies in Table II. We also compare our work with the payload method proposed by [26].

We present the classification accuracies of a simple convolutional neural network, LeNet, and InceptionV3 when classifying unobfuscated malware, adversarial malware examples generated using the payload method, and adversarial malware examples generated using AMAO. Each model attempted the classification task with no defense, adversarial training, and defensive distillation. The accuracy of classifying true data samples is also included to show that the defense techniques are not overfitting to the adversarial examples.

The defenses were both done as a ”one time” retraining. Each classifier was first trained on true samples before generating adversarial examples to be used in the retraining phase. During retraining, each classifier was trained until the validation accuracy reached the same accuracy as for classifying true samples. We present the classification accuracy on new adversarial examples that were generated against the defended networks.

Interestingly, defensive distillation slightly increases the classification accuracy of the true test set. The results show that distillation increased the average classification accuracy of the true test set by $1\%$ across the three classifiers.

The defense techniques were not able to significantly increase classification accuracy against attacks generated using AMAO. Surprisingly, InceptionV3’s classification drastically dropped when it was trained using adversarial training and distillation.

The payload method did not reduce any model’s classification accuracy significantly. We believe that the addition of bytes to the end of the malware binaries may work with deep neural networks with an embedding layer, such as MalConv, but is not enough to affect image classifiers [25].

We also attempted to experimentally compare our method with the method proposed in [28]. A toy implementation of the proposed method was tested. However, because this work creates adversarial malware examples by perturbing bytes in the header, we did not include these results as neither the Malimg dataset nor the Microsoft malware challenge dataset contains complete headers. The toy implementation was tested on randomly generated bytes acting as a header to the existing data. Because we had no guarantees that the toy implementation behaved on random byte sequences as the authors intended, we omit these results. However, because of its similarity to the payload method, we believe perturbing bytes in the header only works for architectures similar to MalConv and not image based classifies.

IV-F Comparisons to other obfuscation methods

In this section, we will begin with a brief overview of some other obfuscation methods (found in [29] and the references therein) and compare them to AMAO.

IV-F1 Subroutine reordering

In this type of obfuscation, the order in which the subroutines appear in the executable are permuted. This change does not alter the program logic as it does not affect the execution of a program.

IV-F2 Mixing control flow

Control flow mixing relies heavily on the jmp instruction to alter the code sequencing but preserve the original behavior. The number of additional jmp instruction increases with the number of lines that are permuted, leading to different signatures and different memory mappings. Below is a simple example of control flow mixing.

xor eax, eax 00 jmp short 16 mov eax, 0x45 05 mov eax, 0x45 mov ecx, 0x20 --> 0a mov ecx, 0x20 ret 0f jmp short 1d 16 xor eax, eax 1b jmp 05 1d ret

IV-F3 Instruction substitution

Instruction Substitution relies on the fact that instructions can be executed in multiple ways. For example, an XOR gate can be constructed in at least 4 ways. There are two common ways to utilize this transformation.

a. Static value obfuscation The first is to obfuscate static values that are assigned to variables or moved to registers. We can change a mov instruction into a sequence of instructions that is logically equivalent like shown in the example below.

                mov eax, 0x45

mov eax, 0x12 --> add eax, 0x03 xor eax, 0x5a

The sequence on the right results in the same value in eax, but does not immediately leak the value of 0x12.

b. Binary operators The second commonly used method is to replace standard binary operators, such as addition and subtraction, with more complicated, but equivalent, code sequences. For example, a simple addition $a=b+c$ can be substituted with

r = rand()
a = b + r;
a = a + c;
a = a - r;

IV-F4 Obfuscation results

To test the effectiveness of the obfuscation techniques in a real world setting, we apply obfuscation to the test set given in the Microsoft malware challenge [5] and feed it to a trained classifier. In this set of experiments, the top scoring submission to the Microsoft malware challenge was used as the classifier. The combination of features used in this classifier makes it more similar to current malware detection and classification approaches.

Table III shows the classification accuracy of the model when fed malware data that has undergone different obfuscation. All obfuscation, other than AMAO, was applied randomly to the malware samples with a fixed file size limit. The results show that instruction substitution, subroutine reordering, and static value obfuscation do not significantly reduce the classification accuracy of the classifier. Random dummy code insertion results in $87.98\%$ classification accuracy, an $11.3\%$ decrease in classification accuracy compared to the same model classifying the original test set. Mixing control flow is most effective out of the randomly inserted obfuscation with a $39.46\%$ classification accuracy. However, as shown in Table III and Section IV, AMAO results in $0.0\%$ classification accuracy. AMAO only uses dummy code insertion, but still results in greater evasion rates than the other obfuscation techniques. In Section V, we will further discuss the patterns learned by AMAO.

IV-F5 A note on packers

Packers are the most popular obfuscation technique currently used to evade real-world antivirus systems [30]. Packers use compression algorithms to obfuscate malicious code by attempting to eliminate malign features. Typically, packed malware will contain the compressed malware and a decryption engine that will undo the compression at runtime. We experimented with packed malware but the results were omitted because recent work has shown that entropy, section hashing, and consistently executing graph mining can be used to classify packed malware [31, 32, 33]. Being able to be detected using entropy and hashing approaches leads us to believe packing is not well-suited for use in adversarial example generation.

V Discussion

By using obfuscation, our method ensures the adversarial example is executable. This makes our examples effective against dynamic analysis as well as static analysis. A simple method to detect adversarial examples given malware samples to classify would be to run the sample in a sandbox environment to extract dynamic features. If the sample does not run or does not behave maliciously before any kind of termination, it can be categorized as an adversarial example or a corrupted sample. To the best of our knowledge, AMAO is the first proposed method to use obfuscation to create executable adversarial examples. This allows AMAO to modify any section of a binary file. Its resulting malware samples can also be used as input to other detectors and classifiers because both static and dynamic features can be extracted from it. We also believe that the addition of nop-like system and API calls, such as time(), creates adversarial input to non-image classification models, meaning the adversarial examples cover multiple feature spaces, unlike other methods in the literature. Another example would be to insert nops, affecting classifiers that use n-grams as a feature.

Obfuscation is usually applied to binaries randomly or without discretion because its goal is only to convolute the program’s logic, hiding it from reverse engineers and analysis tools. However, AMAO uses generated adversarial examples, which are created using established methods, to generate obfuscation. Because the obfuscation is designed according to adversarial examples, AMAO is much more effective against classifiers than randomized obfuscation methods.

V-A Learning to insert dummy code

We can further learn effective dummy code insertion from creating executable adversarial malware examples using AMAO by extracting learned patterns.

By outputting the decisions of the dynamic programming algorithm, we can develop a heuristic for dummy code insertion. Specifically, for each semantic nop in our vocabulary, we extract the frequency that it is inserted over the set of all valid insertion points. The frequencies of insertion can be separated by criteria such as attack target class, specific semantic-nops, and the intersection of the two as can be seen in Figure 5.

VI Related works in adversarial examples

Reference [34] proposed generating adversarial examples of the DREBIN Android malware dataset and claimed up to an 84% misclassification rate. The DREBIN dataset, introduced in [35], is a collection of features from static and dynamic analysis of the Android malware. Similar to the work by Grosse, [36] proposed a method to craft adversarial examples against RNNs, further building upon the work of [18], which introduced an iterative algorithm to generate adversarial examples and then extended their work to RNNs. Reference [37] introduced MalGAN, a generative adversarial network used to generate adversarial malware examples to fool black-box machine learning models, and showed high evasion rates. MalGAN currently uses API calls as features, but extending the method to create executable adversarial malware examples would make it a more dangerous tool necessitating increased research towards robust models.

Our approaches are similar in that they are both based around perturbing an input $X$ while limiting insertions of features to indices in a set $I$, which contains locations where insertions will not destroying the application’s functionality. However, unlike previous work, our method inserts executable assembly code to the malware, ensuring that binary is immediately executable instead of perturbing extracted features.

After [25] first proposed detecting malware using sequences of raw bytes with MalConv, [10] proposed a method to generate adversarial examples while preserving functionality by injecting a payload of byte sequences into unused sections in the middle or end of a file, and claimed adversarial examples generated using FGSM might not preserve the functionality of the file as the changes to the embedding layer of their network architecture may have unwanted effects on the functionality of the code. Our method circumvents this by using an image representation of malware instead of the one-hot representation used in [27]. Our method also is not limited to inserting payloads or adversarial perturbations into non-executable sections as our perturbations are in the form of already executable instructions. This enables our method to also be effective against classifiers using features such as API and system calls, as well as n-grams. We also showed in Section IV that this payload method cannot evade image-based classifiers such as LeNet and InceptionV3, however AMAO evades classification by MalConv.

Reference [28] proposed a method to generate adversarial malware examples by perturbing bytes in the malicious binary’s header. The proposed attack uses feature attribution to identify important input features to perturb. This proposed approach is similar to that of [27] as they both perturb ”allowable” bytes. The payload method perturbs bytes in the data sections or to padding at the end of the binary and [28]’s method perturbs bytes in the header that are unimportant to the header’s functionality. Because their similarities, header perturbations suffer the same drawbacks as the payload method.

VII Conclusion and future work

In this paper, we introduced a novel method for generating executable adversarial examples of malware samples. We designed and used the Adversarial Malware Alignment Obfuscation algorithm and showed, through our evaluation on the Malimg dataset, that we were able to achieve high evasion rates in both white and black box settings against state of the art image and malware classifiers. Our method works by creating adversarial examples and then designing obfuscation based off of those examples. To the best of our knowledge, AMAO is the first proposed method to incorporate obfuscation in creating executable adversarial malware examples. This allows adversarial perturbation in any section of the malware while ensuring its executability and persevering its functionality. Because AMAO works with byte sequences, the resulting examples can be easily converted to binary files from images. This means that our adversarial examples can also be used against classifiers that use static and dynamic features extracted using program analysis techniques.

We further showed the effectiveness of our proposed method by evading deep neural network classifiers such as LeNet5 and InceptionV3 with and without popular defense techniques, adversarial training and distillation. In this defensive analysis, we compared the proposed method with that of [26] and showed that our proposed method achieved higher evasion rates against image-based classifiers while also evading other classifiers such as MalConv.

This work also introduced an effective obfuscation algorithm to evade classification to replace ad-hoc or randomized obfuscation. By gathering information during the proposed adversarial example generation algorithm, heuristics for obfuscating malware binaries can be developed. Executable adversarial malware examples can be generated by using the learned patterns as a guide for semantic nop insertion.