Selective system call monitoring

Abstract

According to one embodiment of the invention, a computerized method is described for improved efficiency in malware detection. The method comprises detecting a system call initiated by a virtual machine and determining a class assigned to the detected system call. In response to determining that the system call is associated with a first class of system calls, providing information associated with the system call to virtualized device hardware. In contrast, in response to determining that the system call is associated with a second class of system calls, which is different from the first class of system calls, the virtual machine resumes virtual processing of an object without providing information to the virtualized device hardware.

Description

FIELD

Embodiments of the disclosure relate to the field of cyber security. More specifically, embodiments of the disclosure relate to a system and computerized method that detects a system call during processing of an object by one or more virtual machines and classifies the detected system call, where the assigned classification at least partially controls the manner in which further virtual processing of that detected system call is conducted.

GENERAL BACKGROUND

Malware detection systems often employ virtual environments to enable potentially malicious objects to be safely analyzed during run-time in one or more sandboxed virtual machines. Each virtual machine is provisioned with a guest image, where the guest image is configured in accordance with a particular software profile. This particular software profile is dependent on the type of object being analyzed. For example, where the object is an accessed web page, the software profile may prescribe a browser application that runs over a specific operating system (e.g., Windows®, Linux®, etc.). As another example, where the object is an electronic message, the software profile may prescribe an email application running over the same or a different operating system (e.g., Microsoft® Mobile®, Blackberry® OS, etc.).

For processing a suspicious object, the virtual machine is provisioned with a guest image that features software components for the prescribed software profile. Typically, during virtual processing, the suspicious object may cause a software application associated with the guest image to initiate a system call that requests a service from the guest operating system (OS). The service may include a hardware-related service (e.g., accessing a hard disk drive, etc.). According to certain conventional security architectures, all system calls are intercepted by a virtual machine monitor (VMM), which is operating in kernel mode. Thereafter, the parameters associated with the system call are subsequently passed to virtual machine memory inspection logic (VMMI), which monitors behaviors (e.g., activities and/or omissions) conducted by virtualized device hardware in the processing of an instruction pertaining to the system call. Stated differently, the VMM passes control of the virtual processing to the VMMI, which is operating in user mode.

This conventional system call monitoring process features a few disadvantages. One disadvantage is that the amount of processing time required for conducting a context switch in passing parameters associated with the system call (from the VMM operating in the kernel mode to the VMMI operating in the user mode) is substantial which may impact performance of the malware detection system.

BRIEF DESCRIPTION OF THE DRAWINGS

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:

FIG. 1 is an exemplary block diagram of a network appliance with system call classification handled by a virtual machine monitor (VMM) as described herein.

FIG. 2A is an exemplary block diagram of a first logical representation of the operability of a virtual machine, virtualized device hardware and the virtual machine monitor within the virtual execution logic as described herein.

FIG. 2B is an exemplary block diagram of a second logical representation of the operability of the virtual machine, virtualized device hardware and the virtual machine monitor within the virtual execution logic as described herein.

FIG. 3 is an exemplary embodiment of a logical representation of the network appliance of FIG. 1.

FIG. 4 is an illustrative embodiment of the operations conducted in accordance with the selective system call tracing.

DETAILED DESCRIPTION

Various embodiments of the disclosure relate to a system and computerized method that detects a system call during processing of an object by one or more virtual machines and classifies the detected system call. The assigned classification may be used to control whether or not the handling of the detected system call is conducted by virtualized device hardware targeted by the system call. Hence, by classifying the system call and controlling the handling of these system calls, the monitoring of guest operating system (OS) activity may be controlled.

A system call includes a request to the OS kernel for a service. Normally, the OS kernel manages input/output (I/O) requests from software and translates these requests into data processing instructions for a central processing unit (CPU) or other electronic components. The service may include hardware-related services (e.g., access to a storage device such as a hard disk drive), or process management (e.g., creation, termination, scheduling of a process). In a virtual analysis environment, a system call may be initiated from a process running on a virtual machine (VM). A virtual machine monitor (VMM), also referred to as a hypervisor, manages VM operability, including processing of the guest OS, and is configured to detect and control the handling of system calls through call classification.

Herein, system calls may be classified into a plurality of classes. According to one embodiment of the disclosure, these classes may include (1) a first class that features a first set of system calls (sometimes referred to as “system-wide” system calls), and (2) a second class that features a second set of system calls (sometimes referred to as “process-specific” system calls). It is contemplated that there is no specific set of system calls that are necessary to the implementation of the invention, as the illustrative system calls for a selected class may be dynamic in nature based on the security threat landscape.

According to one embodiment of the disclosure, “system-wide” system calls represent selected system calls that tend to occur during malicious attacks, but are less processing intensive and/or less frequently initiated than other types of system calls. “Process-specific” system calls represent selected system calls that tend to involve behaviors that may be more susceptible to malicious attacks for that particular process.

When the detected system call is a member of the first class (and in some cases the second class), the detected system call is serviced by virtualized device hardware and activities associated with the virtual processing of the detected system call by the virtualized device hardware are monitored by virtual machine memory inspection logic (VMMI) residing in the VMM. Similarly, when the detected system call is a member of the second class and the process initiating the detected system call has been identified as “suspicious” (e.g., activities of the process suggests that the process is associated with a malicious attack), the detected system call is serviced by virtualized device hardware and activities associated with the virtual processing of the detected system call by the virtualized device hardware are monitored by the VMMI.

For instance, in some deployments of the network appliance, VMMI monitors virtual processing of system-wide system calls by the virtualized device hardware, regardless of the process from which the system-wide system calls originated. Additionally, the VMMI monitors virtual processing of process-specific system calls where the process has been identified as suspicious. These process-specific system calls are applicable to all of the suspicious processes.

