Cyber ​​Detection Fuzzy Pattern Matching

The use of fuzzy pattern matching with temporal graphs and neural networks addresses the limitations of existing cyber-attack detection systems by effectively identifying sophisticated attacks through comprehensive modeling of interprocess activities, enhancing detection accuracy and timeliness.

JP7593724B2Active Publication Date: 2024-12-03INTERNATIONAL BUSINESS MACHINE CORPORATION
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
JP2022545371
Authority / Receiving Office
JP · JP
Patent Type
Patents
Current Assignee / Owner
Priority Date
2020-02-06
Filing Date
2020-11-26
Publication Date
2024-12-03
Estimated Expiration
2040-11-26

AI Technical Summary

Technical Problem

Existing cyber-attack detection systems fail to effectively identify sophisticated attacks, particularly those involving indirect interprocess activities, due to reliance on static signature matching and limited modeling of direct interprocess behaviors, leading to false alarms and missed detections.

Method used

A mechanism for fuzzy pattern matching using temporal graphs and neural networks to analyze interprocess activities, enabling detection of complex cyber-attacks by recognizing abstract graph patterns and learning patterns of cyber threats through machine learning.

Benefits of technology

Enhances the detection of complex cyber-attacks by systematically modeling both direct and indirect interprocess activities, reducing false alarms and improving the timeliness and accuracy of threat identification.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 0007593724000001
    Figure 0007593724000001
  • Figure 0007593724000002
    Figure 0007593724000002
  • Figure 0007593724000003
    Figure 0007593724000003
Patent Text Reader

Abstract

A mechanism is provided for identifying patterns of activity of a target computational resource in activity data characterizing activity of elements of a computer system. A temporal graph of the activity data is generated, and a filter is applied to the temporal graph to generate one or more first vector representations, each characterizing nodes and edges within a moving time window defined by the filter. The filter is applied to a pattern graph representing a pattern of entities and events indicative of the target pattern to generate a second vector representation. The second vector representation is compared to the one or more first vector representations to identify one or more proximity vectors, and one or more corresponding subgraph instances are output to an intelligence console computing system as partial matches of the temporal graph.
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] The present invention relates generally to improved data processing apparatus and methods, and more particularly to mechanisms for fuzzy cyber detection pattern matching. [Background technology]

[0002] Emerging cyber attacks, such as advanced persistent threat (APT) attacks, have become increasingly elusive and sophisticated, usually involving the interplay of multiple processes. Such comprehensive attack campaigns consist of long attack paths / vectors that typically utilize multiple processes on a single host or across multiple hosts to achieve the attack objective. Therefore, understanding the inter-process behavior is critical to identifying attacks and reducing false alarms.

[0003] Attack / intrusion detection products, systems, and services are well known. Most host-based and network-based attack / intrusion detection products utilize static signature matching techniques. For example, antivirus products, firewalls, intrusion detection systems (IDS), etc. rely on specific binary or network communication signatures to identify attacks. In these products, the detection procedure includes (i) attack discovery, (ii) signature selection, (iii) signature distribution, and (iv) endpoint signature matching.

[0004] Intra-process behavior modeling and detection is also well known, as evidenced by the program anomaly detection literature and state-of-the-art commercial endpoint intrusion detection products. These mechanisms essentially monitor system events (e.g., system calls and / or Windows® APIs for each process) and then determine whether a process is malicious based on a behavior model. This kind of solution can be rendered ineffective if unseen attacks are conducted across processes or if attackers exploit benign processes to achieve their attack objectives. Although the aforementioned techniques provide advantages, they often fail to detect new or rapidly updated attacks in a timely manner, nor provide sufficient attack surface coverage for attacks that leverage cross-process activities.

[0005] Some behavior-based endpoint detection products attempt to address these deficiencies by attempting to model direct inter-process activity, such as process spawning and malware downloading. While modeling this type of inter-process activity is useful, known solutions operate on an ad-hoc basis, modeling only a small amount of direct inter-process activity due to practicality constraints in existing products. Furthermore, these approaches do not address indirect inter-process activity. Thus, even when some inter-process activity modeling is available, attackers can evade detection by, for example, constructing invisible attacks that involve multiple processes and files within a large time frame.

[0006] One example of such an attack was the recent data breach at a Target® store. During this breach, data leaked from a store's point-of-sale machines was encrypted on disk but later read by another process during tabulation operations. In this environment, indirect inter-process activity (between the process that writes and reads the encrypted files) was not explicit and therefore was not identified and mitigated. That is, existing research for cyber incident inference focuses on either exact signature matches or regular expression-based string matching. Summary of the Invention

[0007] This Summary is provided to introduce a selection of concepts in a simplified form that are further described herein in the Detailed Description. This Summary is not intended to identify key elements or essential features of the claimed subject matter, nor is it intended for use in limiting the scope of the claimed subject matter.

[0008] In one example embodiment, a method is provided within a data processing system for identifying patterns of activity of a computing resource of interest in activity data characterizing activity of elements of a computer system. The method includes receiving, by the data processing system, activity data characterizing activity of the elements of the computer system from one or more computing devices of a monitored computing environment, and generating, by the data processing system, a temporal graph of the activity data. The temporal graph includes nodes representing elements of the computer system and edges connecting the nodes, each edge representing an event occurring between the elements of the computer system represented by the nodes connected by the edge.

[0009] The method further includes applying, by the data processing system, the filter to the temporal graph to generate one or more first vector representations, each vector representation characterizing nodes and edges within a moving time window defined by the filter. The method further includes generating, by the data processing system, a first vector representation that indicates a pattern of activity of the computational resources identified in the temporal graph. Multiple entity and multiple The method also includes applying a filter to a pattern graph representing a pattern of events between the entities. Applying the filter to the pattern graph creates a second vector representation. In addition, the method includes comparing, by the data processing system, the second vector representation to the one or more first vector representations to identify one or more proximity vectors in the one or more first vector representations, and outputting, by the data processing system, one or more subgraph instances corresponding to the identified one or more proximity vectors as partial matches of the temporal graph to the intelligence console computing system.

[0010] In another example embodiment, a computer program product is provided that includes a computer usable or computer readable medium that contains a computer readable program that, when executed on a computing device, causes the computing device to perform various and combinations of the operations outlined above with respect to the example method embodiments.

[0011] In yet another example embodiment, a system / apparatus is provided that may include one or more processors and a memory coupled to the one or more processors. The memory may include instructions that, when executed by the one or more processors, cause the one or more processors to perform various and combinations of the operations outlined above with respect to the example method embodiments.

[0012] These and other features and advantages of the present invention will be described, or become apparent to those of ordinary skill in the art, in light of the following detailed description of example embodiments of the invention.

[0013] The invention, together with its most commonly used uses and further objects and advantages, will be best understood by reference to the following detailed description of illustrative embodiments, when read in conjunction with the accompanying drawings. [Brief description of the drawings]

[0014] [Figure 1] FIG. 1 depicts an exemplary block diagram of a distributed data processing environment in which exemplary aspects of example embodiments may be implemented. [Diagram 2] 1 is an exemplary block diagram of a data processing system in which exemplary aspects of an example embodiment may be implemented; [Diagram 3] FIG. 1 illustrates a security intelligence platform in which techniques of one or more example embodiments may be practiced. [Figure 4] FIG. 1 illustrates an Advanced Persistent Threat (APT) platform in which techniques of one or more example embodiments may be practiced. [Diagram 5] FIG. 1 illustrates an operating environment in which a cognitive cybersecurity intelligence center is used to manage endpoint machines and in which techniques of one or more example embodiments may be implemented. [Figure 6] FIG. 2 illustrates a graph abstraction of representative malicious behavior and multiple inter-process activity graphs that are matched against the graph abstraction, according to one example embodiment. [Figure 7] FIG. 1 illustrates a representative inter-process graph constructed by monitoring activity between entities within an endpoint and how various matching techniques are performed on the graph by an endpoint protection system in accordance with one or more of the embodiments. [Figure 8]FIG. 2 illustrates an implementation of an endpoint inter-process activity extraction and pattern matching system according to an example embodiment. [Figure 9] FIG. 2 illustrates how labeled subgraph matching is implemented in one example embodiment. [Figure 10] FIG. 13 illustrates a capture function in further detail according to an example embodiment. [Figure 11] FIG. 13 illustrates how an aging function is used to develop an activity graph according to an example embodiment. [Figure 12] FIG. 13 illustrates the aging function in further detail according to an example embodiment. [Figure 13] FIG. 2 illustrates how the detection system uses on-disk storage to model indirect inter-process activity for transient and persistent inter-process activity according to an example embodiment. [Figure 14] FIG. 13 illustrates additional details regarding the matching function and the mitigation and resilience functions according to an example embodiment. [Figure 15] FIG. 1 illustrates a representative activity graph of host level activity according to one example embodiment. [Figure 16] FIG. 2 illustrates a representative activity graph of network level activity according to one example embodiment. [Figure 17] FIG. 1 illustrates an exemplary activity graph of process level activity according to one example embodiment. [Figure 18] FIG. 2 illustrates an iterative constraint solving algorithm as a process flow, according to an example embodiment. [Figure 19] FIG. 2 illustrates a representative example of a representative pattern graph and the corresponding graph of constraints (GoC) obtained from this example, according to one example embodiment. [Figure 20] FIG. 20 illustrates the application of an iterative constraint solving process or algorithm of one example embodiment to the pattern graph of FIG. [Figure 21] FIG. 20 illustrates the application of an iterative constraint solving process or algorithm of one example embodiment to the pattern graph of FIG. [Figure 22] FIG. 20 illustrates the application of an iterative constraint solving process or algorithm of one example embodiment to the pattern graph of FIG. [Diagram 23] FIG. 20 illustrates the application of an iterative constraint solving process or algorithm of one example embodiment to the pattern graph of FIG. [Figure 24] FIG. 1 illustrates a representative graph computing platform in which the techniques of one or more example embodiments may be implemented. [Diagram 25] 2 illustrates an example of a pattern and two fuzzy match subgraphs used to define a pattern that represents an intrusion, attack, or threat, according to one example embodiment. [Figure 26] 1 is an exemplary diagram illustrating a dynamically growing temporal graph according to an example embodiment. [Figure 27] FIG. 1 is an exemplary diagram that graphically illustrates a process for extracting information from subgraphs of a temporal graph (eg, AG / CG) using a moving convolution filter. [Figure 28] 1 is an example flow diagram outlining an example generalized operation for performing fuzzy matching according to one example embodiment. [Figure 29] FIG. 1 is a flow chart diagram outlining an exemplary fuzzy matching operation according to one example embodiment in which multiple graph neural networks (GNNs) are implemented to perform the embedding. [Diagram 30] FIG. 1 illustrates an exemplary system design and process flow for performing cyber detection fuzzy pattern matching according to one example embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0015] Example embodiments provide a mechanism for performing cyber detection fuzzy pattern matching. As previously discussed, known approaches for attack / threat detection have various shortcomings. In addition to the above shortcomings, it should also be noted that these known approaches do not address abstract graph patterns, which are a category of high-level behavioral descriptions of malicious / interesting behavior. That is, the monitored computational activity of a computing device may be represented as a temporal graph, and the mechanism of example embodiments may use the temporal graph as a basis for performing fuzzy pattern matching to detect cyber attacks. The temporal graph may, for example, show specific computational components with respect to instances of time along one axis and interactions of those computational components occurring at that time instance.

[0016] Abstract graph pattern matching may be used in behavior-based threat detection and cyber hunting. That is, given an abstract pattern, such as one process creating a thread within another process, a graph pattern matching algorithm may be used to search a temporal graph to find matching activity by monitored hosts. The matching activity can then be returned for further inspection (e.g., by a security analyst or threat hunter). In addition, higher level abstract patterns, such as "a particular file flows into any network socket in n steps," may be evaluated and used to detect data exfiltration.

[0017] More generally, an abstract graph pattern can be thought of as elements along with constraints (or predicate expressions) and the connections between elements. Pattern matching requires satisfying all constraints on all elements and how those elements are connected. This task is computationally non-trivial because a pattern may reference other patterns through parameters, and because graphs are typically stored in distributed external storage, making it expensive to check the data associated with each predicate.

