Malware Detection Using Dynamic Birthmarks

Swapna Vemparala; Fabio Di Troia; Corrado A. Visaggio; Thomas H.; Austin; and Mark Stamp

arXiv:1901.07312·cs.CR·January 23, 2019

Malware Detection Using Dynamic Birthmarks

Swapna Vemparala, Fabio Di Troia, Corrado A. Visaggio, Thomas H., Austin, and Mark Stamp

PDF

Open Access

TL;DR

This paper evaluates dynamic analysis techniques, specifically Hidden Markov Models and Profile Hidden Markov Models, for malware detection based on API call sequences, showing that dynamic analysis outperforms static methods and PHMMs outperform HMMs.

Contribution

It introduces and compares dynamic analysis methods for malware detection, demonstrating the superior performance of PHMMs over HMMs and static analysis.

Findings

01

Dynamic analysis with HMMs and PHMMs is more effective than static analysis.

02

PHMMs outperform HMMs in malware detection.

03

Dynamic analysis techniques achieve significantly stronger results in many cases.

Abstract

In this paper, we explore the effectiveness of dynamic analysis techniques for identifying malware, using Hidden Markov Models (HMMs) and Profile Hidden Markov Models (PHMMs), both trained on sequences of API calls. We contrast our results to static analysis using HMMs trained on sequences of opcodes, and show that dynamic analysis achieves significantly stronger results in many cases. Furthermore, in contrasting our two dynamic analysis techniques, we find that using PHMMs consistently outperforms our analysis based on HMMs.

Tables12

Table 1. Table 1: HMM Notation

notation	explanation
$T$	length of the observation sequence
$N$	number of states in the model
$M$	number of observation symbols
$Q$	distinct states, ${q_{0}, q_{1}, \dots, q_{N - 1}}$
$V$	set of possible observations, ${0, 1, \dots, M - 1}$
$A$	state transition probabilities
$B$	observation probability matrix
$π$	initial state distribution
$𝒪$	observation sequence $(𝒪_{0}, 𝒪_{1}, \dots, 𝒪_{T - 1})$

Table 2. Table 2: PHMM Notation

notation	explanation
$X$	sequence of emitted symbols, $x_{1}, x_{2}, \dots, x_{i}$
$N$	number of states
$M$	match states, $M_{1}, M_{2}, \dots, M_{N}$
$I$	insert states, $I_{1}, I_{2}, \dots, I_{N}$
$D$	delete states, $D_{1}, D_{2}, \dots, D_{N}$
$π$	initial state distribution
$A$	state transition probability matrix
$a_{M_{i} M_{i + 1}}$	transition probability from $M_{i}$ to $M_{i + 1}$
$E$	emission probability matrix
$ε_{M_{i}} (k)$	emission probability of symbol $k$ at state $M_{i}$
$λ$	the PHMM, $λ = (A, E, π)$

Table 3. Table 3: Global versus Local Alignment

unaligned sequences	CBCBJILIIJEJE
	GCBJIIIJJEG
global alignment	-CBCBJILIIJEJE-
	\| \|\|\| \|\|\| \|\|
	GC--BJI-IIJ-JEG
local alignment	*CBJILII-JE
	\|\|\|\| \|\| \|\|
	*CBJI-IIJJE

Table 4. Table 4: Example Pairwise Alignment Scores

	1	2	3	4	5	6	7	8	9	10
1	—	85	63	74	70	84	61	57	62	70
2	85	—	79	73	66	59	94	61	59	51
3	63	79	—	75	68	60	55	85	52	65
4	74	73	75	—	105	54	60	78	59	53
5	70	66	68	105	—	40	61	79	58	39
6	84	59	60	54	40	—	68	45	75	78
7	61	94	55	60	61	68	—	64	72	42
8	57	61	85	78	79	45	64	—	50	70
9	62	59	52	59	58	75	72	50	—	81
10	70	51	65	53	39	78	42	70	81	—

Table 5. Table 5: Snapshots of MSA Construction

MSA at intermediate step
seq.	alignment
5	`CDABBAFCDB1AAEAA+CEDA+EQ+CDABABABALF4`
4	`2AABBAFCDABA+EAABCEDCDEQFCDABA+APALF4`
8	`++AABA+CDB+AAEAA+CEDCDEQ+CDABPBA+ABF4`
3	`A+ABBAFCDABA+EAA+CEDCDEQA++ABFBAN++F4`
Next pairwise alignment
seq.	alignment
2	`A-ABNBAFCD-BAAEAABCEDA-EQ-CDABAB--BAF4`
3	`A+AB-BAFCDABA+EAA+CEDCDEQA++ABFBAN++F4`
MSA after including sequence 2
seq.	alignment
5	`CDAB+BAFCDB1AAEAA+CEDA+EQ+CDABABABALF4`
4	`2AAB+BAFCDABA+EAABCEDCDEQFCDABA+APALF4`
8	`++AA+BA+CDB+AAEAA+CEDCDEQ+CDABPBA+ABF4`
3	`A+AB+BAFCDABA+EAA+CEDCDEQA++ABFBAN++F4`
2	`A+ABNBAFCD+BAAEAABCEDA+EQ+CDABAB++BAF4`

Table 6. Table 6: Final MSA

seq.	alignment
01	`A-AB-BAFCD-B-AAEA0ACEDA-EQ---A-ABCDBALF4`
02	`A-ABNBAFCD-B-AAEAABCEDA-EQ-CDABAB--BA-F4`
03	`A-AB-BAFCDAB-A-EAA-CEDCDEQA--ABFBAN---F4`
04	`2AAB-BAFCDAB-A-EAABCEDCDEQFCDABA-APAL-F4`
05	`CDAB-BAFCDB1-AAEAA-CEDA-EQ-CDABABABAL-F4`
06	`CDABAAA----B-A-EA-ACEDCDEQ---A-ABCD-A-F4`
07	`CDAB--A-CDAB-A-EAA-CEDA-EQ-CDABCDCDAA-F4`
08	`--AA-BA-CDB--AAEAA-CEDCDEQ-CDABPBA-AB-F4`
09	`CDAB--RBAFABPAAEA-ACEDCDEQAABCDAFAL---F4`
10	`A-ABAA-----B-AAEA-ACEDCDEQAABAFA------F4`

Table 7. Table 8: Emission Probabilities for the MSA in Table 7

$ε_{M_{1}} (E) = 5 / 8$	$ε_{I_{1}} (E) = 1 / 4$
$ε_{M_{1}} (G) = 1 / 8$	$ε_{I_{1}} (G) = 1 / 4$
$ε_{M_{1}} (C) = 1 / 8$	$ε_{I_{1}} (C) = 1 / 4$
$ε_{M_{1}} (J) = 1 / 8$	$ε_{I_{1}} (J) = 1 / 4$
$ε_{M_{2}} (E) = 1 / 9$	$ε_{I_{2}} (E) = 3 / 9$
$ε_{M_{2}} (G) = 3 / 9$	$ε_{I_{2}} (G) = 2 / 9$
$ε_{M_{2}} (C) = 4 / 9$	$ε_{I_{2}} (C) = 1 / 9$
$ε_{M_{2}} (J) = 1 / 9$	$ε_{I_{2}} (J) = 3 / 9$
$ε_{M_{3}} (E) = 1 / 8$	$ε_{I_{3}} (E) = 1 / 4$
$ε_{M_{3}} (G) = 5 / 8$	$ε_{I_{3}} (G) = 1 / 4$
$ε_{M_{3}} (C) = 1 / 8$	$ε_{I_{3}} (C) = 1 / 4$
$ε_{M_{3}} (J) = 1 / 8$	$ε_{I_{3}} (J) = 1 / 4$

Table 8. Table 9: Transition Probabilities for the MSA in Table 7

$a_{B M_{1}} = 5 / 8$	$a_{I_{0} M_{1}} = 1 / 3$
$a_{B I_{0}} = 1 / 8$	$a_{I_{0} I_{0}} = 1 / 3$
$a_{B D_{1}} = 2 / 8$	$a_{I_{0} D_{1}} = 1 / 3$
$a_{M_{1} M_{2}} = 5 / 7$	$a_{I_{1} M_{2}} = 1 / 3$	$a_{D_{1} M_{2}} = 2 / 4$
$a_{M_{1} I_{1}} = 1 / 7$	$a_{I_{1} I_{1}} = 1 / 3$	$a_{D_{1} I_{1}} = 1 / 4$
$a_{M_{1} D_{2}} = 1 / 7$	$a_{I_{1} D_{2}} = 1 / 3$	$a_{D_{1} D_{2}} = 1 / 4$
$a_{M_{2} M_{3}} = 2 / 8$	$a_{I_{2} M_{3}} = 4 / 8$	$a_{D_{2} M_{3}} = 1 / 3$
$a_{M_{2} I_{2}} = 4 / 8$	$a_{I_{2} I_{2}} = 3 / 8$	$a_{D_{2} I_{2}} = 1 / 3$
$a_{M_{2} D_{3}} = 2 / 8$	$a_{I_{2} D_{3}} = 1 / 8$	$a_{D_{2} D_{3}} = 1 / 3$
$a_{M_{3} E} = 5 / 6$	$a_{I_{3} E} = 1 / 2$	$a_{D_{3} E} = 2 / 3$
$a_{M_{3} I_{3}} = 1 / 6$	$a_{I_{3} I_{3}} = 1 / 2$	$a_{D_{3} I_{3}} = 1 / 3$

