Detection efficacy of virtual machine-based analysis with application specific events
A computerized system and method is described for classifying objects as malicious by processing the objects in a virtual environment and monitoring behaviors during processing by one or more monitors. The monitors may monitor and record selected sets of process operations and capture associated process parameters, which describe the context in which the process operations were performed. By recording the context of process operations, the system and method described herein improves the intelligence of classifications and consequently reduces the likelihood of incorrectly identifying objects as malware or vice versa.
Latest FireEye, Inc. Patents:
- Determining malware via symbolic function hash analysis
- System and method for detecting malicious network content using virtual environment components
- Systems and methods for attack simulation on a production network
- Virtual system and method for securing external network connectivity
- System and method for analyzing binary code for malware classification using artificial neural network techniques
Embodiments of the disclosure relate to the field of network and cyber security. More specifically, one embodiment of the disclosure relates to a system and method of detecting malicious activity.
2. GENERAL BACKGROUNDOver the last decade, malicious software (malware) has become a pervasive problem for Internet users. In some situations, malware is a program or file that is embedded within downloadable content and designed to adversely influence or attack normal operations of a computer. Examples of different types of malware may include bots, computer viruses, worms, Trojan horses, spyware, adware, or any other programming that operates within an electronic device (e.g., computer, tablet, smartphone, server, router, wearable technology, or other types of electronics with data processing capability) without permission by the user or an administrator.
For instance, content may be embedded within objects associated with a web page hosted by a malicious web site. By downloading this content, malware causing another web page to be requested from a malicious web site may be unknowingly installed on the computer. Similarly, malware may also be installed on a computer upon receipt or opening of an electronic mail (email) message. For example, an email message may contain an attachment, such as a Portable Document Format (PDF) document, with embedded executable malware. Also, malware may exist in files infected through any of a variety of attack vectors, which are uploaded from the infected computer onto a networked storage device such as a file share.
Over the past few years, various types of security appliances have been deployed at different segments of a network. These security appliances use virtual machines to uncover the presence of malware embedded within ingress content propagating over these different segments. In particular, virtual machines (VMs) are equipped to monitor operations performed by ingress content during processing. The security appliances analyze the observed operations in an attempt to identify unexpected or anomalous operations that may indicate exploits. However, this operation monitoring is executed conventionally without knowledge of the context in which these operations are performed. This lack of context may occasionally lead to incorrect classification of ingress content as either benign or malicious, that is, as false negatives or false positives respectively in relation to malware detection. False negatives may result in malware going undetected and, therefore, failures to issue appropriate security alerts to network administrators or security professionals. False positives may result in security alerts issuing too often, raising the possibility that false positives will overshadow and dilute responses to ‘true positives’ and render associated remediation misplaced. In extreme situations, false negatives and false positives may impact system performance.
Embodiments of the invention are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which:
In one embodiment, a malware content detection (MCD) system is provided that intercepts or otherwise captures objects for analysis. Subsequent to optional static analysis, dynamic analysis may be initiated for a suspect object. During this dynamic analysis, a virtual machine (VM) instance may process (e.g., open, load, detonate, and/or run) the suspect object such that process operations associated with the suspect object are performed. The VM instance is provided with monitors to capture activities and other behaviors of the suspect object during processing, and associate the behaviors with specific processes running within the VM instance. The monitors may inspect predefined sets of process operations and associated process parameters to infer and identify application specific behaviors.
A determined application specific behavior combined with a process identifier may be provided to the analysis engine as an event for classification of a suspect object. For example, the suspect object may be classified as malware, non-malware, or as needing further analysis. A confidence score may be generated in arriving at this classification by the analysis engine. The analysis can compare the captured operations and associated parameters with those expected for the particular process (e.g., computer program or application) to identify application specific behaviors that in some cases may indicate malicious activities (exploits). To that end, the analysis may utilize experiential knowledge and machine learned information regarding operations and associated parameters that may ordinarily be expected for each type of application executed in the virtual machine instance.
In some embodiments, one or more stages of analysis (e.g., three are described below) may be used to arrive at a confidence score for a suspect object. A first analysis stage may compare captured operations and associated parameters with those expected for the relevant process, such as by performing a look-up of the captured operation in a table or other data structure of expected operations (called a “whitelist”), a data structure of anomalous operations (called a “blacklist”), or in both a whitelist and blacklist. The results of the first analysis stage may update an event data structure with all captured or developed event information (including information regarding the flagged operation).
A second analysis stage receives the event data structure associated with each captured event as established by the first analysis stage with its determination of application specific behavior (e.g., a flagged operation). The second analysis stage may use all of the captured events including the flagged operation in a state machine based analysis. In this context, a state machine for a process is a representation of the expected sequencing of events that the process may be expected to yield when monitored. The second analysis stage may identify captured operations that are anomalous (not represented in the state machine), operations that should have been monitored and captured but appear to have been omitted, and operations that occurred out of order. A state machine associated with a process may generate additional events based on a partial match of state machine “states” with the observed events. The second analysis stage may update the event data structure to reflect its results. A suitable state machine representation for a process 203 can be developed through analysis of the process 203 and its expected operations and parameters prior to virtual processing of suspect objects. In some embodiments, the second analysis stage may store information in the event data structure associated with objects, or may simply discard the information related to those benign objects. Accordingly, the second analysis stage may act to filter the suspect objects to those that have a certain likelihood of being classified as malware. The likelihood level may be factory set, user set or dynamically determined, and different likelihood levels may be used based on history of malware detection, network traffic conditions, type of process, or other considerations.
A third analysis stage may use pre-defined rules to determine whether the suspect object should be classified as malware. To that end, the rules used in the third analysis stage may be developed through experiential knowledge and machine learning techniques regarding behaviors of known malware and benign objects processed by applications. The third analysis stage may generate a confidence score (e.g., a weight) for each of the suspect objects related to the probability that it is malicious (e.g., the probability that observed behaviors constitute or are associated with an exploit). The confidence score may be based on the recorded operations and process parameters and corresponding application specific behaviors and events that these operations and process parameters yield. The third analysis stage may use the confidence score for each suspect object (or combine confidence scores for plural objects (e.g., of a flow of related packets)) to yield an overall confidence score. The overall confidence score may also reflect, e.g., be generated based in part on, other scores from other analyses (e.g., static or heuristic analysis of the object). The third analysis stage may use that overall confidence score to classify the suspect object or objects as malware.
Where the overall confidence score is not sufficiently high to classify the suspect object as malware (e.g., above a threshold), the object may be classified as benign or as requiring further forensic analysis. A need for further forensic analysis of the suspect object may be indicated when the analysis has reported an event (including an additional event, e.g., from the second analysis) that suggests further analysis may yield a classification other than benign. Where the suspect object is classified as malware, the MCD system may issue an alert or otherwise report its findings, including its confidence score that led to that classification. Security or network professionals may use the information in the report in deciding on remedial actions to be taken in light of the malware.
Utilizing process parameters that describe the context in which a detected process operation was performed provides greater insight into the characteristics of a suspect object. In particular, the detection of a process operation in a first context may be highly indicative of malware while the detection of the same process operation in a second context may provide little or no support for the classification of the object as malware. This improved insight results in a more accurate classification of the suspect object and a reduced number of malware false positives (FPs) and false negatives (FNs). Malware incorrectly classified in conventional detection systems as malicious (FPs) may not be marked malicious in embodiments of the invention based on application specific behavior. The same goes for malware incorrectly classified in conventional detection systems as non-malicious (FNs).
II. TerminologyIn the following description, certain terminology is used to describe aspects of the invention. For example, in certain situations, both terms “logic” and “engine” are representative of hardware, firmware and/or software that is configured to perform one or more functions. As hardware, logic (or engine) may include circuitry having data processing or storage functionality. Examples of such circuitry may include, but are not limited or restricted to a microprocessor, one or more processor cores, a programmable gate array, a microcontroller, an application specific integrated circuit, wireless receiver, transmitter and/or transceiver circuitry, semiconductor memory, or combinatorial logic.
Logic (or engine) may be in the form of one or more software modules, such as executable code in the form of an executable application, an application programming interface (API), a subroutine, a function, a procedure, an applet, a servlet, a routine, source code, object code, a shared library/dynamic load library, or one or more instructions. These software modules may be stored in any type of a suitable non-transitory storage medium, or transitory storage medium (e.g., electrical, optical, acoustical or other form of propagated signals such as carrier waves, infrared signals, or digital signals). Examples of non-transitory storage media may include, but are not limited or restricted to a programmable circuit; a semiconductor memory; non-persistent storage such as volatile memory (e.g., any type of random access memory “RAM”); persistent storage such as non-volatile memory (e.g., read-only memory “ROM”, power-backed RAM, flash memory, phase-change memory, etc.), a solid-state drive, hard disk drive, an optical disc drive, or a portable memory device. As firmware, the executable code is stored in persistent storage.
The term “object” generally refers to a collection of data, whether in transit (e.g., over a network) or at rest (e.g., stored), often having a logical structure or organization that enables it to be classified for purposes of analysis. During analysis, for example, the object may exhibit a set of expected characteristics and/or, during processing, a set of expected behaviors. The object may also exhibit a set of unexpected characteristics and/or a set of unexpected behaviors that may evidence an exploit or malware and potentially allow the object to be classified as an exploit or malware.
Examples of objects may include one or more flows or a self-contained element within a flow itself. A “flow” generally refers to related packets that are received, transmitted, or exchanged within a communication session. For convenience, a packet is broadly referred to as a series of bits or bytes having a prescribed format, which may include, for example, an HTTP packet, a frame, or a cell.
As an illustrative example, an object may include a set of flows such as (1) a sequence of transmissions in accordance with a particular communication protocol (e.g., User Datagram Protocol (UDP); Transmission Control Protocol (TCP); or Hypertext Transfer Protocol (HTTP); etc.), or (2) inter-process communications (e.g., Remote Procedure Call “RPC” or analogous processes, etc.). Similarly, as another illustrative example, the object may be a self-contained element, where different types of such objects may include an executable file, a non-executable file (such as a document or a dynamically linked library), a Portable Document Format (PDF) file, a JavaScript file, a Zip file, a Flash file, a document (for example, a Microsoft Office® document), an electronic mail (email), a downloaded web page, an instant messaging element in accordance with Session Initiation Protocol (SIP) or another messaging protocol, or the like.
The term “content” generally refers to information transmitted as one or more messages, where each message(s) may be in the form of a packet, a frame, an Asynchronous Transfer Mode “ATM” cell, another object, or any other series of bits having a prescribed format. The content may be received as a data flow.
An “exploit” may be construed broadly as information (e.g., executable code, data, command(s), etc.) that attempts to take advantage of a software vulnerability or user error. Typically, a “vulnerability” is a coding error or artifact of software (e.g., computer program) that allows an attacker to alter legitimate control flow during processing of the software (computer program) by an electronic device, and thus, causes the electronic device to experience undesirable or unexpected behaviors. The undesired or unexpected behaviors may include a communication-based anomaly or an execution-based anomaly, which, for example, could (1) alter the functionality of an electronic device executing application software in a malicious manner; (2) alter the functionality of the electronic device executing that application software without any malicious intent; and/or (3) provide unwanted functionality which may be generally acceptable in another context. To illustrate, a computer program may be considered as a state machine, where all valid states (and transitions between states) are managed and defined by the program, in which case an exploit may be viewed as seeking to alter one or more of the states (or transitions) from those defined by the program.
Malware may be construed broadly as computer code that executes an exploit or otherwise harms or co-opts operation of an electronic device or misappropriates, modifies or deletes data. Conventionally, malware is often said to be designed with malicious intent. An object may constitute or contain malware.
The term “parameter” is often defined as a variable (or, colloquially speaking, a “placeholder”) in a computer program that represents any of a number of different values of data to be provided as input to a function or routine of an application, and may also refer to the value or values themselves. In the following description, unless the context demands otherwise, “parameter” will usually be used to denote the value or values. Accordingly, passing a parameter means to provide an input value to the function. For example, a heuristics engine may pass parameters/messages to a virtual machine manager to identify software profile information associated with a needed virtual machine instance. In another example, an operations/parameters capture (“OPC”) module within a monitor may pass events and/or application specific events to a filtering and reporting module for additional analysis.
The parameters may include various types of data that may be used to detect malicious behavior. For example, in one case an application specific behavior that may be monitored is the loading/running of macros in a Microsoft Office application. Upon detection of a macro in a Microsoft Office application, an OPC module of a monitor may record the specific module that requested the loading/running of the macro (e.g., an address or identifier of the specific module). This data may define parameter data that is recorded and analyzed along with other data (e.g., macro activity) to determine the presence of malware.
In another example, an application specific behavior that may be monitored is the loading/running of a module that processes dynamic content of a PDF document in an Adobe Reader application. Upon detection of dynamic content in an Adobe Reader application, an OPC module of a monitor may record the values of an associated stack trace. This data may define parameter data that is recorded and analyzed along with other data to determine the presence of malware.
The term “transmission medium” is a communication path between two or more systems (e.g., any electronic device with data processing functionality such as, for example, a security appliance, server, mainframe, computer, netbook, tablet, smart phone, router, switch, bridge or router). The communication path may include wired and/or wireless segments. Examples of wired and/or wireless segments include electrical wiring, optical fiber, cable, bus trace, or a wireless channel using infrared, radio frequency (RF), or any other wired/wireless signaling mechanism.
In general, a “virtual machine” (VM) is a simulation of an electronic device (abstract or real) that is usually different from the electronic device conducting the simulation. A VM may be used to provide a sandbox or safe runtime environment separate from a production environment to enable detection of APTs or malware in a safe environment. The VM may be based on specifications of a hypothetical computer or emulate the computer architecture and/or functions of a real world computer.
The term “computerized” generally represents that any corresponding operations are conducted by hardware in combination with software and/or firmware.
Lastly, the terms “or” and “and/or” as used herein are to be interpreted as inclusive or meaning any one or any combination. Therefore, “A, B or C” or “A, B and/or C” mean “any of the following: A; B; C; A and B; A and C; B and C; A, B and C.” An exception to this definition will occur only when a combination of elements, functions, steps or acts are in some way inherently mutually exclusive.
As this invention is susceptible to embodiments of many different forms, it is intended that the present disclosure is to be considered as an example of the principles of the invention and not intended to limit the invention to the specific embodiments shown and described.
III. General ArchitectureReferring to
Herein, according to this embodiment of the invention, the first MCD system 1101 is an electronic device that is adapted to (i) intercept data traffic that is routed over a communication network 130 between at least one server device 140 and at least one client device 150 and (ii) monitor, in real-time, objects within the data traffic. More specifically, the first MCD system 1101 may be configured to inspect data objects received via the communication network 130 and identify “suspicious” objects. The incoming objects are identified as “suspicious” when it is assessed, with a certain level of likelihood, that at least one characteristic identified during inspection of the objects indicates or is associated with the presence of malware.
Thereafter, the suspicious objects are further analyzed within a virtual machine (VM) execution environment to detect whether the suspicious objects include malware. The VM execution environment may comprise multiple VM instances 196 supporting the same or different software profiles corresponding to multiple intercepted objects from various sources within the communication system 100. The particulars of this malware analysis performed by the VM execution environment are described in further detail below.
The communication network 130 may include a public computer network such as the Internet, in which case an optional firewall 155 (represented by dashed lines) may be interposed between the communication network 130 and the client device 150. Alternatively, the communication network 130 may be a private computer network such as a wireless telecommunications network, a wide area network, or local area network, or a combination of networks.
The first MCD system 1101 is shown as being coupled with the communication network 130 (behind the firewall 155) via a network interface 160. The network interface 160 operates as a data capturing device (referred to as a “tap” or “network tap”) that is configured to receive data traffic propagating to/from the client device 150 and provide at least some of the objects (or a copy thereof) associated with the data traffic to the first MCD system 1101.
In general, the network interface 160 receives and routes objects that are received from and provided to client device 150 normally without an appreciable decline in performance by the server device 140, the client device 150, or the communication network 130. The network interface 160 may intercept any portion of the data traffic, for example, any number of data packets or other objects. Of course, it is contemplated that the first MCD system 1101 may be positioned behind the firewall 155 and in-line with client device 150.
In some embodiments, the network interface 160 may capture metadata from data traffic intended for the client device 150, where the metadata is used to determine whether the data traffic includes any suspicious objects as well as the software profile for such suspicious objects. The metadata may be associated with the server device 140 and/or the client device 150. In other embodiments, a heuristics engine 170 within the first MCD system 1101 may determine the software profile by analyzing the objects and/or metadata associated with the data traffic.
It is contemplated that, for any embodiments where the first MCD system 1101 is implemented as a dedicated appliance or a dedicated computer system, the network interface 160 may include an assembly integrated into the appliance or computer system that includes network ports, a network interface card and related logic (not shown) for connecting to the communication network 130 to non-disruptively “tap” data traffic propagating through firewall 155 and provide the data traffic to the heuristics engine 170. In other embodiments, the network interface 160 can be integrated into an intermediary device in the communication path (e.g., the firewall 155, a router, a switch or another network device) or can be a standalone component, such as an appropriate commercially available network tap. In virtual environments, a virtual tap (vTAP) may be used to intercept traffic from virtual networks.
Referring still to
Referring now to
The processor(s) 200 is (are) further coupled to persistent storage 230 via transmission medium 225. According to one embodiment of the disclosure, the persistent storage 230 may include the heuristics engine 170, the analysis engine 190, the VMM 193, the filtering and reporting module 195, the one or more VM instances 196, graphical user interface (GUI) logic 271, and configuration logic 273. Of course, when implemented as hardware, engines 170 and 190, module 195, VMM 193, logic 271 and 273, and VM instance(s) 196 may be implemented separately from the persistent storage 230.
In general, the heuristics engine 170 serves as a filter to permit subsequent malware analysis only on a portion of incoming objects (e.g., those that are “suspicious”), which effectively conserves system resources and provides faster response time in determining the presence of malware within analyzed suspicious objects that are more likely to carry, constitute, or be otherwise associated with malware. As an ancillary benefit in some embodiments, by performing a dynamic or run-time analysis in a virtual environment on only the suspicious incoming objects, such analysis may prove more efficient and effective, and, in some cases, monitoring may continue for a longer duration. This may be important for detecting time-delayed malware-related behaviors.
As illustrated in
As an example, the heuristics engine 170 may examine the metadata or attributes of the captured objects and/or the code image (e.g., a binary image of an executable) to determine whether a certain portion of the captured objects matches or has a high correlation with a predetermined pattern of attributes that is associated with a malicious attack. According to one embodiment of the disclosure, the heuristics engine 170 flags objects from one or more data flows as suspicious after applying this heuristics analysis.
Thereafter, according to one embodiment of the invention, the heuristics engine 170 may be adapted to transmit at least a portion of the metadata or attributes of the suspicious objects to the VMM 193. Such metadata or attributes are used to identify a software profile to be used by a VM instance 196 needed for subsequent malware analysis. In another embodiment of the disclosure, the VMM 193 may be adapted to receive one or more messages (e.g., data packets) from the heuristics engine 170 and analyze the message(s) to identify the software profile information associated with the needed VM instance 196.
For instance, as an illustrative example, a suspicious object under test may include an email message that was generated, under control of Windows® 7 Operating System, using Windows® Outlook 2007, version 12. The email message further includes a Portable Document Format (PDF) attachment in accordance with Adobe® Acrobat®, version 9.0. Upon determining that the email message includes suspicious content, the heuristics engine 170 provides software profile information to identify a particular type/configuration of a VM instance 196 needed to conduct dynamic analysis of the suspicious content. According to this illustrative example, the software profile information would include (1) Windows® 7 Operating System (OS); (2) Windows® Outlook 2007, version 12; and (3) PDF support through Adobe® Acrobat®, version 9.0.
In another embodiment of the disclosure, the heuristics engine 170 may determine the features of the client device 150 that are affected by the data traffic by receiving and analyzing the objects from the network interface 160. The heuristics engine 170 may then transmit the features of the client device 150 to the scheduler 180, the VMM 193, and/or the analysis engine 190.
Upon determination of the proper software profile, the scheduler 180, the VMM 193, and/or the analysis engine 190 may generate, configure, and run a VM instance 196 based on the determined software profile. The VM instance 196 may include one or more processes 203, an operating system component 207, one or more monitors 197 (including an operations/parameters capture module 198), and other components that are required to process the suspect object (and may, in some embodiments simulate the processing environment of the client device 150), and allow dynamic analysis of a suspect object.
In one embodiment, the VM instance 196 mimics the processing environment on the client device 150 such that a dynamic analysis of an object under examination may be performed. By generating a VM instance 196 that simulates the environment on the client device 105, the VM instance 196 allows the suspect object to be processed in a similar fashion as would be processed on the client device 150 without exposing the client device 150 to potential malicious behaviors of a suspect object.
The processes 203A and 203B may be any instance or component of a computer program. The processes 203A and 203B may be formed by code and instructions that define process operations. Each of the process operations may be performed at various intervals or points in time based on operating parameters, user inputs, or other factors/stimuli. For example, the process 203A may be an Adobe® reader process that defines multiple process operations. The process operations may include a function call, a process or thread lifecycle operation, a module operation, etc.
The monitors 197A and 197B are portions of code that may be injected within the processes 203A and 203B, respectively, for monitoring operations of interest associated with each process 203A and 203B. Although shown and described in relation to the processes 203A and 203B, monitoring may be similarly performed by operating system component 207 within the VM instance 196. In some embodiments, monitors 197 may be placed outside the VM instance 196. For example, monitors 197 may be placed in the VMM 193 for monitoring process operations and associated process parameters. In one embodiment, the VMM 193 may be a combination of hardware, software, and firmware that creates, runs, and controls the VM instance 196.
In any case, the monitors 197A and 197B, (or other monitoring functions, wherever located) include a novel operations/parameters capture (“OPC”) module 198. The OPC module 198 enables the monitors 197A and 197B to inspect or examine operations of the processes 203A and 203B, respectively, during run-time, and capture both the operations and associated parameters for use in malware detection. In some embodiments, the monitors 197A and 197B may be designed or positioned (pre-set) to examine specific, and preferably predefined, operations.
Although described as being inserted during instantiation, in some embodiments, the monitors 197 may be injected/inserted within processes 203 prior to instantiation of the VM instance 196. In this fashion, processes 203 with monitors 197 may be retrieved from storage during instantiation of the VM instance 196 without the need for monitor 197 insertion.
For example, the MCD system 1011 may in some embodiments inject a first monitor 197A into an Adobe® reader process 203A running within a VM instance 196 or may in other embodiments instantiate the VM instance 196 with a first monitor 197A injected into or otherwise located (i.e., positioned) to monitor behaviors of the Adobe® reader process 203A. The first monitor 197A may examine and capture a first set of process operations and process parameters associated, for example, with an Adobe® reader process 203A.
The MCD system 1011 may in some embodiments also inject a second monitor 197B into a Firefox® web-browser process 203B running within the VM instance 196 or may in other embodiments instantiate the VM instance 196 with a second monitor 197B injected into or being otherwise positioned to monitor behaviors of a Firefox® web-browser process 203B. The second monitor 197B may examine and capture a second set of process operations and associated process parameters associated with the Firefox® web-browser process 203B. In this example embodiment, the first and second sets of process operations and associated process parameters may have been preselected for each associated process 203 (e.g., Adobe® reader and Firefox® web-browser) to indicate the occurrence of application specific behaviors.
For example, the processes 203A and 203B may each include the process operations 301A and 301B. In this example, the monitor 197A is preset to monitor process operation 301A based on association with the process 203A. Similarly, the monitor 197B is preset to monitor process operation 301B within the process 203B. The decision on which process operations 301 to monitor may be preconfigured based on known malware. The monitors 197A and 197B may also monitor and record process parameters associated with process operations.
Referring now to
In one embodiment, the monitors 197A and 197B may compare recorded process parameters for a process operation with a set of predefined values, which may be derived through experimentation and/or machine learning. Upon detecting a match between the recorded process parameters and the set of predefined values, the corresponding monitor 197 may flag the process operation and recorded process parameters as an application specific behavior that may be useful in determining whether the suspect object is malware. In other embodiments, the monitors 197 may send all recorded process parameters to logic that performs the foregoing comparison with predefined values. The application specific behavior may be reported to the filtering and reporting module 195 as an event. The event describes the process 203 within which the application specific behavior was detected and the application specific behavior itself.
Referring back to
Accordingly, for example, where the suspect object has an associated score of 7 out of 10, and the first threshold is set at 6 out of 10, the suspect object may be classified as malware. Where the suspect object has an associated score of 5 out of 10, and the first threshold is set at 6 out of 10, the suspect object's associated score may be compared against a second threshold and the suspect objects events/application specific behaviors may be analyzed to determine whether the suspect object may be classified as requiring further analysis by the process operation analyzer 191.
As will be described in further detail below, these scores and classifications may be based on traversal of state machines by a state machine based analyzer 303 within the filtering and reporting module 195. In one embodiment, the generated score may be associated with the suspect object, stored in the storage device 185, and reported to a user, a network administrator, and/or a security professional by the reporting module 195.
As described above, the communication system 100 monitors and records process operations and process parameters of an associated process. By selectively recording process operations and process parameters of an associated process within a VM instance 196, the communication system 100 may better understand the context of process operations and generate more intelligent classifications for associated objects.
In some embodiments, the MCD system 1011 may include one or more stages of analysis (e.g., three are described below) in arriving at a confidence score for a suspect object as described above. The analysis stages may be performed in separate analysis engines 190, one per stage, or may be executed by a different number of analysis engines 190 in various embodiments by omitting, combining or dividing steps or stages. The analysis stages may be performed sequentially or concurrently (in an overlapping fashion). The analysis stages may be performed by a single processor or by separate processors, which may be located within the same device or appliance or located remotely from one another, and may communicate over a communication link or network.
Turning now to
The method 500 may commence at operation 501 with receipt of a suspect object to be analyzed. The suspect object may be intercepted by the network interface 160 and passed (or copied and passed) to the MCD system 1101 for analysis. In another embodiment, an anti-malware system running on the client device 150 may periodically or aperiodically (i.e., from time to time) and without direct provocation by the user intercept and transmit an object to the MCD system 1101 for processing and analysis. This independent interception and analysis of objects allows the client device 150 to maintain an automatic examination of potential malware content received without direct interaction by a user.
In another embodiment, a user of the client device 150 may submit objects through a user interface. The interface may be generated by the GUI logic 271 and served to the client device 150 by the configuration logic 273 of the MCD system 1101. In this fashion, the MCD system 1101 may operate as a web-server to deliver data and a user interface to the client device 150.
In one embodiment, the object received/intercepted at operation 501 may be any digital data structure. For example, the object may be a file (e.g., PDF document), a component of a file, a component of a web page, an image, a series of captured network/web traffic that is capable of being replayed, etc. As described above, a user of the client device 150 may manually determine that an object is suspected to be malware or the client device 150 may automatically classify the object as potential/suspected malware and transmit the object to the MCD system 1101.
Referring back to
Following interception and/or receipt of an object, operation 503 may perform a static analysis on the received object using the heuristics engine 170 and/or the heuristics database 175. As described above, this static analysis filters for content that is suspected to contain malware code. In general, this static analysis filtering serves to permit subsequent dynamic malware analysis only on a portion of incoming content, which effectively conserves system resources and provides faster response time in determining the presence of malware within analyzed content. When the object being analyzed is not suspected at operation 503 to be malware, operation 509 may permit the intercepted/received object to reach the client device 150 or, where the heuristic analysis is performed on a copy, to discard the copy and otherwise terminate the method 500 for this object and permit the client device 150 to proceed as normal. Conversely, when operation 505 determines that the object may be malicious based on the static analysis performed at operation 503, one or more stages of a dynamic analysis may be performed on the suspect object as described below at operation 507.
The dynamic analysis performed at operation 507 may include the use of the VM instance 196 to process the suspect object. In one embodiment, one or more monitors 197 are injected into or reside in components of the VM instance 196 (e.g., processes 203, etc.), or are otherwise positioned within the VM instance 196 so as to be able to monitor processing of the suspect object. More specifically, the monitors 197 monitor a predefined set of process operations and associated process parameters of their associated process. Utilizing process parameters that describe the context in which a detected process operation was performed allows the dynamic analysis greater insight into the characteristics of the suspect object. This improved insight results in a more accurate classification of the suspect object and a reduced number of malware false positives.
As shown in
Following sub-operation 507A, sub-operation 507B instantiates the VM instance 196 based on the determined software profile. The VM instance 196 may include an operating system component 207, one or more processes 203, and other components that simulate the processing environment. By generating and configuring the VM instance 196 to simulate the environment on the client device 150, the method 500 allows the suspect object to be processed without exposing the client device 150 to potential malicious behaviors.
Upon instantiating/running the VM instance 196, sub-operation 507C injects one or more monitors 197 into one or more components of the VM instance 196. For example, as shown in
Although described as being inserted during/after instantiation, in some embodiments, the monitors 197A and 197B may be injected/inserted within processes 203A and/or 203B or components of the operating system component 207 prior to instantiation of the VM instance 196. For example, the monitors 197A and 197B may reside within the computer programs such as computer applications or operating systems or virtual machine managers for use in instantiating a VM instance 196. In this fashion, processes 203 (or the computer programs) with the monitors 197A and 197B already inserted may be retrieved from storage during instantiation of the VM instance 196 without the need for the monitors 197A and 197B to be inserted at sub-operation 507C.
Continuing with the dynamic analysis, at sub-operation 507D, the suspect object is detonated, opened, run, or otherwise processed within the VM instance 196. Sub-operation 507D may include the processing of the suspect object by one or more components of the VM instance 196 (e.g., one or more of the processes 203A and 203B or an operating system component 207). For example, when the suspect object is a PDF file, an Adobe® reader process may be used to open the suspect object. Opening the PDF file using the Adobe® reader process allows the suspect object to perform process operations and alter process parameters associated with the suspect object such that further analysis may be performed regarding potential malicious code/content contained within the suspect object.
At sub-operation 507E, each of the injected monitors 197 attempts to detect an associated process operation. As noted above, each monitor 197 monitors a different set of process operations based on their associated process 203 within the VM instance 196. In some embodiments, the process operations monitored by each monitor 197 may overlap. In one embodiment, process operations are detected through the use of hooks, which intercept function calls or messages generated by corresponding process operations during their performance.
Upon detection of a process operation by a monitor 197 at sub-operation 507E, sub-operation 507F may record the values of one or more process parameters associated with the detected process operation. As described above,
Following recordation of process parameters for a detected process operation, one or more stages of analysis may be performed for the suspect object. For example, a first stage of analysis may be performed at sub-operation 507G. During this first stage of analysis, operations and associated parameters may be compared with those expected for the relevant process, such as by performing a look-up of the captured operation in a table or other data structure of expected operations (called a “whitelist”) for the process. Other embodiments may perform a look-up in a data structure of anomalous operations (called a “blacklist”), or in both a whitelist and blacklist. Suspicious operations are those not matching whitelist entries or those matching blacklist entries, depending on the embodiment. The first analysis stage may be performed by logic located within or associated with a monitor 197 (e.g., the OPC module 198). Since the monitor 197 may avail itself of such logic, it may be referred to herein as an “inference monitor.” The results of the first analysis stage may update a corresponding event data structure with all captured or developed event information (including information regarding the flagged operation and an associated application specific event), which may be arranged and accessed, for example, by a process identifier and/or an event identifier. The event data structure may be located in a local storage device (e.g., the storage device 185) or in a central or remote storage device.
Following sub-operation 507G, a second stage of the analysis may be performed at sub-operation 507H. The second stage of analysis may receive the event data structure associated with each captured event as established by the first analysis stage with its determination of application specific behavior (e.g., a flagged operation). The second analysis stage may use all of the captured events including the flagged operation in a state machine based analysis. In this context, a state machine for a process 203 is a representation of the expected sequencing of events that the process 203 may be expected to yield when monitored. For example,
The second analysis stage may identify captured operations that are anomalous (not represented in the state machine), operations that should have been monitored and captured but appear to have been omitted, and operations that occurred out of order. These identified operations and anomalous occurrences may include the flagged operation as well as one or more additional captured operations that appear anomalous based on the state machine analysis (even if they were not flagged in the first analysis stage). The state machine associated with the process 203 may generate additional events based on a partial match of state machine “states” with the observed events. The second analysis stage may update the event data structure to reflect its results. A suitable state machine representation for a process 203 can be developed through analysis of the process 203 and its expected operations and parameters prior to virtual processing of suspect objects. In some embodiments, the second analysis stage may store information in the event data structure associated with objects, or may simply discard the information related to those benign objects. Accordingly, the second analysis stage may act to filter the suspect objects to those that have a certain likelihood of being classified as malware. The likelihood level may be factory set, user set or dynamically determined, and different likelihood levels may be used based on history of malware detection, network traffic conditions, type of process, or other considerations. The second analysis stage may be performed by the state machine based analyzer 303 that resides within the filtering and reporting module 195. The filtering and reporting module 195 may be located within the virtual machine instance 196, within an associated virtual machine manager (VMM) 193 of the MCD system 1011 or within a controller external to the virtual machine instance 196 and the VMM 193, depending on the embodiment. Other forms of analysis may be used in substitution for or in addition to the state machine analysis to filter the captured operations.
Following sub-operation 507H, a third stage of the analysis may be performed at sub-operation 507I. This third analysis stage may obtain an event data structure directly from the second stage or by accessing a memory or other storage device that stores the event data structure (e.g., the storage device 185). The third analysis stage may use pre-defined rules to determine whether the suspect object should be classified as malware. To that end, the rules used in the third analysis stage may be developed through experiential knowledge and machine learning techniques regarding behaviors of known malware and benign objects processed by applications. The third analysis stage may generate a confidence score (e.g., a weight) for each of the suspect objects related to the probability that the suspect object is malicious (e.g., the probability that observed behaviors constitute or are associated with an exploit). The third analysis stage may use the confidence score for each suspect object (or combine confidence scores for plural objects (e.g., of a flow of related packets)) to yield an overall confidence score. The overall confidence score may also reflect, e.g., be generated based in part on, other scores from other analyses (e.g., static or heuristic analysis of the object). The third analysis stage may use that overall confidence score to classify the suspect object or objects as malware. In one embodiment, this confidence score is generated by the score generator 192.
Where the overall confidence score is not sufficiently high to classify the suspect object as malware (e.g., above a threshold), the object may be classified as benign or as requiring further forensic analysis. This classification and score may be reported to a user, a network administrator, and/or a security professional at operation 507J. When the object is classified as benign, the intercepted/received object may be permitted to reach the client device 150 or, where the analysis is performed on a copy, to discard the copy and otherwise terminate the method 500 for this object and permit the client device 150 to proceed as normal. A need for further forensic analysis of the suspect object may be indicated when the analysis has reported an event (including an additional event, e.g., from the second analysis) that suggests further analysis may yield a classification other than benign.
Where the suspect object is classified as malware, the MCD system 1011 may issue an alert or otherwise report its findings, including its confidence score that led to that classification at operation 507J. Security or network professionals may use the information in the report in deciding on remedial actions to be taken in light of the malware.
Utilizing process parameters that describe the context in which a detected process operation was performed provides greater insight into the characteristics of a suspect object. In particular, the detection of a process operation in a first context may be highly indicative of malware while the detection of the same process operation in a second context may provide little or no support for the classification of the object as malware. This improved insight results in a more accurate classification of the suspect object and a reduced number of malware false positives (FPs) and false negatives (FNs). Malware incorrectly classified in conventional detection systems as malicious (FPs) may not be marked malicious in embodiments of the invention based on application specific behavior. The same goes for malware incorrectly classified in conventional detection systems as non-malicious (FNs).
The embodiments of the invention can be further understood through the following examples that illustrate the benefits of using application specific behavior to provide context for classifying suspect objects.
“Malware to Non-Malware” Example
Monitors 197 capture operations performed by an application being processed (i.e., a process 203) and assess these operations in light of those expected for the application (i.e., application specific behavior). Though suspicious in some contexts (e.g., if dynamic content were loaded), the operations are not suspicious for the process 203 running. The captured information (regarding the process 203, operations, and parameters as obtained by the monitors 197) is passed to the filtering and reporting module 195. In some embodiments, the filtering and reporting module 195 decides against conducting a state machine analysis and the event is dropped from further analysis. In other embodiments, the event is subjected to state machine analysis, where either (i) the benign characterization of the object may be confirmed and the event then dropped from further analysis (filtered out) and not reported out by the filtering and reporting module 195 to the analysis engine 190, or (ii) the event information for the object is stored in a storage device (e.g., the storage device 185) with a likely low level of suspicion (e.g., low weight or score). The analysis engine 190 (and specifically, its classification logic, classifier 194, or score generator 192) may generate an overall score for a suspect object based on events from the filtering and reporting module 195 and compare this score to a threshold, and may determine that the threshold was not met so the object should be classified as non-malware. In other words, practice of the invention in this embodiment may result in the MCD system 1011 assigning a weight or score in light of the application being run and its analysis of the observed operations and parameters that may have the effect of classifying the object as non-malicious where, without the contribution of the context information, the object may have been falsely designated as malicious (false positive).
“Requires Further Analysis” Example
Monitors 197 observe a potential heap spray operation, but conditions make the characterization of the type of operation less than certain. This information is passed to the filtering and reporting module 195. State machine analysis sees dynamic content of a PDF document was loaded in an Adobe Reader application, but a decision is made that the observed operations are not enough to classify the object as malware. In the light of the loading of dynamic content (which is a known vehicle for exploits), the filtering and reporting module 195 generates an additional event related to that operation after matching observed events against states of the state machine, and stores the event in the storage device 185. If the analysis engine 190 assigns an overall confidence score to the object that is below the threshold to classify the object as malicious and one or more additional events are received from the filtering and reporting module 195, the analysis engine 190 may be in a position to classify the object as requiring further analysis, perhaps with longer analysis in virtual machine instance 196. Consequently, the practice of the invention in this embodiment may result in the system 1011 assigning a weight or score in light of the application being run and its analysis of the observed operations and parameters that may have the effect of raising the probability that the object is malware, and possibly classifying the object as requiring further analysis, where, without the contribution of the context information (e.g., dynamic content of a PDF document loaded in an Adobe Reader application), the object may have been falsely designated as non-malicious (potential false negative, depending on the outcome of the further analysis).
“Non-Malware to Malware” Example
Monitors 197 observe operations including crashing of an application during processing within the virtual machine instance 196, and determine that crashing of the particular application is unusual or unexpected absent malware. (Some applications are known to crash frequently for non-malicious reasons (e.g., coding issues) so crashing in and of itself may actually be deemed expected). The monitors 197 pass this information to the filtering and reporting module 195. The state machine analysis determines that certain operations performed prior to the application crashing support the conclusion that the object is at least suspicious. The filtering and reporting module 195 stores this information along with an event score in the storage device 185. The analysis engine 190 classifies the object as malware, based on a total score for the object being over a malware threshold. Accordingly, the practice of the invention in this embodiment may result in the system 1011 assigning a weight or score in light of the application being run and its analysis of the observed operations and parameters that may have the effect of raising the probability that the object is malware, and possibly classifying the object as malware where, without the contribution of the context information, the object may have been falsely designated as non-malicious (potential false negative). For example, process parameters may indicate that macros were loaded in a Microsoft Office application. In this case, tracking macro activity allows deeper inspection of an associated object. Accordingly, the object may be classified/reclassified as malicious and a false negative may be avoided.
As described above, the method 500 and system 1011 monitors and records process operations and process parameters using one or more monitors 197 within a VM instance 196. By selectively recording process operations and process parameters within a VM instance 196, the method 500 and system 1011 may better understand the context of process operations and generate more intelligent classifications for associated objects.
Claims
1. A computerized method for classifying an object based on detected process operations and associated process parameters that describe the context of the process operations, comprising:
- receiving an object to be examined for malware;
- performing dynamic analysis on the object, wherein the dynamic analysis includes:
- processing the object within a virtual machine,
- detecting, by a monitor, a process operation during the processing of the object within the virtual machine, and
- recording the process operation and a corresponding set of process parameters associated with the process operation, wherein the set of process defines a context in which the process operation was performed within the virtual machine when the process operation was detected, wherein the recorded process operation and the set of process parameters comprise a behavior;
- generating a probability the behavior is suspicious based on a comparison of the recorded process operation and the set of process parameters with at least one of (i) a set of expected process operations and process parameters, or (ii) a set of anomalous process operations and process parameters; and
- responsive to the probability being equal to or above a first predefined level, classifying the object as malware.
2. The computerized method of claim 1, wherein the process operation and the set of process parameters are pre-selected based on the location within the virtual machine in which the monitor is located.
3. The computerized method of claim 1, wherein the process operation is a function call, a process/thread lifecycle operation, or a module operation.
4. The computerized method of claim 1, wherein the set of process parameters define one or more of a state of modules within the virtual machine and a state of modules within a component of the virtual machine.
5. The computerized method of claim 1, wherein a component in which the monitor is located is a process running within the virtual machine, a portion of an operating system running in the virtual machine, or a virtual machine manager (VMM) running outside the virtual machine.
6. The computerized method of claim 1, wherein classifying the object as malware further comprises: generating, upon the probability being equal or above the first predefined level, a confidence score that the object is malware based on behaviors of known malware and benign objects.
7. A non-transitory storage medium including instructions that, when executed by one or more hardware processors, perform a plurality of operations, comprising:
- receiving, by a malware content detection system, an object to be examined for malware;
- performing dynamic analysis on the object, wherein the dynamic analysis includes:
- processing the object within a virtual machine,
- detecting, by a monitor, a process operation during the processing of the object within the virtual machine, and
- recording the process operation and a corresponding set of process parameters associated with the process operation, wherein the set of process of parameters defines a context in which the process operation was performed within the virtual machine when the process operation was detected, wherein the recorded process operation and the set of process parameters comprise a behavior, and
- generating a probability the behavior is suspicious based on a comparison of the recorded process operation and the set of process parameters with at least one of (i) a set of expected process operations and process parameters, or (ii) a set of anomalous process operations and process parameters; and
- responsive to the probability being equal to or above a first predefined level, classifying the object as malware.
8. The non-transitory storage medium of claim 7, wherein the process operation and the set of process parameters are pre-selected based on the location within the virtual machine in which the monitor is located.
9. The non-transitory storage medium of claim 7, wherein the process operation is a function call, a process/thread lifecycle operation, or a module operation.
10. The non-transitory storage medium of claim 7, wherein the set of process parameters define one or more of a state of modules within the virtual machine and a state of modules within a component.
11. The non-transitory storage medium of claim 7, wherein a component in which the monitor is located is a process running within the virtual machine, a portion of an operating system running in the virtual machine, or a virtual machine manager (VMM) running outside the virtual machine.
12. The non-transitory storage medium of claim 7, wherein classifying the object as malware further comprises:
- generating, upon the probability being equal or above the first predefined level, a confidence score that the object is malware based on behaviors of known malware and benign objects.
13. A system comprising:
- one or more hardware processors;
- a memory including one or more software modules that, when executed by the one or more hardware processors:
- perform dynamic analysis on a received object, wherein the dynamic analysis includes:
- process the object within a virtual machine,
- detect, by a monitor, a process operation during the processing of the object within the virtual machine,
- record the process operation and a corresponding set of process parameters associated with the process operation, wherein the set of process parameters defines a context in which the process operation was performed within the virtual machine when the process operation was detected, wherein the recorded process operation and the set of process parameters comprise a behavior;
- generate a probability the behavior is suspicious based on a comparison of the recorded process operation and the set of process parameters with at least one of (i) a set of expected process operations and process parameters, or (ii) a set of anomalous process operations and process parameters; and
- responsive to the probability being equal to or above a first predefined level, classify the object as malware.
14. The system of claim 13, wherein the process operation and the set of process parameters are pre-selected based on the location within the virtual machine in which the monitor is located.
15. The system of claim 13, wherein the process operation is a function call, a process/thread lifecycle operation, or a module operation.
16. The system of claim 13, wherein the set of process parameters defines one or more of a state of modules within the virtual machine and a state of modules within a component of the virtual machine.
17. The system of claim 13, wherein a component in which the monitor is located is a process running within the virtual machine, a portion of an operating system running in the virtual machine, or a virtual machine manager (VMM) running outside the virtual machine.
18. The system of claim 13, wherein classifying the object as malware further comprises:
- generating, upon probability being equal or above the first predefined level, a confidence score that the object is malware based on behaviors of known malware and benign objects.
19. The computerized method of claim 1, wherein the probability includes a weighted score.
20. The computerized method of claim 1, wherein the monitor is injected into the object prior to detecting the process operation.
21. The computerized method of claim 1 further comprising:
- responsive to the probability being below the first predefined level and above a second predefined level, classifying the object as benign, wherein the second predefined level is lower than the first predefined level.
22. The non-transitory storage medium of claim 7, wherein the probability includes a weighted score.
23. The non-transitory storage medium of claim 7, wherein the monitor is injected into the object prior to detecting the process operation.
24. The non-transitory storage medium of claim 7, wherein the plurality of operations further comprises:
- responsive to the probability being below the first predefined level and above a second predefined level, classifying the object as benign, wherein the second predefined level is lower than the first predefined level.
25. The system of claim 13, wherein the probability includes a weighted score.
26. The system of claim 13, wherein the monitor is injected into the object prior to detecting the process operation.
27. The system of claim 13, wherein the memory further includes one or more software modules that, when executed by the one or more hardware processors: responsive to the probability being below the first predefined level and above a second predefined level, classify the object as benign, wherein the second predefined level is lower than the first predefined level.
4292580 | September 29, 1981 | Ott et al. |
5175732 | December 29, 1992 | Hendel et al. |
5440723 | August 8, 1995 | Arnold et al. |
5490249 | February 6, 1996 | Miller |
5657473 | August 12, 1997 | Killean et al. |
5842002 | November 24, 1998 | Schnurer et al. |
5978917 | November 2, 1999 | Chi |
6088803 | July 11, 2000 | Tso et al. |
6094677 | July 25, 2000 | Capek et al. |
6108799 | August 22, 2000 | Boulay et al. |
6118382 | September 12, 2000 | Hibbs et al. |
6269330 | July 31, 2001 | Cidon et al. |
6272641 | August 7, 2001 | Ji |
6279113 | August 21, 2001 | Vaidya |
6298445 | October 2, 2001 | Shostack et al. |
6357008 | March 12, 2002 | Nachenberg |
6417774 | July 9, 2002 | Hibbs et al. |
6424627 | July 23, 2002 | Sørhaug et al. |
6442696 | August 27, 2002 | Wray et al. |
6484315 | November 19, 2002 | Ziese |
6487666 | November 26, 2002 | Shanklin et al. |
6493756 | December 10, 2002 | O'Brien et al. |
6550012 | April 15, 2003 | Villa et al. |
6700497 | March 2, 2004 | Hibbs et al. |
6775657 | August 10, 2004 | Baker |
6831893 | December 14, 2004 | Ben Nun et al. |
6832367 | December 14, 2004 | Choi et al. |
6895550 | May 17, 2005 | Kanchirayappa et al. |
6898632 | May 24, 2005 | Gordy et al. |
6907396 | June 14, 2005 | Muttik et al. |
6941348 | September 6, 2005 | Petry et al. |
6971097 | November 29, 2005 | Wallman |
6981279 | December 27, 2005 | Arnold et al. |
6995665 | February 7, 2006 | Appelt et al. |
7007107 | February 28, 2006 | Ivchenko et al. |
7028179 | April 11, 2006 | Anderson et al. |
7043757 | May 9, 2006 | Hoefelmeyer et al. |
7069316 | June 27, 2006 | Gryaznov |
7080407 | July 18, 2006 | Zhao et al. |
7080408 | July 18, 2006 | Pak et al. |
7093239 | August 15, 2006 | van der Made |
7096498 | August 22, 2006 | Judge |
7100201 | August 29, 2006 | Izatt |
7107617 | September 12, 2006 | Hursey et al. |
7159149 | January 2, 2007 | Spiegel et al. |
7213260 | May 1, 2007 | Judge |
7231667 | June 12, 2007 | Jordan |
7240364 | July 3, 2007 | Branscomb et al. |
7240368 | July 3, 2007 | Roesch et al. |
7243371 | July 10, 2007 | Kasper et al. |
7249175 | July 24, 2007 | Donaldson |
7287278 | October 23, 2007 | Liang |
7308716 | December 11, 2007 | Danford et al. |
7328453 | February 5, 2008 | Merkle, Jr. et al. |
7346486 | March 18, 2008 | Ivancic et al. |
7356736 | April 8, 2008 | Natvig |
7386888 | June 10, 2008 | Liang et al. |
7392542 | June 24, 2008 | Bucher |
7418729 | August 26, 2008 | Szor |
7428300 | September 23, 2008 | Drew et al. |
7441272 | October 21, 2008 | Durham et al. |
7448084 | November 4, 2008 | Apap et al. |
7458098 | November 25, 2008 | Judge et al. |
7464404 | December 9, 2008 | Carpenter et al. |
7464407 | December 9, 2008 | Nakae et al. |
7467408 | December 16, 2008 | O'Toole, Jr. |
7478428 | January 13, 2009 | Thomlinson |
7480773 | January 20, 2009 | Reed |
7487543 | February 3, 2009 | Arnold et al. |
7496960 | February 24, 2009 | Chen et al. |
7496961 | February 24, 2009 | Zimmer et al. |
7519990 | April 14, 2009 | Xie |
7523493 | April 21, 2009 | Liang et al. |
7530104 | May 5, 2009 | Thrower et al. |
7540025 | May 26, 2009 | Tzadikario |
7565550 | July 21, 2009 | Liang et al. |
7568233 | July 28, 2009 | Szor et al. |
7584455 | September 1, 2009 | Ball |
7603715 | October 13, 2009 | Costa et al. |
7607171 | October 20, 2009 | Marsden et al. |
7639714 | December 29, 2009 | Stolfo et al. |
7644441 | January 5, 2010 | Schmid et al. |
7657419 | February 2, 2010 | van der Made |
7676841 | March 9, 2010 | Sobchuk et al. |
7698548 | April 13, 2010 | Shelest et al. |
7707633 | April 27, 2010 | Danford et al. |
7712136 | May 4, 2010 | Sprosts et al. |
7730011 | June 1, 2010 | Deninger et al. |
7739740 | June 15, 2010 | Nachenberg et al. |
7779463 | August 17, 2010 | Stolfo et al. |
7784097 | August 24, 2010 | Stolfo et al. |
7836502 | November 16, 2010 | Zhao et al. |
7849506 | December 7, 2010 | Dansey et al. |
7854007 | December 14, 2010 | Sprosts et al. |
7869073 | January 11, 2011 | Oshima |
7877803 | January 25, 2011 | Enstone et al. |
7904959 | March 8, 2011 | Sidiroglou et al. |
7908660 | March 15, 2011 | Bahl |
7930738 | April 19, 2011 | Petersen |
7937761 | May 3, 2011 | Bennett |
7949849 | May 24, 2011 | Lowe et al. |
7996556 | August 9, 2011 | Raghavan et al. |
7996836 | August 9, 2011 | McCorkendale et al. |
7996904 | August 9, 2011 | Chiueh et al. |
7996905 | August 9, 2011 | Arnold et al. |
8006305 | August 23, 2011 | Aziz |
8010667 | August 30, 2011 | Zhang et al. |
8020206 | September 13, 2011 | Hubbard et al. |
8028338 | September 27, 2011 | Schneider et al. |
8042184 | October 18, 2011 | Batenin |
8045094 | October 25, 2011 | Teragawa |
8045458 | October 25, 2011 | Alperovitch et al. |
8069484 | November 29, 2011 | McMillan et al. |
8087086 | December 27, 2011 | Lai et al. |
8171553 | May 1, 2012 | Aziz et al. |
8176049 | May 8, 2012 | Deninger et al. |
8176480 | May 8, 2012 | Spertus |
8204984 | June 19, 2012 | Aziz et al. |
8214905 | July 3, 2012 | Doukhvalov et al. |
8220055 | July 10, 2012 | Kennedy |
8225373 | July 17, 2012 | Kraemer |
8233882 | July 31, 2012 | Rogel |
8234640 | July 31, 2012 | Fitzgerald et al. |
8234709 | July 31, 2012 | Viljoen et al. |
8239944 | August 7, 2012 | Nachenberg et al. |
8260914 | September 4, 2012 | Ranjan |
8266091 | September 11, 2012 | Gubin et al. |
8286251 | October 9, 2012 | Eker et al. |
8291499 | October 16, 2012 | Aziz et al. |
8307435 | November 6, 2012 | Mann et al. |
8307443 | November 6, 2012 | Wang et al. |
8312545 | November 13, 2012 | Tuvell et al. |
8316439 | November 20, 2012 | Fang et al. |
8321936 | November 27, 2012 | Green et al. |
8321941 | November 27, 2012 | Tuvell et al. |
8332571 | December 11, 2012 | Edwards, Sr. |
8365286 | January 29, 2013 | Poston |
8365297 | January 29, 2013 | Parshin et al. |
8370938 | February 5, 2013 | Daswani et al. |
8370939 | February 5, 2013 | Zaitsev et al. |
8375444 | February 12, 2013 | Aziz et al. |
8381299 | February 19, 2013 | Stolfo et al. |
8402529 | March 19, 2013 | Green et al. |
8464340 | June 11, 2013 | Ahn et al. |
8479174 | July 2, 2013 | Chiriac |
8479276 | July 2, 2013 | Vaystikh et al. |
8479291 | July 2, 2013 | Bodke |
8510827 | August 13, 2013 | Leake et al. |
8510828 | August 13, 2013 | Guo et al. |
8510842 | August 13, 2013 | Amit et al. |
8516478 | August 20, 2013 | Edwards et al. |
8516590 | August 20, 2013 | Ranadive et al. |
8516593 | August 20, 2013 | Aziz |
8522348 | August 27, 2013 | Chen et al. |
8528086 | September 3, 2013 | Aziz |
8533824 | September 10, 2013 | Hutton et al. |
8539582 | September 17, 2013 | Aziz et al. |
8549638 | October 1, 2013 | Aziz |
8555391 | October 8, 2013 | Demir et al. |
8561177 | October 15, 2013 | Aziz et al. |
8566946 | October 22, 2013 | Aziz et al. |
8584094 | November 12, 2013 | Dadhia et al. |
8584234 | November 12, 2013 | Sobel et al. |
8584239 | November 12, 2013 | Aziz et al. |
8595834 | November 26, 2013 | Xie et al. |
8627476 | January 7, 2014 | Satish et al. |
8635696 | January 21, 2014 | Aziz |
8682054 | March 25, 2014 | Xue et al. |
8682812 | March 25, 2014 | Ranjan |
8689333 | April 1, 2014 | Aziz |
8695096 | April 8, 2014 | Zhang |
8713631 | April 29, 2014 | Pavlyushchik |
8713681 | April 29, 2014 | Silberman et al. |
8726392 | May 13, 2014 | McCorkendale et al. |
8739280 | May 27, 2014 | Chess et al. |
8776229 | July 8, 2014 | Aziz |
8782792 | July 15, 2014 | Bodke |
8789172 | July 22, 2014 | Stolfo et al. |
8789178 | July 22, 2014 | Kejriwal et al. |
8793787 | July 29, 2014 | Ismael et al. |
8805947 | August 12, 2014 | Kuzkin et al. |
8806647 | August 12, 2014 | Daswani et al. |
8832829 | September 9, 2014 | Manni et al. |
8850570 | September 30, 2014 | Ramzan |
8850571 | September 30, 2014 | Staniford et al. |
8881234 | November 4, 2014 | Narasimhan et al. |
8881282 | November 4, 2014 | Aziz et al. |
8898788 | November 25, 2014 | Aziz et al. |
8935779 | January 13, 2015 | Manni et al. |
8984638 | March 17, 2015 | Aziz et al. |
8990939 | March 24, 2015 | Staniford et al. |
8990944 | March 24, 2015 | Singh et al. |
8997219 | March 31, 2015 | Staniford et al. |
9009822 | April 14, 2015 | Ismael et al. |
9009823 | April 14, 2015 | Ismael et al. |
9027135 | May 5, 2015 | Aziz |
9071638 | June 30, 2015 | Aziz et al. |
9104867 | August 11, 2015 | Thioux et al. |
9106694 | August 11, 2015 | Aziz et al. |
9118715 | August 25, 2015 | Staniford et al. |
20010005889 | June 28, 2001 | Albrecht |
20010047326 | November 29, 2001 | Broadbent et al. |
20020018903 | February 14, 2002 | Kokubo et al. |
20020038430 | March 28, 2002 | Edwards et al. |
20020091819 | July 11, 2002 | Melchione et al. |
20020095607 | July 18, 2002 | Lin-Hendel |
20020116627 | August 22, 2002 | Tarbotton et al. |
20020144156 | October 3, 2002 | Copeland |
20020162015 | October 31, 2002 | Tang |
20020166063 | November 7, 2002 | Lachman et al. |
20020169952 | November 14, 2002 | DiSanto et al. |
20020184528 | December 5, 2002 | Shevenell et al. |
20020188887 | December 12, 2002 | Largman et al. |
20020194490 | December 19, 2002 | Halperin et al. |
20030074578 | April 17, 2003 | Ford et al. |
20030084318 | May 1, 2003 | Schertz |
20030101381 | May 29, 2003 | Mateev et al. |
20030115483 | June 19, 2003 | Liang |
20030188190 | October 2, 2003 | Aaron et al. |
20030191957 | October 9, 2003 | Hypponen et al. |
20030200460 | October 23, 2003 | Morota et al. |
20030212902 | November 13, 2003 | van der Made |
20030229801 | December 11, 2003 | Kouznetsov et al. |
20030237000 | December 25, 2003 | Denton et al. |
20040003323 | January 1, 2004 | Bennett et al. |
20040015712 | January 22, 2004 | Szor |
20040019832 | January 29, 2004 | Arnold et al. |
20040047356 | March 11, 2004 | Bauer |
20040083408 | April 29, 2004 | Spiegel et al. |
20040088581 | May 6, 2004 | Brawn et al. |
20040093513 | May 13, 2004 | Cantrell et al. |
20040111531 | June 10, 2004 | Staniford et al. |
20040117478 | June 17, 2004 | Triulzi et al. |
20040117624 | June 17, 2004 | Brandt et al. |
20040128355 | July 1, 2004 | Chao et al. |
20040165588 | August 26, 2004 | Pandya |
20040236963 | November 25, 2004 | Danford et al. |
20040243349 | December 2, 2004 | Greifeneder et al. |
20040249911 | December 9, 2004 | Alkhatib et al. |
20040255161 | December 16, 2004 | Cavanaugh |
20040268147 | December 30, 2004 | Wiederin et al. |
20050005159 | January 6, 2005 | Oliphant |
20050021740 | January 27, 2005 | Bar et al. |
20050033960 | February 10, 2005 | Vialen et al. |
20050033989 | February 10, 2005 | Poletto et al. |
20050050148 | March 3, 2005 | Mohammadioun et al. |
20050086523 | April 21, 2005 | Zimmer et al. |
20050091513 | April 28, 2005 | Mitomo et al. |
20050091533 | April 28, 2005 | Omote et al. |
20050091652 | April 28, 2005 | Ross et al. |
20050108562 | May 19, 2005 | Khazan et al. |
20050114663 | May 26, 2005 | Cornell et al. |
20050125195 | June 9, 2005 | Brendel |
20050149726 | July 7, 2005 | Joshi et al. |
20050157662 | July 21, 2005 | Bingham et al. |
20050183143 | August 18, 2005 | Anderholm et al. |
20050201297 | September 15, 2005 | Peikari |
20050210533 | September 22, 2005 | Copeland et al. |
20050238005 | October 27, 2005 | Chen et al. |
20050240781 | October 27, 2005 | Gassoway |
20050262562 | November 24, 2005 | Gassoway |
20050265331 | December 1, 2005 | Stolfo |
20050283839 | December 22, 2005 | Cowburn |
20060010495 | January 12, 2006 | Cohen et al. |
20060015416 | January 19, 2006 | Hoffman et al. |
20060015715 | January 19, 2006 | Anderson |
20060015747 | January 19, 2006 | Van de Ven |
20060021029 | January 26, 2006 | Brickell et al. |
20060021054 | January 26, 2006 | Costa et al. |
20060031476 | February 9, 2006 | Mathes et al. |
20060047665 | March 2, 2006 | Neil |
20060070130 | March 30, 2006 | Costea et al. |
20060075496 | April 6, 2006 | Carpenter et al. |
20060095968 | May 4, 2006 | Portolani et al. |
20060101516 | May 11, 2006 | Sudaharan et al. |
20060101517 | May 11, 2006 | Banzhof et al. |
20060117385 | June 1, 2006 | Mester et al. |
20060123477 | June 8, 2006 | Raghavan et al. |
20060143709 | June 29, 2006 | Brooks et al. |
20060150249 | July 6, 2006 | Gassen et al. |
20060161983 | July 20, 2006 | Cothrell et al. |
20060161987 | July 20, 2006 | Levy-Yurista |
20060161989 | July 20, 2006 | Reshef et al. |
20060164199 | July 27, 2006 | Gilde et al. |
20060173992 | August 3, 2006 | Weber et al. |
20060179147 | August 10, 2006 | Tran et al. |
20060184632 | August 17, 2006 | Marino et al. |
20060191010 | August 24, 2006 | Benjamin |
20060221956 | October 5, 2006 | Narayan et al. |
20060236393 | October 19, 2006 | Kramer et al. |
20060242709 | October 26, 2006 | Seinfeld et al. |
20060248519 | November 2, 2006 | Jaeger et al. |
20060248582 | November 2, 2006 | Panjwani et al. |
20060251104 | November 9, 2006 | Koga |
20060288417 | December 21, 2006 | Bookbinder et al. |
20070006288 | January 4, 2007 | Mayfield et al. |
20070006313 | January 4, 2007 | Porras et al. |
20070011174 | January 11, 2007 | Takaragi et al. |
20070016951 | January 18, 2007 | Piccard et al. |
20070016953 | January 18, 2007 | Morris et al. |
20070033645 | February 8, 2007 | Jones |
20070038943 | February 15, 2007 | FitzGerald et al. |
20070064689 | March 22, 2007 | Shin et al. |
20070074169 | March 29, 2007 | Chess et al. |
20070094730 | April 26, 2007 | Bhikkaji et al. |
20070101435 | May 3, 2007 | Konanka et al. |
20070128855 | June 7, 2007 | Cho et al. |
20070142030 | June 21, 2007 | Sinha et al. |
20070143827 | June 21, 2007 | Nicodemus et al. |
20070156895 | July 5, 2007 | Vuong |
20070157180 | July 5, 2007 | Tillmann et al. |
20070157306 | July 5, 2007 | Elrod et al. |
20070168988 | July 19, 2007 | Eisner et al. |
20070171824 | July 26, 2007 | Ruello et al. |
20070174915 | July 26, 2007 | Gribble et al. |
20070192500 | August 16, 2007 | Lum |
20070192858 | August 16, 2007 | Lum |
20070198275 | August 23, 2007 | Malden et al. |
20070208822 | September 6, 2007 | Wang et al. |
20070220607 | September 20, 2007 | Sprosts et al. |
20070240218 | October 11, 2007 | Tuvell et al. |
20070240219 | October 11, 2007 | Tuvell et al. |
20070240220 | October 11, 2007 | Tuvell et al. |
20070240222 | October 11, 2007 | Tuvell et al. |
20070250930 | October 25, 2007 | Aziz et al. |
20070256132 | November 1, 2007 | Oliphant |
20070271446 | November 22, 2007 | Nakamura |
20080005782 | January 3, 2008 | Aziz |
20080028463 | January 31, 2008 | Dagon et al. |
20080032556 | February 7, 2008 | Schreier |
20080040710 | February 14, 2008 | Chiriac |
20080046781 | February 21, 2008 | Childs et al. |
20080066179 | March 13, 2008 | Liu |
20080072326 | March 20, 2008 | Danford et al. |
20080077793 | March 27, 2008 | Tan et al. |
20080080518 | April 3, 2008 | Hoeflin et al. |
20080086720 | April 10, 2008 | Lekel |
20080098476 | April 24, 2008 | Syversen |
20080120722 | May 22, 2008 | Sima et al. |
20080134178 | June 5, 2008 | Fitzgerald et al. |
20080134334 | June 5, 2008 | Kim et al. |
20080141376 | June 12, 2008 | Clausen et al. |
20080184373 | July 31, 2008 | Traut et al. |
20080189787 | August 7, 2008 | Arnold et al. |
20080201778 | August 21, 2008 | Guo et al. |
20080209557 | August 28, 2008 | Herley et al. |
20080215742 | September 4, 2008 | Goldszmidt et al. |
20080222729 | September 11, 2008 | Chen et al. |
20080263665 | October 23, 2008 | Ma et al. |
20080295172 | November 27, 2008 | Bohacek |
20080301810 | December 4, 2008 | Lehane et al. |
20080307524 | December 11, 2008 | Singh et al. |
20080313738 | December 18, 2008 | Enderby |
20080320594 | December 25, 2008 | Jiang |
20090003317 | January 1, 2009 | Kasralikar et al. |
20090007100 | January 1, 2009 | Field et al. |
20090013408 | January 8, 2009 | Schipka |
20090031423 | January 29, 2009 | Liu et al. |
20090036111 | February 5, 2009 | Danford et al. |
20090037835 | February 5, 2009 | Goldman |
20090044024 | February 12, 2009 | Oberheide et al. |
20090044274 | February 12, 2009 | Budko et al. |
20090064332 | March 5, 2009 | Porras et al. |
20090077666 | March 19, 2009 | Chen et al. |
20090083369 | March 26, 2009 | Marmor |
20090083855 | March 26, 2009 | Apap et al. |
20090089879 | April 2, 2009 | Wang et al. |
20090094697 | April 9, 2009 | Provos et al. |
20090113425 | April 30, 2009 | Ports et al. |
20090125976 | May 14, 2009 | Wassermann et al. |
20090126015 | May 14, 2009 | Monastyrsky et al. |
20090126016 | May 14, 2009 | Sobko et al. |
20090133125 | May 21, 2009 | Choi et al. |
20090144823 | June 4, 2009 | Lamastra et al. |
20090158430 | June 18, 2009 | Borders |
20090172815 | July 2, 2009 | Gu et al. |
20090187992 | July 23, 2009 | Poston |
20090193293 | July 30, 2009 | Stolfo et al. |
20090199296 | August 6, 2009 | Xie et al. |
20090228233 | September 10, 2009 | Anderson et al. |
20090241187 | September 24, 2009 | Troyansky |
20090241190 | September 24, 2009 | Todd et al. |
20090265692 | October 22, 2009 | Godefroid et al. |
20090271867 | October 29, 2009 | Zhang |
20090300415 | December 3, 2009 | Zhang et al. |
20090300761 | December 3, 2009 | Park et al. |
20090328185 | December 31, 2009 | Berg et al. |
20090328221 | December 31, 2009 | Blumfield et al. |
20100005146 | January 7, 2010 | Drako et al. |
20100011205 | January 14, 2010 | McKenna |
20100017546 | January 21, 2010 | Poo et al. |
20100031353 | February 4, 2010 | Thomas et al. |
20100037314 | February 11, 2010 | Perdisci et al. |
20100054278 | March 4, 2010 | Stolfo et al. |
20100115621 | May 6, 2010 | Staniford et al. |
20100180344 | July 15, 2010 | Malyshev et al. |
20100192223 | July 29, 2010 | Ismael et al. |
20100220863 | September 2, 2010 | Dupaquis et al. |
20100235831 | September 16, 2010 | Dittmer |
20100281541 | November 4, 2010 | Stolfo et al. |
20100281542 | November 4, 2010 | Stolfo et al. |
20100299754 | November 25, 2010 | Amit et al. |
20100306173 | December 2, 2010 | Frank |
20110004737 | January 6, 2011 | Greenebaum |
20110047620 | February 24, 2011 | Mahaffey et al. |
20110055907 | March 3, 2011 | Narasimhan et al. |
20110078794 | March 31, 2011 | Manni et al. |
20110093951 | April 21, 2011 | Aziz |
20110099620 | April 28, 2011 | Stavrou et al. |
20110099633 | April 28, 2011 | Aziz |
20110113231 | May 12, 2011 | Kaminsky |
20110145918 | June 16, 2011 | Jung et al. |
20110145920 | June 16, 2011 | Mahaffey et al. |
20110145934 | June 16, 2011 | Abramovici et al. |
20110167493 | July 7, 2011 | Song et al. |
20110167494 | July 7, 2011 | Bowen et al. |
20110173460 | July 14, 2011 | Ito et al. |
20110219449 | September 8, 2011 | St. Neitzel et al. |
20110219450 | September 8, 2011 | McDougal et al. |
20110225624 | September 15, 2011 | Sawhney et al. |
20110225655 | September 15, 2011 | Niemela et al. |
20110247072 | October 6, 2011 | Staniford et al. |
20110265182 | October 27, 2011 | Peinado et al. |
20110289582 | November 24, 2011 | Kejriwal et al. |
20110302587 | December 8, 2011 | Nishikawa et al. |
20110307954 | December 15, 2011 | Melnik et al. |
20110307955 | December 15, 2011 | Kaplan et al. |
20110307956 | December 15, 2011 | Yermakov et al. |
20110314546 | December 22, 2011 | Aziz et al. |
20120023593 | January 26, 2012 | Puder et al. |
20120054869 | March 1, 2012 | Yen et al. |
20120066698 | March 15, 2012 | Yanoo |
20120079596 | March 29, 2012 | Thomas et al. |
20120084859 | April 5, 2012 | Radinsky et al. |
20120110667 | May 3, 2012 | Zubrilin et al. |
20120117652 | May 10, 2012 | Manni et al. |
20120121154 | May 17, 2012 | Xue et al. |
20120124426 | May 17, 2012 | Maybee et al. |
20120174186 | July 5, 2012 | Aziz et al. |
20120174196 | July 5, 2012 | Bhogavilli et al. |
20120174218 | July 5, 2012 | McCoy et al. |
20120198279 | August 2, 2012 | Schroeder |
20120210423 | August 16, 2012 | Friedrichs et al. |
20120222121 | August 30, 2012 | Staniford et al. |
20120255015 | October 4, 2012 | Sahita et al. |
20120255017 | October 4, 2012 | Sallam |
20120260304 | October 11, 2012 | Morris et al. |
20120260342 | October 11, 2012 | Dube et al. |
20120266244 | October 18, 2012 | Green et al. |
20120278886 | November 1, 2012 | Luna |
20120297489 | November 22, 2012 | Dequevy |
20120330801 | December 27, 2012 | McDougal et al. |
20130014259 | January 10, 2013 | Gribble et al. |
20130036472 | February 7, 2013 | Aziz |
20130047257 | February 21, 2013 | Aziz |
20130074185 | March 21, 2013 | McDougal et al. |
20130086684 | April 4, 2013 | Mohler |
20130097699 | April 18, 2013 | Balupari et al. |
20130097706 | April 18, 2013 | Titonis et al. |
20130111587 | May 2, 2013 | Goel et al. |
20130117852 | May 9, 2013 | Stute |
20130117855 | May 9, 2013 | Kim et al. |
20130139264 | May 30, 2013 | Brinkley et al. |
20130160125 | June 20, 2013 | Likhachev et al. |
20130160127 | June 20, 2013 | Jeong et al. |
20130160130 | June 20, 2013 | Mendelev et al. |
20130160131 | June 20, 2013 | Madou et al. |
20130167236 | June 27, 2013 | Sick |
20130174214 | July 4, 2013 | Duncan |
20130185789 | July 18, 2013 | Hagiwara et al. |
20130185795 | July 18, 2013 | Winn et al. |
20130185798 | July 18, 2013 | Saunders et al. |
20130191915 | July 25, 2013 | Antonakakis et al. |
20130196649 | August 1, 2013 | Paddon et al. |
20130227691 | August 29, 2013 | Aziz et al. |
20130246370 | September 19, 2013 | Bartram et al. |
20130263260 | October 3, 2013 | Mahaffey et al. |
20130291109 | October 31, 2013 | Staniford et al. |
20130298243 | November 7, 2013 | Kumar et al. |
20140053260 | February 20, 2014 | Gupta et al. |
20140053261 | February 20, 2014 | Gupta et al. |
20140130158 | May 8, 2014 | Wang et al. |
20140130161 | May 8, 2014 | Golovanov |
20140137180 | May 15, 2014 | Lukacs et al. |
20140157407 | June 5, 2014 | Krishnan et al. |
20140169762 | June 19, 2014 | Ryu |
20140179360 | June 26, 2014 | Jackson et al. |
20140328204 | November 6, 2014 | Klotsche et al. |
20140337836 | November 13, 2014 | Ismael |
20140351935 | November 27, 2014 | Shao et al. |
20150096018 | April 2, 2015 | Mircescu |
20150096025 | April 2, 2015 | Ismael |
2439806 | January 2008 | GB |
2490431 | October 2012 | GB |
02/06928 | January 2002 | WO |
02/23805 | March 2002 | WO |
2007117636 | October 2007 | WO |
2008041950 | April 2008 | WO |
2011084431 | July 2011 | WO |
2011/112348 | September 2011 | WO |
2012/075336 | June 2012 | WO |
2013/067505 | May 2013 | WO |
- “Network Security: NetDetector—Network Intrusion Forensic System (NIFS) Whitepaper”, (“NetDetector Whitepaper”), (2003).
- “Packet”, Microsoft Computer Dictionary, Microsoft Press, (Mar. 2002), 1 page.
- “When Virtual is Better Than Real”, IEEEXplore Digital Library, available at, http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&arnumbe- r=990073, (Dec. 7, 2013).
- Abdullah, et al., Visualizing Network Data for Intrusion Detection, 2005 IEEE Workshop on Information Assurance and Security, pp. 100-108.
- Adetoye, Adedayo, et al., “Network Intrusion Detection & Response System”, (“Adetoye”), (Sep. 2003).
- AltaVista Advanced Search Results. “attack vector identifier”. Http://www.altavista.com/web/results?ltag=ody&pg=aq&aqmode=aqa=Event+Orch- estrator . . . , (Accessed on Sep. 15, 2009).
- AltaVista Advanced Search Results. “Event Orchestrator”. Http://www.altavista.com/web/results?ltag=ody&pg=aq&aqmode=aqa=Event+Orch- esrator . . . , (Accessed on Sep. 3, 2009).
- Aura, Tuomas, “Scanning electronic documents for personally identifiable information”, Proceedings of the 5th ACM workshop on Privacy in electronic society. ACM, 2006.
- Baecher, “The Nepenthes Platform: An Efficient Approach to collect Malware”, Springer-verlag Berlin Heidelberg, (2006), pp. 165-184.
- Baldi, Mario; Risso, Fulvio; “A Framework for Rapid Development and Portable Execution of Packet-Handling Applications”, 5th IEEE International Symposium Processing and Information Technology, Dec. 21, 2005, pp. 233-238.
- Bayer, et al., “Dynamic Analysis of Malicious Code”, J Comput Virol, Springer-Verlag, France., (2006), pp. 67-77.
- Boubalos, Chris, “extracting syslog data out of raw pcap dumps, seclists.org, Honeypots mailing list archives”, available at http://seclists.org/honeypots/2003/q2/319 (“Boubalos”), (Jun. 5, 2003).
- Chaudet, C., et al., “Optimal Positioning of Active and Passive Monitoring Devices”, International Conference on Emerging Networking Experiments and Technologies, Proceedings of the 2005 ACM Conference on Emerging Network Experiment and Technology, CoNEXT '05, Toulousse, France, (Oct. 2005), pp. 71-82.
- Chen, P. M. and Noble, B. D., “When Virtual is Better Than Real, Department of Electrical Engineering and Computer Science”, University of Michigan (“Chen”).
- Cisco “Intrusion Prevention for the Cisco ASA 5500-x Series” Data Sheet (2012).
- Cisco, Configuring the Catalyst Switched Port Analyzer (SPAN) (“Cisco”), (1992-2003).
- Cohen, M.I., “PyFlag—An advanced network forensic framework”, Digital investigation 5, Elsevier, (2008), pp. S112-S120.
- Costa, M., et al., “Vigilante: End-to-End Containment of Internet Worms”, SOSP '05, Association for Computing Machinery, Inc., Brighton U.K., (Oct. 23-26, 2005).
- Crandall, J.R., et al., “Minos:Control Data Attack Prevention Orthogonal to Memory Model”, 37th International Symposium on Microarchitecture, Portland, Oregon, (Dec. 2004).
- Deutsch, P., “Zlib compressed data format specification version 3.3” RFC 1950, (1996).
- Distler, “Malware Analysis: An Introduction”, SANS Institute InfoSec Reading Room, SANS Institute, (2007).
- Dunlap, George W., et al., “ReVirt: Enabling Intrusion Analysis through Virtual-Machine Logging and Replay”, Proceeding of the 5th Symposium on Operating Systems Design and Implementation, USENIX Association, (“Dunlap”), (Dec. 9, 2002).
- Excerpt regarding First Printing Date for Merike Kaeo, Designing Network Security (“Kaeo”), (2005).
- Filiol, Eric, et al., “Combinatorial Optimisation of Worm Propagation on an Unknown Network”, International Journal of Computer Science 2.2 (2007).
- Goel, et al., Reconstructing System State for Intrusion Analysis, Apr. 2008 SIGOPS Operating Systems Review, vol. 42 Issue 3, pp. 21-28.
- Hjelmvik, Erik, “Passive Network Security Analysis with NetworkMiner”, (IN)Secure, Issue 18, (Oct. 2008), pp. 1-100.
- IEEE Xplore Digital Library Sear Results for “detection of unknown computer worms”. Http//ieeexplore.ieee.org/searchresult.jsp?SortField=Score&SortOrder=desc- &ResultC . . . , (Accessed on Aug. 28, 2009).
- Kaeo, Merike, “Designing Network Security”, (“Kaeo”), (Nov. 2003).
- Kim, H., et al., “Autograph: Toward Automated, Distributed Worm Signature Detection”, Proceedings of the 13th Usenix Security Symposium (Security 2004), San Diego, (Aug. 2004), pp. 271-286.
- King, Samuel T., et al., “Operating System Support for Virtual Machines”, (“King”).
- Krasnyansky, Max, et al., Universal TUN/TAP driver, available at https://www.kernel.org/doc/Documentation/networking/tuntap.txt (2002) (“Krasnyansky”).
- Kreibich, C., et al., “Honeycomb-Creating Intrusion Detection Signatures Using Honeypots”, 2nd Workshop on Hot Topics in Networks (HotNets-11), Boston, USA, (2003).
- Kristoff, J., “Botnets, Detection and Mitigation: DNS-Based Techniques”, NU Security Day, (2005), 23 pages.
- Liljenstam, Michael, et al., “Simulating Realistic Network Traffic for Worm Warning System Design and Testing”, Institute for Security Technology studies, Dartmouth College (“Liljenstam”), (Oct. 27, 2003).
- Lok Kwong et al: “DroidScope: Seamlessly Reconstructing the OS and Dalvik Semantic Views for Dynamic Android Malware Analysis”, Aug. 10, 2012, XP055158513, Retrieved from the Internet: URL:https://www.usenix.org/system/files/conference/usenixsecurity12/sec12--final107.pdf [retrieved on Dec. 15, 2014].
- Marchette, David J., “Computer Intrusion Detection and Network Monitoring: A Statistical Viewpoint”, (“Marchette”), (2001).
- Margolis, P.E., “Random House Webster's ‘Computer & Internet Dictionary 3rd Edition’”, ISBN 0375703519, (Dec. 1998).
- Moore, D., et al., “Internet Quarantine: Requirements for Containing Self-Propagating Code”, INFOCOM, vol. 3, (Mar. 30-Apr. 3, 2003), pp. 1901-1910.
- Morales, Jose A., et al., “Analyzing and exploiting network behaviors of malware.”, Security and Privacy in Communication Networks. Springer Berlin Heidelberg, 2010. 20-34.
- Natvig, Kurt, “SANDBOXII: Internet”, Virus Bulletin Conference, (“Natvig”), (Sep. 2002).
- NetBIOS Working Group. Protocol Standard for a NetBIOS Service on a TCP/UDP transport: Concepts and Methods. STD 19, RFC 1001, Mar. 1987.
- Newsome, J., et al., “Dynamic Taint Analysis for Automatic Detection, Analysis, and Signature Generation of Exploits on Commodity Software”, In Proceedings of the 12th Annual Network and Distributed System Security, Symposium (NDSS '05), (Feb. 2005).
- Newsome, J., et al., “Polygraph: Automatically Generating Signatures for Polymorphic Worms”, In Proceedings of the IEEE Symposium on Security and Privacy, (May 2005).
- Nojiri, D., et al., “Cooperation Response Strategies for Large Scale Attack Mitigation”, DARPA Information Survivability Conference and Exposition, vol. 1, (Apr. 22-24, 2003), pp. 293-302.
- Reiner Sailer, Enriquillo Valdez, Trent Jaeger, Roonald Perez, Leendert van Doom, John Linwood Griffin, Stefan Berger., sHype: Secure Hypervisor Appraoch to Trusted Virtualized Systems (Feb. 2, 2005) (“Sailer”).
- Silicon Defense, “Worm Containment in the Internal Network”, (Mar. 2003), pp. 1-25.
- Singh, S., et al., “Automated Worm Fingerprinting”, Proceedings of the ACM/USENIX Symposium on Operating System Design and Implementation, San Francisco, California, (Dec. 2004).
- Spitzner, Lance, “Honeypots: Tracking Hackers”, (“Spizner”), (Sep. 17, 2002).
- The Sniffers's Guide to Raw Traffic available at: yuba.stanford.edu/.about.casado/pcap/section1.html, (Jan. 6, 2014).
- Thomas H. Ptacek, and Timothy N. Newsham, “Insertion, Evasion, and Denial of Service: Eluding Network Intrusion Detection”, Secure Networks, (“Ptacek”), (Jan. 1998).
- U.S. Pat. No. 8,171,553 filed Apr. 20, 2006, Inter Parties Review Decision dated Jul. 10, 2015.
- U.S. Pat. No. 8,291,499 filed Mar. 16, 2012, Inter Parties Review Decision dated Jul. 10, 2015.
- Venezia, Paul, “NetDetector Captures Intrusions”, InfoWorld Issue 27, (“Venezia”), (Jul. 14, 2003).
- Whyte, et al., “DNS-Based Detection of Scanning Works in an Enterprise Network”, Proceedings of the 12th Annual Network and Distributed System Security Symposium, (Feb. 2005), 15 pages.
- Williamson, Matthew M., “Throttling Viruses: Restricting Propagation to Defeat Malicious Mobile Code”, ACSAC Conference, Las Vegas, NV, USA, (Dec. 2002), pp. 1-9.
- Adobe Systems Incorporated, “PDF 32000-1:2008, Document management—Portable document format—Part1:PDF 1.7”, First Edition, Jul. 1, 2008, 756 pages.
- Apostolopoulos, George; hassapis, Constantinos; “V-eM: A cluster of Virtual Machines for Robust, Detailed, and High-Performance Network Emulation”, 14th IEEE International Symposium on Modeling, Analysis, and Simulation of Computer and Telecommunication Systems, Sep. 11-14, 2006, pp. 117-126.
- Clark, John, Sylvian Leblanc,and Scott Knight. “Risks associated with usb hardware trojan devices used by insiders.” Systems Conference (SysCon), 2011 IEEE International. IEEE, 2011.
- FireEye Malware Analysis & Exchange Network, Malware Protection System, FireEye Inc., 2010.
- FireEye Malware Analysis, Modern Malware Forensics, FireEye Inc., 2010.
- FireEye v.6.0 Security Target, pp. 1-35, Version 1.1, FireEye Inc., May 2011.
- Gibler, Clint, et al. AndroidLeaks: automatically detecting potential privacy leaks in android applications on a large scale. Springer Berlin Heidelberg, 2012.
- Gregg Keizer: “Microsoft's HoneyMonkeys Show Patching Windows Works”, Aug. 8, 2005, XP055143386, Retrieved from the Internet: URL:https://web.archive.org/web/20121022220617/http://www.informationweek- .com/microsofts-honeymonkeys-show-patching-wi/167600716 [retrieved on Sep. 29, 2014].
- Heng Yin et al, Panorama: Capturing System-Wide Information Flow for Malware Detection and Analysis, Research Showcase @ CMU, Carnegie Mellon University, 2007.
- Idika et al., A-Survey-of-Malware-Detection-Techniques, Feb. 2, 2007, Department of Computer Science, Purdue University.
- Isohara, Takamasa, Keisuke Takemori, and Ayumu Kubota. “Kernel-based behavior analysis for android malware detection,” Computational intelligence and Security (CIS), 2011 Seventh International Conference on. IEEE, 2011.
- Kevin A Roundy et al: “Hybrid Analysis and Control of Malware”, Sep. 15, 2010, Recent Advances in Intrusion Detection, Springer Berlin Heidelberg, Berlin, Heidelberg, pp. 317-338, XP019150454 ISBN:978-3-642-15511-6.
- Leading Colleges Select FireEye to Stop Malware-Related Data Breaches, FireEye Inc., 2009.
- Li et al., A VMM-Based System Call Interposition Framework for Program Monitoring, Dec. 2010, IEEE 16th International Conference on Parallel and Distributed Systems, pp. 706-711.
- Lindorfer, Martina, Clemens Kolbitsch, and Paolo Milani Comparetti. “Detecting environment-sensitive malware.” Recent Advances in Intrusion Detection. Springer Berlin Heidelberg, 2011.
- Mori, Detecting Unknown Computer Viruses, 2004, Springer-Verlag Berlin Heidelberg.
- Oberheide et al., CloudAV.sub.—N-Version Antivirus in the Network Cloud, 17th USENIX Security Symposium USENIX Security '08 Jul. 28-Aug. 1, 2008 San Jose, CA.
- Wahid et al., Characterising the Evolution in Scanning Activity of Suspicious Hosts, Oct. 2009, Third International Conference on Network and System Security, pp. 344-350.
- Yuhei Kawakoya et al: “Memory behavior-based automatic malware unpacking in stealth debugging environment”, Malicious and Unwanted Software (Malware), 2010 5th International Conference on, IEEE, Piscataway, NJ, USA, Oct. 19, 2010, pp. 39-46, XP031833827, ISBN:978-1-4244-8-9353-1.
- Zhang et al., The Effects of Threading, Infection Time, and Multiple-Attacker Collaboration on Malware Propagation, Sep. 2009, IEEE 28th International Symposium on Reliable Distributed Systems, pp. 73-82.
Type: Grant
Filed: Feb 5, 2014
Date of Patent: Feb 16, 2016
Patent Publication Number: 20150220735
Assignee: FireEye, Inc. (Milpitas, CA)
Inventors: Sushant Paithane (Sunnyvale, CA), Sai Vashisht (Union City, CA)
Primary Examiner: Morshed Mehedi
Application Number: 14/173,765
International Classification: G06F 21/00 (20130101); G06F 21/56 (20130101); G06F 21/53 (20130101);