[0018] Abstract graph pattern matching, in some example embodiments described herein, includes full matching of subgraphs. That is, given a computation graph (CG), or a temporal graph of a computer's execution states at various levels (see examples in Figures 15-17 below), abstract graph pattern matching attempts to fully match a pattern graph (PG) of an attack or threat with a portion or subgraph of the CG, as described below. In this way, based on abstract graph pattern matching, possible cyber attacks or threats may be identified. However, some cyber attacks or threats may be devised where a full pattern matching does not necessarily identify an instance of such an attack or threat (e.g., there is not enough information about the cyber attack / threat to generate a PG of the cyber attack / threat). For such situations, the mechanism of example embodiments also provides a fuzzy or partial pattern matching computer mechanism that can utilize neural networks and machine learning to learn patterns of cyber attacks / threats and use those patterns to identify possible attacks / threats present in a temporal graph of the computing system's activities, such as the computation graph (CG) described above, as described below.

[0019] Referring now to the drawings, and in particular to Figures 1-2, exemplary diagrams of data processing environments are shown in which example embodiments of the present invention may be implemented. It should be understood that Figures 1-2 are merely examples, and are not intended to assert or imply any limitation with respect to the environments in which aspects or embodiments of the disclosed subject matter may be implemented. Many modifications to the depicted environments may be made without departing from the scope of the present invention.

[0020] Referring now to the drawings, FIG. 1 illustrates an exemplary distributed data processing system. Distributed data processing system 100 may include a network of computers in which aspects of the exemplary implementations may be implemented. Distributed data processing system 100 includes at least one network 102, which is a medium used to provide communication links between various devices and computers connected together in distributed data processing system 100. Network 102 may include connections such as wires, wireless communication links, or fiber optic cables. In the illustrated example, server 104 and server 106 are connected to network 102 along with storage unit 108. In addition, clients 110, 112, and 114 are also connected to network 102. These clients 110, 112, and 114 may be, for example, personal computers, network computers, and the like. In the illustrated example, server 104 provides data such as boot files, operating system images, and applications to clients 110, 112, and 114. Clients 110, 112, and 114, in the depicted example, are clients to server 104. Distributed data processing system 100 may include additional servers, clients, and other devices not shown.

[0021] In the depicted example, distributed data processing system 100 is the Internet, which includes network 102, which represents a worldwide collection of networks and gateways that use Transmission Control Protocol / Internet Protocol (TCP / IP), a set of protocols, to communicate with one another. At the heart of the Internet is a backbone of high-speed data communication lines connecting major nodes or host computers, which are made up of numerous commercial, government, educational, and other computer systems that route data and messages. Of course, distributed data processing system 100 may be implemented to include a number of different networks, such as, for example, intranets, local area networks (LANs), wide area networks (WANs), and the like. As previously noted, FIG. 1 is intended as an example, rather than an architectural limitation for different embodiments of the disclosed subject matter, and thus the specific elements illustrated in FIG. 1 should not be considered limiting with respect to the environments in which example embodiments of the invention may be implemented.

[0022] Referring now to FIG. 2, a block diagram of a data processing system in which example embodiments may be implemented is shown. Data processing system 200 is an example of a computer, such as server 104 or client 110 of FIG. 1, in which computer usable program code or instructions implementing the processes of example embodiments may be located. In this example, data processing system 200 includes a communication fabric 202 that provides communication between a processor unit 204, a memory 206, a persistent storage 208, a communication unit 210, an input / output (I / O) unit 212, and a display 214. Processor unit 204 is responsible for executing instructions of software that may be loaded into memory 206. Processor unit 204 may be a set of one or more processors or may be a multi-processor core, depending on the particular implementation. Additionally, processor unit 204 may be implemented using one or more heterogeneous processor systems, where a main processor exists on a single chip along with secondary processors. As another example, processor unit 204 may be a symmetric multi-processor (SMP) system including multiple processors of the same type. Memory 206 and persistent storage 208 are examples of storage devices. A storage device is any hardware that can store information temporarily, persistently, or both. In these examples, memory 206 may be, for example, a random access memory or any other suitable volatile or non-volatile storage device.

[0023] Persistent storage 208 may take various forms, depending on the particular implementation. For example, persistent storage 208 may include one or more components or devices. For example, persistent storage 208 may be a hard drive, a flash memory, a rewritable optical disk, a rewritable magnetic tape, or a combination thereof. The medium used by persistent storage 208 may be removable. For example, a removable hard drive may be used for persistent storage 208. In these examples, communications unit 210 provides for communication with other data processing systems or devices. In these examples, communications unit 210 is a network interface card. Communications unit 210 may provide for communication using either physical or wireless communications links, or both.

[0024] Input / output unit 212 allows for the input and output of data to and from other devices that may be connected to data processing system 200. For example, input / output unit 212 may provide a connection for user input through a keyboard and mouse. Additionally, input / output unit 212 may send output to a printer. Display 214 provides a mechanism for displaying information to a user.

[0025] Instructions for the operating system and applications or programs are located on persistent storage 208. These instructions may be loaded into memory 206 for execution by processor unit 204. The processes of the various embodiments may be executed by processor unit 204 using computer-implemented instructions, which may be located in a memory, such as memory 206. These instructions are referred to as program code, computer usable program code, or computer readable program code, that may be read and executed by a processor in processor unit 204. The program code in the various embodiments may be embodied on different physical or tangible computer readable media, such as memory 206 or persistent storage 208. Program code 216 is located in a functional form on selectively removable computer readable medium 218 and may be loaded or transferred to data processing system 200 for execution by processor unit 204. In these examples, program code 216 and computer readable medium 218 form computer program product 220. In one example, the computer readable medium 218 may exist in a tangible form, such as an optical or magnetic disk inserted or placed into a drive or other device that is part of the persistent storage 208 for transfer to a storage device, such as a hard drive that is part of the persistent storage 208. In a tangible form, the computer readable medium 218 may take the form of persistent storage, such as a hard drive, thumb drive, or flash memory connected to the data processing system 200. The tangible form of the computer readable medium 218 is also referred to as a computer recordable storage medium. In some examples, the computer recordable medium 218 may not be removable.

[0026] Alternatively, program code 216 may be transferred to data processing system 200 from computer readable medium 218 through a communications link to communications unit 210 or through a connection to input / output unit 212, or both. In this example, the communications link and / or connection may be physical or wireless. The computer readable medium may also take the form of a non-tangible medium, such as a communications link or wireless transmission containing the program code. The various components illustrated in data processing system 200 are not intended to provide architectural limitations to the manner in which different embodiments may be implemented. Various example embodiments may be implemented in the data processing system including components in addition to or in place of the components illustrated in data processing system 200. Other components illustrated in FIG. 2 may vary from the illustrated example. As one example, a storage device in data processing system 200 is any hardware device capable of storing data. Memory 206, persistent storage 208, and computer readable medium 218 are examples of storage devices in a tangible form. In another example, a bus system may be used to implement communications fabric 202 and may be comprised of one or more buses, such as a system bus or an input / output bus. Of course, the bus system may be implemented using any suitable type of architecture that provides for a transfer of data between different components or devices attached to the bus system.

[0027] Additionally, the communications unit may include one or more devices used to transmit and receive data, such as a modem or network adapter. Additionally, the memory may be, for example, memory 206 or a cache, such as found in an interface and memory controller hub that may be present in communications fabric 202. Computer program code for carrying out the operations of the present invention may be written in any combination of one or more programming languages, including object-oriented programming languages, such as Java(R)(TM), Smalltalk(R), C++, and traditional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may run entirely on the user's computer, partially on the user's computer as a standalone software package, partially on the user's computer and on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or wide area network (WAN), or the connection may be made to an external computer (e.g., via the Internet using an Internet Service Provider).

[0028] Those skilled in the art will appreciate that the hardware in Figures 1-2 may vary depending on the implementation. Other internal hardware or peripheral devices, such as flash memory, equivalent non-volatile memory, or optical disk drives, may be used in addition to or in place of the hardware depicted in Figures 1-2. Additionally, the processes of the example embodiments may be applied to multiprocessor data processing systems other than the SMP systems described above without departing from the scope of the disclosed subject matter. As described below, the techniques described herein may operate in conjunction with a standard client / server framework such as that shown in Figure 1, in which a client machine communicates with an Internet-accessible web-based portal running on a set of one or more machines. End users operate Internet-enabled devices (e.g., desktop computers, notebook computers, Internet-enabled mobile devices, etc.) that can access and interact with the portal.

[0029] Typically, each client or server machine is a data processing system as shown in Figure 2, comprising hardware and software, and these entities communicate with each other over a network (such as the Internet, an intranet, an extranet, a private network, or any other communications medium or link). The data processing system typically includes one or more processors, an operating system, one or more applications, and one or more utilities. The applications on the data processing system provide native support for Web services, including but not limited to support for HTTP, SOAP, XML, WSDL, UDDI, and WSFL, among others. Details regarding SOAP, WSDL, UDDI, and WSFL are available from the World Wide Web Consortium (W3C), which is responsible for developing and maintaining these standards, and details regarding HTTP and XML are available from the Internet Engineering Task Force (IETF). Familiarity with these standards is assumed.

[0030] Security Intelligence Platform Including Incident Forensics

[0031] FIG. 3 illustrates a representative security intelligence platform in which techniques of one or more example embodiments may be practiced. Typically, the platform provides search-driven data exploration, session reconstruction, and forensics intelligence to aid in security incident investigations. In relevant part, the platform 300 includes a series of packet capture appliances 302, incident forensics module appliances 304, a distributed database 306, and a security intelligence console 308. The packet capture appliances 302 and the incident forensics module appliances 304 are configured as network appliances, but may also be configured as virtual appliances. The packet capture appliances 302 function to capture packets from a network, such as the network 102 of FIG. 1, using known or later developed packet capture (pcap) application programming interfaces (APIs) or other known or later developed technologies. The packet capture appliance 302 also provides such data (e.g., real-time log events and network flows) to a distributed database 306 where the data is stored and available for analysis by the forensics module 304 and the security intelligence console 308. The packet capture appliance 302 operates in a session-oriented manner, capturing all packets in a flow and indexing the metadata and payload to enable fast, search-driven data exploration.

[0032] The database 306 provides a forensic repository, which includes a distributed, heterogeneous data set containing information collected by the packet capture appliance 302. The console 308 provides a web or cloud accessible user interface (UI) that exposes a "forensics" dashboard tab to facilitate incident investigation workflow by investigators. An investigator uses the dashboard to select a security incident. The incident forensics module 304 retrieves all packets (including metadata, payload, etc.) related to the selected security incident and reconstructs the session for analysis.

[0033] A typical commercial product that implements this type of incident investigation workflow is IBM® Security QRadar® Incident Forensics V7.2.3 (or higher). Using this platform, investigators search across distributed, heterogeneous data sets stored in databases and receive a unified list of search results. Search results can be merged into a grid to allow users to explore relationships between identities and can be visualized with a "digital impression" tool.

[0034] Typically, appliances for use in the aforementioned systems are implemented as network-attached, display-less devices. For example, appliances built to perform traditional middleware service oriented architecture (SOA) functions are pervasive throughout a particular computing environment. SOA middleware appliances can simplify, help secure, or speed up the deployment of XML or Web services while extending existing SOA infrastructure across an enterprise. The use of hardware for middleware and lightweight middleware stacks can address the performance burdens imposed by traditional software solutions. Additionally, the appliance form factor provides a secure, consumable packaging for implementing middleware SOA functions. One distinct advantage that these types of devices offer is offloading processing from back-end systems. This type of network appliance is typically a rack-mounted device. The device includes physical security that allows the appliance to serve as a secure vault for sensitive information. Typically, the appliance is manufactured and pre-loaded with software and then deployed within or in conjunction with an enterprise or other network operating environment, alternatively, the box may be provisioned with standard or customized middleware virtual images that can be deployed and managed securely, for example, in a private or on-premise cloud computing environment, and the appliance may include support for hardware and firmware encryption, in some cases to encrypt data on the hard disk.

[0035] This type of appliance can facilitate Security Information Event Management (SIEM). For example, IBM® Security QRadar® SIEM is an enterprise solution that includes a packet data capture appliance that can be configured as this type of appliance. Such a device can, for example, function to capture real-time Layer 4 network flow data, which can then be analyzed for Layer 7 application payloads using, for example, deep packet inspection and other techniques. IBM® Security QRadar® SIEM uses a combination of flow-based network knowledge, security event correlation, and asset-based vulnerability assessment to provide situational awareness and support compliance. In a basic IBM® Security QRadar® SIEM installation, a system such as that shown in Figure 4 is configured to collect event and flow data and generate reports. A user (e.g., a SOC analyst) can then investigate the attack and determine the root cause of the network problem.