Table 9. Table 10: Malware Files

Malware Family	Number of Files
Cridex	050
Harebot	050
Security Shield	050
SmartHdd	050
Winwebsec	100
Zbot	100
Zeroaccess	100

Table 10. Table 11: Benign files

No.	Benign file
1	bdaycontrol.exe
2	IRATrack.exe
3	MineSweeper.exe
4	SpiderSolitaire.exe
5	PurblePlace.exe
6	FreeCell.exe
7	Chess.exe
8	7zFM.exe
9	hh.exe
10	Mahjong.exe
11	DVDMaker.exe
12	datewiz.exe
13	winhlp32.exe
14	bdaycheck.exe
15	setup.exe
16	Countdown Pro.exe
17	unins000.exe
18	bckgzm.exe
19	nanoclock.exe
20	shvlzm.exe

Table 11. Table 12: AUC Curve Results for Static and Dynamic HMMs

	AUC
Malware family	Dynamic	Static
Cridex	0.964	0.596
Harebot	0.974	0.622
Security Shield	1.000	0.676
SmartHdd	0.980	0.996
Winwebsec	0.985	0.835
Zbot	0.990	0.847
Zeroaccess	0.979	0.923

Table 12. Table 13: PHMM Results

Malware Family	AUC Results
Malware Family	group 5	group 10	group 15	group 20	group 30
Cridex	0.958	1.000	—	—	—
Harebot	0.875	0.952	1.000	—	—
Security Shield	0.988	0.964	1.000	—	—
SmartHdd	0.812	0.905	0.963	1.000	—
Winwebsec	0.997	0.995	1.000	—	—
Zbot	0.915	0.970	1.000	—	—
Zeroaccess	0.905	0.988	0.968	0.975	1.000

Equations74

P (O ∣ X, λ) = b_{x_{0}} (O_{0}) b_{x_{1}} (O_{1}) \dots b_{x_{T - 1}} (O_{T - 1})

P (O ∣ X, λ) = b_{x_{0}} (O_{0}) b_{x_{1}} (O_{1}) \dots b_{x_{T - 1}} (O_{T - 1})

P (X ∣ λ) = π_{x_{0}} a_{x_{0}, x_{1}} a_{x_{1}, x_{2}} \dots a_{x_{T - 2}, x_{T - 1}} .

P (X ∣ λ) = π_{x_{0}} a_{x_{0}, x_{1}} a_{x_{1}, x_{2}} \dots a_{x_{T - 2}, x_{T - 1}} .

P (O, X ∣ λ) = \frac{P ( O \cap X \cap λ )}{P ( λ )}

P (O, X ∣ λ) = \frac{P ( O \cap X \cap λ )}{P ( λ )}

P (O ∣ X, λ) P (X ∣ λ)

P (O ∣ X, λ) P (X ∣ λ)

= \frac{P ( O \cap X \cap λ )}{P ( λ )}

P (O, X ∣ λ) = P (O ∣ X, λ) P (X ∣ λ) .

P (O, X ∣ λ) = P (O ∣ X, λ) P (X ∣ λ) .

P (O ∣ λ)

P (O ∣ λ)

= X \sum P (O ∣ X, λ) P (X ∣ λ)

= X \sum π_{x_{0}} b_{x_{0}} (O_{0}) a_{x_{0}, x_{1}} b_{x_{1}} (O_{1}) \dots

\dots a_{x_{T - 2}, x_{T - 1}} b_{x_{T - 1}} (O_{T - 1}) .

α_{t} (i) = P (O_{0}, O_{1}, \dots, O_{t}, x_{t} = q_{i} ∣ λ) .

α_{t} (i) = P (O_{0}, O_{1}, \dots, O_{t}, x_{t} = q_{i} ∣ λ) .

\alpha_{t}(i)=\Biggl{(}\sum_{j=0}^{N-1}\alpha_{t-1}(j)a_{ji}\Biggr{)}b_{i}({\cal O}_{t})

\alpha_{t}(i)=\Biggl{(}\sum_{j=0}^{N-1}\alpha_{t-1}(j)a_{ji}\Biggr{)}b_{i}({\cal O}_{t})

P (O ∣ λ) = i = 0 \sum N - 1 α_{T - 1} (i) .

P (O ∣ λ) = i = 0 \sum N - 1 α_{T - 1} (i) .

β_{t} (i) = P (O_{t + 1}, O_{t + 2}, \dots, O_{T - 1} ∣ x_{t} = q_{i}, λ)

β_{t} (i) = P (O_{t + 1}, O_{t + 2}, \dots, O_{T - 1} ∣ x_{t} = q_{i}, λ)

β_{t} (i) = j = 0 \sum N - 1 a_{ij} b_{j} (O_{t + 1}) β_{t + 1} (j) .

β_{t} (i) = j = 0 \sum N - 1 a_{ij} b_{j} (O_{t + 1}) β_{t + 1} (j) .

γ_{t} (i) = P (x_{t} = q_{i} ∣ O, λ) .

γ_{t} (i) = P (x_{t} = q_{i} ∣ O, λ) .

γ_{t} (i) = \frac{α _{t} ( i ) β _{t} ( i )}{P ( O ∣ λ )} .

γ_{t} (i) = \frac{α _{t} ( i ) β _{t} ( i )}{P ( O ∣ λ )} .

γ_{t} (i, j) = P (x_{t} = q_{i}, x_{t + 1} = q_{j} ∣ O, λ) .

γ_{t} (i, j) = P (x_{t} = q_{i}, x_{t + 1} = q_{j} ∣ O, λ) .

γ_{t} (i, j) = \frac{α _{t} ( i ) a _{ij} b _{j} ( O _{t + 1} ) β _{t + 1} ( j )}{P ( O ∣ λ )} .

γ_{t} (i, j) = \frac{α _{t} ( i ) a _{ij} b _{j} ( O _{t + 1} ) β _{t + 1} ( j )}{P ( O ∣ λ )} .

γ_{t} (i) = j = 0 \sum N - 1 γ_{t} (i, j) .

γ_{t} (i) = j = 0 \sum N - 1 γ_{t} (i, j) .

π_{i} = γ_{0} (i)

π_{i} = γ_{0} (i)

a_{ij}=\sum_{t=0}^{T-2}\gamma_{t}(i,j)\bigg{/}\sum_{t=0}^{T-2}\gamma_{t}(i).

a_{ij}=\sum_{t=0}^{T-2}\gamma_{t}(i,j)\bigg{/}\sum_{t=0}^{T-2}\gamma_{t}(i).

b_{j}(k)=\sum_{\begin{subarray}{c}t\in\{0,1,\ldots,T-1\}\\ {\cal O}_{t}=k\end{subarray}}\gamma_{t}(j)\bigg{/}\sum_{t=0}^{T-1}\gamma_{t}(j).

b_{j}(k)=\sum_{\begin{subarray}{c}t\in\{0,1,\ldots,T-1\}\\ {\cal O}_{t}=k\end{subarray}}\gamma_{t}(j)\bigg{/}\sum_{t=0}^{T-1}\gamma_{t}(j).

\mbox CBCBJILIIJEJE \mbox an d \mbox GCBJIIIJJEG .

\mbox CBCBJILIIJEJE \mbox an d \mbox GCBJIIIJJEG .

{(4, 5), (2, 7), (1, 2), (3, 8), (1, 6), (9, 10), (2, 3), (5, 8), (6, 10)}

{(4, 5), (2, 7), (1, 2), (3, 8), (1, 6), (9, 10), (2, 3), (5, 8), (6, 10)}

(5, 4), (5, 8), (8, 3), (3, 2), (2, 7), (2, 1), (1, 6), (6, 10), \mbox an d (10, 9) .

(5, 4), (5, 8), (8, 3), (3, 2), (2, 7), (2, 1), (1, 6), (6, 10), \mbox an d (10, 9) .

(5, 4), (5, 8), \mbox an d (8, 3)

(5, 4), (5, 8), \mbox an d (8, 3)

ε_{M_{1}} (\mbox E) = 4/4, ε_{M_{1}} (\mbox G) = e_{M_{1}} (\mbox C) = e_{M_{1}} (\mbox J) = 0/4

