Cloud computing forensics technology using security map
By using security graphs in the cloud computing environment to detect network security threats and generate compact forensic event logs, the problem of inefficient network security threat detection in the cloud computing environment is solved, and efficient network security analysis and storage optimization are achieved.
Patent Information
- Application Number
- CN202380024636.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2022-01-31
- Filing Date
- 2023-01-31
- Publication Date
- 2024-11-08
Smart Images

Figure CN118923094A_ABST
Abstract
Description
[0001] CROSS-REFERENCE TO RELATED APPLICATIONS
[0002] This application claims the benefit of U.S. Provisional Application No. 63 / 267,365, filed on January 31, 2022, the contents of which are incorporated herein by reference. Technical Field
[0003] The present disclosure relates generally to cloud computing and, more particularly, to performing forensic analysis in a cloud computing environment. Background Art
[0004] Cloud computing technology allows hardware considerations to be abstracted away from the technology stack. For example, The computing environments of Web Services (AWS) or Google Cloud Platform (GCP) allow users to implement a wide variety of software and provide the associated hardware, paying only for what they need. This shared provisioning allows resources to be better utilized, both for the owners of the resources and for those who wish to execute the software applications and services that require those resources.
[0005] However, this technology is not without its drawbacks. Because the computing environment is now physically located outside the organization and is exposed in terms of access to and from the computing environment, there is a greater potential for breaches.
[0006] While many solutions exist to attempt to prevent cyberattacks, the reality is that at least some of these attacks will inevitably succeed. For example, an attack could be unauthorized access to sensitive information (e.g., information stored in a database). Attacks can be categorized based on severity, for example, an attack that only allows an attacker to view a file present on a workload may not be as severe as an attack that allows the attacker to view or download the same file.
[0007] Digital forensics, or cybersecurity forensics, is a technical field that involves attempting to identify the actions an attacker was able to accomplish in a compromised computing environment. Typically, individuals with knowledge of the computing environment will manually examine workloads to try to discover the extent of the damage performed by the attacker, if such damage was present. This process requires specialized knowledge that is not easily transferable and is labor intensive in terms of human time.
[0008] Therefore, it would be advantageous to provide a solution that can overcome the above challenges. Summary of the invention
[0009] Below is an overview of several example embodiments of the present disclosure. This overview is provided to facilitate the reader to provide a basic understanding of these embodiments and does not completely limit the scope of the present disclosure. This overview is not an extensive review of all contemplated embodiments, and is neither intended to identify the key or important elements of all embodiments nor to describe the scope of any or all aspects. Its sole purpose is to present some concepts of one or more embodiments in a simplified form as a preface to a more detailed description presented later. For convenience, the term "some embodiments" or "certain embodiments" may be used herein to refer to a single embodiment or multiple embodiments of the present disclosure.
[0010] Certain embodiments disclosed herein include a method for generating a compact forensic event log based on a cloud log. The method also includes traversing a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detecting nodes representing network security threats connected to the nodes representing the cloud entities; parsing the cloud log of the cloud computing environment to detect data records, the data records including attributes of the nodes representing the cloud entities; and generating a compact forensic event log including the detected data records.
[0011] Certain embodiments disclosed herein also include a non-transitory computer-readable medium having stored thereon a process for causing a processing circuit to execute the process, the process comprising: traversing a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detecting nodes representing network security threats connected to the nodes representing the cloud entities; parsing a cloud log of the cloud computing environment to detect data records, the data records including attributes of the nodes representing the cloud entities; and generating a compact forensic event log including the detected data records.
[0012] Certain embodiments disclosed herein also include a system for generating a compact forensic event log based on a cloud log. The system also includes a processing circuit. The system also includes a memory, the memory containing instructions, when the instructions are executed by the processing circuit, the system is configured to: traverse a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detect nodes representing network security threats connected to nodes representing cloud entities; parse the cloud log of the cloud computing environment to detect data records, the data records including attributes of the nodes representing the cloud entities; and generate a compact forensic event log including the detected data records. BRIEF DESCRIPTION OF THE DRAWINGS
[0013] The subject matter disclosed herein is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The foregoing and other objects, features and advantages of the embodiments of the present disclosure will become apparent from the following detailed description taken in conjunction with the accompanying drawings.
[0014] Figure 1 is a network diagram used to describe various disclosed embodiments.
[0015] Figure 2 is a web log of a cloud-based computing environment according to an embodiment.
[0016] Figure 3 is a role log of a cloud computing environment according to an embodiment.
[0017] Figure 4 is another role log of a cloud-based computing environment according to an embodiment.
[0018] Figure 5 is a safety diagram implemented according to an embodiment.
[0019] Figure 6 It is a flowchart of a method for generating a forensic analysis report based on a security graph according to an embodiment.
[0020] Figure 7 is a schematic diagram of a forensic analyzer according to an embodiment. DETAILED DESCRIPTION
[0021] It is important to note that the embodiments disclosed herein are merely examples of the many advantageous uses of the innovative teachings herein. In general, statements made in the specification of the present application do not necessarily limit any of the various claimed embodiments. In addition, some statements may apply to some inventive features but not to others. In general, unless otherwise stated, singular elements may be plural and vice versa without loss of generality. In the accompanying drawings, the same numerals refer to the same parts in several views.
[0022] Various disclosed embodiments include methods and systems for generating compact forensic logs based on cloud logs and security graphs. Cloud entities detected in cloud logs (such as network logs and role logs) can be referenced in security logs to determine whether exploitation has occurred. In certain embodiments, forensic analysis output is stored in place of cloud logs. This is advantageous because cloud logs typically require a large amount of storage space as it can easily include millions of events. By storing smaller relevant logs (which only include, for example, records related to vulnerable resources), storage space is saved while ensuring that the most relevant information remains stored.
[0023] Additionally, in some embodiments where a user is viewing forensic events, the amount of information that needs to be manually sifted through is significantly reduced to determine if a vulnerability led to an exploit of the same vulnerability. Cloud logs may contain a large amount of information even over a short period of time, which is time consuming for a human to read in order to find an indication that a vulnerability was exploited. By determining what the relevant events are based on the security graph, and only presenting the relevant events to the user, the amount of information that the user has to sift through is reduced, so this is beneficial.
[0024] In this regard, it should be noted that users can detect forensic events in cloud logs. In fact, oftentimes, users do sift through cloud logs to detect forensic events. However, not only is this inefficient, it is also impossible for humans to reliably and consistently detect relevant events in cloud logs, as the sheer volume of events makes this task impossible.
[0025] Furthermore, even if a human could somehow do this, a persistent copy of the events would need to be maintained (i.e., stored in memory) as the user screens each event and checks each data field of the event record against a check value. It would therefore be useful to detect cybersecurity threats in a security graph and generate a compact log that includes only events that are potentially relevant for forensic analysis, as this would greatly reduce the amount of storage (e.g., by storing only relevant events) and reduce the number of event logs that a human would need to manually review. Furthermore, it would eliminate the need for a persistent copy of events other than those relevant to the forensics log.
[0026] Figure 1 is an example network diagram 100 for describing various disclosed embodiments. In the example network diagram 100, two cloud environments are shown for simplicity, but it should be readily apparent that different configurations of computing environments may be utilized without departing from the scope of the present disclosure.
[0027] In an embodiment, the production environment 110 is implemented on a first cloud computing environment. According to an embodiment, the first cloud computing environment is deployed on a server such as Web Services (AWS), Google Cloud Platform (GCP), The production environment 110 is a computing environment that provides resources, services, etc. to, for example, client devices.
[0028] In some embodiments, the production environment 110 is implemented as a virtual private cloud (VPC) in AWS, a virtual network (VNet) in Azure, etc. According to an embodiment, the production environment 110 is used as the main environment in which the organization operates and can provide services. In some embodiments, this is to distinguish from a staging environment, which is substantially the same as the production environment but is used for testing purposes in order to test services, workloads, policies, etc. before implementation in the production environment.
[0029] In an embodiment, the production environment 110 includes a plurality of resources. A resource is a cloud entity that provides services, exposes hardware resources (e.g., processors, memory, storage devices, etc.), performs actions in a cloud computing environment, etc. In an embodiment, a resource is a workload (e.g., serverless function 112, virtual machine 114, software container cluster 116, etc.). In some embodiments, a resource is a software application deployed on a workload, device, network server, gateway, network application firewall, etc. In an embodiment, the production environment 110 includes multiple of each of the different resource types. In some embodiments, the serverless function 112 (e.g., Lambda), virtual machines 114 (e.g., Oracle VirtualBox), and software container clusters 116, such as using platform, Engines etc. to implement.
[0030] In some embodiments, production environment 110 includes a principal (not shown). In an embodiment, a principal is a cloud entity that is authorized to operate on a resource, initiate an action in production environment 110, initiate an operation on a resource, and combinations thereof. In some embodiments, a resource is also a principal, such as when operating on another resource. According to an embodiment, a principal is, for example, a user account, a service account, a role, and the like.
[0031] In some embodiments, the workloads in the production environment 110 are configured to generate activities that are recorded in the network log 118. According to an embodiment, the network log 118 is implemented as a file containing events (also referred to as data records), which correspond to actions of one or more applications. In an embodiment, the events are, for example, user calls to objects in the production environment 110, procedure calls to objects, authentication attempts, access requests, etc.
[0032] In an embodiment, a service, such as implemented as serverless function 112, is configured to generate a network log 118 (a type of cloud log). The service is configured to monitor at least one workload in production environment 110 and write events to network log 118. In an embodiment, the events are added to network log 118 as records (e.g., based on a predetermined data structure).
[0033] In some embodiments, production environment 110 is communicatively coupled to a public network 120 (such as the Internet) and inspection environment 130. In an embodiment, inspection environment 130 is implemented as a VPC deployed on a cloud computing infrastructure (such as AWS). In an embodiment, production environment 110 and inspection environment 130 are deployed using the same cloud computing infrastructure.
[0034] In some embodiments, the inspection environment 130 includes a forensic analyzer 132 and a security graph 134. Figure 5 Discussing safety diagram 134 in more detail, Figure 5 is an example of a portion of a security graph. In an embodiment, the security graph 134 is stored in a graph database (e.g. ). In an embodiment, the inspection environment 130 also includes a plurality of inspector workloads (not shown), each inspector being configured to detect network security objects in the workload of the production environment. According to an embodiment, the network security objects are malware objects, passwords, certificates, applications, vulnerabilities, exposures, misconfigurations, combinations thereof, and the like. In an embodiment, the forensic analyzer 132 is implemented as a workload (e.g., a node in a software container).
[0035] The forensic analyzer 132 is configured to access the cloud log, the network log, and the security graph 134. The forensic analyzer 132 may generate a forensic report based on any of the cloud log, the network log, the security graph, and a combination thereof. In an embodiment, the forensic report includes a portion extracted from the cloud log, a portion extracted from the network log, and the like, wherein the extracted portion is based on an identifier of the cloud entity. Figure 4 An example of a method for generating a forensic report is described in more detail.
[0036] Figure 2 is an example of a network log 200 of a cloud-based computing environment according to an embodiment. In an embodiment, the network log 200 (a cloud log) includes multiple events, each event is recorded as a line in the log. According to some embodiments, the record includes multiple data fields and their values. In an embodiment, the order of the multiple data fields corresponds to a data structure. In some embodiments, the data fields are, for example, account identifiers, interface identifiers, source addresses and destination addresses (for network messages), ports, protocols, number of bytes transmitted, number of packets transmitted, actions (e.g., accept, reject, etc.) and combinations thereof, etc.
[0037] Figure 3is an example of a role log 300 for describing a cloud computing environment of an embodiment. In an embodiment, the role log includes data records related to events based on an identifier of a subject. In some embodiments, the role log 300 includes records generated based on events associated with user accounts, service accounts, roles, etc.
[0038] For example, according to an embodiment, a first record 310 includes an event for creating a new user account. The first record 310 includes a plurality of data fields, each having a value. In some embodiments, the data field values are unique to the event. For example, the event has an event name 320 indicating that the event is associated with creating a user account at an event time 322. Other identifiers (e.g., a username 324 of the created user account) are also recorded.
[0039] Figure 4 is another example of a role log 400 for describing a cloud-based computing environment of an embodiment. In an embodiment, role log 400 includes a second record 410 indicating that user "Alice", who previously (based on event time 412) created user account "Bob", added user account "Bob" to the "Admin" group. Event name 420 indicates that user account 422 was added to the Admin group. Adding an administrator account is not common, and if this is performed by a machine that includes a vulnerability, as described herein, this may indicate that the new administrator-level account is actually exploited.
[0040] Figure 5 is an example of a security graph 500 implemented according to an embodiment. According to an embodiment, the security graph 500 represents a cloud computing environment (such as the above) in a graph database according to a predefined data schema. Figure 1 production environment 110).
[0041] In an embodiment, a cloud computing environment is represented in a graph by mapping resources, subjects, enrichments, etc. to nodes in the security graph 500. In an embodiment, nodes are generated in the security graph in response to detecting cloud entities in the cloud computing environment. In some embodiments, resource nodes are generated to represent resources (such as workloads). In some embodiments, subject nodes are generated to represent user accounts, service accounts, roles, etc. In an embodiment, enrichment nodes are generated to represent endpoint connections to public networks (e.g., the Internet), vulnerabilities, attributes of workloads, etc.
[0042] According to an embodiment, enrichment node 510 represents Internet access, such that any node connected to enrichment node 510 (e.g., by an edge) represents a workload that can access the Internet. In an embodiment, resource node 520 represents a gateway workload, which is implemented as, for example, a node in a software container cluster. According to an embodiment, second resource node 530 represents a load balancer workload, which is connected to gateway resource node 520 (representing a gateway resource) and network interface node 540 (representing a network interface) by an edge.
[0043] In an embodiment, the network interface node 540 is connected to a resource node 550 (such as a Figure 1 According to an embodiment, the virtual machine 114 includes an operating system represented by an OS node 542, an application executed on the OS of the virtual machine 114 represented by an application node 544, a user account node 546 representing a user account bound to the virtual machine 114, and a vulnerability node 548 representing a vulnerability detected as existing on or related to the virtual machine 114. According to an embodiment, the vulnerability is, for example, outdated software, a specific open port, a user account with high (i.e., excessive) privileges, and any combination thereof.
[0044] For example, in an embodiment, the checker is configured to detect vulnerabilities on the disk of virtual machine 114. A node is generated to represent virtual machine 114 in the security graph (i.e., resource node 550), a node is generated to represent the vulnerability (i.e., vulnerability node 548), and an edge is generated to connect resource node 550 to vulnerability node 548, thereby indicating that virtual machine 114 includes the detected vulnerability.
[0045] Figure 6 is a flow chart 600 of a method for generating a forensic analysis report based on a security graph, implemented according to an embodiment.
[0046] At S610, a cloud entity is selected. In an embodiment, the cloud entity is, for example, a workload type (e.g., VM, container, serverless function, etc.), an application type (e.g., software application, device, OS, gateway, load balancer, etc.), a subject (e.g., user account, service account, etc.), an enrichment, a vulnerability, a combination thereof, and the like. In an embodiment, the cloud entity selection includes an identifier of the cloud entity. The identifier is, for example, a user name, an IP address, a name from a namespace, a combination thereof, and the like.
[0047] In some embodiments, the cloud entity selection is received via a user interface (such as a graphical user interface). For example, a user may select a cloud entity from a predetermined list, and may also select a relationship between a plurality of selected cloud entities. For example, a user may indicate a selection of a virtual machine (workload type) that runs (relationship) a first application (reference type) and has (relationship) a user account (principal) that has (relationship) specific privileges, and is connected to the Internet (enrichment).
[0048] At S620, a network security threat is determined. In an embodiment, a network security threat is determined for a cloud entity based on the security graph. In some embodiments, the network security threat is, for example, a vulnerability, a misconfiguration, an exploit, etc. According to an embodiment, the misconfiguration is, for example, a database that is not password protected and should be password protected. For example, in an embodiment, the forensic analyzer is configured to receive a cloud entity selection and generate a query to the security graph that, when executed, returns results including nodes matching the selected cloud entity.
[0049] For example, in an embodiment, a vulnerability on a workload is not necessarily exploited, or even exploitable. For example, in an embodiment, a workload has a vulnerability that allows broad access, however, if the workload is determined to be inaccessible to an external network, the vulnerability cannot be exploited from outside the cloud computing environment where the workload is deployed. Therefore, it is beneficial to refer to cloud logs to further detect whether the vulnerability is exploited.
[0050] At S630, based on the selected cloud entity and the determined vulnerability, cloud logs are checked to detect events. In an embodiment, the cloud logs are, for example, network logs, role logs, and combinations thereof, etc. In some embodiments, multiple logs are checked to detect one event, multiple events, etc.
[0051] In an embodiment, the forensic analyzer is configured to examine the cloud logs based on data from the security graph. For example, according to an embodiment, the forensic analyzer is configured to query the security graph based on cloud entity selection and receive node identifiers, node attributes, identifiers of enriched nodes connected to the cloud entity, etc.
[0052] In some embodiments, the node attributes correspond to data field values (such as unique identifiers, IP addresses, workload types, user account identifiers, authentication statuses, combinations thereof, etc.). In some embodiments, the forensic analyzer is configured to extract the values of the data fields from the output received from the security graph and perform a search on the cloud log for the extracted values. In an embodiment, an event is detected when a match is generated between the data field values of the event and the values extracted from the output of the security graph query.
[0053] At S640, a forensic analysis output is generated. In an embodiment, the forensic analysis output includes at least a portion of a cloud log with the detected event. In certain embodiments, the forensic analysis output is stored instead of the cloud log. This is advantageous because a cloud log typically requires a large amount of storage space because it can easily include millions of events. By storing smaller relevant logs (which only include, for example, records related to vulnerable resources), storage space is saved while ensuring that the most relevant information remains stored. In some embodiments, a time-based portion of the cloud log is stored (e.g., the last 48 hours of events). In certain embodiments, a number-based portion of the cloud log is stored (e.g., the last 10,000 records). Therefore, in an embodiment, storing the forensic analysis output (i.e., a compact forensic event log) allows the preservation of information and data that is useful for detecting suspicious events, performing network security forensics, and the like.
[0054] Furthermore, in an embodiment, by generating a forensic analysis output, a user may significantly reduce the amount of information they need to sift through in order to determine if a vulnerability led to an exploit of the same vulnerability. Cloud logs may contain a large amount of information even in a short period of time, which is time consuming for a human to understand in order to find an indication that a vulnerability was exploited. By determining what the relevant events are based on the security graph, and only providing the user with the relevant events, the amount of information the user has to sift through is reduced, and therefore this is beneficial.
[0055] Figure 7 7 is an example schematic diagram of a forensic analyzer 132 according to an embodiment. The forensic analyzer 132 includes a processing circuit 710 coupled to a memory 720, a storage device 730, and a network interface 740. In an embodiment, the components of the forensic analyzer 700 may be communicatively connected via a bus 750.
[0056] Processing circuit 710 may be implemented as one or more hardware logic components and circuits. For example, but not limited to, illustrative types of hardware logic components that may be used include field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on a chip (SOCs), graphics processing units (GPUs), tensor processing units (TPUs), general purpose microprocessors, microcontrollers, digital signal processors (DSPs), etc., or any other hardware logic components that can perform calculations or other information operations.
[0057] The memory 720 may be volatile (eg, random access memory, etc.), non-volatile (eg, read-only memory, flash memory, etc.), or a combination thereof.
[0058] In one configuration, software for implementing one or more embodiments disclosed herein may be stored in storage device 730. In another configuration, memory 720 is configured to store such software. Software should be broadly interpreted as any type of instructions (whether referred to as software, firmware, middleware, microcode, hardware description language, or other). Instructions may include code (e.g., source code format, binary code format, executable code format, or any other suitable code format). When an instruction is executed by processing circuit 510, the instruction causes processing circuit 710 to perform various processes described herein.
[0059] The storage device 730 may be a magnetic storage device, an optical storage device, etc., and may be implemented as, for example, flash memory or other memory technology, or any other medium that may be used to store the desired information.
[0060] The network interface 740 allows the forensic analyzer 132 to communicate with, for example, a security graph, a cloud environment, etc.
[0061] It should be understood that the embodiments described herein are not limited to Figure 7 While specific architectures are shown, other architectures may equally be used without departing from the scope of the embodiments of the present disclosure.
[0062] Various embodiments disclosed herein can be implemented as hardware, firmware, software or any combination thereof. In addition, the software is preferably implemented as an application tangibly contained in a program storage unit or a computer-readable medium, and the program storage unit or the computer-readable medium is composed of a combination of part or some devices and / or devices. The application can be uploaded to a machine including any suitable architecture and executed by the machine. Preferably, the machine is implemented on a computer platform with hardware such as one or more central processing units ("CPU"), memory and input / output interface. The computer platform may also include an operating system and microinstruction code. The various processes and functions described herein may be a part of the microinstruction code or a part of the application, or any combination thereof, and they may be executed by the CPU, regardless of whether such a computer or processor is explicitly shown. In addition, various other peripheral units may be connected to the computer platform, such as additional data storage units and printing units. In addition, a non-transient computer-readable medium is any computer-readable medium other than a transient propagation signal.
[0063] All examples and conditional language cited herein are intended for teaching purposes, to help the reader understand the principles of the embodiments of the present disclosure and the concepts contributed by the inventor to promote this area, and should be interpreted as not being limited to these specifically cited examples and conditions. In addition, all statements of the principles, aspects and embodiments of the embodiments of the present disclosure and their specific examples are intended to cover their structural and functional equivalents. In addition, it is intended that such equivalents include currently known equivalents and equivalents developed in the future, that is, any element of the development that performs the same function, regardless of the structure.
[0064] It should be understood that any reference to an element using names such as "first", "second" etc. herein does not generally limit the quantity or order of these elements. On the contrary, these names are generally used as a convenient method to distinguish two or more elements or element instances herein. Therefore, reference to the first and second elements does not mean that only two elements can be used there, or that the first element must be before the second element in some way. In addition, unless otherwise stated, a group of elements includes one or more elements.
[0065] As used herein, the phrase "at least one of" followed by a list of items means that any of the listed items may be used alone, or any combination of two or more of the listed items may be used. For example, if a system is described as including "at least one of A, B, and C," the system may include only A; only B; only C; 2 As; 2 Bs; 2 Cs; 3 As; a combination of A and B; a combination of B and C; a combination of A and C; a combination of A, B, and C; a combination of 2 A and C; a combination of A, 3 Bs, and 2 Cs, and so on.
Claims
1. A method for generating a compact forensic event log based on a cloud log, the method comprising: traversing a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detecting a node representing a network security threat connected to the node representing the cloud entity; parsing a cloud log of the cloud computing environment to detect a data record, the data record comprising an attribute of the node representing the cloud entity; and Generates a compact forensic event log including detected data records.
2. The method according to claim 1, further comprising: receiving an identifier of the cloud entity; as well as The security graph is further traversed based on the received identifier to detect the node representing the cloud entity.
3. The method according to claim 1, further comprising: The data record is further inspected based on an identifier of the network security threat.
4. The method according to claim 1, further comprising: In response to detecting that the node representing the cloud entity is connected to the node representing the network security threat, the compact forensic event log is generated.
5. The method according to claim 1, wherein: The cloud log is any one of the following: a network log and a role log.
6. The method according to claim 1, wherein: The attribute is any of the following: unique identifier, IP address, workload type, user account name, role, and authentication status.
7. The method according to claim 1, wherein: The cybersecurity threats are any of the following: vulnerabilities, misconfigurations, and exploits.
8. The method according to claim 1, further comprising: The compact forensic event log is generated based on a plurality of cloud logs, each cloud log being parsed to detect data records including the attributes of the node representing the cloud entity.
9. The method according to claim 1, further comprising: storing the compact forensic event log in a storage device; as well as A time-based portion of the cloud log is stored in the storage device.
10. A non-transitory computer readable medium having stored thereon instructions for causing a processing circuit to perform a process, the process comprising: traversing a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detecting a node representing a network security threat connected to the node representing the cloud entity; parsing a cloud log of the cloud computing environment to detect a data record, the data record comprising an attribute of the node representing the cloud entity; and Generates a compact forensic event log including detected data records.
11. A system for generating a compact forensic event log based on a cloud log, the system comprising: Processing circuit; as well as a memory, the memory comprising instructions that, when executed by the processing circuit, configure the system to: traversing a security graph to detect nodes representing cloud entities in a cloud computing environment, wherein the security graph includes a representation of the cloud computing environment; detecting a node representing a network security threat connected to the node representing the cloud entity; parsing a cloud log of the cloud computing environment to detect a data record, the data record comprising an attribute of the node representing the cloud entity; and Generates a compact forensic event log including detected data records.
12. The system according to claim 11, wherein: The memory contains further instructions which, when executed by the processing circuit, further configure the system to: receiving an identifier of the cloud entity; and The security graph is further traversed based on the received identifier to detect the node representing the cloud entity.
13. The system according to claim 11, wherein: The memory contains further instructions which, when executed by the processing circuit, further configure the system to: The data record is further inspected based on an identifier of the network security threat.
14. The system according to claim 11, wherein: The memory contains further instructions which, when executed by the processing circuit, further configure the system to: The compact forensic event log is generated in response to detecting that the node representing the cloud entity is connected to a node representing the network security threat.
15. The system according to claim 11, wherein: The cloud log is any one of the following: a network log and a role log.
16. The system according to claim 11, wherein: The attribute is any of the following: unique identifier, IP address, workload type, user account name, role, and authentication status.
17. The system of claim 11, wherein: The cybersecurity threats are any of the following: vulnerabilities, misconfigurations, and exploits.
18. The system of claim 11, wherein: The memory contains further instructions which, when executed by the processing circuit, further configure the system to: The compact forensic event log is generated based on a plurality of cloud logs, each cloud log being parsed to detect data records including the attributes of the node representing the cloud entity.
19. The system of claim 11, wherein: The memory contains further instructions which, when executed by the processing circuit, further configure the system to: storing the compact forensic event log in a storage device; as well as A time-based portion of the cloud log is stored in the storage device.