[0036] Generally speaking, security information and event management (SIEM) tools provide a variety of services for analyzing, managing, monitoring, and reporting on IT security events and vulnerabilities. Such services typically include the aggregation of events related to monitored access and unexpected occurrences across data networks, and analyzing those events in correlation to determine their contribution to profiled higher-level security events. SIEM tools may include analysis of firewall configurations, network topology and connectivity visualization tools to display current and potential network traffic patterns, correlation of asset vulnerabilities with network configurations and traffic to identify valid attack paths and high-risk assets, and support for policy conformance monitoring of network traffic, topology, and vulnerability exposure. Some SIEM tools have the ability to build topologies of managed network devices such as routers, firewalls, and switches based on the transformation analysis of device configurations processed by a general network information model. The result is a deployment structure that can be used for security threat simulation, firewall filter operational analysis, and other applications. However, the primary device criteria are entirely based on the network and network configuration. While there are multiple ways to initiate discovery for managed assets / systems and containment within the user interface is semi-automatically managed (i.e., a method via the user interface that allows for semi-automated, human input based placement, where the topology and its display and formatting are data-driven based on discovery of both initial configuration and changes / removals within the underlying network), nothing is offered in terms of fully automated placement analysis and placement analysis that generates recommendations.

[0037] Preventing Advanced Persistent Threats (APTs)

[0038] APT mitigation and prevention techniques are well known. For example, IBM® Trusteer Apex® is an automated solution that prevents exploits and malware from gaining unauthorized access to corporate endpoints and extracting information. This type of solution typically provides multiple layers of security: exploit prevention, data exfiltration prevention, and credential protection.

[0039] FIG. 4 illustrates a standard embodiment in which an APT solution is generally designed as agent code 400 running within an enterprise endpoint 402, along with a web-based console 404 that allows IT security to manage the deployment (for both managed and unmanaged endpoints) from a central location of control. The agent code 400 operates by monitoring the state of an application 406 at the time the application performs a sensitive operation (e.g., writing a file to a file system). In general, the agent 400 uses a whitelist of legitimate application states to verify that the sensitive operation is (or is not) being performed under known, legitimate states. An exploit attempts to perform the sensitive operation under unknown (non-whitelisted) states and is therefore stopped. This approach allows the APT agent to accurately detect and block both known and zero-day exploits without knowing anything about the threat or the vulnerability being exploited. An "agent" can be any code-based module, program, process, component, thread, etc.

[0040] Figure 4 shows how an APT attack typically unfolds and where APT solutions work to stop the intrusion. For example, here, an attacker 408 uses a spear-phishing email 410 to send a weaponized document (i.e., a document containing hidden exploit code 412) to a user. When the user opens this document using a viewer such as Adobe® Acrobat® or Microsoft® Word, the exploit code executes, binds to a vulnerability in the application, and silently downloads malware to the employee's computer 402. The user is unaware of this download. Another option is to send the user a link 414 to a malicious website 416 that contains the exploit code, or to a genuine website that has been compromised (e.g., by a watering hole attack). When the user clicks on this link and the browser renders the HTML content, the exploit code executes, latches onto a vulnerability in the browser (or browser plugin), and silently downloads malware to the user's computer. The link may also direct the user to a phishing site 418 (such as a fake web app login page) in order to convince the user to submit corporate credentials. After infecting the computer 402 with advanced malware or compromising corporate credentials, the attacker 408 has established a foothold within the corporate network and can then proceed with the attack.

[0041] As shown, agent 400 protects the enterprise from such threats at multiple junctions: (1) exploit prevention 420, which prevents exploit attempts from gaining unauthorized access to a user's computer, (2) data exfiltration prevention 422, which prevents malware from communicating and sending information to attackers if the machine is already infected with malware, and (3) credential protection 424, which prevents users from using enterprise credentials on unauthorized enterprise sites (including, for example, phishing sites or public sites such as social networks or e-commerce). In one known approach, agent 400 performs these and related actions by monitoring applications and their operations using a state whitelist of legitimate applications.

[0042] Information stealing malware can be installed directly on an endpoint by a user without the need for an exploit. Typically, the malware must communicate either directly using the Internet or through the process of a compromised application to extract data. Advanced malware uses a small number of evasion techniques to avoid detection. For example, information stealing malware may compromise the process of another legitimate application and communicate with the attacker via a genuine website (such as Forums and Google® Docs). Agent 400 also functions to stop the execution of untrusted code that indicates a data exfiltration condition. To this end, agent 400 preferably validates that only trusted programs are allowed to communicate with the external network using data exfiltration techniques. Agent 400 preferably uses multiple techniques to identify unauthorized exfiltration conditions and malicious communication channels and block them. Because agent 400 monitors activity on the host itself, it has good visibility and can accurately detect and block these exfiltration conditions.

[0043] References to commercially available products identified herein are not intended to be limiting, as the techniques herein may be implemented using any APT solution or functionality (even when incorporated into other systems).

[0044] Extraction and pattern matching of endpoint inter-process activity

[0045] With the above in mind, FIG. 5 illustrates a basic operating environment including a cognitive cybersecurity intelligence center 500 and an endpoint 502. The endpoint 502 is a networked data processing system or device, such as the data processing system illustrated in FIG. 2, that executes system management code (software) that enables management and monitoring of the endpoint by the intelligence center 500. The intelligence center 500 may be implemented as a security management platform, such as that illustrated in FIG. 3, in conjunction with an APT solution, such as that illustrated in FIG. 4, or other management solutions. Thus, for example, known commercially available products and systems that provide endpoint management include IBM® BigFix®, which provides remote control, patch management, software distribution, operating system deployment, network access protection, and hardware and software inventory capabilities to system administrators. Such commercially available systems may be extended to include endpoint inter-process activity extraction and pattern matching techniques of one or more of the example embodiments described herein, including the cyber detection fuzzy pattern matching mechanisms described below, or such techniques may be implemented in a dedicated product or system for this purpose.

[0046] The endpoints 502 are physical or virtual machines or devices that, in some example embodiments, run operating systems such as Microsoft® Windows®, Mac OS X®, VMware ESX®, Linux®, Unix®, as well as various mobile operating systems such as Microsoft® Windows® Phone®, Symbian®, Apple iOS®, and Google® Android®. The cognitive cybersecurity intelligence center 500 operates as a network-accessible security management platform that includes multiple machines and application software. The cognitive cybersecurity intelligence center 500 supports cybersecurity analysis, for example, using machine learning. The cognitive cybersecurity intelligence center 500 may operate in a dedicated manner to support multiple endpoints or "as a service" on behalf of multiple enterprises, each of which includes its own endpoints 502. Typically, the endpoint machines communicate with the intelligence center within a client / server framework as shown in FIG. 1 and described above. The intelligence center may be located and accessed within a cloud-based operating environment.

[0047] As described, according to one or more example embodiments, inter-process events are sent from an endpoint, such as endpoint 502, to a detection server running a cognitive cybersecurity intelligence center 500 where such events are analyzed. At the detection server, detection of an attack or threat occurs. As will be appreciated, the approach according to one or more example embodiments described herein provides an efficient and systematic (as opposed to merely ad-hoc) mechanism for recording endpoint activity via inter-process events, for representing malicious or suspicious behavior of targets using abstractions (network graphs), and for matching concrete activity (as represented in the recorded events) with abstract patterns. Additionally, according to some example embodiments, the approach according to some example embodiments may include a cyber detection fuzzy pattern matching function. The pattern matching of the example embodiments, in addition to enabling the cognitive cybersecurity intelligence center 500 to act on malicious / suspicious behavior (e.g., by stopping involved processes, alerting, deleting ongoing network sessions, stopping ongoing disk operations, etc.), can also assist security analysts in identifying activities of interest (e.g., threat hunting) or determining next steps that may be taken in a workflow to address suspicious or malicious activity.

[0048] According to one technique herein, both direct and indirect inter-process activities are extracted at the endpoint and compared to predefined malicious behavior patterns for detection. Direct and indirect inter-process activities may include control flow, such as process spawning, and information exchange through channels, such as files, sockets, messages, shared memory, etc. Inter-process activities reveal the purpose and specific execution paths of processes. In one approach herein, inter-process activities are matched with malicious inter-process behavior to detect attack cases. In some example embodiments, malicious behavior patterns are predefined using abstractions to characterize key steps in a cyber attack. These malicious behavior patterns may be stored at the endpoint and can be updated as needed.

[0049] FIG. 6 illustrates how a graph may be used to facilitate behavior-based detection / inference in accordance with one or more example embodiment techniques described herein. In this approach, an individual (e.g., software developer, security analyst, etc.) represents malicious or interesting behavior in an abstract graph pattern 600, also referred to as a pattern graph (PG). In the illustrated example of malicious behavior, a DLL injection attack is modeled by a process 602 executing an event (type::create thread) 604 that spawns another process 606. Generally speaking, the graph pattern 600 includes nodes (in this example, processes 602 and 606) and edges (in this example, an event 604 linking the two nodes). In operation, a pattern matching algorithm may return concrete activities on a host endpoint that match the pattern defined in the graph pattern 600 (or PG). The concrete activities on the endpoint are also modeled by a graph to facilitate pattern matching. Two such example activity graphs 608 and 610 are shown that match the abstract graph behavior 600, obtained from the inter-process activity of an endpoint. In the first example activity graph 608, process rundll.exe running event Syscall 10 spawns process lsass.exe, and in the second example activity graph 610, process Firefox.exe running event Syscall 11 spawns process explorer.exe. This is an example of topology matching.

[0050] FIG. 7 shows a more complex example, where a graph 700 is generated as a result of monitoring inter-process activity. As shown in legend 702, the graph typically includes a set of entities: processes 704, files 706, network resources 708, and events 710. Each entity in an endpoint system is preferably associated with a label (or "tag") that describes the entity's category and properties, e.g., an installed Firefox (an entity of a process) is a "browser", an installed Firefox is "64-bit", etc. Labels may be assigned manually (e.g., "browser"), automatically generated (e.g., if it is a 64-bit executable), or computed by functionality (e.g., if a process meets certain requirements, the label "trusted" is assigned). Labels may replace the names of entities to create behavior patterns of categories of processes. Graph 700 of FIG. 7 shows and includes a set of entities, each of which may include an associated label (tag) defined in an offline manner. Inter-process activity is monitored on the endpoint and activity between entities is recorded, for example, by monitoring system calls, kernel hooking, system monitoring services, etc. In some example embodiments, a relatively constrained set of system calls or events needs to be monitored to obtain the information necessary to build the graph. One example (assuming Linux as the operating system) is the system calls that relate one entity to another (e.g., sys_open and stub_execve). A graph may be built (and updated, if necessary) by connecting the entities and the monitored activity, an example being graph 700. In some example embodiments, the graph is stored on disk and cached in memory.

[0051] Generally speaking, an activity graph represents an extraction of real-time inter-process activities occurring at an endpoint. As also shown in FIG. 7, this extraction facilitates behavior matching (which may occur in a detection server running in an intelligence center) using one or more matching techniques. These matching techniques may include one or more matching techniques such as topology matching 712, label matching 714, and, optionally, specific signature matching 716. As mentioned above, the inter-process activities depicted in the graph (and their associated labeling) reveal the purpose of one or more processes, as well as the specific execution paths of those processes. Matching the generated graph with malicious inter-process behavior (also defined in the form of a graph) enables the system to detect and respond to attack cases. As mentioned, malicious behavior patterns are predefined using a degree of abstraction to characterize key steps in a cyber attack.

[0052] More formally, as used herein, an abstract pattern graph (such as graph 600 in FIG. 6) against which monitored inter-process activity is compared may be referred to herein as a pattern graph (PG). A PG may include one or more constraints, where a constraint may be, for example, a Boolean function on the elements of the graph or on element relationships. In some example embodiments, there are two types of constraints: single-element constraints (e.g., properties / classes / concepts of vertices / edges in the pattern graph (PG)) and one or more element relationship constraints (i.e., how one element relates to another element, e.g., direct connection, greater than, connected in "n" steps). The monitored activities of hosts (endpoints) are instantiated in a graph, which may be referred to herein as an activity graph (AG) or computation graph (CG). In FIG. 6, graphs 608 and 610 represent an AG or CG. As explained, the goal of pattern matching is to find all subgraphs of the AG that satisfy the PG. As described further herein, it is assumed that the database is queried to verify that single element constraints or one element relationship constraints are actionable, and the remaining challenge is to provide a solution for multi-constraint graphs, i.e., how to tailor the database query generation to efficiently satisfy all constraints. Techniques associated with example embodiments, as described herein, address this problem.