ε_{M_{1}} (\mbox E) = 4/4, ε_{M_{1}} (\mbox G) = e_{M_{1}} (\mbox C) = e_{M_{1}} (\mbox J) = 0/4

ε_{M_{1}} (\mbox E) = 5/8, ε_{M_{1}} (\mbox G) = ε_{M_{1}} (\mbox C) = ε_{M_{1}} (\mbox J) = 1/8.

ε_{M_{1}} (\mbox E) = 5/8, ε_{M_{1}} (\mbox G) = ε_{M_{1}} (\mbox C) = ε_{M_{1}} (\mbox J) = 1/8.

ε_{I_{2}} (\mbox E) = 2/5, ε_{I_{2}} (\mbox G) = 1/5, ε_{I_{2}} (\mbox C) = 0/5, ε_{I_{2}} (\mbox J) = 2/5

ε_{I_{2}} (\mbox E) = 2/5, ε_{I_{2}} (\mbox G) = 1/5, ε_{I_{2}} (\mbox C) = 0/5, ε_{I_{2}} (\mbox J) = 2/5

ε_{I_{2}} (\mbox E) = 3/9, ε_{I_{2}} (\mbox G) = 2/9, ε_{I_{2}} (\mbox C) = 1/9, ε_{I_{2}} (\mbox J) = 3/9.

ε_{I_{2}} (\mbox E) = 3/9, ε_{I_{2}} (\mbox G) = 2/9, ε_{I_{2}} (\mbox C) = 1/9, ε_{I_{2}} (\mbox J) = 3/9.

a_{mn}=\frac{\mbox{transitions from state $m$ to state $n$}}{\mbox{total transitions from state $m$ to any state}}.

a_{mn}=\frac{\mbox{transitions from state $m$ to state $n$}}{\mbox{total transitions from state $m$ to any state}}.

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Taxonomy

TopicsAdvanced Malware Detection Techniques · Network Security and Intrusion Detection · Anomaly Detection Techniques and Applications

Full text

Malware Detection Using Dynamic Birthmarks

Swapna Vemparala111Department of Computer Science, San Jose State University Fabio Di Troia222Department of Engineering, Università degli Studi del Sannio Visaggio Aaron Corrado22footnotemark: 2

Thomas H. Austin11footnotemark: 1 Mark Stamp11footnotemark: 1 333stamp $@$ cs.sjsu.edu

Abstract

In this paper, we explore the effectiveness of dynamic analysis techniques for identifying malware, using Hidden Markov Models (HMMs) and Profile Hidden Markov Models (PHMMs), both trained on sequences of API calls. We contrast our results to static analysis using HMMs trained on sequences of opcodes, and show that dynamic analysis achieves significantly stronger results in many cases. Furthermore, in contrasting our two dynamic analysis techniques, we find that using PHMMs consistently outperforms our analysis based on HMMs.

1 Introduction

News stories abound about cyber attacks relating to malware. In 2014, Twitter was at the receiving end of a major cyber attack. According to news reports, 250,000 users’ email addresses, user names, and passwords were compromised. Twitter was able to detect the attack by identifying the abnormal patterns in which data was accessed [14].

Target fell victim to a major security breach during the 2013 holiday season, where credit and debit card details of more than a million customers were compromised. The information was stolen by hacking the credit card swipe systems at Target stores [10]. This one attack drove down quarterly revenues of Target by tens of millions of dollars [11].

In today’s world of malware and cyber threats, it has become critical to develop techniques that quickly identify malware. In this paper, we look at different malware detection techniques and compare their results.

We use the concept of software birthmarks for malware detection. Software birthmarks are inherent characteristics that can be used to identify particular software [23, 33]. The goal is to obtain a unique identifier for each executable. We can then use these birthmarks to test the similarity between two executables. If the birthmarks of the two files are sufficiently similar, then we assume that one software is closely related to the other. This strategy has been the basis of a variety of techniques for identifying metamorphic malware with statistical approaches [17, 21, 23, 26, 33, 34, 41, 44].

Software birthmarks can be either static or dynamic [17]. Static birthmarks are characteristics that can be extracted from a program without executing it [44]. For example, a static birthmark can be based on an extracted opcode sequence. In contrast, dynamic birthmarks are obtained from a program when it is executed [21, 33, 44]. An example of a dynamic birthmark is the sequence of API calls that occur when a program is executed [34].

Previous work explored static birthmarks for malware detection [34]; this paper instead considers dynamic birthmarks. Specifically, we use Hidden Markov Models (HMMs) and Profile Hidden Markov Models (PHMMs) as the bases for our detection techniques. Both HMM-based analysis [43] and PHMM-based analysis [3] have been previously applied to the malware detection problem.

To compare the effectiveness of our dynamic analysis techniques, we compare static and dynamic analysis results on substantial malware datasets using Receiving Operating Characteristic (ROC) analysis [8]. We show that significantly stronger malware detection results can be obtained using dynamic analysis of software birthmarks, as compared to static analysis. Stated another way, our results suggest that it is more beneficial to consider the API calls used during program execution than to statically analyze the opcodes in a program. Our work also demonstrates that PHMMs are more effective than HMMs in malware analysis when considering this particular type of dynamic birthmark. In our tests, properly tuned PHMMs built from dynamic birthmarks always outperform HMMs built from the same birthmarks.

The remainder of this paper is organized as follows. In Section 2, we provide background information on malware and detection techniques. Sections 3 and 4 respectively cover Hidden Markov Models and Profile Hidden Markov Models. These are the machine learning techniques used in this paper. Section 5 gives a brief survey of related work involving these machine learning techniques. In Section 6, we discuss implementation details. Here, we discuss in detail the tools used for extracting the data, the dataset used, and the application of the machine learning techniques used. Experiments and discussion of the results is given in Section 7. Section 8 concludes and we briefly consider future work.

2 Malware

In this section, we discuss relevant topics related to malware. First, we briefly consider different types of malware. Then we discuss methods used to obfuscate malware, which is followed by an overview of some advanced anti-virus techniques. We conclude with a discussion of software birthmarks, in the context of malware analysis.

2.1 Types of Malware

Malware is a generic term that encompasses viruses, worms, backdoors, and Trojans. In this section, we discuss the different types of malware in detail. Note that here we are primarily concerned with the transmission technique of the malware. Section 2.2 discusses different obfuscation techniques that might be employed by malware writers, and could be applied to any of the forms of malware listed here.

“Virus” is perhaps the most overloaded term used for malware—in the vernacular, virus is a synonym for malware. Technical usage is also sometimes ambiguous. The term virus is sometimes used to refer to self-replicating malware [32], and by this definition includes worms, for instance. In this paper we us a stricter definition: a virus is a type of malware that replicates itself by infecting other files, that is, a virus is parasitic. This definition seems to be somewhat more common, and is the definition used, for example, by Cohen [32].

A germ file (the initial malicious program) infects other, benign files and inserts the virus code into the execution of the benign program. When these infected program are executed, the virus can insert itself into another generation of victim programs. For example, Word macro viruses execute when the user opens an infected Word document, executing their payload and infecting other Word documents [5].

Stuxnet, created in 2010, is a famous examples of a virus. It was primarily developed to target the industrial control systems used in power plants. This malware attacked the programmable logic controllers present in the control systems [40].

In subsequent sections, we often use the term virus in its vernacular sense. That is, we use the terms “virus” and “malware” interchangeably.

A Trojan is malware that looks innocuous to the user, but performs malicious activities in the background. Unlike a virus, a Trojan is a standalone program. Trojans are generally not self-replicating in nature and depend on users for their propagation. As an example, an attacker can create a login program that prompts users to enter their usernames and passwords. If the user enters his or her credentials, the program steals the users login credentials and displays an invalid login message and then runs the actual login program [5]. Trojans can be very harmful, as the user is completely unaware of the malicious activities that take place in the background. Trojans constitute a major portion of the today’s malware activity [20].

Worms are defined primarily by their method of propagation; they self-replicate to different systems through the network [32]. Unlike viruses, worms are not parasitic in behavior, meaning that they do not alter the instructions of other programs. Worms have accounted for some well-known malware exploits, including the Morris worm, Code Red, and SQL Slammer [29].

A backdoor is used to bypass the normal security authentication processes, and could be installed as the result of a worm or virus. After gaining access, it takes control and can remotely monitor the system while stealing personal information [5]. An example for a backdoor malware is Back Orifice. On gaining control of the infected system, this malware can download, upload, or delete files, lock or shutdown the computer, or even take control of the keyboard and mouse [6].

2.2 Malware Obfuscation Strategies

Signature-based detection is the most common strategy used by anti-virus products. This approach involves scanning through the files in a system in search of specific bit patterns. An anti-virus product has a database of patterns or signatures, and if a match is found, then that file is likely to be malware. It is essential that the signature database be updated frequently; otherwise new malware will go undetected.