For other deployments, the VMMI monitors virtual processing of system-wide system calls by the virtualized device hardware, regardless of the process from which the system-wide system calls originated. The VMMI monitors virtual processing of the process-specific system calls (where the process has been identified as suspicious), but the process-specific system calls are selected for each type of process. As a result, the process-specific system calls may vary, in part or in total, from one categorized process to another categorized process. This deployment would allow the network appliance to concentrate resources in monitoring for different system calls among the processes, such as those system calls with a higher likelihood of being associated with a malicious attack for that particular process.

According to one embodiment of the disclosure, the VMMI will not monitor the second set of system calls (e.g., process-specific system calls) in its classification of a detected system call from a particular process until a triggering event occurs. In response to the triggering event, the VMMI now classifies the detected system call based on both the first and second sets of system calls. An example of a triggering event may include detecting a “system-wide” system call previously initiated by the particular (first) process during virtual processing of the object under analysis within the virtual machine. Another example of a triggering event may include detecting a “system-wide” system call which was previously initiated by another (second) process and created the particular (first) process. Hence, at a minimum, the first process is deemed to be suspicious.

I. TERMINOLOGY

In the following description, certain terminology is used to describe aspects of the invention. For example, in certain situations, terms “logic,” “component” and “engine” are representative of hardware, firmware and/or software that is configured to perform one or more functions. As hardware, logic (or component or engine) may include circuitry having data processing or storage functionality. Examples of such processing or storage circuitry may include, but is not limited or restricted to a processor; one or more processor cores; a programmable gate array; a microcontroller; an application specific integrated circuit; receiver, transmitter and/or transceiver circuitry; semiconductor memory; or combinatorial logic, or combinations of one or more of the above components.