[0053] FIG. 8 illustrates an exemplary embodiment of a detection system in which the endpoint inter-process activity extraction and pattern matching techniques of one example embodiment are practiced. As illustrated in the figure, certain functions (e.g., security management platform, APT solutions, endpoint management solutions, etc.) are located in an intelligence center 800 while certain functions are located in an endpoint 802. This arrangement of functions is illustrated with respect to one example embodiment, but is not intended to be a limitation on possible implementations of embodiments of the present invention. As previously mentioned, the intelligence center 800 may be dedicated to a network of endpoints (e.g., within an enterprise) or may operate as a service provider (or more generally, a "service") on behalf of multiple enterprises, each of which includes its own set of endpoints. In one example implementation, the cybersecurity intelligence center 800 is network accessible and deployed within a cloud-based operating environment, although this is not a limitation. Moreover, typically, each of the functional blocks identified in FIG. 8 is implemented as software, i.e., as a set of computer program instructions executing within a processor. It should be understood that the functions identified in FIG. 8 are provided for illustrative purposes only, and that, if desired, some of these functions may be combined or otherwise rearranged.

[0054] As shown in the figure, the intelligence center 800 performs several functions, namely, label generation 804 (step 1), and malicious behavior discovery and encoding 806 (step (4)). As shown in the figure, these activities are typically informed by existing attack information available within the intelligence center 800 (e.g., threat reports 808, expert knowledge 810, and information obtained from threat sandboxing and evaluation 812). This set of information is available to security analysts or is otherwise obtained. As previously described with respect to FIG. 7, in label generation 804, each entity in the endpoint system 802 is associated with one or more labels that describe the entity's categories and properties. The labels may be applied manually, automatically, programmatically, etc., or by some combination. Label generation 804 may be performed periodically or upon the occurrence of a particular occurrence. Malicious behavior discovery and encoding 806 derives malicious (or suspicious) graph patterns from existing attacks. As noted, in some example embodiments, these patterns are determined by human analysts, other security detection mechanisms, machine learning systems, or a combination thereof. As also shown, the set of malicious patterns generated from the attack source knowledge bases (808, 810, 812) are stored in a malicious pattern database 814.

[0055] Referring to the endpoint functionality 802, functional block 816 (step 2) represents the extraction of inter-process activity and includes monitoring 818 (step 2.1) and labeling 820 (step 2.2). The monitoring function 818 records inter-entity activity, for example by monitoring system calls, kernel hooking, system monitoring services, etc. Thus, the monitoring function 818 may leverage existing endpoint service functionality. As noted, it is not necessary for the monitoring 818 to monitor all system calls or events, and the system calls and events monitored are configurable as needed. In step 2.2, the labeling function 820 takes the behavioral signatures created by the labeling function (step 1) and builds abstract / labeled behavioral signatures. This abstraction is desirable because the abstract / labeled behavioral signatures represent the attack logic in a more general way and therefore target one or more attack variants of a particular attack, and allow efficient matching of labels or concrete vertices / edges during subsequent matching operations (described below).

[0056] Function block 822 (step 3) constructs the activity graph. As will be described, this process typically includes ingestion 824 (step 3.1) and aging 826 (step 3.2) to expand the graph as new activity occurs and is monitored, whereby vertices / edges of the graph are deleted (removed) when they are older than a configurable threshold or when the distance of the vertex / edge to the newly expanded graph is greater than a configurable threshold. These inter-process activity graphs generated by the activity graph construction functions 822 are stored in a database 828. The inter-process activity graphs evolve, preferably continuously, as the monitoring, ingestion, and aging functions operate.

[0057] As also shown in the figure, the endpoint supports an attack subgraph matching function 830 (step 5). Using this function, the endpoint protection system continuously performs graph pattern matching between the evolving inter-process activity graph and graph patterns of malicious behavior. These patterns are provided by the malicious pattern database 814 in the intelligence center 800 and stored in a local cache of malicious patterns 832. As previously mentioned, the attack subgraph matching function searches for graph substructures that match the graph patterns of malicious behavior stored in the local cache 832. Thus, in this approach, a function of the endpoint detection system compares the evolving activity graph with the graph patterns of malicious inter-processes. Based on this matching, a mitigation and resilience function 834 (step 6) may then be invoked. Function 834 includes a reporting function 836 (step 6.1) and a reacting function 838 (step 6.2). Thus, function 834 provides post-detection actions, which may include stopping the contained process, alerting, moving the contained process to a sandbox for further evaluation, deleting ongoing network sessions, stopping ongoing disk operations, passing the matched subgraph to a user to determine next steps, submitting the matched subgraph to a security analyst for further investigation, training a machine learning classifier, etc. These are just representative post-detection actions.

[0058] 8, the mitigation and resiliency functions 834 communicate with the intelligence center 800 in an on-demand manner, while the information flow within the functions of the endpoints is continuous. While this is a preferred approach, it is not intended to be limiting, as one or more functions within the endpoint 802 may be performed periodically, on an incident basis, or on-demand.

[0059] Thus, the techniques of one or more example embodiments provide a robust method for monitoring and protecting endpoints by recording inter-process events, creating an inter-process activity graph based on the recorded inter-process events, matching the inter-process activity (represented in the activity graph) with known malicious or suspicious behavior (embodied in a set of pattern graphs), and performing post-detection actions in response to a match between the inter-process activity and the known malicious or suspicious behavior patterns. The matching preferably includes matching a sub-graph in the activity graph (AG) with the known malicious or suspicious behavior patterns represented in the pattern graph (PG). During this process, inter-process activity, preferably both direct and indirect, at an endpoint (or across a set of endpoints) is compared to known behavior patterns. The following provides further details regarding the various operations (functionality) of the detection system described above.

[0060] FIG. 9 illustrates how labeled subgraph matching is implemented according to one example embodiment. As previously described and illustrated in the figure, label generation (step 1) typically occurs at an intelligence center, and labeling functions (step 2.2) are performed at the endpoints. In this approach, concrete signatures (e.g., signatures that are available to the system, by virtue of previous attack data or otherwise) are preferably converted (in step 1) into (concrete) behavioral signatures, which are then converted (in step 2.2) into abstract / labeled behavioral signatures. This technique facilitates labeled subgraph matching because abstract / labeled behavioral signatures represent general attack logic (as opposed to just specific attack flows). In particular, abstract / labeled behavioral signatures are matched (e.g., by labels or by concrete vertices / edges) during attack subgraph matching. By representing attack logic, graph-based behavioral signatures cover more attack variants than ad-hoc approaches that use simple concrete inter-process behavioral signatures.

[0061] Figure 10 shows the ingestion function (step 3.1) in more detail. As shown in the figure, the ingestion function starts by filtering noise (step 3.1.1), after which events are inserted into an event queue and ordered by time (step 3.1.2). Next, new entities are inserted, preferably as new keys, into the entity-event map (step 3.1.3) to facilitate the development of the inter-process activity graph. As additional events are received, they are added to the associated entity value (list) in the entity-event map (step 3.1.4).

[0062] Figures 11 and 12 illustrate and explain how the aging function is used to develop an activity graph. Figure 11 shows the entity-event map at two different times (initially and after application of the aging function). As shown in the figure, when events are discovered (received), they are put into an event queue and represented by an entity. The resulting entity-event map is shown on the left side of the drawing. When certain events become stale, they are removed (dequeued) from the event queue and, likewise, the affected entities are updated. The updated entity-event map is shown on the right side of the drawing. Figure 12 shows these operations in a process flow. Thus, in step 3.2.1, stale events are dequeued. In step 3.1.2, for each dequeued event, the associated entity identifier (id:identifier) ​​is read and the event is removed from its entity value in the entity-event map. In step 3.2.3, all entities containing zero events in the entity-event map are removed.

[0063] FIG. 13 illustrates how the detection system models indirect inter-process activity, preferably using on-disk storage, for transient and persistent inter-process activity. As shown in the figure, the ingestion function (step 3.1) and the aging function (step 3.2) facilitate the construction of the inter-process activity graph and facilitate the modeling of the attack subgraph (step 5). During these operations, the on-disk storage for the construction of both the transient and persistent inter-process activity graphs ensures that all known inter-process channels are systematically targeted. This approach further ensures that multi-stage attacks, or unseen attacks with delayed behavior, do not escape discovery.

[0064] FIG. 14 shows additional details regarding the matching function (step 5 in FIG. 8) and the mitigation and resilience function (step 6 in FIG. 8). Step 5.1 represents a high confidence match of malicious behavior, typically based on concrete signatures and labels. When this type of match of malicious behavior occurs, typically one or more of the actions identified in the reaction function (step 6.2) are performed. Step 5.2 represents a match of suspicious behavior, typically based on using abstract patterns including labels and topology. When this type of match of suspicious behavior occurs, user-assisted labeling (step 6.1.1) may be performed, followed by one or more reporting actions (step 6.1.2). User-assisted labeling actions are optional.

[0065] There is no requirement that any particular algorithm be implemented for behavioral discovery or for matching behavioral signatures. Rather, the approach of the system as described above provides a systematic approach to detecting complex and / or long-lasting cyber-attacks that arise based on direct and indirect inter-process activity.

[0066] A pattern graph (PG) (such as graph 600 in FIG. 6) may be specified visually (i.e., by drawing the graph), although this is not a requirement. Pattern graphs (or graph patterns) may also be specified in other ways (e.g., by a programming language).

[0067] In the following, the construction of the aforementioned activity graph (AG) is described in more detail. An activity graph typically represents computations on one or more computing devices (which may include endpoints) as a temporal graph. As such, an activity graph is sometimes referred to herein as a computation graph (CG) since it represents an abstraction of computation. The concepts "activity graph" and "computation graph" are used synonymously herein. As already explained, the basic elements of an AG / CG are entities (e.g., processes, files, network sockets, registry keys, GPS sensors, accelerometers, etc.) and events (e.g., reading a file, forking a process, etc.). An entity is any system element that can send or receive information. An event is any information / control flow that connects two or more entities. An event is the flow of information between entities in a pair of entities at a particular time. Events can be captured in the form of system calls, etc. An event has a unique timestamp (the time the event occurred) and the direction of the information flow (directional, bidirectional, non-directional). An indegree instance of an event can be one or two instances of the event, based on direction. An outdegree instance of an event can be one or two instances of the event, based on direction. A timestamp is an integer or real number that records the time of an event, and a join point (or checkpoint) is a tuple of <entity, timestamp>.

[0068] Thus, the AG / CG refers to a history of computations that contain entities or events associated with an attack or threat. Security-related data, such as alerts, indicators of compromise (IOCs), and intermediate results of threat analysis, are subgraphs that can be represented as labels in elements of the AG / CG, where elements are aliases that refer to entities or events. As a result, threat detection becomes a graph computation problem whose solution is to iteratively infer the subgraphs in the AG / CG that cause the threats.

[0069] More generally, as used herein, an activity graph is a labeled semi-directed temporal graph that objectively records both intrusive and non-intrusive computations on a computing device along with security knowledge associated with the computation. A particular label on the graph (e.g., element attribute labels, element relationship labels, and security knowledge labels) typically denotes one of several categories. An element attribute label is objective information obtained from the computation record (as described above). An element attribute label is a type of label that identifies a set of elements that have a particular attribute (e.g., event type READ). An element relationship label is objective information obtained from the computation record. An element relationship label is a type of label that expresses some relationship between a set of elements (e.g., a provenance link between a READ event and a WRITE event of a process that connects multiple READ / WRITE events). An element relationship label embeds more fine-grained provenance information into the inter-process level pattern graph (PG). A security knowledge label (when used) is nominative information about security and privacy objectives and reasoning procedures. A security knowledge label is a type of label that marks a group of elements that contain some security knowledge. Security knowledge labels can be generated, for example, as either intermediate / final results of threat inferences, organizational policies, IOCs, or anomaly scores imported from external detection systems (e.g., a set of sensitive files, or IP addresses marked as command and control servers).

[0070] Enterprises and organizations may inspect computations at multiple levels for threat discovery. The AG / CG represents the computation at a selected monitoring level, such as the network, host, or process level. Given a monitoring level (e.g., network), activity within an entity (e.g., process communication within a host) is typically outside the monitoring scope and is not represented in the CG. More fine-grained computation information may be represented in lower level CGs (e.g., CGs at the host level) or embedded in the CG as labels (e.g., provenance labels).

[0071] Figure 15 shows a representative host-level AG / CG (e.g., processes and files). Figure 15 (and subsequent Figures 16-17) represent the computation history as a time grid, where horizontal lines represent entities and vertical lines represent events. In Figure 15, system activity is logged, for example by monitoring system calls and instrumenting programs. Entities (en) in this CG consist of subjects (e.g., processes and threads) and objects (e.g., files, pipes, and network sockets). In this example, security data is embedded in the labels. lb1:sensitive indicates that enf2 contains sensitive information, and lb2:untrusted indicates that enp3 is not certified by the enterprise. In this example, data leakage occurs if enp3 can be traversed from enf2, as shown in Figure 15.