Signature detection has long been the main approach used to identify malware, largely due to its efficiency and low false positive rate. Therefore, virus authors have worked to change the signature of their malware while still providing the same functionality.

Encryption was one of the first obfuscation strategies used by malware writers, and was seen, for example, in the DOS virus Cascade [13]. By encrypting the body of the malware with a different key, the signature of the payload will be different. During execution, the encrypted code can be decrypted and then run normally.

While encrypting the payload of the virus results in a different signature, the virus must decrypt itself before executing its payload. Therefore, the decryption code may be identified by signature detection.

Typically, simple encryption techniques are used, since there is little benefit to the virus user of a strong encryption mechanism. The encryption can be done by means of a static or a variable key, a simple bitwise rotation, or even by incrementing or decrementing the bits in the virus body [5]. In choosing a decryption algorithm, the virus writer might attempt to use an algorithm that can evade signature detection; more advanced variants of encrypted viruses focus on exactly this problem.

Polymorphic viruses [38] are a variant of encrypted viruses where the decryption code changes in each generation, unlike the case of encrypted viruses, whose decryption code remains constant. When executed, polymorphic viruses decrypt and execute their payload in the same manner as with encrypted viruses. Examples of polymorphic viruses include Tequila and Maltese [38].

Polymorphic viruses work by mutating the code of the decryption routine, producing equivalent decryption routines with different instructions, and therefore different signatures. (We discuss the code mutation techniques in more detail when we review metamorphic viruses, below.) With a wide array of possible versions of the decryption code, signature detection is much more difficult, if not impossible [5].

Code emulation is effective for detecting polymorphic malware. The suspect file is executed for some period of time within a virtual machine until the virus decrypts itself [22]. At that point, standard signature detection techniques can be applied to the file in question.

Metamorphic viruses take polymorphic viruses to the logical extreme. Rather than relying on encryption, morphing techniques are used on the body of the virus; for this reason, metamorphic viruses are sometimes described as “body polymorphic” [32].

A metamorphic virus makes use of a mutation engine in order to morph its body at each generation, but the essentially functionality remains unchanged [5]. Metamorphic viruses can make use of different methods to morph the internal structure. A few of these methods are discussed below.

Dead Code Insertion. This technique is used in many metamorphic viruses. The idea here is to insert dead code in such a way that it does not alter the functionality of the original code. The Win32/Evol virus includes a metamorphic engine that inserts garbage code [22]. 2. 2.

Instruction Reordering. This strategy changes the order of instructions, thereby breaking signatures. As long as no code dependency is broken, instruction reordering does not affect the functionality of the virus. Instruction reordering can be used to generate a large number of morphed copies. 3. 3.

Instruction Substitution. This approach involves replacing a group of instructions with equivalent instructions. The functionality of the malware remains unchanged, but the morphed versions can evade signature detection [5]. 4. 4.

Register Swapping. In this technique, the virus body is morphed by swapping operand registers with different registers. Though the virus body is mutated, this technique does not change the opcode sequence. The W95/Regswap virus uses register swapping [22].

2.3 Anti-Virus Techniques

In the face of increasingly effective techniques for evading signature detection, advanced detection strategies have been developed. In this section, we review some of these approaches.

Unlike signature based detection, static heuristics analysis does not identify malware by scanning for specific signatures. Instead, it analyses the behavior, structure, and other attributes for virus-like qualities [5]. This technique can be used to identify zero-day malware as well as existing malware. This method identifies the probability of a file being infected by performing an analysis of the instructions, the logic of the program, the data used, and the overall structure of the binary file it scans. While static heuristics analysis has the ability to detect malware even before they can infect the computer, they tend to have a high false positive rate [39].

A behavior blocker executes the program and closely monitors it for suspicious activities. If any suspicious activity is encountered, the behavior blocker stops the program [5]. Behavior blockers make use of dynamic signatures, which are created by collecting during program execution.

In general, dynamic detection techniques only consider the instructions that have actually been executed. Dead code insertion, for example, has no impact on dynamic analysis. Consequently, we can view dynamic analysis as stripping away one layer of obfuscation. However, the tradeoff is that dynamic analysis is based only on the parts of the code that execute.

Unlike behavior blockers, emulators do not run the malware directly on the system. Instead, they execute the code in an emulated environment. Emulators make use of dynamic heuristics, which collect information about the malware that is being executed in the emulated environment. Given the fact that dynamic heuristics closely monitor the operating system, they have a significant advantage over static heuristics in detecting malware that targets operating systems. On the negative side, the CPU emulation process is much slower compared to signature scanning, and hence the dynamic heuristics is slower than static heuristics. Also some viruses attempt to hide their infection logic from the emulator by performing the infection only under specific conditions [39].

2.4 Software Birthmarks

Software birthmarks are characteristics that are derived from a particular software. There are two types of birthmarks—static and dynamic. Static birthmarks are characteristics that can be extracted from the program itself without executing it. For example, opcodes sequences can be considered a static birthmark for a program. Dynamic birthmarks are characteristics that are obtained from a program when it is executed. For example, API calls that are recorded when the program is executed could serve as a dynamic birthmark. Next, we briefly discuss examples of analysis techniques that use static and dynamic birthmarks for malware detection

As previously mentioned, static analysis involves analyzing the program without executing it. In [26], static analysis is performed by extracting opcode sequences with the help of a disassembler. The key advantage of static analysis is that it is relatively faster and efficient. Compared to dynamic analysis techniques, it is also safer since it does not involve execution of the malware. The drawback of a static approach is that it may be defeated by code obfuscation techniques [5].

In [23], the authors propose a static $k$ -gram based birthmark. This birthmark is computed by extracting opcode sequences of length $k$ . The effectiveness of this birthmark is tested on randomly selected applications and on programs that are semantically different, but which accomplish the same task. The authors identify an optimum $k$ value at which the credibility and resilience of the birthmark is maximized.

Dynamic analysis is performed to extract dynamic software birthmarks. Dynamic birthmarks, such as API calls obtained at runtime, can be difficult for malware writers to defeated [33], since dynamic birthmarks are resilient to code obfuscation when compared to static birthmarks. The tradeoff is that the cost of dynamic analysis is generally higher and there is risk involved in executing the malware.

In [7], the authors construct a $k$ -gram based birthmark by traversing a window of length $k$ over an opcode sequence in the case of the static analysis and over an executable trace for the dynamic analysis case. The authors evaluated the strength of the dynamic birthmark technique by comparing the results obtained from static and dynamic cases when code obfuscation is applied. They show that the dynamic $k$ -gram birthmark is much more robust than the static case.

Anderson [2] discusses a graph based technique in which a graph is constructed by collecting dynamic instruction traces. The constructed graphs are Markov chains consisting of instructions and transition probabilities. A similarity matrix is created using the graph kernels for different instruction traces. A Support Vector Machine is applied to the similarity matrix to perform the malware classification. The author of [2] shows that this technique is an improvement over previous work.

Tamada et al. [33] use both the API call sequences and the API call frequencies that are collected during runtime as dynamic birthmarks. The authors leverage the fact that different programs using the same APIs do not have the same order of API calls upon execution.

Fukuda et al. [17] consider the operand stack runtime behavior of a Java Virtual Machine. This is a dynamic birthmark, due to its unique nature at runtime. This birthmark exhibits high tolerance to code changes and a good ability to discern programs that could be a pirated version of another.

It is evident from the works above that dynamic birthmarks have some inherent advantages as compared to their static counterparts. Our work consists of developing and analyzing malware detection strategies based on dynamic birthmarks and using Hidden Markov Models and Profile Hidden Markov Models for classification.

3 Hidden Markov Models

In this section, we discuss Hidden Markov Models (HMMs) in some detail. HMMs have proven useful in a wide array of fields, including speech recognition [25], malware detection [43], and software piracy analysis [26]. In this paper, we apply HMMs to the problem of malware detection based on software birthmarks.

A Markov process of order one is a memoryless process where the current state depends only on the prvious state. In a Hidden Markov Model, the state is hidden, in the sense that it cannot be directly observed. However, we do have observations that depend (probabilistically) on the hidden states.

Each state of an HMM has an associated probability distribution over the set of possible observations. Since we have a Markov process, the transition probabilities between the states are fixed. For our research we train an HMM using observation sequences from malware samples belonging to a given family. After training, we can score any given observation sequence against the trained HMM to determine the likelihood of the sequence belonging to the same family that was used to train the HMM. A high probability indicates the scored sample closely matches the sequence used to train the HMM [28].

We use the standard notation in Table 1 in our discussion of HMMs.

The matrices $A$ , $B$ , and $\pi$ provide all relevant information about the model and hence we denote an HMM as $\lambda=(A,B,\pi)$ .