Logic (or component 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 a “non-transitory storage medium” may include, but are not limited or restricted to a programmable circuit; 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; and/or a semiconductor memory. 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 behaviors. The object may also exhibit a set of unexpected behaviors systematic of malicious activity that may provide evidence that the object may be classified as malicious.

In general, a “process” is an instance of software that is executed, in a virtual environment, for processing of an object under analysis. Each process may include one or more threads of execution (“threads”). For a multi-thread deployment, it is contemplated that each thread may be responsible for processing an object under analysis. The threads may operate successively or concurrently (e.g., at least partially overlapping in time) within the process, and share state information, memory and other process resources.

A “virtual machine” generally refers to an operating system (OS) or application environment that is virtualized and operates with virtualized device hardware, which may be different from the device on which the virtualization is conducted. Virtual machines may be based on specifications of a hypothetical computer or emulate the computer architecture and functions of a real world computing device.

A “network appliance” generally refers to an electronic device which network connectivity that typically includes a housing that protects, and sometimes encases, circuitry with data processing and/or data storage. Examples of a network appliance may include a server or an endpoint device that may include, but is not limited or restricted to a stationary or portable computer including a desktop computer, laptop, electronic reader, netbook or tablet; a wireless or wired access point; a router or other signal propagation networking equipment; a smart phone; a video-game console; or wearable technology (e.g., watch phone, etc.).

The term “transmission medium” is a physical or logical communication path with an endpoint device. For instance, 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.

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.

II. GENERAL ARCHITECTURES AND METHODS OF OPERATIONS

Referring to FIG. 1, an exemplary block diagram of a network appliance 100 deploying within a network 110 is shown. As shown, the network appliance 100 comprises a processing engine 120, a static analysis engine 130, a scheduler 140, a storage device 150, a dynamic analysis engine 160, an object classification engine 180, and/or a reporting engine 190 with an optional user interface capability.

According to one embodiment, the network appliance 100 is adapted to analyze received objects for malware, where a portion of the analysis is directed to detecting and classifying system calls (sometimes referred to as “syscalls”) initiated by a process that is commenced during virtual processing of the received object within a sandboxed environment. The rules and/or parameters used in classifying the detected system call may be updated (e.g., upload new rules or modified rules, delete rules, modify parameters that are utilized by the rules) within a virtual machine monitor (VMM), which manages virtual processing of received objects that are deemed to be “suspicious” when loaded into the dynamic analysis engine 160 for further analysis.

As shown in FIG. 1, the network appliance 100 is an electronic device that is adapted to analyze information associated with incoming data (e.g., data over a transmission medium 112 that is part of the network 110. The incoming data may be directed from/to one or more endpoint devices (not shown) via any type of transmission medium 112, such as data routed via a wireless channel from a server, data routed via a wired cable coupled to the server or any device with storage capability, data routed via a combination of wired and wireless mediums, or the like. As this illustrative embodiment, the network 110 may include a public network such as the Internet, a private network (e.g., a local area network “LAN”, wireless LAN, etc.), or a combination thereof.

Although not shown, the network appliance 100 may be communicatively coupled with the network 110 via an interface 114 operating as a data capturing device. According to one embodiment of the disclosure, the interface 114 is configured to receive the incoming data and provide information associated with the received incoming data to the network appliance 100. For instance, the interface 114 may operates a network tap that provides at least one or more objects (hereinafter “object(s)”) extracted from network traffic propagating over the transmission medium 112. Alternatively, although not shown, the network appliance 100 may be configured to receive files or other objects that automatically (or on command), accessed from a storage system. As yet another alternative, the network appliance 100 may be configured to receive objects that are not provided over the network 110. For instance, as an illustrative example, the interface 114 may be a data capturing device (e.g., port) for receiving objects manually provided via a suitable dedicated communication link or from portable storage media such as a flash drive.

Metadata may accompany the object(s) for analysis. According to one embodiment of the disclosure, the metadata may be used, at least in part, to determine protocols, application types and other information that identifies characteristics of the object under analysis. The metadata may be used by logic (e.g., scheduler 140) within the network appliance 100 to select one or more software (guest) images that correspond to and include a particular software profile and which virtual machines 162₁-162_M are selected to be active or inactive. The software images are used to provision virtual machines 162₁-162_M (M≧1) within the dynamic analysis engine 160 according to a particular software profile. For instance, accessible by the scheduler 140, a plurality of different types of software images may be stored in a storage device 150, which correspond to a plurality of different types of software profiles. The software images can be updated via an external source (e.g., management system and/or cloud computing services) under a “push” or “pull” delivery scheme. These software images are used for configuring virtual machine(s) 162₁-162_M within the dynamic analysis engine 160.

In some embodiments, although not shown, interface 114 may be contained within the network appliance 100. In other embodiments, the interface 114 can be integrated into an intermediary device in the communication path (e.g., a firewall, router, switch or other networked electronic device) or can be a standalone component, such as an appropriate commercially available network tap.

As further shown in FIG. 1, a first embodiment of the network appliance 100 includes the processing engine 120, static analysis engine 130, scheduler 140, storage device 150, dynamic analysis engine 160, object classification engine 180, and reporting engine 190. Herein, according to one embodiment of the disclosure, the processing engine 120 receives a flow that features related information (e.g., data packets, etc.), including an object, and converts that object into a format, as need or appropriate, on which deep scanning by the static analysis engine 130 can be applied (see operations 1 & 2). This conversion and scanning may involve decompression of the object, decompilation of the object, extraction of specific data associated with the object, and/or emulation of the extracted data (like Javascript).

The static analysis engine 130 may include processing circuitry, such as one or more processors for example, which features metadata capture logic 132 and static analysis logic 134. For example, the metadata capture logic 132 is responsible for extracting and/or generating metadata contained with and/or associated with incoming data (e.g., network traffic). The metadata may be identified as being associated with a particular object 145 under analysis, and is temporarily stored. Examples of types of the metadata may include, but are not restricted or limited to information associated with the object such as object type. For example, code is an example of an object type, which may be in the form of an executable file or code embedded into another type of object. This metadata may be subsequently used for configuring one or more VMs 162₁-162_M within the dynamic analysis engine for virtual processing the object associated with that metadata.

In addition to, or in lieu of the metadata associated with the source of the object 145, it is contemplated that other types of metadata may be captured by metadata capture logic 132. For instance, these other types of metadata may include metadata associated with the destination targeted to receive the object 145. As examples, the metadata may include the device type or Media Access Control (MAC) address for the endpoint device, the particular software configuration of the endpoint device 130, or the like.

Referring still to FIG. 1, the static analysis logic 130 includes one or more software modules that, when executed by the controller(s), analyzes features for one or more incoming objects 145, which may be a portion of network traffic according to this embodiment of the disclosure (see operation 2). Such analysis may involve a static analysis of the features of each object under analysis to determine whether the object 145 is “suspicious,” namely there exists a certain level of likelihood that the object 145 is associated with malware. This static analysis may include one or more checks being conducted on the object without its execution.

Examples of the checks may include signature matching to conduct (a) exploit signature checks, which may be adapted to compare at least a portion of the object under analysis with one or more pre-stored exploit signatures (pre-configured and predetermined attack patterns) from signature database (not shown), and/or (b) vulnerability signature checks that may be adapted to uncover deviations in messaging practices (e.g., non-compliance in communication protocols, message formats or ordering, and/or payload parameters including size). Other examples of these checks may include (i) heuristics, which is based on rules or policies as applied to the object and may determine whether one or more portions of the object under analysis is associated with an anomalous or suspicious characteristic (e.g., a particular URL associated with known exploits, or a particular source or destination address etc.) associated with known exploits; or (ii) determinative rule-based analysis that may include blacklist or whitelist checking.

Upon static analysis of the features of the object 145, the static analysis engine 130 determines whether this object 145 is “suspicious,” namely the object 145 has features that suggest its association with a malicious attack. As a result, the static analysis engine 130 may route this suspicious object 148 (e.g., some or the entire analyzed object 145) to the dynamic analysis engine 160 for more in-depth analysis.

More specifically, after analysis of the features of the object 145 has been completed, the static analysis engine 130 may provide the suspicious object 148 to the dynamic analysis engine 160 for in-depth dynamic analysis by VMs 162₁-162_M that is part of the virtual analysis environment 165 (see operation 4). Such analysis is illustrated in FIGS. 2A and 2B, described below in detail.

Referring still to FIG. 1, according to one embodiment, the scheduler 140 may be adapted to configure one or more VMs 162₁-162_M, namely the first VM 162₁ and the M^th VM 162_M as shown, based on metadata associated with the suspicious object 148 (see operation 3). For instance, the VMs 162₁-162_M may be provisioned with software images stored within the storage device 150. These software images are configured with in accordance with certain software profiles. The software profiles may be directed to software components supplied by an enterprise and/or software components commonly utilized by endpoint devices within the enterprise (e.g., a certain version of Windows® OS; a certain version of a particular web browser such as Internet Explorer®; Adobe® PDF™ reader application; etc.). As yet another alternative embodiment, the software image may include a script that fetches the software components from a third party (e.g., software manufacturer, distributor, etc.). Of course, it is contemplated that the VM configuration described above may be handled by logic other than the scheduler 140 such as a virtual machine monitor (VMM) 164.

According to one embodiment of the disclosure, the dynamic analysis engine 160 may be adapted to execute one or more VMs 162₁-162_M, which provides processing for the suspicious object 148 within a virtual run-time environment (see operation 4). For instance, dynamic analysis engine 160 comprises the VMM 164 operating in a kernel mode, which is configured to detect and classify system calls received from the VM(s) 162₁-162_M operating in a user mode. The “kernel mode” is a privileged mode, where a processor in this mode can access the entire address space, executes the entire instruction set (privileged and non-privileged instructions).

Additionally, the VMM 164 may emulate and/or provide anticipated signaling to the VM(s) 162₁, . . . , and/or 162_M during virtual processing. As an example, the VMM 164 is configured to obtain information associated with the system call received from one of the VMs 162₁-162_M (e.g., VM 162₁). For instance, when the VMM 164 detects of a system call, virtual machine memory inspection logic (VMMI) 166 that is part of the VMM 164 accesses certain portions of the virtualized device hardware (e.g., one or more registers of the virtual processor “vCPU”, virtualized memory, etc.) to identify the type of system call detected. The VMMI 166 may obtain a system call identifier (e.g., a value that uniquely represents the system call) and/or additional parameters associated with the system call. It is contemplated that retrieval of the additional parameters may require address translations prior to accessing the additional parameters where the content associated with the parameters is referenced by address pointers.

Thereafter, the VMMI 166 is configured to classify the detected system call from the VMs 162₁-162_M to determine whether the system call is to be handled by the virtualized device hardware 168 (operating in the user mode). While switching from VM mode to VMM mode (sometimes referred to as “kernel mode”) is not “expensive” from a processing time perspective, the context switching from kernel mode to user mode is expensive. Hence, system call classification may, in certain situations, avoid unnecessary processing of a system call by the virtualized device hardware 168.

Where the detected system call from a virtual machine (e.g., VM 162₁) is part of a first set of system calls, one or more instructions associated with the detected system call are provided to the virtualized device hardware 168 and the resultant behaviors by the virtualized device hardware 168 are monitored and/or stored. After the virtualized device hardware 168 has completed such processing, the VMMI 166 signals the VMM 164 to issue a message that causes the VM 162₁ to resume operations. The first set of system calls may include one or more system calls where system call hooking using the VMMI 166 is enabled for all processes in the guest OS.

Herein, according to one embodiment of the disclosure, the classification of system calls may be dynamic in nature based on the security threat landscape. For instance, the first set of system calls may represent “system-wide” system calls, namely selected system calls that tend to occur during malicious attacks, but are less processing intensive and/or less frequently initiated than other system calls. As a result, the monitoring of guest OS activity initiated by the first set of system calls does not warrant significant performance overhead. Examples of some of the first set of system calls may include, but are not limited to, certain system calls may be directed to (i) process control); (ii) certain file management system calls; and/or (iii) device management system calls such as input/output control that conducts device-specific input/output operations and other operations which cannot be expressed by regular system calls.

Given that the level of security threats may change on a weekly or daily basis and the particular system calls used by exploits may vary depending on the particular customers and/or its industry, the first set of system calls may be dynamic in nature with updates to the first set of system calls from external sources. This allows for some or all of the system calls to be added and/or removed on a periodic or aperiodic basis.

Where the detected system call from a particular process running on the VM 162₁ is one of the second set of the system calls and the particular process has already been determined to be suspicious, one or more instructions (sometimes referred to as “instruction(s)”) associated with the detected system call is provided to the virtualized device hardware 168. Thereafter, the resultant behaviors by the virtualized device hardware 168 are monitored and/or stored in a data store (sometimes referred to as an “event log”) 170.

Herein, the second set of system calls include “process-specific” system calls, namely selected system calls which may involve behaviors that are more susceptible to malicious attacks for that particular process. According to one embodiment of the disclosure, the process-specific system calls may include one or more system calls that differ from the “system-wide” system calls, and these process-specific system calls are selected for all suspicious processes. For other deployments, the process-specific system calls may include one or more system calls, different than the “system-wide” system calls, which are configurable for each type of process.

Thus, these process-specific system calls may differ, in part or in total, from one categorized process to another categorized process in order to target those system calls from different processes that may be more susceptible to malicious attack. Examples of the process-specific system calls may include, but are not limited or restricted to file management system calls; communication-based system calls; and/or other types of system calls that are hooked to identify necessary OS activity of the suspicious process for analyzing malicious behavior.

Additionally, where the detected system call is not a member of the first class or second class of system calls, instruction(s) within the second set of system calls are not handled by the virtual device hardware 168 to avoid the need for context switching. Rather, the VMM 164 merely emulates operation of the instruction(s) and returns a message to cause the VM 162₁ to resume its current process.

The monitored behaviors by the VMs 162₁-162_M and/or the virtualized device hardware 168 may be stored within the data store 170 for subsequent transfer as part of the VM-based results 172 to the object classification engine 180 (see operation 6).

According to one embodiment of the disclosure, the object classification engine 180 includes logic that is configured to receive the VM-based result 172, which include information associated with the monitored behaviors associated with processing of the suspicious object 148 with the VM(s) 162₁, . . . , and/or 162_M. Based on the VM-based results 172, the object classification engine 180 classifies the suspicious object 148 as malicious or not. According to one embodiment of the disclosure, the object classification engine 180 comprises prioritization logic 182, score determination logic 184, and comparison logic 186. The optional prioritization logic 182 may be configured to apply weighting to analysis results 174 from the static analysis engine 130 (illustrated by dashed lines) and/or the VM-based results 172.

The score determination logic 184 analyzes the VM-based results and determines (i) a probability (e.g., a score value) that the suspicious object 148 is associated with a malicious attack and/or (ii) a suspected severity of the malicious attack. The probability (score) may be included as part of the results provided to the reporting engine 190. According to one embodiment of the disclosure, the score determination logic 184 may rely on a rule-based predictive model to determine the probability (score) and/severity assigned to the suspicious object 148. Such information may be used in reporting for ordering of alerts, determining the medium or mediums of transmission of the alert from the reporting engine 190, the presentation style (font color, font size, selected image, etc.) used for the alert, or the like.

As shown in FIG. 1, the reporting engine 190 is configured to receive information from the object classification engine 180 and generate alerts. The alerts may include various types of messages that identify to a network administrator the suspicious object 148 as malicious (see operation 7). The message types may include text messages and/or email messages, video or audio stream, or other types of information over a wired or wireless communication path.

Referring to FIG. 2A, a first exemplary logical representation of the operations between a virtual machine (e.g., VM 162₁), the VMM 164 and the virtualized device hardware 168 is shown. Herein, one or more processes 200₁-200_N (N≧1) are running on the VM 162₁. For instance, process 200₁ is configured as a single or multi-threaded process to execute the suspect object 148 of FIG. 1. The process 200₁ may be assigned a process identifier (e.g., PID_1) at start time, or perhaps prior to or subsequent to execution by the VM 162₁. Each process identifier (e.g., PID_1, . . . , PID_N) may be a unique number or a unique alphanumeric string.

The VMM 164 is in communication with the VM 162₁. The VMM 164 includes a virtual machine control structure (VMCS) 210, which is a data store pre-loaded with information 215 that enables management logic 220 of the VMM 164 to intercept a system call 230 generated by process 200₁ during virtual processing of the suspicious object. The system call 230 comprises (i) one or more instructions 232, and (ii) an index 234 to one or more parameter values that are needed for execution of the instruction(s) 232.

In response to detecting and intercepting the system call 230, the VMM management logic 220 temporarily halts execution of the process 200₁ running in the VM 162₁ and passes information associated with the detected system call 230 to the VMMI 166. In fact, it is contemplated that the VM 162₁ is halted for all system calls, and thus, all processes running on the VM 162₁ are halted as well. The information associated with the detected system call 230 comprises (i) the instruction(s) 232, (ii) the index 234, and/or (iii) a process identifier 236 (e.g., PID_1) for the process 200₁ that initiated the system call 230.

According to one embodiment of the disclosure, the VMMI 166 includes classification logic 240, a first data store 250 and a second data store 260. Initially, in response to receipt of the information associated with the detected system call 230, the classification logic 240 of the VMMI 166 accesses portions of the virtualized hardware 168 to obtain a system call identifier 270 and/or parameters 275 associated with the detected system call 230. For instance, as an illustrative example, in response to receipt of signaling identifying receipt of the system call 230 by the VMM management logic 220, the VMMI 166 accesses one or more registers 282 associated with virtual processor (vCPU 280) that is part of the virtualized device hardware 168. The register(s) 282 includes the system call identifier 270, namely data that enables the VMMI 166 to identify system call type. Additionally, the VMMI 166 may access certain memory locations 292 within the virtual memory (vMemory) 290, which is part of the virtualized device hardware 168, to obtain the parameters 275 needed to complete execution of the instruction(s) 232 that are part of the system call 230. For instance, the VMMI 166 may access memory locations 292 to obtain the content of an address pointer, which is subsequently used to determine a handle for a particular file to be opened.

Additionally, the classification logic 240 accesses the first data store 250 to determine whether the process 200₁ has been previously identified as being suspicious. According to one embodiment of the disclosure, this determination may be conducted by the classification logic 240 comparing the process identifier (PID_1) 236 of the process 200₁ with a listing of PIDs within the first data store 250 that have been previously identified as suspicious. A process may be identified as suspicious based on the type of system calls generated by the process and/or how the process was created. For instance, where process 200₁ has been created through a fork system call initiated by another process (e.g., process 200_N), the first data store 250 would identify PID_1 for process 200₁ as a suspicious process. Additionally, unless process 200_N is a trusted process, it is contemplated that the first data store 250 may also include PID_N to identify that process 200_N is suspicious as well.

When the classification logic 240 determines that the process 200₁ has not been previously identified as being suspicious (e.g., PID_1 236 fails to match any PIDs in the first data store 250), the classification logic 240 compares the system call identifier 270, which identifies the specific system call type, against identifiers associated with a first set of system calls 262 within the second data store 260. The first set of system calls 262 includes system call identifiers for system-wide system calls.

In response to determining that the detected system call 230 is one of the system-wide system calls 262, the classification logic 240 now identifies the process (PID_1) as suspicious in the first data store 250. Additionally, the VMMI 166 provides the information associated with the detected system call 230 to the virtualized device hardware 168 for processing. The activities of the virtualized device hardware 168 are monitored by the VMMI 166 and data pertaining to these activities (e.g., state changes including changes in content within register or addressed memory, ports accessed, etc.) is stored in the event log (not shown). Thereafter, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

In contrast, in response to determining that the detected system call 230 is not one of the system-wide system calls 262, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 and return a message to the VM 162₁ that causes the process 200₁ to resume operations.

When the classification logic 240 determines that the process 200₁ has been previously identified as being suspicious (e.g., PID_1 236 matches a PID in the first data store 250), the classification logic 240 compares the system call identifier 270, which identifies the specific system call type, against identifiers associated with both the first set of system calls 262 and the second set of system calls 264 within the second data store 260. The second set of system calls 264 includes system call identifiers for process-specific system calls, as described above.

In response to determining that the detected system call 230 is one of the system-wide system calls 262 or one of the process-specific system calls, the classification logic 240 provides the information associated with the detected system call 230 to the virtualized device hardware 168 for processing. The activities of the virtualized device hardware 168 are monitored by the VMMI 168 and stored in the event log (not shown). Thereafter, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

In contrast, in response to determining that the detected system call 230 is not one of the system-wide system calls 262 or one of the process-specific system calls 264, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

As a secondary embodiment of the disclosure, prior to comparison of the first and second sets of system calls, the classification logic 240 may determine whether the system call identifier 270, which identifies the specific system call type, is present in a third set of system calls 266. The third set of system calls 266 operates as a “white list” to identify those system calls that should not to be passed to the virtualized device hardware 168 under any circumstance or in response to a prescribed state of operation (e.g., the virtual analysis environment exceeding certain load conditions or falling before performance thresholds). Rather, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

Referring to FIG. 2B, a second exemplary logical representation of the operations between the VM 162₁, the VMM 164 and the virtualized device hardware 168 is shown. Similar to FIG. 2A, one or more processes 200₁-200_N (N≧1) are running on the VM 162₁, where the process 200₁ is assigned PID_1 as its process identifier.

In response to detecting and intercepting the system call 230, the VMM management logic 220 temporarily halts execution of the process 200₁ running in the VM 162₁ and passes information associated with the detected system call 230 to the VMMI 166. The information associated with the detected system call 230 comprises (i) one or more instructions 232, (ii) the index 234, and/or (iii) the process identifier 236 (e.g., PID_1) for the process 200₁ that initiated the system call 230.

It is contemplated that VMM management logic 220 may be configured to halt the VM 162₁ in response to detecting the system call 230. This halts all of the processes running on the VM 162₁. Where the VM 162₁ includes multiple virtual processors (e.g., multiple vCPUs), for a process running on a first vCPU and initiating a system call during an analysis of an object, the second vCPU is also halted to avoid changing data within the virtual memory.

According to one embodiment of the disclosure, in response to receipt of the information associated with the detected system call 230, the classification logic 240 of the VMMI 166 accesses portions of the virtualized hardware 168 to obtain the system call identifier 270 and/or parameters 275 associated with the detected system call 230, as described above. Additionally, the classification logic 240 accesses the first data store 250 to determine whether the process 200₁ has been previously identified as being suspicious, as described above.

When the classification logic 240 determines that the process 200₁ has not been previously identified as being suspicious (e.g., PID_1 236 fails to match any PIDs in the first data store 250), the classification logic 240 compares the system call identifier 270 against identifiers associated with the first set of system calls 262 within the second data store 260, namely the system-wide system calls, as described above.

In response to determining that the detected system call 230 is one of the system-wide system calls 262, the classification logic 240 now identifies the process (PID_1) as suspicious in the first data store 250. Additionally, the VMMI 166 provides the information associated with the detected system call 230 to the virtualized device hardware 168 for processing. The activities of the virtualized device hardware 168 are monitored by the VMMI 166 and data pertaining to these activities is stored. Thereafter, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

In contrast, in response to determining that the detected system call 230 is not one of the system-wide system calls 262, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 and return a message to the VM 162₁ that causes the process 200₁ to resume operations.

When the classification logic 240 determines that the process 200₁ has been previously identified as being suspicious (e.g., PID_1 236 matches a PID in the first data store 250), the classification logic 240 compares the system call identifier 270, which identifies the specific system call type, against identifiers associated with both the first set of system calls 262 and the second set of system calls 264 within the second data store 260. The second set of system calls 264 includes system call identifiers for process-specific system calls, as described above.

However, with respect to comparison of the system call identifier 270 identifiers associated with the second set of system calls 264 within the second data store 260, the classification logic 240 may PID_1 or other data associated with the process 200₁ in order to identify a particular category for the process 200₁ (e.g., network connectivity, file management, etc.). After associating the process 200₁ to a particular process category, the system call identifier is compared to those identifiers associated with system calls selected for that particular process category. As a result, a first process category 268 (e.g., network connectivity) may include a first subset of system calls, which may be more prone for use in malicious attacks against network connection-based processes than a second subset of system calls assigned to a second process category 269 (e.g., file management).

It is contemplated that the granularity of the process categories may be adjusted to achieve desired performance for the network appliance. For instance, the first process category 268 may be directed to system calls that are typically used for malicious attacks against Microsoft® Internet Explorer® browser applications while another process category may be directed to a different type of browser application. Additionally, another process category 269 may be directed to system calls that are more commonly used for malicious attacks against Portable Document Format (PDF) reader applications. Hence, the system calls for one process category may vary from system calls for another process category.

In contrast, in response to determining that the detected system call 230 is not one of the system-wide system calls 262 or one of the process-specific system calls 264, the classification logic 240 signals the VMM management logic 220 to emulate the instruction 232 by returning a message to the VM 162₁ that causes the process 200₁ to resume operations.

III. EXEMPLARY LOGICAL LAYOUT

Referring now to FIG. 3, an exemplary embodiment of a logical representation of the network appliance 100 is shown. The network appliance 100 includes a housing 300, which is made entirely or partially of a hardened material (e.g., hardened plastic, metal, glass, composite or any combination thereof) that protect circuitry within the housing 300, namely one or more processors 310 that are coupled to communication interface logic 320 via a first transmission medium 330. Communication interface logic 320 enables communications with external network devices and/or other network appliances to receive updates for the VMM 164. According to one embodiment of the disclosure, communication interface logic 320 may be implemented as a physical interface including one or more ports for wired connectors. Additionally, or in the alternative, communication interface logic 320 may be implemented with one or more radio units for supporting wireless communications with other electronic devices.

Processor(s) 310 is further coupled to persistent storage 350 via transmission medium 340. According to one embodiment of the disclosure, persistent storage 350 may include (a) processing engine 120; (b) static analysis engine 130; (c) the dynamic analysis engine 160, which includes one or more VMs 1621-162M and the VMM 164; (d) object classification engine 180; and (e) reporting engine 190. Of course, when implemented as hardware, one or more of these logic units could be implemented separately from each other.

Collective logic within the dynamic analysis engine 160 may be configured to detect a system call during processing of an object by one or more virtual machines and classify the detected system call. The assigned classification may be used to control whether or not the handling of the detected system call is conducted by virtualized device hardware targeted by the system call to enhance overall performance of the network appliance.

IV. SELECTIVE SYSTEM CALL MONITORING OPERABILITY

Referring to now FIG. 4, an illustrative embodiment of the operations conducted in accordance with the selective system call monitoring is shown. Herein, the VMM is set to detect system calls during virtual processing of objects by one or more VMs managed by the VMM (block 400). Additionally, a class hierarchy for system calls is set (block 405). As an illustrative example, one of the classes may identify system-wide system calls that include a set of system calls that tend to occur during malicious attacks, but are less processing intensive and/or less frequently initiated than other types of system calls. Another class may identify process-specific system calls that include a set of system calls that may be more susceptible to malicious attacks for one or more particular processes.

During processing of a received object by a particular process running on a VM, a system call is detected by the VMM (blocks 410 and 415). Thereafter, the system call identifier for the detected system call and the process identifier (PID) for the process that initiated the detected system call are determined (block 420).

Based on the PID, a determination is made whether the process has been previously identified as suspicious (block 425). If not, a determination is made whether the detected system call is one of the system-wide system calls (block 430). If the detected system call is one of the system-wide system calls, the information associated with the detected system call (e.g. instruction(s), parameters used in execution of the instruction(s), etc.) is provided to the virtualized device hardware (block 435). Then, the activities that occur during the processing of the information are monitored and the data associated with the activities (e.g., state changes including changes in content within register or addressed memory, ports accessed, etc.) is stored (block 440). Thereafter, the instruction(s) associated with the detected system call is emulated by generating a message for the VM to resume operations (blocks 445 and 450).

Alternatively, if the process has been previously identified as suspicious, a determination is made whether the detected system call is either one of the system-wide system calls or one of the process-specific system calls (blocks 455 and 460). If the detected system call is one of the system-wide system calls or one of the process-specific system calls, the information associated with the detected system call is provided to the virtualized device hardware, activities that occur during the processing of the information is monitored, and the resultant data is stored (blocks 435 and 440). Thereafter, the instruction(s) associated with the detected system call is emulated by generating a message for the VM to resume operations (blocks 445 and 450).

Once virtual processing of the object is complete, a determination may be made as to whether any system call classes require an update (block 465). If so, the class hierarchy for system calls is updated and the selective system call monitoring operations continue (block 470).

In the foregoing description, the invention is described with reference to specific exemplary embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. For instance, the selective system call monitoring may be conducted on system calls generated by logic outside the guest image.

Claims

1. A computerized method performed by a network appliance, comprising: determining, by the network appliance including one or more hardware processors, whether a detected system call, which is generated by a process that is executing an object within a virtual machine, belongs to a first class of system calls by at least halting operations by the virtual machine in response to the detected system call,determining that there exists a prescribed level of likelihood that the process is associated with a malicious attack that identifies the process is suspicious,responsive to determining that the process is not suspicious, comparing the identifier for the detected system call to each identifier for a first plurality of system calls that are part of the first class of system calls, and subsequently determining that the process is associated with a malicious attack by determining that the detected system call belongs to the first class of system calls upon successfully comparing the identifier for the detected system call to a first identifier for one of the first class of system calls; andproviding information associated with the system call to virtualized device hardware in response to determining that the system call is associated with the first class of system calls.

2. The computerized method of claim 1, wherein prior to determining whether the detected system call initiated by the virtual machine belongs to the first class of system calls, the method further comprises configuring a virtual machine monitor (VMM) to detect system calls initiated by the virtual machine.

3. The computerized method of claim 1, wherein the determining whether the detected system call belongs to the first class of system calls comprises: accessing one or more data stores within the virtualized device hardware while the virtual machine is halted from operation to determine the identifier for the detected system call; andcomparing the identifier for the detected system call to each identifier for a plurality of system calls that are part of the first class of system calls.

4. The computerized method of claim 3, wherein prior to determining whether the detected system call initiated by the virtual machine belongs to the first class of system calls, the method further comprises configuring a virtual machine monitor (VMM) to detect system calls initiated by the virtual machine.

5. The computerized method of claim 1, further comprising in lieu of providing information associated with the system call to the virtualized device hardware, resuming processing of the object by the process running on the virtual machine in response to determining that the system call differs from the first class of system calls.

6. The computerized method of claim 5, wherein the first class of system calls includes system-wide system calls and the second class of system calls includes process-specific system calls.

7. The computerized method of claim 6, wherein the second class of system calls includes a first subset of system calls for the process and a second subset of system calls for a second process different than the process.

8. The computerized method of claim 1, wherein the virtualized hardware device includes (i) one or more registers of a virtual processor or (ii) a virtualized memory.

9. The computerized method of claim 1, wherein the first class of system calls includes system-wide system calls that represent selected system calls that occur during malicious attacks, but are less processing intensive and/or less frequently initiated than other types of system calls.

10. The computerized method of claim 1, wherein the first class of system calls includes a system call that initiates a second process different from the process.

11. The computerized method of claim 1, wherein the process is a software component initiating the detected system call during execution of the object, the software component including (i) an application or (ii) an operating system.

12. The computerized method of claim 11, wherein the application includes a web browser.

13. The computerized method of claim 1, wherein the process includes the object that initiates the detected system call.

14. A computerized method for determining whether a detected system call that is generated by a process executing an object on a virtual machine is potentially associated with a malicious attack, the method comprising: halting operations by the virtual machine executed by a network appliance including one or more hardware processors, in response to detecting the system call;determining an identifier for the system call;determining whether a prescribed level of likelihood exists that the process is associated with a malicious attack that identifies the process is suspicious;responsive to determining that the process is not suspicious, comparing the identifier for the system call to each identifier for a first plurality of system calls that are part of a first class of system calls and a second class of system calls different than the first class of system calls; anddetermining that the system call belongs to one of the first class of system calls and the second class of system calls upon successfully comparing the identifier for the system call to a first identifier for one of the first class of system calls and the second class of system calls.

15. The computerized method of claim 14 further comprising: providing information associated with the system call to virtualized device hardware in response to determining that the system call is associated with either the first class of system calls or the second class of system calls.

16. The computerized method of claim 15, wherein the virtualized device hardware includes a virtual memory from which parameters needed to complete execution of one or more instructions that are part of the system call.

17. The computerized method of claim 15, wherein the determining whether the prescribed level of likelihood exists, the comparing of the identifier for the system call, and the determining that the system call belongs to one of the first class of system calls and the second class of system calls is performed by a virtual machine monitor.

18. The computerized method of claim 15, wherein the determining whether the prescribed level of likelihood exists, the comparing of the identifier for the system call, and the determining that the system call belongs to one of the first class of system calls and the second class of system calls is performed by a virtual machine memory inspection (VMMI) logic that is part of a virtual machine monitor.

19. The computerized method of claim 14, wherein the first class of system calls includes a system call that initiates a second process different from the process.

20. The computerized method of claim 14, wherein the process is a software component initiating the detected system call during execution of the object, the software component including (i) an application or (ii) an operating system.

21. The computerized method of claim 20, wherein the application includes a web browser.

22. The computerized method of claim 14, wherein the process includes the object that initiates the detected system call.

23. A computerized method comprising: detecting a system call initiated by a virtual machine executed by a network appliance including one or more hardware processors, the detecting of the system call comprises halting operations by the virtual machine in response to detecting the system call,determining an identifier for the system call,determining that there exists a prescribed level of likelihood that a process running on the virtual machine and processing an object is associated with a malicious attack to identify that the process is suspicious,responsive to determining that the process is not suspicious, comparing the identifier for the system call to each identifier for a first plurality of system calls that are part of a first class of system calls, anddetermining that the system call belongs to the first class of system calls upon successfully comparing the identifier for the system call to a first identifier for one of the first plurality of system calls;providing information associated with the system call to virtualized device hardware in response to determining that the system call is associated with the first class of system calls; andresuming processing of an object by the virtual machine without providing information associated with the system call to the virtualized device hardware in response to determining that the system call is associated with a second class of system calls that is different from the first class of system calls.

24. The computerized method of claim 23, wherein the detecting of the system call comprises configuring a virtual machine monitor (VMM) to detect system calls initiated by the virtual machine.

25. The computerized method of claim 23, wherein the determining whether the system call belongs to the first class of system calls comprises: accessing one or more data stores within the virtualized device hardware while operations of the virtual machine are halted to determine an identifier for the system call; andcomparing the identifier for the system call to each identifier for a plurality of system calls that are part of the first class of system calls.

26. The computerized method of claim 23, wherein prior to determining the class assigned to the system call, the method further comprises configuring a virtual machine monitor (VMM) to detect system calls initiated by the virtual machine.

27. The computerized method of claim 23, wherein the first class of system calls includes system-wide system calls and the second class of system calls includes process-specific system calls.

28. The computerized method of claim 23, wherein the second class of system calls includes a first subset of system calls for the process and a second subset of system calls for a second process different than the process.

29. An apparatus comprising: one or more processors; anda memory coupled to the one or more processors, the memory comprises software that, when executed by the one or more processors, generates(1) a virtual machine including a process that executes an object and initiates a system call during processing of the object, and(2) a virtual machine monitor that (a) detects the system call initiated by the virtual machine, (b) determines a class assigned to the detected system call by at least comparing an identifier for the detected system call to each identifier for a first plurality of system calls that are part of a first class of system calls in response to failing to determine that the process is suspicious based on activities of the process failing to suggest that the process is associated with a malicious attack, (c) provides information associated with the system call to virtualized device hardware in response to determining that the system call is associated with the first class of system calls, and (d) resumes processing of the object by the virtual machine providing the information to the virtual device hardware in response to determining that the system call is associated with a second class of system calls that is different from the first class of system calls.

30. The apparatus of claim 29, wherein the determining of the class assigned to the detected system call by the virtual machine monitor comprises: halting operations by the virtual machine in response to detecting the system call;accessing one or more data stores within the virtualized device hardware while operations of the virtual machine are halted to determine the identifier for the detected system call; andcomparing the identifier for the detected system call to each identifier for a plurality of system calls that are part of the first class of system calls.

31. The apparatus of claim 29, wherein the determining of the class assigned to the detected system call by the virtual machine monitor further comprises: halting operations by the virtual machine in response to detecting the system call;accessing one or more data stores within the virtualized device hardware while operations of the virtual machine are halted to determine the identifier for the detected system call;determining that the process is suspicious when there exists a prescribed level of likelihood that the process running on the virtual machine is associated with a malicious attack;responsive to determining that the process is not suspicious, comparing the identifier for the detected system call to each identifier for the first plurality of system calls that are part of the first class of system calls; anddetermining that the detected system call belongs to the first class of system calls upon successfully comparing the identifier for the detected system call to a first identifier for one of the first class of system calls.

32. The apparatus of claim 29, wherein the first class of system calls includes system-wide system calls and the second class of system calls includes process-specific system calls that are different from system-wide system calls.

33. The apparatus of claim 29, wherein the first class of system calls includes a system call that initiates a second process different from the process.

34. The apparatus of claim 29, wherein the process running on the virtual machine is a software component that initiates the detected system call, the software component including (i) an application or (ii) an operating system.

35. The apparatus of claim 34, wherein the application includes a web browser.

36. The apparatus of claim 29, wherein the process running on the virtual machine includes the object that initiates the detected system call.

37. A non-transitory computer readable medium that includes software that, when processed by one or more processor, performs operations comprising: detecting a system call initiated by a virtual machine that is included as part of the software and is being executed by the one or more processors;responsive to determining that the system call is not malicious, determining a class assigned to the detected system call by at least comparing an identifier for the detected system call to each identifier for a first plurality of system calls that are part of a first class of system calls;providing information associated with the system call to virtualized device hardware in response to determining that the system call is associated with the first class of system calls; andresuming processing of an object by the virtual machine without providing information associated with the system call to the virtualized device hardware in response to determining that the system call is associated with a second class of system calls that is different from the first class of system calls.