[0072] Figure 16 shows a representative AG / CG at the network level. In this example, metadata of link layer communication of a small network is logged for threat intelligence computing. As shown in the figure, lb1 is a provenance label that links four events between entities enσ2, enσ3, and enσ4. Link lb1 helps to identify the causal chain between enσ3 and enσ4, avoiding impossible paths. Attack steps such as port scanning and lateral movement between hosts can be identified and inferred on this computation graph.

[0073] Figure 17 shows AG / CG at the process level, where activity involving processes is monitored, e.g., by dynamic program analysis. In this graph, entities are memory addresses of code and data, and events are instructions (e.g., calls) or system calls (nmap). The infinity of θ (the space of entities that can be monitored or traced) supports the representation of recursive calls, e.g., an instance of foo() is represented as enfoo, en'foo, ... On this computation graph, software exploits such as return-to-libc and return-oriented programming (ROP) can be captured and inspected.

[0074] Given an activity / computation graph that records objective computation history on both intrusive and non-intrusive data, threat recovery reduces to a graph query problem of iteratively computing proximity for a subset of security-relevant subgraphs in the AG / CG, ultimately obtaining a subgraph that represents a threat or intrusion. Graph queries can be programmed into intrusion detection systems or behavioral anomaly detection systems, or can be achieved by on-demand rapid reasoning development. Threat hunting involves creating a sequence of graph queries to iteratively and interactively come up with, verify, refine, and confirm threat hypotheses.

[0075] The process of creating graph queries and executing them in an activity / computation graph is a graph computation. During this computation, variables that refer to a subgraph are also labels to the set of entities and events in that subgraph, and this variable can be stored in the AG / CG as a label. Since the result of each iterative graph computation step is a subgraph or a label, each step can be implemented natively in a graph computation language or in an external module as a black box that outputs a set of events and entities as a subgraph. Thus, threat intelligence is generated with graph queries as threats are discovered. Queries, specifically pattern graphs (PGs), represent threats and can be executed to search other activity / computation graphs for a particular threat.

[0076] Graph pattern matching is at the core of graph queries. In general, a graph pattern is essentially a set of constraints that represent the subgraph to be matched, and the constraints on the graph elements represent (1) a single graph element (e.g., labels / properties of entities), or (2) element relations (e.g., entities connect to events). Pattern creation allows human domain knowledge to be embedded in the reasoning procedure. Examples of simple patterns that can be represented by most graph languages ​​include standard DLL injection behavior (e.g., entities labeled with PROCESS are connected by an event labeled with CREATE_THREAD), untrusted execution behavior (e.g., an entity labeled with FILE but not with TRUSTED_EXE connects to an event labeled with EXECUTE, which in turn connects to an entity labeled with PROCESS), and data leakage behavior (e.g., an entity labeled with SENSITIVE connects to an entity labeled with NETFLOW within a certain number of hops). These are representative but non-limiting examples.

[0077] To manage the computation of the activity / computation graph and the pattern graph, the aforementioned system comprises a graph database designed and implemented to provide efficient data storage and retrieval for live forensic threat investigations. In some example embodiments, the graph database is backed by a distributed key-value store for low-level PG operation optimizations that target inherent computation graph properties such as data locality and immutability. A representative database of this type is described in “FCCE: Highly scalable distributed Feature Collection and Correlation Engine for low latency big data analytics,” to Schales, et al. (hereinafter, “FCCE”). In general, a suitable database is one that employs a distributed key-value store for concurrent multi-source streaming data ingestion, as well as long-term monitoring data storage with data locality optimization.

[0078] The aforementioned approach offers significant advantages. As described, the approach allows for systematic inter-process activity extraction and behavior matching. The technique addresses deficiencies in conventional approaches that rely on signature matching, single process (intra) detection schemes, and ad-hoc inter-process behavior modeling. As noted, the approach herein allows for modeling of both direct and indirect inter-process activity, as well as efficient matching of concrete activity with abstract patterns indicative of malicious or suspicious behavior. The result is more robust and accurate protection of endpoints from attacks. Additionally, the technique allows for more effective post-detection actions that can be carefully tailored to the activity being detected.

[0079] The use of inter-process behavior patterns as abstract attack signatures as described provides significant benefits compared to existing concrete attack signature schemes. Inter-process activity monitored according to the techniques herein records attacks that have long attack vectors or that use multiple processes to accomplish the attack goal. Conventional signature-based approaches do not find such attacks. Using abstract / labeled behavior signatures (as opposed to more specific signatures) to represent attack logic, more attack variants can be targeted during the detection process. Indeed, conventional techniques that often operate against fine-grained attack descriptions require significantly greater computational power for modeling and reasoning, thereby making these techniques impractical or expensive. In addition, attack descriptions that are less fine-grained than the abstract / labeled behavior signatures herein often cannot aid in the detection of intrusions at the endpoint itself. Furthermore, inter-process behavior according to example embodiments has clear semantic meaning for end users to understand and take action if necessary.

[0080] In general, the aforementioned techniques provide improved endpoint detection-based cybersecurity. The present subject matter further provides a new technique for systematically modeling inter-process behavior for use in characterizing malicious or suspicious inter-process behavior patterns. This modeling provides a foundation for advanced detection and, in particular, discovery of malicious / suspicious inter-process behavior and matching of inter-process behavior signatures.

[0081] The described technique provides an improved process for security event data (e.g., cybersecurity incidents) and enables the system to respond to incidents more efficiently. This automated technique is highly efficient and significantly reduces the workflow requirements of SOC analysts, facilitating post-detection actions such as threat hunting.

[0082] Iterative Constraint Solving in Graph Matching for Cyber ​​Incident Inference

[0083] As stated, an AG / CG is a graph of elements, including constraints and connections between elements. Pattern matching of such a graph requires satisfying all constraints of all elements and how those elements are connected. Typically, however, one query on a graph database can only handle one constraint or connection relationship. To address this limitation, aspects of the example embodiments described below provide novel constraint solving algorithms for computing and reconciling queries and for processing query results, thereby ensuring correctness and efficiency of abstract graph pattern matching.

[0084] Below, we describe techniques for pattern matching, e.g., resolving constraints utilized in matching an activity graph (e.g., an activity graph constructed by an endpoint) with a graph pattern. This operation is used, for example, in the attack subgraph matching function (e.g., element 830, step (5) of FIG. 8). As previously mentioned, evaluating a pattern match involves resolving a set of constraints or predicate expressions defined by the pattern. This task is computationally non-trivial because a pattern may reference other patterns through parameters and because pattern graphs are typically stored in distributed external storage, making it expensive to check the data associated with each predicate.

[0085] To address the parameterization of patterns, the following techniques are implemented. In particular, the constraint resolution process efficiently determines when and how many applications of a pattern need to be performed for a single pattern reference. For example, if a pattern reference is associated with a variable that is related to a particular predicate (e.g., "reaches"), the referenced pattern may be applied repeatedly in the traversal procedure to minimize on-disk data requests in subsequent traversal steps.

[0086] Because queries of on-disk data only support resolving one constraint at a time, the constraint resolution process (or algorithm) of example embodiments works by iteratively resolving constraints and propagating the last resolved constraint to all variables associated with constraints already satisfied. In particular, when a pattern graph (PG) defining, for example, an attack / threat is parsed and an abstract syntax tree (AST) is created, the interpreter determines how the constraints are connected and stores the constraint relationships in an auxiliary data structure in the AST as a constraint graph (GoC). To evaluate a pattern, the constraint solver orders the constraints (e.g., by heuristics, user guidance, etc.) and iteratively satisfies all constraints, including single-element constraints (e.g., x has <type:READ>) and multi-element constraints (e.g., x connects y). After each iterative constraint resolution step, variables associated with the pattern may undergo a state change. According to one example embodiment, this state change is propagated to all already stored variables by a graph traversal on the GoC, from the changed variable towards all resolved variables (variables as used herein refer to the set of matching results of elements in an abstract pattern graph).

[0087] Thus, a constraint graph (GoC) is obtained from the PG as a complementary data structure for use by the constraint solving algorithm. After the constraints in the PG are satisfied, the algorithm checks if all already satisfied constraints still hold that state. This operation is designed to remove some subgraph instances in the AG / CG that satisfy the previous, but not necessarily the last, constraint. This operation is realized as a graph traversal from the last constraint node in the GoC to all other existing nodes (already solved constraints).

[0088] Thus, according to aspects of example embodiments, the abstract graph pattern matching system serializes simple database queries for constraint resolution of single graph elements, and then performs iterative constraint propagation to ensure correctness of matching of the entire abstract graph pattern. The basic concept is to evaluate constraints of a single element at a time, and then propagate the constraint resolution results to all related pattern elements, e.g., by traversing the pattern (as a connected graph, i.e., GoC). As described, in some example embodiments, the second half of the single element constraint resolution step evaluates only connectivity constraints, not single element constraints. The single element constraint resolution step is repeated, with single element constraints being evaluated, followed by propagation. This process continues until all single element constraints have been evaluated and all propagations performed.

[0089] FIG. 18 illustrates an iterative constraint solving process as a process flow according to one example embodiment. The iterative constraint solving process (also referred to as "iterative constraint solving") provides significant computational and storage efficiency by iteratively solving constraints and propagating the last resolved constraint to all variables associated with constraints that have already been satisfied. With reference to FIG. 18, the process begins at step 1800 by building a relationship graph between elements of the PG, which is the GoC discussed above. At step 1802, all elements in the GoC are marked as unresolved. At step 1804, a test is performed to determine whether all elements in the GoC have been marked as resolved. If not, the routine proceeds to resolve the constraints of one element at step 1806 and then marks the element as resolved. As previously discussed, the iterative constraint solving preferably solves one constraint at a time. In step 1808, for constraints of an element, the result (of the resolution of the element) is propagated to all connected elements in the GoC being resolved. The process then returns to 1804 and repeats until all elements in the GoC are marked as resolved. If the result of the test in step 1804 is positive (i.e., all elements in the GoC are marked as resolved), the process proceeds to output the matched subgraph in step 1810, thereby completing the process.

[0090] Thus, the iterative solution of this example embodiment starts with an empty set of touched variables and initializes each untouched variable (step 1802). The process then performs evaluation of the new constraints by evaluating a single constraint per iteration and sets the associated variables as touched (step 1806). Within the same iteration, the process then propagates the constraints, specifically by updating the associated touched variables to reflect the changes (step 1808). The process then repeats the evaluation of the new constraints (for any other constraints not yet marked) until all constraints have been evaluated.

[0091] When evaluating single-element constraints, each constraint acts like a filter on the graph elements. For example, "element x{type:event_read}" filters out elements in "x" that are not of type event_read. When evaluating connectivity constraints, each constraint acts like a filter on two or more graph elements. For example, "element x connects to y" filters out elements stored in variable "x" that are not connected to "y" and vice versa for "y". The aforementioned filtering occurs in memory if the variable was touched in the previous iteration. Otherwise, the variable maintains a reference to the entire activity graph (stored in a database). In that case, a database query is generated to filter the entire activity graph.

[0092] In one embodiment, the propagation operation (1808) uses a proprietary breadth first search (BFS) function that uses a queue that considers the connectivity of the GoC. This function considers whether an element is resolved (as only resolved elements are added to the queue) and whether constraints have made changes (if no changes occur, the vertex is removed from the queue). In one example embodiment, propagation applies element relationship constraints based on the newly resolved element, affecting other elements within the relationship constraints.

[0093] FIG. 19 shows a representative example of a pattern graph 1900 and a corresponding GoC 1902. FIG. 19 thus corresponds to step 1800 in the process flow of FIG. 18. It should be noted that a GoC may differ from a pattern graph because some element relationships may not be explicitly described in the pattern graph. In these examples, FIGS. 20-23 show the application of an iterative constraint resolution process to a pattern graph using a GoC. In particular, FIG. 20 corresponds to step 1806 in the process flow. Here, by matching all vertices that are in the process, the first element with a property "cmdline" whose value contains the substring "firefox" is matched (resolved). FIG. 21, which corresponds to steps 1806 and 1808, shows how the process then performs a propagation from element 2 (in the GoC) to element 1 in this case, and removes all matched vertices in element 1 that do not have an element 2 connecting to it. This is the concept of removing a subgraph instance that satisfies the previous, but not necessarily the last, constraint. FIG. 22, also corresponding to steps 1806 and 1808, shows a further propagation operation, namely, propagating backwards from element 3 (in the GoC) to element 2, removing all matching edges connecting to false element 3 that is not a process (single-element constraint on property "type"). FIG. 23, also corresponding to steps 1806 and 1808, shows a further propagation operation, namely, propagating backwards from element 4 to all related elements (in this case elements 3, 2, and 1), removing vertices and edges due to the single-element constraint of element 4 (type read).