Figure 1 provides a generic illustration of an HMM. In Figure 1, the $X_{i}$ represent the hidden states. The (hidden) Markov process is determined by the $A$ matrix and the present state. The observations ${\cal O}_{i}$ are known and are related to the hidden states by the $B$ matrix. Hence, we can indirectly obtain information about the hidden states from the observation sequence and the $B$ matrix. The matrices $A$ , $B$ and $\pi$ are all row stochastic, that is, each row satisfies the conditions of a discrete probability distribution.

HMMs are useful primarily because there exist efficient algorithms to solve each of the following three problems [28].

3.0.1 Problem 1

Given a model $\lambda=(A,B,\pi)$ and an observation sequence ${\cal O}$ , determine $P({\cal O}\,|\,\lambda)$ . That is, we can score a given observation sequence against a given model.

3.0.2 Problem 2

Given a model $\lambda=(A,B,\pi)$ and an observation sequence ${\cal O}$ , determine an optimal state sequence for the underlying Markov model. That is, we can “uncover” the most likely hidden state sequence.

3.0.3 Problem 3

Given a observation sequence ${\cal O}$ we can generate a model $\lambda=(A,B,\pi)$ such that $P({\cal O}\,|\,\lambda)$ is maximized. That is, we can train a model to fit a given observations sequence.

Next, we discuss the solution to each of these three problems. For additional details, see the tutorial [28] or Rabiner’s classic introduction [25].

3.0.4 Solution to Problem 1

Let $\lambda=(A,B,\pi)$ be a given model and let ${\cal O}=(O_{0},{\cal O}_{1},\ldots,{\cal O}_{T-1})$ be a series of observations. We want to find $P({\cal O}\,|\,\lambda)$ .

Let $X=(x_{0},x_{1},\ldots,x_{T-1})$ be a state sequence. Then by the definition of $B$ we have

[TABLE]

and by the definition of $\pi$ and $A$ it follows that

[TABLE]

Since

[TABLE]

and

[TABLE]

we have

[TABLE]

By summing over all possible state sequences we obtain

[TABLE]

However, this direct computation is generally computationally infeasible.

To compute $P({\cal O}\,|\,\lambda)$ efficiently, the so-called forward algorithm is used. For $t=0,1,\ldots,T-1$ and $i=0,1,\ldots,N-1$ , define

[TABLE]

Then $\alpha_{t}(i)$ is the probability of the partial observation sequence up to time $t$ , where the underlying Markov process is in state $q_{i}$ at time $t$ .

The $\alpha_{t}(i)$ can be computed recursively as follows.

Let $\alpha_{0}(i)=\pi_{i}b_{i}({\cal O}_{0})$ , for $i=0,1,\ldots,N-1$ 2. 2.

For $t=1,2,\ldots,T-1$ and $i=0,1,\ldots,N-1$ , compute

[TABLE] 3. 3.

Then from (3), we have

[TABLE]

The forward algorithm only requires about $N^{2}T$ multiplications, as opposed to more than $2TN^{T}$ for the naïve approach.

3.0.5 Solution to Problem 2

Given the model $\lambda=(A,B,\pi)$ and a sequence of observations ${\cal O}$ , we can find the most likely state sequence. There are different possible interpretations of “most likely.” For HMMs, “most likely” means that we maximize the expected number of correct states.

In analogy to the forward algorithm, we define the backward algorithm as follows. Let

[TABLE]

for $t=0,1,\ldots,T-1$ and $i=0,1,\ldots,N-1$ . Then the $\beta_{t}(i)$ can be computed recursively (and efficiently) using the following algorithm.

Let $\beta_{T-1}(i)=1$ , for $i=0,1,\ldots,N-1$ . 2. 2.

For $t=T-2,T-3,\ldots,0$ and $i=0,1,\ldots,N-1$ compute

[TABLE]

Next, for $t=0,1,\ldots,T-1$ and $i=0,1,\ldots,N-1$ , define

[TABLE]

Since $\alpha_{t}(i)$ measures the relevant probability up to time $t$ and $\beta_{t}(i)$ measures the relevant probability after time $t$ , we have

[TABLE]

As noted above, the denominator $P({\cal O}\,|\,\lambda)$ is obtained by summing $\alpha_{T-1}(i)$ over $i$ . From the definition of $\gamma_{t}(i)$ it follows that the most likely state at time $t$ is the state $q_{i}$ for which $\gamma_{t}(i)$ is maximum, where the maximum is taken over the index $i$ .

3.0.6 Solution to Problem 3

We want to adjust the model parameters to best fit the observations. The sizes of the matrices ( $N$ and $M$ ) are specified, but the elements of $A$ , $B$ and $\pi$ are to be determined, subject to the row stochastic conditions. The fact that we can efficiently re-estimate the model itself is perhaps the most impressive aspect of HMMs.

For $t=0,1,\ldots,T-2$ and $i,j\in\{0,1,\ldots,N-1\}$ , define “di-gammas” as

[TABLE]

Then $\gamma_{t}(i,j)$ is the probability of being in state $q_{i}$ at time $t$ and transiting to state $q_{j}$ at time $t+1$ . The di-gammas can be written in terms of $\alpha$ , $\beta$ , $A$ and $B$ as

[TABLE]

For $t=0,1,\ldots,T-2$ , the $\gamma_{t}(i)$ and $\gamma_{t}(i,j)$ are related by

[TABLE]

Given the $\gamma$ and di-gamma, the model $\lambda=(A,B,\pi)$ can be re-estimated as follows.

For $i=0,1,\ldots,N-1$ , let

[TABLE] 2. 2.

For $i=0,1,\ldots,N-1$ and $j=0,1,\ldots,N-1$ , compute

[TABLE] 3. 3.

For $j=0,1,\ldots,N-1$ and $k=0,1,\ldots,M-1$ , compute

[TABLE]

The numerator of the re-estimated $a_{ij}$ is the expected number of transitions from state $q_{i}$ to state $q_{j}$ , while the denominator is the expected number of transitions from $q_{i}$ to any state. The ratio of these two quantities is the probability of transiting from state $q_{i}$ to state $q_{j}$ , which is our best estimate for $a_{ij}$ .

The numerator of the re-estimated $b_{j}(k)$ is the expected number of times the model is in state $q_{j}$ and we observe symbol $k$ , while the denominator is the expected number of times the model is in state $q_{j}$ . The ratio is the probability of observing $k$ , given that the model is in state $q_{j}$ . This ratio is our best estimate for $b_{j}(k)$ .

Re-estimation is an iterative process. Typically, we initialize $\lambda=(A,B,\pi)$ with random values such that $\pi_{i}\approx 1/N$ and $a_{ij}\approx 1/N$ and $b_{j}(k)\approx 1/M$ . It is critical that $A$ , $B$ and $\pi$ be randomized, since exactly uniform values will result in a local maximum and the model will fail to climb. The matrices $\pi$ , $A$ and $B$ must be initialized to be row stochastic.

The solution to Problem 3 can be summarized as follows.

Initialize, $\lambda=(A,B,\pi)$ . 2. 2.

Compute $\alpha_{t}(i)$ , $\beta_{t}(i)$ , $\gamma_{t}(i,j)$ and $\gamma_{t}(i)$ . 3. 3.

Re-estimate the model $\lambda=(A,B,\pi)$ . 4. 4.

If $P({\cal O}\,|\,\lambda)$ increases, goto 2.

In Section 6, we discuss how we use HMMs in the experiments considered in this paper.

4 Profile Hidden Markov Models

In this section we introduce Profile Hidden Markov Models. Note that in a Hidden Markov Model, the positional information within the observation sequence is not relevant. A PHMM can be viewed as an HMM that takes this positional information into account. In addition, a PHMM accounts for possible insertions and deletions within the observation sequence, which is not the case with a standard HMM.

Not surprisingly, PHMMs are more complex to describe than HMMs. Hence, we do not provide quite as much detail in this section as we did in the previous section.

4.1 Overview and Notation

First, we consider state transitions within a PHMM. That is, we want to determine the PHMM equivalent of the $A$ matrix in an HMM.

Generically, a PHMM includes match ( $M$ ), insert ( $I$ ), and delete ( $D$ ) states, as illustrated in Figure 2. This illustration is essentially the PHMM equivalent of the hidden states (and transitions) in the HMM illustration in Figure 1. That is, the complicated illustration in Figure 2 is just the state transitions of the PHMM, and does not directly include information related to the emissions (i.e., observations). That is, nothing in this figure that corresponds to the $B$ matrix in the HMM.

For a PHMM, the standard notation [12] is summarized in Table 2.

It may be instructive to compare the PHMM notation in Table 2 to the HMM notation that is given in Table 1.

Next, we turn our attention to generating pairwise alignments. Then we consider the process of generating a multiple sequence alignment (MSA) from a collection of pairwise alignments, and we discuss the process used to generate the PHMM matrices from an MSA. As mentioned above, generating the MSA is the most challenging step in the training process. Finally, we consider the scoring process using a PHMM. The scoring procedure for a PHMM uses a similar process as is used in an HMM.

4.2 Pairwise Alignment

We require a method to align a pair of sequences from the training set. Ideally, we would like to globally align a pair of sequences, that is, we want an alignment that accounts for all elements in both sequences. However, we also want to minimize the number of gaps that are inserted, since gaps tend to weaken the resulting PHMM by making it more generic. By using a local alignment strategy instead of a global approach, we can often significantly reduce the number of gaps. The tradeoff is that a local alignment strategy does not utilize all of the information available in the sequences.

To simplify the local alignment problem, we only consider such alignments where the initial and ending parts of the sequences can remain unaligned. For example, suppose that we want to align the sequences

[TABLE]

In Table 3 we give a global alignment, along with a local alignment, where the initial and final parts of the sequences are not aligned. Note that we use “-” to represent an inserted gap, while “*” is an omitted symbol, that is, a symbol omitted from consideration in the local alignment. Also, “|” indicates the corresponding elements are aligned.

For the global alignment in Table 3, we are able to align 9 out of 15 of the positions (60%), while for the local alignment, we have aligned 8 of the 10 positions (80%) under consideration. Consequently, model based on this local alignment is likely to be stronger than a model based on the global alignment. Therefore, we consider local alignments of the type illustrated in Table 3. However, to simplify the presentation, in the remainder of this section, we illustrate global alignments. To obtain optimal local alignments, we could simply repeat the alignment process several times, omitting symbols at the beginning and end of the sequences.

To construct a pairwise alignment, it is standard practice to use dynamic programming. In the context of sequence alignment, we specify an $n\times n$ substitution matrix $S$ , where $n$ is the number of symbols under consideration, and a gap penalty function $g$ . The substitution matrix specifies the cost associated with aligning various symbols with each other, while $g$ specifies the penalty incurred when opening (or extending) a gap. Once $S$ and $g$ have been specified, the dynamic program is relatively straightforward. For the sake of brevity, we omit further details on pairwise alignment. For more information on sequence alignment within the context of a PHMM, see Chapter 3 of the tutorial [30].

4.3 Multiple Sequence Alignment

Given a set of training sequences, we construct pairwise alignments for all pairs. From these pairwise alignments, we want to construct a multiple sequence alignment. Constructing the MSA is essentially the training process for a PHMM.

For efficiency, a progressive alignment strategy is generally used to construct the MSA. That is, we start with one pair of aligned sequence and merge it with another aligned pair, and merge that result with another, and so on. In this way, at each step we include more sequences into the MSA, until all training sequences have been used. The advantage of a progressive approach is that it is far more efficient than trying to align multiple sequences simultaneously. The disadvantage of a progressive alignment strategy is that it is likely to be unstable, in the sense that the order in which the pairwise alignments are considered can have a major impact on the resulting MSA. Specifically, the order can affect the number of gaps that are inserted into the MSA, and it is always desirable to minimize gaps.

There are many progressive alignment techniques available. Here, we discuss an approach based on the Feng-Dolittle algorithm, as used in [3]. To construct an MSA, we proceed as follows, where we assume that we are given as set of $n$ training sequences, a substitution matrix $S$ and a gap penalty function $g$ .

Compute pairwise alignments for all $n\choose 2$ pairs of sequences in the training set, using dynamic programming. For each pairwise alignment, we obtain a score from the dynamic program. 2. 2.

Select a set of $n-1$ pairwise alignments that includes all $n$ sequences from the original training set, and maximizes the sum of the pairwise alignment scores. 3. 3.

Generate a minimum spanning tree (using Prim’s algorithm) for these $n-1$ pairwise alignments, based on the pairwise alignment scores. 4. 4.

Add pairwise alignments to the MSA based on the spanning tree (from highest score to lowest score), inserting additional gaps as needed. The gap penalty function $g$ is used when inserting gaps.

For example, suppose we have 10 training sequences which result in the pairwise alignment scores in Table 4, where element $(i,j)$ is the score obtained for the pairwise alignment of sequence $i$ with sequence $j$ .

We then select a set of $9$ of these pairs so that each sequence $1,2,\dots,10$ is included at least once, while maximizing the sum of the scores. Using the scores in Table 4, the set

[TABLE]

satisfies these requirements. The minimum spanning tree corresponding to these pairwise alignments is given in Figure 3, where the nodes are labeled with the training sequence number, and the edges are labeled with pairwise alignment scores.

Using this procedure, we construct a minimum spanning tree that includes every sequence in the training set. This spanning tree will be used to generate the MSA which, in turn, is used to generate the PHMM.

To generate an MSA from a minimum spanning tree, such as that in Figure 3, we start with the pairwise alignment at the root. Then we traverse the tree, adding the specified new sequence into the alignment at each step. For the example in Figure 3, we consider the pairwise alignments in the order

[TABLE]

With the exception of the initial pair, one new sequence is added to the MSA at each step.

Again referring to the example in Figure 3, one step in the MSA construction is given in Table 5, At this particular step, we have already included sequences 5, 4, 8, and 3, based on the pairwise alignments

[TABLE]

and we are adding sequence 2 based on the pairwise alignment $(3,2)$ . Note that at these intermediate steps, we have used “+” to represent gaps that are inserted to align the new sequence with the existing MSA, as opposed to “-” which we use for gaps in the pairwise alignments. The final MSA appears in Table 6, where all gaps are represented by “-” symbols.

4.4 PHMM from MSA

A PHMM is determined directly from an MSA, that is, the probabilities in the matrices in $\lambda=(A,E,\pi)$ are determined from the MSA. The process might look somewhat complex, but it is actually straightforward, since probabilities are based only on counts of elements that appear in the MSA. First, we consider the emission probability matrix $E$ , then we turn our attention to the state transition matrix $A$ .

Recall that the PHMM includes match ( $M$ ), insert ( $I$ ), and delete ( $D$ ) states. We define “conservative” columns of the MSA as those for which half or less of the elements are gaps. Conservative columns correspond to match states of the PHMM. In contrast, if the majority of elements in a column are gaps, the column represents an insert state. The delete states will be considered later.

Consider the simple MSA in Table 7, which only includes the four symbols, C, E, G, and J. Note that columns 1, 2 and 6 are conservative, and hence correspond to match states. Columns 3, 4, and 5 are not conservative. Consecutive non-conservative columns are treated as a single insert state.

Emissions occur at match and insert states. The probabilities in the $E$ matrix are determined from the MSA based on the counts in each state. Referring to the MSA in Table 7, for column 1 we have

[TABLE]

since all 4 of the (non-gap) symbols that appear are E.

Any model that includes probabilities of zero is prone to overfit the training data, since “nearby” sequences are eliminated. Several standard methods are available to eliminate zero probabilities. Here, we employ the “add-one rule” [12] which, consists of adding one to each numerator and, so as to maintain probabilities, also adding the total number of symbols to each denominator. Since there are four distinct symbols in our example, applying the add-one rule to the probabilities in equation (7) yields

[TABLE]

For the insert state $I_{2}$ , the natural probabilities are

[TABLE]

which come from the ratios of the emitted symbols in the dashed box in Table 7. Using the add-one rule, the insert state probabilities become

[TABLE]

The emission probabilities for the example in Table 7, with the add-one rule applied, are given Table 8. Note that for states for which we have no information (e.g., $I_{1}$ in this example), we assume a uniform distribution.

Intuitively, it might seem that the more sequences we use for training, the stronger the resulting model, since more sequences provide more information. However, by using more training sequences, we are likely to have more gaps in the resulting MSA, which tends to weaken the model. Consequently, the number of sequences used to generate the MSA is a critical parameter that we can analyze via experimentation.

Next, we consider the transition probabilities, that is, we show how to derive the state transition probabilities from an MSA. Again, we illustrate the process using simple MSA in Table 7.

Intuitively, the probabilities should be given by

[TABLE]

As with emission probabilities, we want to avoid probabilities of zero, so we will use the add-one rule.

Let $B$ be the begin state. Then, ignoring the add-one rule,

[TABLE]

since four of the five elements in column 1 are matches, which implies that the probability of transitioning from the begin state to $M_{1}$ is $4/5$ .. Similarly,

[TABLE]

since one element in column 1 represents delete state $D_{1}$ and insert state $I_{0}$ is empty.

As with the emission probability calculations, we use the add-one rule. However, instead of adding one for each symbol, we add one for each possible transition, namely, match, insert, and delete. Thus, using the add-one rule, equations (9) and (10) become

[TABLE]