[0094] In general, according to this approach, a GoC is extracted and stored as an auxiliary data structure for the pattern. During constraint propagation within an iteration, the GoC is traversed to propagate the filtering influence from the variables of the evaluated predicate to all other connected touched variables. There is no requirement that the activity graphs on which the iterative constraint solving works be restricted to inter-process activity graphs. The iterative constraint solving techniques described above may be used for any kind of activity graph, e.g., activity graphs representing activity data captured in association with processes, host machines, networks of machines (e.g., each entity is a host), etc.

[0095] Additionally, there is no requirement that the iterative constraint resolution process be used exclusively for cybersecurity reasoning, as this technique may be applicable to other use cases that utilize graph pattern matching. Thus, the described technique (i.e., constraint resolution of a single graph element using an auxiliary graph of constraints, followed by serialization of a simple database query to perform iterative constraint propagation) may be implemented in any abstract graph pattern matching system.

[0096] FIG. 24 is a block diagram of an exemplary architecture of a graph computation platform 2400 in which techniques according to one or more example embodiments may be provided. The platform may be implemented in the intelligence center shown in FIG. 8, in the security intelligence platform of FIG. 3, in the APT solution of FIG. 4, as a standalone feature or application, as a network or cloud accessible service, or otherwise. As shown in the figure, the platform 2400 includes a language interpreter 2402, a graph database 2404, and a user interface component 2406. The user interface component 2406 includes an interactive console 2408 and a computation graph visualization tool (browser) 2410. The user interface component provides an interactive programming and data inspection environment for threat reasoning. The graph database 2404 preferably includes a graph query interface 2412, an in-memory graph cache 2414, an element cache 2416, a label cache 2418, one or more graph construction routines 2420, an on-disk element query function 2422, a key-value store translation table 2424, and an FCCE client 2426. The FCC3 client 2426 interfaces with one or more FCCE data nodes 2428 across the network, which typically store the graph in a distributed manner. As previously mentioned, the graph database 2404 employs a distributed key-value store across all of the FCCE data nodes 2428 for long term monitoring of data storage with optimization of data locality, and for simultaneous multi-source streaming data ingestion.

[0097] The interpreter 2402 contains several functional elements, including a constraint solver 2430, other built-in algorithms 2432, and a code generation module 2439 that works in conjunction with a Universal Disk Format (UDF) linker 2433. The interpreter 2402 also includes a lexer / parser 2434, a type checking and inference module 2436, and an AST optimizer 2438.

[0098] The user interface also includes a batch processor 2440. A graph database 2404 stores portions of the pattern graph both in memory and on disk, and provides a graph query API (2412) to the interpreter 2402. The main function of a graph database is to bridge the semantics of the pattern graph and low-level data storage, as well as to optimize the throughput of graph searches, preferably using multi-tier caches (2414, 2416, 2418) and data management based on PG properties such as temporal locality of events. As mentioned above, one such graph database solution that provides these capabilities is FCCE. In particular, FCCE supports simultaneous multi-source asynchronous ingestion, distributed data storage, and data locality management. To optimize graph queries based on the properties of the pattern graph, an FCCE schema is used. This schema represents the pattern graph in key-value pairs, with certain values ​​preferably replicated within one or more schemas for maintaining data locality and fast lookup from different perspectives. So, for example, one copy of events may handle temporal locality - events are indexed by time and events occurring within a time window are managed on a single memory page and stored in contiguous file system blocks - another copy of events may handle labels and shared entities.

[0099] To process a graph query, the graph database first checks whether any piece of data has already been loaded into memory by a previous query. If not, the database breaks the graph query into one or more on-disk element queries, and each of these queries is translated into a key-value query that the graph database (e.g., FCCE) can process. Labels are represented as dictionary entries to represent complex element attributes. In an exemplary operation, a simple element query searching for file instances with paths containing the substring "firefox" is translated into two graph database queries, one to search for all satisfied labels, and a second to search for the raw data that constructs the elements associated with these labels. As the raw data is retrieved from disk, buckets of key-value pairs are preferably cached first within the graph database client, so that the data in the buckets has tight data locality and a high probability of being queried in the same high-level graph query or in subsequent queries. Next, the various components of the element are constructed and some are cached for frequent reference (e.g. the primary label of the process which contains multiple pieces of information including username, uid, groups, etc.) and this is cached as a reference. Next, the element is constructed and cached. Finally, the requested graph is assembled and returned.

[0100] Cyber ​​Detection Fuzzy Pattern Matching

[0101] As mentioned above, an Activity Graph (AG) typically represents computations on one or more computing devices (which may include endpoints) as a temporal graph (also referred to herein as a Computation Graph (CG) since it represents an abstraction of computation). As mentioned above, the basic elements of an AG / CG are entities (e.g., processes, files, network sockets, registry keys, GPS sensors, accelerometers, etc.) and events (e.g., reading a file, forking a process, etc.), where an entity is any system element that can send or receive information, and an event is any information / control flow that connects two or more entities. An event is the flow of information between entities in a pair of entities at a particular time, and can be captured in the form of a system call, etc. An event has a unique timestamp (the time the event occurred) and the direction of the information flow (directional, bidirectional, non-directional). The aforementioned mechanism according to one or more of the example embodiments performs pattern matching in the AG / CG using iterative constraint solving based on a Pattern Graph (PG) and / or a Constraint Graph (GoC), thereby identifying or detecting possible intrusions, identifying or detecting cyber attacks or cyber threats, performing cyber forensics, and performing cyber reasoning.

[0102] In graph pattern matching, different human knowledge about patterns of activity are encoded into different patterns, which are graphs of subgraphs of interest in the AG / CG. Although it is a useful practice to have a complete record of computational activity in the AG / CG and to use patterns to represent exactly what security developers and analysts are looking for in terms of intrusions, attacks, threats, etc., the assumption that the AG / CG represents a complete record and that security developers and analysts have precise knowledge of intrusions, attacks, or threats such that their knowledge can be represented in a pattern graph (PG) is not always realistic. For example, the AG / CG may in fact be incomplete in many real-world cases. Furthermore, a developer or analyst may only consider a skeleton of a pattern instead of the exact pattern of intrusion, attack, or threat that may need to be identified in the AG / CG representation. Furthermore, it is useful to be able to detect variants of an intrusion, attack, or threat defined by a particular pattern graph. In each of these cases, requiring full matching of the pattern graph with subgraphs in the AG / CG is a limitation that either reduces the effectiveness of pattern matching or makes it less usable for analysts / developers.

[0103] In further aspects of the example embodiments, rather than requiring complete pattern matching of a pattern graph (PG) with subgraphs of the AG / CG, the example embodiments provide a mechanism to perform fuzzy graph pattern matching or subgraph pattern matching given a temporal graph such as the AG / CG growing through time, and given a pattern graph (PG) that may generally define subgraphs to return, e.g., patterns representing cyber attacks / threats or unauthorized intrusions (sometimes collectively referred to as cyber incidents). With respect to these further aspects of the example embodiments, a training module and a matching module are provided, where the training module continuously inspects the growing AG / CG at specified time intervals (within a particular time period) and cuts the streaming AG / CG into progressive graph sections. Each graph section is treated as a separate training sample. A filter with the parameters to be learned is then applied to each training sample using a convolutional calculation, while sliding the filter through the training sample to learn at different positions. In this way, the filter represents a graph embedding technique that can leverage graph embedding algorithms such as node2vec or graph neural networks (GNNs) without having to deal with the special properties of temporal graphs.

[0104] The filter captures both features of the graph's topology and features of the attributes of the vertices (nodes) / edges (activities or events). The goal is to learn filter parameters that build a good embedding of the subgraph. In some example embodiments, the filter can slide over entities and target time periods. In this way, the subgraph that is the subject of the filter can be represented by the entity's neighborhood in the time range. The filter learns a good embedding of the nodes / entities instead of complex subgraphs.

[0105] The matching module executes only in response to being provided with a pattern graph (PG), e.g., by a user via a user interface or by other sources, such as an automated computational component, and identifies similar subgraphs in the AG / CG that match the particular pattern graph (PG). The matching module selects an appropriate filter and applies the selected filter to the pattern to obtain an embedding, searching for similar subgraphs in the embedding space. The matching module then maps the retrieved embeddings back into the graph space and outputs the subgraphs of fuzzy matches.

[0106] As previously mentioned, the output of these mechanisms according to further aspects of example embodiments is a set of subgraphs that resemble a pattern graph (PG), but are not necessarily identical or isomorphic to any particular pattern. For example, FIG. 25 shows an example of a pattern 2510 used to define a pattern representing an intrusion, attack, or threat, and two fuzzy matching subgraphs 2520 and 2530 or AG / CG (not shown) that may match this pattern 2510 by the fuzzy matching mechanism of example embodiments. It should be understood that in these graphs, the horizontal lines represent entities, the arrows between the horizontal lines represent events, and the direction of the arrows represents the direction of the system calls, etc., that correspond to those events. The horizontal lines to represent entities are for convenience in the graphs, allowing events to be shown as arrows connecting two horizontal lines, indicating events between the connected entities.

[0107] As shown in FIG. 25, fuzzy match subgraphs 2520 and 2530 do not perfectly match the original pattern graph 2510, at least with respect to certain entities and / or events between entities. For example, fuzzy match subgraph 2520 differs from the original pattern graph 2510 in that the entity "python" exists instead of the entity "sh" and the entity " / etc / passwd" exists instead of the entity " / etc / shadow". Similarly, fuzzy match subgraph 2530 differs from the original pattern graph 2510 in that the entity "IMG2019.jpg" exists instead of the entity " / etc / shadow" and the entity "IMG2019.jpg.rasome" exists instead of the bottom entity (which is not named in pattern graph 2510).

[0108] In conventional pattern matching methods, such differences in patterns and subgraphs would result in the subgraphs not being returned as possible intrusions, attacks, or threats, since there would not be an exact match between the pattern graph 2510 and the subgraphs 2520, 2530. However, as described in more detail below, example embodiments provide mechanisms for performing such fuzzy matching in the pattern graphs and AG / CGs, such that such similar subgraphs may be identified, according to further aspects. This allows for incomplete pattern graphs even when an exact match does not exist, for example, when an analyst or developer does not have access to knowledge of something to use as a basis for matching, when a pattern graph containing erroneous information is utilized, or when similar pattern graphs for known attack campaigns are used to identify similar attack subgraphs in the AG / CG.

[0109] It should be appreciated that full temporal graph pattern matching as described above operates in the original graph space of AG / CG and pattern graph (PG) using the tools and mechanisms described above, e.g., graph databases, multi-aspect locality caching, dynamic programming for pattern matching, constraint graphs (CoG), iterative constraint solving, etc. Meanwhile, a further aspect of example embodiment, temporal graph fuzzy pattern matching, operates by transforming the matching space from the original graph space to a vector space using convolutions on the temporal graph (operations on spaces that show how the shape of one space is modified by other spaces), subgraph embedding using trained neural networks, and continuous learning on the evolving graph.

[0110] Temporal graph fuzzy pattern matching operates on a dynamically growing temporal graph (e.g., AG / CG) where new parts of the graph are added over time. FIG. 26 is an exemplary diagram illustrating such a dynamically growing temporal graph, again with horizontal lines representing entities in the AG / CG and vertical arrows or edges representing events. As shown in FIG. 26, during an initial time t0, the temporal graph (e.g., AG / CG) is as shown in element 2610. At a later time t1, the temporal graph is as shown in element 2620, where there are additional nodes and events 2621-2625 because additional activity occurs between entities from time t0 to time t1. The same is true for further times t2 and t3, as shown in elements 2630 and 2640 of FIG. 26. At each point in time, the portion of the temporal graph indicated by the dashed box, representing a new portion of the temporal graph, is processed to determine whether this portion, alone or in combination with portions of the graph already processed, contains a subgraph that matches a pattern graph indicative of an intrusion, attack, or threat.

[0111] FIG. 27 is an exemplary diagram that graphically illustrates a process for extracting information from subgraphs of a temporal graph (e.g., AG / CG) using moving convolution filters. The process illustrated in FIG. 27 may be executed at predefined time points (e.g., t0, t1, t2, etc.) to evaluate nodes and events that occur since the previous time point the process was executed and generate vector representations of nodes and events that occur between time points (e.g., during the time periods represented as dashed boxes in FIG. 26). The process collects vector representations within that time frame so that those vector representations can be compared to vector representations of pattern graphs that indicate intrusions, attacks, or threats, or simply activity, that an analyst, developer, or automated computational component may wish to search for within the temporal graph.