respectively.

As with the emission probabilities, in cases where there is no data, we set the transition probabilities to uniform. For example, we have no transitions from $I_{1}$ , and consequently

[TABLE]

Next, consider the delete state $D_{1}$ , which corresponds to the “dash” in column 1 of Table 7. We see that the transition from $D_{1}$ is to a match state in column 2. Consequently,

[TABLE]

where we have used the add-one rule.

Now consider $M_{2}$ . In the bottom row, no letter appears in the boxed region of the MSA in Table 7 and, consequently, for this row, we transition from $M_{2}$ to $M_{3}$ . Similarly, in the top row, we transition from $M_{2}$ to $D_{3}$ . However, the three middle rows all go from $M_{2}$ to $I_{3}$ . Therefore, using the add-one rule, we have

[TABLE]

Finally, we calculate transition probabilities for $I_{2}$ . Note that there are five symbols in $I_{2}$ , and of these, three transition to $M_{3}$ , namely, the E in the second row, the J in the third row, and the J in the fourth row. Both of the remaining symbols (G and E in the third row) transition to symbols in $I_{2}$ . Therefore,

[TABLE]

The complete set of transition probabilities for the MSA in Table 7 appears in Table 9. Note that the add-one rule has been applied in all cases.

To conclude this section, we summarize the process used to training a PHMM. Here, we assume that we are given a set of training sequences and that a substitution matrix $S$ and gap penalty function $g$ have been specified.

Construct pairwise alignments for the training sequences using $S$ and $g$ . Typically, dynamic programming is used in this step. 2. 2.

From the pairwise alignments, construct an MSA. There are many ways to construct an MSA from pairwise alignments—in this paper, we used a spanning tree and a progressive alignment strategy. 3. 3.

Use the MSA to determine the PHMM, that is, the probabilities that constitute $\lambda=(A,E,\pi)$ are determined directly from the MSA. To avoid zero probabilities, use some form of pseudo-counts, such as the add-one rule.

To score a given sequence against a specific PHMM, we use the forward algorithm. The PHMM version of the forward algorithm is fairly similar to the forward algorithm as used for scoring in HMMs, so we omit the details here; see [30] for additional information.

5 Related Work

Wong and Stamp [43] showed the effectiveness of HMMs for detecting metamorphic malware based on opcode sequences. Austin et al. [4] extend this idea to a dueling HMM strategy, that is, a multi-sensor approach that handles more complex viruses by using models of both benign and malicious files. Kalbhor et al. [19] highlight how the overhead of the dueling HMM strategy can be reduced to levels approaching that of Wong and Stamp’s approach by using a tiered analysis. The central idea in [19] is to quickly analyze files with the simpler approach first, and only use the more expensive multi-sensor approach in the more difficult cases. Annachhatre et al. [1] show how this multi-sensor approach can be useful in the classification of malware, based on clustering.

Filiol and Josse [16] discuss statistical testing simulability and describe how an attacker might use information about the defender’s detection strategy to evade detection. Madenur Sridhara and Stamp [31] use a similar strategy in the design of an experimental metamorphic worm MWOR. The MWOR worm relies primarily on dead code insertion, which seems to be one of the more effective metamorphic techniques at evading HMM-based detection that is based on static analysis.

Attaluri et al. [3] use profile hidden Markov models to detect metamorphic malware based on static opcode sequences. The approach works well against certain kinds of metamorphic malware, but seems to be less effective when the blocks of code are shifted farther apart. This paper continues this work by instead considering dynamic birthmarks. While PHMMs trained on static data have not proven particularly useful for malware detection [3], their positional information seems more likely to be beneficial when training on dynamic birthmarks.

6 Implementation

In this section, we review the design of each of our systems. First, we discuss our HMM-based approach, then we turn our attention to our PHMM-based technique.

6.1 Static Analysis Using HMMs

We begin with our system using HMMs and static birthmarks for malware analysis. As mentioned previously, this strategy has been used with some success in the literature [43, 4], but it can be defeated by malware that inserts dead-code as an obfuscation technique [31].

Following past research for static HMM analysis [43], we use opcodes as our static birthmarks. We use IDA Pro to disassemble the malware and generate asm files. From those files, we extract the mnemonic opcodes for training and testing our models. Labels, operands, and other details are discarded.

We construct the HMMs from these sequences. Following the approach taken by Wong and Stamp [43], we use $N=2$ two hidden states. We also use 800 iterations of the Baum-Welch re-estimation algorithm when training all of our models. We use five-fold cross-validation. That is, for each experiment, the family dataset is partitioned into five equal subsets, say, $S_{1}$ , $S_{2}$ , $S_{3}$ , $S_{4}$ , and $S_{5}$ . Then we train a model using $S_{1}$ , $S_{2}$ , $S_{3}$ , and $S_{4}$ , and we use the resulting model to score $S_{5}$ as well as the representative benign set. This process is repeated five times, with a different subset reserved for testing in each “fold”. The use of cross validation serves to smooth any biases in the data, while also maximizing the number of scores from a given dataset.

6.2 Dynamic Analysis Using HMMs

To compare the effectiveness of dynamic versus static analysis, we also consider a HMM analysis based on dynamic birthmarks. For the dynamic birthmark, we extract API calls at runtime. One useful advantage of this approach is that API calls would seem to more closely capture the actual functionality of the program than the opcodes, potentially making it a more resilient tool against various code obfuscation techniques.

To collect the API calls, we use the Buster Sandbox Analyzer [9] (BSA). BSA logs information about file system changes, windows registry changes, port changes, etc. BSA also executes files in a sandbox so that malware can be run safely.

Once the API call sequences are produced, they are used for training and testing in the same manner as discussed in Section 6.1. We note that there is an additional parameter in this case, namely, the amount of time that we run the software to generate the sequences.

6.3 Dynamic Analysis Using PHMMs

Here, we use the same API call sequences as in the dynamic HMM case. Once we have the sequences of API calls for a given malware family, we align the sequences. Some amount of preprocessing is required in this step. We followed the general approach in [3], that is, the API calls are first sorted by the frequency of occurrence. In our data, the top 36 API calls constitute at least 99.8% of the total API calls for each family tested. Consequently, we only consider the top 36 API calls, with all remaining API calls mapped to a single “other” state. This preprocessing step strengthens the resulting models.

The next step involves creating a substitution matrix and a gap penalty function. As described in Section 4, we use a the Feng-Doolittle algorithm [15] to create our multiple sequence alignment (MSA). After constructing the MSA, we use it to build the PHMM, as discussed in Section 4. Once we have built the PHMM, we use the forward algorithm to score sequences against the PHMM.

7 Experiments and Results

In this section, we evaluate the effectiveness of our dynamic and static analysis techniques and present our results. Specifically, we use a static HMM analysis based on extracted opcodes as a baseline to compare against both HMMs and PHMMs trained on dynamically extracted API call sequences.

7.1 Setup

For all experiments, we have used the Oracle VM Virtual Box. The host machine has an Intel(R) Core(TM) i5-3317U [email protected] processor, 6GB RAM, 64-bit system, and Windows 8.1 operating system. The guest machine used in our experiments was an Oracle Virtual Box 4.3.16 VM with a base memory of 3310MB, 6 GB RAM, 32 bit system, running Windows 7. The training and testing of the HMMs and PHMM are done in the host machine whereas the API calls and opcode extraction are done in the guest machine.

7.2 Dataset

For our malware set, we have considered the following seven different malware families [24].

•

Cridex is a worm that multiplies and spreads through removable drives. It downloads malicious programs onto the system it has attacked [35].

•

Harebot is a backdoor that affects Windows systems. The Harebot backdoor enables hackers to gain access to the compromised system and steal information [18].

•

Security Shield is fake anti-virus software that falsely claims to protect the system from malware. Security Shield then tries to convince the user to pay money to remove these nonexistent threats [27].

•

SmartHdd targets Windows users. It tricks the users into thinking that it is a legitimate hardware monitoring tool (SMART). It generates fake messages indicating that the hard drive is failing and tries to convince the user to pay to fix the supposed issues. It also disables antivirus software in the compromised system [20].

•

Winwebsec is a Windows Trojan that impersonates anti-malware software and displays fake messages stating that the user’s system has been infected. Once installed, it tries to convince the user to pay for a fake anti-malware product [42].

•

Zbot is another Trojan. Zbot steals confidential information such as online credentials [36].

•

Zeroaccess is a Trojan that attacks Windows systems. It uses a botnet to download other malicious programs onto the compromised system [37].

Table 10 lists the number of files from each of the malware families used in our experiments.

For our representative benign dataset, we use the 20 Windows executable files listed in Table 12. These executables are available in Windows 7 or as freeware.

7.3 Results