[0112] As shown in FIG. 27, a convolution filter 2710, shown in FIG. 27 as a moving filter window 2710, is defined and centered around the entity (horizontal line) of the temporal graph. Subgraphs within the moving filter window are computed as vectors (i.e., graph embedding). Graph embedding is a commonly known technique for transforming nodes, edges, and their features into a vector space while maximally preserving properties such as graph structure. Machine learning algorithms may operate on this vector space representation generated by graph embedding. Such embedding can be performed at various levels, such as node level, subgraph level, etc.

[0113] In the example shown in FIG. 27, the filter 2710 is moved around the selected entity 2712, and the subgraph of the filter window is summarized around the central entity 2712. As the filter 2710 is moved along the selected entity 2712 in the temporal graph from the previous time point where the embedding was performed to the second time point where the current embedding is performed, a vector representation of the filter window corresponding to the filter 2710 is generated and stored for the range of time points of the filter window. That is, the graph embedding is implemented as a convolution filter 2710 with a temporal boundary (e.g., the number of time points included in the filter window) (horizontal axis) and a reachability constraint (e.g., the number of direct / indirect events to / from the selected entity 2712 that is within the filter window) (vertical axis). To perform the embedding of the temporal graph, various filters of different sizes may be defined, e.g., filters of one hop, two hop, three hop size from the selected central entity, smaller / larger time intervals, etc. Thus, the horizontal boundaries of the filter window 2710 are defined by the range of time points desired for the implementation, and the vertical boundaries of the filter window 2710 are defined by the reachability constraints within which events are considered for embedding purposes, e.g., the number of hops from a central entity (e.g., 2712 or 2714 in FIG. 27).

[0114] Non-temporal graph node embedding mechanisms can be used to perform the embedding of information within the filter window by constraining the problem to node embedding using temporal bounds and reachability constraints. For example, node2vec embedding (distance embedding), graph convolution network (GCN) embedding (where the graph is represented as a normalized graph Laplacian matrix), graph neural networks (where the neighborhood of a vertex is summarized based on the summary of connected vertices (within a layer)), etc. may be used to perform the actual embedding of the information contained within the filter window.

[0115] In an implementation of embedding a graph into a vector using a GCN or Graph Neural Network (GNN), first values ​​are assigned to the weight matrix (parameters of neurons) in the GCN / GNN. It is important to train these values ​​so that the generated embedding maintains the similarity between similar graphs (CG / AG, or parts of PG). The procedure to find these good neuron value parameters or weights is called "training" and thus the GCN / GNN is trained to generate these weight matrices. After the GCN / GNN is trained, it can be used to perform the embedding of the moving filter time frame 2710. This training can be unsupervised training, for example, where the training data is previously seen CG / AG and PG, and this training uses a defined loss function that can be defined by the user, and the loss function is minimized by epochs of the training process. One example of a loss function is a loss function that encourages nearby nodes to have similar embeddings, as described in Hamilton et al., “Inductive Representation Learning on Large Graphs,” Advances in Neural Information Processing Systems, pp. 1024-1034, 2017. This is just one example of a loss function and is not intended to be a limitation on the present invention. Any type of loss function desirable for a particular purpose implementation may be used without departing from the scope of the present invention.

[0116] As shown in Figure 27, the selected center entity 2712 may then be repeated for the number of specified entities in the temporal graph according to the size of the filter (e.g., the number of filter "hops"). For example, the depiction of the moving filter window at time points (1)-(3) is for the selected entity 2712 from a first time point (denoted as (1)), to a second time point (denoted as (2)), and to a third time point (denoted as (3)). After the movement of the filter window reaches a temporal boundary, the filter window is repositioned to be centered on the new selected entity, such as selected entity 2714, and the process is repeated, as shown for time points (4)-(6) in Figure 27.

[0117] This process results in a vector representation of the temporal graph, for example based on an embedding performed by a distance embedding technique such as node2vec, or a trained neural network mechanism such as a GNN or a multi-layer CNN. For example, in one example embodiment, different convolution filters with different sizes are defined and multiple GNNs, each containing one filter, are trained continuously. Assuming that the process results in a vector representation of the temporal graph portion, a fuzzy match of the vector representation of the moving filter 2710 on the CG / AG with the vector representation of a particular pattern graph (PG) is performed to determine whether a sufficient match exists, i.e. a search for nearby vectors in the vector space is performed.

[0118] That is, a search for a "close" vector is a search for portions of the pattern graph (PG) (i.e., "graph patches") that appear similar (e.g., similar topography, similar node / edge attributes, etc.) to the portion of the graph currently under the moving filter 2710 in the CG / AG. Similar graph patches may be close or far away in the CG / AG, but are similar in attributes as represented by the vector embeddings. The "close vector" technique for comparison of vector representations or embeddings of graph patches is used to determine, for each vector slot of the vector representations, how close or far the vector representations are to each other (i.e., the distance between the values ​​in the vector slots of the vector representations), thereby generating a measure of similarity of the two vector representations. This similarity measure may be compared to a similarity measure threshold to determine whether the two vectors are the same within a certain tolerance of each other, and thus determine whether the two vectors are similar (i.e., whether they are "close" vectors). The "proximity vector" approach allows for a less computationally intensive approach to operate in vector spaces than the relatively computationally intensive approach of determining how similar or dissimilar graphs are in graph spaces. Thus, in the proximity vector approach, graphs are incorporated into vectors to search for proximity vectors using fuzzy graph pattern matching or subgraph pattern matching. Any currently known or later developed technique for calculating distances between vectors in high dimensional vector spaces may be used to actually calculate the distances between the vectors and thus identify which vectors are "close". In one example embodiment, a Euclidean distance measure or a cosine similarity measure may be used to identify the distances, which can then be used along with a defined distance threshold level to identify similar or "close" vectors.

[0119] For the proximity vectors found by this fuzzy or partial matching process, the proximity vectors are mapped back from the vector space to the graph space, specifically to subgraph instances. For example, in one example embodiment, a mapping / lookup table (e.g., Vec2Graph mapping 3120 in FIG. 30 below) may be maintained that maps vector slot values ​​or combinations of vector slot values ​​to corresponding nodes / edges as the embedding is processed, and thus vector values ​​in this table may be looked up and used to recreate corresponding nodes and edges of the subgraph. The subgraph instances generated by this back mapping to the graph space are then stored for use in identifying possible attacks or threats, such as by presenting the subgraphs to analysts or developers via a cyber security intelligence center interface and determining whether the subgraph instances are actual attacks, threats, or unwanted intrusions.

[0120] As previously discussed, the actual fuzzy matching or partial matching process may be implemented using node2vec, multiple GNNs each including a particular one of the multiple defined filters, and the like. FIG. 28 is an exemplary flow diagram outlining an exemplary generalized operation for performing fuzzy matching according to one example embodiment. FIG. 28 assumes that embedding is performed using a trained graph neural network model as opposed to a more simple distance-based neural network model embedding such as node2vec. However, it should be understood that example embodiments may be implemented using a distance-based neural network model embedding as opposed to a trained graph neural network model based mechanism without departing from the scope of the present invention. That is, in some example embodiments, the trained GNN approach is preferred as it is more accurate and can embed a more complex set of attributes as compared to the node2vec embodiment which is relatively simple but limited to providing information about the topology (e.g., node / edge attributes), while in other example embodiments, the node2vec embodiment may be utilized.

[0121] The operations outlined in Figure 28 may be implemented, for example, by Attack Subgraph Matching 830 of Figures 8 and 14, where malicious patterns correspond to a particular Pattern Graph (PG) of an intrusion, attack, or threat, where the malicious patterns are matched against patterns present in an inter-process Activity Graph (AG) or Computation Graph (CG). The process illustrated in steps 5.1 and 5.2 of Figure 14 may be replaced with a new fuzzy matching process (or algorithm), for example, according to Figure 28.

[0122] As shown in FIG. 28, the process begins with the definition of filters of different sizes (step 2810). A number of filters of different sizes are used to perform embedding at different graph patch sizes. Since the mechanism of the example embodiment may not be aware of the size of the PG when the PG is provided as the basis for fuzzy matching or partial matching, the different size filters allow for the accommodation of PGs of various sizes, i.e., PGs of different sizes require filters of different sizes corresponding to different graph patch sizes on the CG / AG for vector encoding. For example, filters based on 1-hop, 2-hop, 3-hop, and different time ranges may be defined for use in performing graph embedding of the time-framed portion of the AG / CG and / or pattern graph as a vector representation. However, it should be understood that in some example embodiments where a single graph patch size is required and known in advance, a single size filter may be utilized. Without departing from the scope of the invention, example embodiments of the invention may utilize a single size filter or multiple filters of different sizes.

[0123] One or more neural network models are trained to perform graph embedding and generate vector representations based on the defined filters (step 2820). This training includes initial training of the neural network based on a training dataset that may be based on known CGs / AGs and PGs. That is, for example, in certain embodiments, an initial set of one or more CGs / AGs may be obtained from monitoring computer resources and one or more existing PGs (knowledge to search) may be defined by an analyst for use in training the GCN / GNN using one or more filters. For example, the GCN / GNN may operate on the CGs / AGs and PGs to determine whether there is a subgraph in the CG / AG that matches the PG and generate a corresponding output. A determination is then made as to whether the GCN / GNN has generated a correct output based on the loss function, and if not, the operating parameters (e.g., weights) of the GCN / GNN are adjusted to minimize the loss function over epochs or iterations until a predefined threshold level of loss or error for the GCN / GNN is obtained. After being trained, the GCN / GNN may be run substantially simultaneously with the computer system being monitored, such that the trained GCN / GNN can embed the newly arrived CG / AG and PG and return portions of the similar graphs of the CG / AG according to the PG.

[0124] That is, given the input AG / CG, the AG / CG is processed by the trained neural network using the defined filters as described above to generate one or more first embedding vectors (step 2830). For example, in one example embodiment, multiple graph convolutional networks (GNNs) each implementing one of the defined filters may be trained, and a selected one of the GNNs may be applied to the AG / CG according to the size of the filter and the size of the particular graph pattern. In another example embodiment, a single multi-layer convolutional neural network may be used with layers corresponding to filters of different sizes, and a fuzzy pattern matching task that performs convolutions on a pattern graph similar to the AG / CG up to a layer where one filter covers the entire pattern in the pattern graph.

[0125] The selected filter size is used to generate an embedding vector of the pattern in the pattern graph, thereby generating a second embedding vector (step 2840). The second embedding vector is used to search for a proximity vector in the vector space of the AG / CG generated by the application of the corresponding trained neural network (step 2850). The proximity vectors found in the vector space are then reverse-mapped to the subgraph instance of the corresponding AG / CG (step 2860). The subgraph instance is then returned for reaction and reporting operations (step 2870). For example, various reactions and reports may be implemented, such as raising an alarm, terminating the involved process, delaying the process request, limiting resources (e.g., disk / network access), submitting the suspicious subgraph for further evaluation by an analyst, etc., as shown in FIG. 14 as steps 6.2 and 6.1.2. The operation then ends. Although the process is shown terminated, it should be understood that the process may be repeated in an apparently continuous manner, at additional times or at certain predefined time intervals, at the request of a user or automated computational component, upon the occurrence of a predefined event, etc. Additionally, the process may be performed for each of a number of different pattern graphs (i.e., various defined intrusions, attacks, or threats) against which pattern matching is performed.

[0126] As described herein, example embodiments based on additional fuzzy matching or partial matching identify similar portions or patches of the CG / AG compared to one or more PGs that represent possible cyber attacks, cyber threats, etc., or even simply pattern graphs of particular interest to a systems analyst, administrator, or other authorized person, or other computing system resource (e.g., other computing algorithms that may operate based on identifying similar portions of patches of the CG / AG). It should be understood that upon detection of similar portions or patches of the CG / AG, a single vector output may be returned corresponding to the vector closest to the vector representing the PG, or the top k closest vectors may be returned, depending on the desired implementation. In such a case, the closest vector or the top k closest vectors may be mapped back to similar subgraph patches in the CG / AG, as previously described. Additionally, in some example embodiments, a user may specify a distance threshold, and all vectors within this threshold (i.e., all vectors that are similar to the PG vector within the distance threshold) may be returned as results and mapped back to subgraph portions or patches of the CG / AG.