After performing each experiment, we plot the Receiver Operating Characteristic (ROC) curve and compute area under the ROC curve (AUC). The ROC curve is obtained from a scatterplot by graphing the true positive rate (TPR) versus the false positive rate (FPR) as the threshold varies through the range of possible values. The AUC can be interpreted as the probability that a randomly-selected positive instance scores higher than a randomly selected negative instance [8]. Consequently, an AUC of 1.0 represents the ideal case where a threshold exists that results in no classification errors. On the other hand, an AUC of 0.5 implies that the binary classifier is not better than flipping a coin.

We first perform our analysis on seven malware families using both static and dynamic analysis techniques based on HMMs. We then plot the ROC for each case and calculate the AUC. To perform a comparison on both the techniques, we have chosen the same data set in both cases. We now consider a single family and examine the results.

For the Security Shield family, Figure 4 (a) shows the scatterplot for the static HMM based on extracted opcode sequences. The corresponding ROC curve appears in Figure 4 (c). The ROC curve in Figure 4 (c) yields an AUC of 0.676.

Again for the Security Shield family, the scatterplot for the dynamic HMM based on extracted API call sequences is given in Figure 4 (b). The corresponding ROC curve appears in Figure 4 (d), which has an AUC of 1.0.

HMMs based on static opcode sequences have performed well when tested on various malware families [1, 31, 43]. The AUC of 0.676 for the static HMM indicates that the Security Shield represents a challenging detection problem This makes the AUC of 1.0 for the dynamic HMM all the more impressive.

We have performed experiments on each of the seven malware families discussed in Section 7.2. For each family, we have tested an HMM based on static opcodes and both an HMM and PHMM based on dynamic API calls. The results for the static and dynamic HMMs are summarized in Table 12. The ROC curves for the six families other than Security Shield are given in the Appendix.

From the results in Table 12 we see that the dynamic HMM outperforms the static HMM in every case, except for the Smart HDD family, in which case both the static and dynamic HMMs perform very well. The average AUC for the dynamic HMM cases is 0.976, whereas the average AUC for the static HMM cases is 0.785. This clearly shows the advantage of dynamic birthmarks.

Next, we consider PHMMs trained on the same dynamic birthmarks used for the dynamic HMMs. For a PHMM, the number of sequences used to train is a critical parameter. Table 13 contains results for our PHMM experiments, where “group $n$ ” means that we trained the corresponding PHMM using $n$ sequences. In each case, we were able to achieve an AUC of 1.0, and once we have attained such a result, there is no need for further experimentation with the parameter $n$ .

The PHMM results in Table 13 may be somewhat surprising when compared to PHMM results obtained in previous research. For example, in the paper [3], a PHMM is trained on static opcode sequences from metamorphic malware families. The PHMM results in [3] are significantly worse than those obtained from HMMs trained on the same static opcode data. Apparently, this is due to obfuscations that cause opcode sequences to be shifted to different locations within the binaries, causing gaps to proliferate when constructing the PHMMs, and thereby weakening the models. In contrast, for the dynamic API calls considered in this research it is far more difficult to obfuscate the sequential information. That is, the positional information in API call sequences is highly informative, whereas the positional information in opcode sequences is much less so.

Finally, in Figure we compare the results for our static HMM, dynamic HMM, and dynamic PHMM, in the form of a bar graph. While the dynamic HMM results are indeed very strong, the PHMM result cannot be improved.

8 Conclusion and Future work

As malware has become increasingly difficult to detect with traditional techniques, new approaches are needed, and machine learning based tools seem a promising avenue. Hidden Markov models are one such technique that has been used effectively for malware detection in previous work [1, 4, 19, 21, 26, 31, 43]. In contrast, Profile Hidden Markov Models seem to have rarely been studied in this context, with previous results being mixed, at best [3].

In this paper, we have shown the efficacy of detection tools using HMMs built from dynamic birthmarks; specifically API calls. In fact, this dynamic approach far outperforms previous static analysis tools that relied on HMMs based on opcodes as static birthmarks. The average area under the ROC curve (AUC) that we obtained for all malware families in our dataset using our dynamic HMMs was 0.976, while the average AUC using static HMMs was 0.785. The static HMMs have shown strong results in several previous studies, which indicates that our dataset presents a relatively challenging case. This makes the dynamic HMM results all the more impressive.

We also experimented with Profile Hidden Markov Models. The PHMM can be viewed as a generalization of an HMM that take positional information into account. Our PHMM experiments, based again on dynamic API call sequences, outperform the HMMs in every case. In fact, the PHMMs achieved ideal separation in every case, with an AUC of 1.0. These results show that PHMMs can be a very powerful tool for certain types of software analysis problems.

For future work, we intend to further explore different morphing and obfuscation techniques and test how effective our techniques are against different strategies. In particular, it would be interesting to try to defeat HMM—and especially PHMM—techniques that are based on dynamic API calls. By doing so, we can hope to strengthen these detection techniques. Also, while the dynamic birthmarks considered in this paper are based on API calls, other dynamic birthmarks might provide beneficial information. We also note that a potential strategy could be to combine the API calls with other types of dynamic birthmarks using, say, Support Vector Machines in order to develop an even robust malware detection model. Finally, it would be interesting to test these dynamic tools in the situation where we want to monitor untrusted code at runtime.

Appendix

Here, we provide additional results from our experiments. Figure 6 (a) through (f) give ROC curves of HMMs trained on static opcode sequences, for Cridex, Harebot, Smart HDD, Winwebsec, Zbot, and Zeroaccess, respectively. The ROC curves of HMMs trained on dynamic API call sequences are given in Figure 7 (a) through (f). The corresponding results for Security Shield are given in Figure 4, parts (c) and (d).

Bibliography44

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[1] C. Annachhatre, M. Stamp, and T. H. Austin, Hidden Markov Models for Malware Classification, Journal of Computer Virology and Hacking Techniques , 11(2):59–73, 2014
2[2] B. Anderson, Graph-Based Malware Detection Using Dynamic Analysis, Journal in Computer Virology , 7(4):247–258, 2011
3[3] S. Attaluri, S. Mc Ghee, and M. Stamp, Profile Hidden Markov Models and Metamorphic Virus Detection, Journal in Computer Virology , 5(2):151–169, 2009
4[4] T. H. Austin, E. Filiol, S. Josse, and M. Stamp, Exploring Hidden Markov Models for Virus Analysis: A Semantic Approach Hawaii International Conference on System Sciences , 2013
5[5] J. Aycock, Computer Viruses and Malware , Springer, 2006
6[6] Back Orifice.Trojan, Symantec, 2007, http://www.symantec.com/security_response/writeup.jsp?docid=2003-021815-3238-99&tabid=2
7[7] Y. Bai, X. Sun, G. Sun, X. Deng, and X. Zhou, Dynamic k 𝑘 k -Gram Based Software Birthmark, 19th Australian Conference on Software Engineering, 2008
8[8] A. P. Bradley, The Use of the Area Under the ROC Curve in the Evaluation of Machine Learning Algorithms, Journal Pattern Recognition , 30(7):1145–1159, 1997

	1	2	3	4	5	6	7	8	9	10
1	—	85	63	74	70	84	61	57	62	70
2	85	—	79	73	66	59	94	61	59	51
3	63	79	—	75	68	60	55	85	52	65
4	74	73	75	—	105	54	60	78	59	53
5	70	66	68	105	—	40	61	79	58	39
6	84	59	60	54	40	—	68	45	75	78
7	61	94	55	60	61	68	—	64	72	42
8	57	61	85	78	79	45	64	—	50	70
9	62	59	52	59	58	75	72	50	—	81
10	70	51	65	53	39	78	42	70	81	—

	1	2	3	4	5	6	7	8	9	10
1	—	85	63	74	70	84	61	57	62	70
2	85	—	79	73	66	59	94	61	59	51
3	63	79	—	75	68	60	55	85	52	65
4	74	73	75	—	105	54	60	78	59	53
5	70	66	68	105	—	40	61	79	58	39
6	84	59	60	54	40	—	68	45	75	78
7	61	94	55	60	61	68	—	64	72	42
8	57	61	85	78	79	45	64	—	50	70
9	62	59	52	59	58	75	72	50	—	81
10	70	51	65	53	39	78	42	70	81	—

	1	2	3	4	5	6	7	8	9	10
1	—	85	63	74	70	84	61	57	62	70
2	85	—	79	73	66	59	94	61	59	51
3	63	79	—	75	68	60	55	85	52	65
4	74	73	75	—	105	54	60	78	59	53
5	70	66	68	105	—	40	61	79	58	39
6	84	59	60	54	40	—	68	45	75	78
7	61	94	55	60	61	68	—	64	72	42
8	57	61	85	78	79	45	64	—	50	70
9	62	59	52	59	58	75	72	50	—	81
10	70	51	65	53	39	78	42	70	81	—