[0127] FIG. 29 is a flow chart diagram outlining an exemplary fuzzy matching operation according to an example embodiment in which multiple graph neural networks (GNNs) are implemented to perform the embedding. As shown in FIG. 29, the process again starts with the definition of filters of different sizes (step 2910). At step 2910 (step 2920), multiple GNNs are trained with each GNN implementing one of the defined filters. In response to a trigger (step 2930) of the process for performing a cyber threat assessment of an activity graph representing events occurring with respect to an entity of a computing system, a specific pattern graph (PG) is provided (step 2940). A filter having a filter size corresponding to the size of the pattern graph (e.g., a filter that is neither too small nor too large in terms of hop count or time range than the patterns in the pattern graph) is selected (step 2950). The size of the selected filter may be selected, for example, as a filter of the smallest size that encompasses the size of the pattern graph.

[0128] The selected filters are used to generate a vector representation of the pattern graph, i.e., to compute an embedding vector for the pattern (step 2960), which is then used to search for proximity vectors in the AG / CG in the vector space (step 2970). The identified proximity vectors are then mapped back to subgraph instances in the AG / CG (step 2980), and the subgraph instances are returned for further reaction and reporting operations (step 2990). The operation then terminates.

[0129] FIG. 30 illustrates an exemplary system design and process flow for performing cyber detection fuzzy pattern matching, according to one example embodiment. As shown in FIG. 30, endpoints in a monitored network 3010 are monitored by a monitoring process 3020 of a SIEM system 3030 to perform inter-process activity extraction (e.g., monitoring 818, labeling 820, and ingestion 824 of FIG. 8 to generate an inter-process activity graph 828, referred to in FIG. 30 as a streaming temporal graph 3040). This monitoring 3020 and generation 3040 of the temporal graph may be performed continuously such that the temporal graph 3040 grows dynamically and the process of the example embodiment may be performed at specified intervals to perform cyber detection fuzzy pattern matching based on the state of the temporal graph 3040 at a particular time point relative to the previous time point at which the cyber detection fuzzy pattern matching was performed.

[0130] A temporal convolution operation 3050 using one or more filters and a moving filter time window approach described above is performed on the temporal graph 3040 to learn parameters for the filter 3070 and generate a subgraph embedding 3060. The term "temporal convolution" refers to convolution over time. Rather than performing the convolution on the temporal graph at a particular instant in time (a snapshot of the graph at that instant in time), example embodiments provide a mechanism for performing the convolution to account for the graph changing through time by structuring the temporal graph as a two-dimensional grid with one axis as time and the other axis as space. Thus, operations 3040-3060 may be performed continuously as the temporal graph dynamically grows. Additionally, the learning performed by the neural network used to implement the temporal convolution operation 3050 may be trained continuously in an unsupervised manner using an unsupervised machine learning process.

[0131] The subgraph embedding 3060 may be used to generate vectors in a vector space 3080, which may be used to identify proximity vectors to a particular pattern graph 3090. That is, a filter 3070 corresponding to the size of the particular pattern graph 3090 may be applied to the pattern graph to generate a subgraph embedding 3100 of the pattern graph 3090, which may also be used to generate a vector representation in the vector space 3080. Based on the vector representation in the vector space 3080, proximity vectors 3110 are identified that are proximate to the subgraph embedding 3100 of the pattern graph 3090. The proximity vectors 3110 are mapped back to the corresponding subgraphs using a vector-to-graph mapping operation 3120. The resulting subgraph instances 3130 are then output for further reaction and reporting operations.

[0132] The techniques described herein are designed, in some example embodiments, to be implemented in an automated manner within or in conjunction with security systems such as SIEMs, APT solutions, endpoint management solutions, etc. The functionality described above may be implemented as a standalone technique (e.g., software-based functionality executed by a processor) or may be utilized as a managed service (including web services via a SOAP / XML interface). Specific hardware and software implementation details described herein are for illustrative purposes only and are not intended to limit the scope of the subject matter described.

[0133] More generally, in the context of the disclosed subject matter, a computing device is a data processing system (e.g., as shown in FIG. 2) each having hardware and software, and these entities communicate with each other over a network (such as the Internet, an intranet, an extranet, a private network, or any other communications medium or link). Applications on the data processing systems provide native support for the Web and other known services and protocols, including, but not limited to, support for HTTP, FTP, SMTP, SOAP, XML, WSDL, UDDI, and WSFL, among others. Details regarding SOAP, WSDL, UDDI, and WSFL are available from the World Wide Web Consortium (W3C), which is responsible for developing and maintaining these standards, and details regarding HTTP, FTP, SMTP, and XML are available from the Internet Engineering Task Force (IETF). Familiarity with these known standards and protocols is assumed.

[0134] The mechanisms described herein may be implemented in or in conjunction with a variety of server-side architectures, including simple n-tier architectures, web portals, federated systems, etc. The techniques herein may be practiced in loosely coupled server (including "cloud" based) environments.

[0135] More generally, the subject matter described herein may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment including both hardware and software elements, with the understanding that an embodiment employing a software component includes a software component executing on hardware, such that the software component specifically configures the hardware component to be a dedicated hardware component specifically configured to perform the operations corresponding to the software component. In a preferred embodiment, the functionality is implemented in software, including but not limited to firmware, resident software, microcode, and the like. Furthermore, as previously described, the identity context based access control functionality may take the form of a computer program product accessible from a computer usable or computer readable medium that provides program code for use by or in connection with a computer or any instruction execution system. For purposes of this description, a computer usable or computer readable medium may be any apparatus that can contain or store a program for use by or in connection with an instruction execution system, instruction execution apparatus, or instruction execution device. The medium may be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device). Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable floppy disk, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk, and an optical disk (current examples of optical disks include compact disk-read only memory (CD-ROM), compact disk-read / write (CD-R / W), and DVD).The computer readable medium is a tangible item.

[0136] A computer program product may be a product that includes program instructions (or program code) for implementing one or more of the described functions. These instructions or code may be stored in a computer readable storage medium in the data processing system after being downloaded from a remote data processing system over a network. In some embodiments, the instructions or code may be stored in a computer readable storage medium in a server data processing system and adapted to be downloaded to the remote data processing system over a network for use in the computer readable storage medium in the remote system. In a representative embodiment, the graph generation technique is implemented in a dedicated computer, preferably in software executed by one or more processors. The software is maintained in one or more data stores or memories associated with the one or more processors, and the software may be implemented as one or more computer programs. Collectively, this dedicated hardware and software comprises the functionality described above.

[0137] Additionally, authentication or authorization functionality required herein may be implemented as an addition or extension to an existing access manager or policy management solution. Although the above describes a particular order of operations performed by certain embodiments of the present invention, it should be understood that such orders are exemplary, as alternative embodiments may perform operations in different orders, combine certain operations, overlap certain operations, etc. References herein to particular embodiments indicate that the described embodiments may include certain features, structures, or characteristics, but not necessarily all embodiments may include certain features, structures, or characteristics.

[0138] Finally, although certain components of the system have been described separately, those skilled in the art will appreciate that some of the functionality may be combined or shared in specific instructions, program sequences, code portions, etc.

[0139] The techniques herein provide improvements to knowledge graph-based cyber analytics, including threat hunting, in addition to improvements to other technologies or technical fields, particularly endpoint management systems, advanced persistent threat (APT) solutions, and security incident and event management (SIEM) systems. Cyber ​​threat hunting is the process of proactively and iteratively creating and validating threat hypotheses based on security-related observations and domain knowledge. The techniques herein facilitate such activities by modeling threat discovery as a graph computation problem. Indeed, given a process graph that records objective computation history on both intrusive and non-intrusive data, threat discovery is reduced to a graph query problem of iteratively computing proximities for a subset of security-related subgraphs in the process graph, ultimately resulting in a subgraph representing a threat or intrusion. The graph queries can be pre-programmed into an intrusion detection system or behavioral anomaly detection system, etc. Threat hunting creates a sequence of graph queries to iteratively and interactively come up with, verify, revise, and confirm threat hypotheses. The graph building and matching techniques herein may be used to discover and act on inter-process activity on other than an enterprise's endpoint machines. The techniques herein may also be used on an intra-process basis.

[0140] The description of the present invention has been presented for purposes of illustration and explanation, and is not intended to be exhaustive or to limit the invention in the disclosed form. It will be apparent to those skilled in the art that many changes and modifications are possible without departing from the scope of the described embodiments. The embodiments have been selected and described to best explain the principles, practical applications of the invention, and to enable other skilled in the art to understand the invention in terms of various embodiments with various modifications as suited to the particular applications contemplated. The terms used in this specification have been selected to best explain the principles, practical applications, or technical improvements over the art found in the marketplace of the embodiments, or to enable other skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A method in a data processing system for identifying patterns of activity of target computing resources in activity data characterizing activity of elements of a computer system, comprising: receiving, by the data processing system, from one or more computing devices of a monitored computing environment, the activity data characterizing activity of elements of computer systems; generating, by the data processing system, a temporal graph of the activity data, the temporal graph including nodes representing elements of the computer system and edges connecting the nodes, each edge representing an event occurring between elements of the computer system represented by the nodes connected by the edge; applying, by the data processing system, a filter to the temporal graph to generate one or more first vector representations, each vector representation characterizing nodes and edges within a moving time window defined by the filter; applying, by the data processing system, the filter to a pattern graph representing a pattern of entities and events between entities indicative of a pattern of activity of the computational resources identified in the temporal graph, wherein applying the filter to the pattern graph creates a second vector representation; comparing, by the data processing system, the second vector representation to the one or more first vector representations to identify one or more adjacent vectors in the one or more first vector representations; outputting, by the data processing system, one or more subgraph instances corresponding to the identified one or more proximity vectors as partial matches of the temporal graph to an intelligence console computing system; A method comprising:

2. The method of claim 1 , wherein the intelligence console computing system is a cyber security intelligence center and the one or more proximity vectors represent possible computer attacks against the one or more computing devices.

3. 2. The method of claim 1, further comprising: training at least one graph neural network (GNN) based on a training dataset to perform vector embedding of attributes of the nodes and edges of an input graph to generate vector outputs corresponding to the attributes of the nodes and edges of the input graph; applying the filter to the temporal graph comprises running the trained at least one GNN on the temporal graph as the input graph; and applying the filter to the pattern graph comprises running the trained at least one GNN on the pattern graph as the input graph.

4. 4. The method of claim 3, wherein the training dataset comprises one or more known activity graphs corresponding to activities performed by a known set of computational elements, at least one known pattern graph corresponding to at least one known pattern of activity of interest, and instructions for correct vector output or classification generated by the at least one GNN based on the one or more known activity graphs and the at least one known pattern graph as inputs to the at least one GNN.

5. 4. The method of claim 3, wherein the at least one GNN comprises a plurality of GNNs, each GNN including a corresponding filter of a different size, and wherein applying the filter to the temporal graph and applying the filter to the pattern graph include executing a GNN selected from the plurality of GNNs that includes a corresponding filter of a size corresponding to a size of the pattern graph.

6. 2. The method of claim 1, wherein the filter has a first dimension corresponding to a reachability constraint indicating a distance of a node from a first node within the moving time window, and a second dimension corresponding to a time range of an event within the moving time window, from a time point corresponding to a center time point of the moving time window.

7. 2. The method of claim 1 , wherein applying the filter to the temporal graph further comprises storing a mapping of portions of the one or more first vector representations to attributes of nodes and edges in the moving time window, and wherein outputting the one or more subgraph instances corresponding to the identified one or more proximity vectors comprises transforming the one or more proximity vectors to corresponding subgraph instances in the one or more subgraph instances based on the stored mapping.

8. 2. The method of claim 1 , wherein comparing the second vector representation to the one or more first vector representations and identifying one or more adjacent vectors in the one or more first vector representations comprises identifying the one or more adjacent vectors based on partial matching of the second vector representation with portions of the one or more first vector representations, thereby identifying the one or more adjacent vectors.

9. Comparing the second vector representation to the one or more first vector representations and identifying the one or more neighboring vectors in the one or more first vector representations includes, for each first vector representation in the one or more first vector representations: performing a vector distance based comparison of a second vector representation with the first vector representation to generate a similarity measure corresponding to the first vector representation; comparing the similarity measure to a similarity measure threshold to determine whether the first vector representation represents a proximity vector; and returning the first vector representation as a proximity vector in response to the similarity measure having a predefined relationship to a threshold value of the similarity measure.

10. The method of claim 1 , wherein the method is performed dynamically, with the temporal graph dynamically changing over time.

11. A program for causing a processor to carry out the method according to any one of claims 1 to 10.

12. A processor; and a memory coupled to said processor, said memory containing instructions that, when executed by said processor, perform the steps of any one of claims 1 to 10.

Citation Information

Patent Citations

  • Similarity search for discovering multiple vector attacks

    US20170346839A1

  • Deep neural network system for similarity-based graph representations

    US20190354689A1

  • Intelligent intrusion detection system utilizing enhanced graph-matching of network activity with context data

    US7624448B2