Patent Application
20230262074
The present disclosure relates generally to network security, and, more specifically, to systems and methods for identifying and modeling attack progressions in real-time into cloud-based resources.
Modern cyberattacks no longer involve a single endpoint or network phenomenon but, instead, have evolved as cyber-kill chain progressions consisting of permutations and combinations of malicious techniques interleaved with legitimate activities exhibited over multiple compute domains spanning across an entire infrastructure, often with varying degrees of temporal distance between the malicious techniques executed. Functions required for autonomous interception and response against such attacks include tracking and mapping the infrastructure as a set of continuous distributed execution trail graphs of application and system level activities, and fusing security detection results on these graphs to continuously rank and re-rank them to intercept malicious progressions as they happen. Tracking of vertical movements from the network and operating system (“OS”) to cloud accounts, and performing a distributed union of server-local subgraphs to capture progression continuation, therefore becomes a vital component towards autonomous interception and response.
In one aspect, a computer-implemented method for detecting attack continuations includes the steps of: providing a central service configured to construct an execution graph based on activities monitored by a plurality of agents deployed on respective systems; identifying, by the central service, a query initiated from a first one of the systems, the first system comprising a cloud-based instance, the query comprising a request to a server for credentials associated with the cloud-based instance; receiving, by the central service, an indication that the credentials were used to access a cloud-based service; and forming, by the central service, a connection between the first system and the cloud-based service in a global execution trail in the execution graph. Other aspects of the foregoing including corresponding systems having memories storing instructions executable by a processor, and computer-executable instructions stored on non-transitory computer-readable storage medium.
In one implementation, maintaining, by the central service, a first local execution trail associated with activities occurring at the first system; and maintaining, by the central service, a second local execution trail associated with activities occurring at the cloud-based service. Forming the connection between the first system and the cloud-based service can comprise connecting the first local execution trail with the second local execution trail. Forming the connection between the first system and the cloud-based service can comprise determining, by the central service, that the use of the credentials to access the cloud-based service resulted from the request for credentials associated with the cloud-based instance.
In one implementation, the identifying the query can comprise receiving an event indicating access to a credential uniform resource locator (URL), wherein the event is received from (i) a first one of the agents, the first agent being deployed on the cloud-based instance and/or (ii) a third-party data source monitoring access to URLs related to credentials. Monitoring a data source comprising information identifying use of an application programming interface of the cloud-based service; and receiving, from the data source, the indication that the credentials were used to access the cloud-based service. The indication that the credentials were used to access the cloud-based service can be based on either (i) information provided by a threat detection service of the cloud-based service or (ii) comparing an instance credential inventory of the cloud-based service and a log associated with the cloud-based service for credential usages.
In one implementation, the cloud-based instance has a role and the credentials are associated with the role. Receiving the indication can comprise receiving information identifying the role. Attributing to the global execution trail, by the central service, behavior exhibited at the cloud-based service following the access using the credentials. The execution graph can comprise a plurality of nodes and a plurality of edges connecting the nodes, wherein each node represents an entity comprising a process or an artifact, and wherein each edge represents an event associated with an entity.
The details of one or more implementations of the subject matter described in the present specification are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the subject matter will become apparent from the description, the drawings, and the claims.
In the drawings, like reference characters generally refer to the same parts throughout the different views. Also, the drawings are not necessarily to scale, emphasis instead generally being placed upon illustrating the principles of the implementations. In the following description, various implementations are described with reference to the following drawings.
Described herein is a unique enterprise security solution that provides for precise interception and surgical response to attack progression, in real time, as it occurs across a distributed infrastructure, whether aggressively in seconds or minutes, or slowly and steadily over hours, days, weeks, months, or longer. The solution achieves this through a novel data monitoring and management framework that continually models system level host and network activities as mutually exclusive infrastructure wide execution sequences, and bucketizes them into unique execution trails. A multimodal intelligent security middleware detects indicators of compromise (IoC) in real-time on top of subsets of each unique execution trail using rule based behavioral analytics, machine learning based anomaly detection, and other sources described further herein. Each such detection result dynamically contributes to aggregated risk scores at execution trail level granularities. These scores can be used to prioritize and identify highest risk attack trails to end users, along with steps that such end users can perform to mitigate further damage and progression of an attack.
In one implementation, the proposed solution incorporates the following primary features, which are described in further detail below: (1) distributed, high-volume, multidimensional (e.g., process, operating system, network) execution trail tracking in real time within hosts, as well as across hosts, within an infrastructure (e.g., an enterprise network); (2) determination of indicators of compromise and assignment of risk on system level entities, individual system level events, or clusters of system level events within execution trails, using behavioral anomaly based detection functions based on rule-based behavioral analytics and learned behavior from observations of user environments; (3) evaluation and iterative re-evaluation of risk of execution trails as they demonstrate multiple indicators of compromise over a timeline; and (4) concise real-time visualization of execution trails, including characterizations of the trails in terms of risk, and descriptions relating to posture, reasons for risk, and recommendations for actions to mitigate identified risks.
The techniques described herein provide numerous benefits to enterprise security. In one instance, such techniques facilitate clear visualization of the complete “storyline” of an attack progression in real-time, including its origination, movement through enterprise infrastructure, and current state. Security operations teams are then able to gauge the complete security posture of the enterprise environment. As another example benefit, the present solution eliminates the painstaking experience of top-down wading through deluges of security alerts, replacing that experience instead with real-time visualization of attack progressions, built from the bottom up. Further, the solution provides machine-based comprehension of attack progressions at fine granularity, which enables automated, surgical responses to attacks. Such responses are not only preventive to stop attack progression, but are also adaptive, such that they are able to dynamically increase scrutiny as the attack progression crosses threat thresholds. Accordingly, armed with a clear visualization of a security posture spanning an entire enterprise environment, security analysts can observe all weaknesses that an attack has taken advantage of, and use this information to bolster defenses in a meaningful way.
As used herein, these terms have the following meanings, except where context dictates otherwise.
“Agent” or sensor” refers to a privileged process executing on a host (or virtual machine) that instruments system level activities (set of events) generated by an operating system or other software on the host (or virtual machine).
“Hub” or “central service” refers to a centralized processing system, service, or cluster which is a consolidation point for events and other information generated and collected by the agents.
“Execution graph” refers to a directed graph, generated by an agent and/or the hub, comprising nodes (vertices) that represent entities, and edges connecting nodes in the graph, where the edges represent events or actions that are associated with one or more of the nodes to which the edges are connected. Edges can represent relationships between two entities, e.g., two processes, a process and a file, a process and a network socket, a process and a registry, and so on. An execution graph can be a “local” execution graph (i.e., associated with the events or actions on a particular system monitored by an agent) or a “global” or “distributed” execution graph (i.e., associated with the events or actions on multiple systems monitored by multiple agents).
“Entity” refers to a process or an artifact (e.g., file, directory, registry, socket, pipe, character device, block device, or other type).
“Event” or “action” refers to a system level or application level event or action that can be associated with an entity, and can include events such as create directory, open file, modify data in a file, delete file, copy data in a file, execute process, connect on a socket, accept connection on a socket, fork process, create thread, execute thread, start/stop thread, send/receive data through socket or device, and so on.
“System events” or “system level activities” and variations thereof refer to events that are generated by an operating system at a host, including, but not limited to, system calls.
“Execution trail” or “progression” refers to a partition or subgraph of an execution graph, typically isolated by a single intent or a single unit of work. For example, an execution trail can be a partitioned graph representing a single SSH session, or a set of activities that is performed for a single database connection. An execution trail can be, for example, a “local” execution trail that is a partition or subgraph of a local execution graph, or a “global” or “distributed” execution trail that is a partition or subgraph of a global execution graph.
“Attacker” refers to an actor (e.g., a hacker, team of individuals, software program, etc.) with the intent or appearance of intent to perform unauthorized or malicious activities. Such attackers may infiltrate an enterprise infrastructure, secretly navigate a network, and access or harm critical assets.
In one implementation, a deterministic system facilitates observing and addressing security problems with powerful, real-time, structured data. The system generates execution graphs by deploying agents across an enterprise infrastructure. Each agent instruments the local system events generated from the host and converts them to graph vertices and edges that are then consumed by a central processing cluster, or hub. Using the relationships and attributes of the execution graph, the central processing cluster can effectively extract meaningful security contexts from events occurring across the infrastructure.
Each agent A-G monitors system level activities in terms of entities and events (e.g., operating system processes, files, network connections, system calls, and so on) and creates, based on the system level activities, an execution graph local to the operating system on which the agent executes. For purposes of illustration,
The local execution graphs created by the agents A-G are sent to the central service 100 (e.g., using a publisher-subscriber framework, where a particular agent publishes its local execution graph or updates thereto to the subscribing central service 100). In some instances, the local execution graphs are compacted and/or filtered prior to being sent to the central service 100. The central service consumes local execution graphs from a multitude of agents (such as agents A-G), performs in-memory processing of such graphs to determine indicators of compromise, and persists them in an online data store. Such data store can be, for example, a distributed flexible schema online data store. As and when chains of execution perform lateral movement between multiple operating systems, the central service 100 performs stateful unification of graphs originating from individual agents to achieve infrastructure wide execution trail continuation. The central service 100 can also include an application programming interface (API) server that communicates risk information associated with execution trails (e.g., risk scores for execution trails at various granularities).
System Event Tracker 401 is responsible for monitoring systems entities, such as processes, local files, network files, and network sockets, and events, such as process creation, execution, artifact manipulation, and so on, from the host operating system. In the case of the Linux operating system, for example, events are tracked via an engineered, high-performance, lightweight, scaled-up kernel module that produces relevant system call activities in kernel ring buffers that are shared with user space consumers. The kernel module has the capability to filter and aggregate system calls based on static configurations, as well as dynamic configurations, communicated from other agent user space components.
In-memory Trail Processor 402 performs numerous functions in user space while maintaining memory footprint constraints on the host, including consuming events from System Event Tracker 401, assigning unique local trail identifiers to the consumed events, and building entity relationships from the consumed events. The relationships are built into a graph, where local trail nodes can represent processes and artifacts (e.g., files, directories, network sockets, character devices, etc.) and local trail edges can represent events (e.g., process triggered by process (fork, execve, exit); artifact generated by process (e.g., connect, open/O_CREATE); process uses artifact (e.g., accept, open, load)). The In-memory Trail Processor 402 can further perform file trust computation, dynamic reconfiguration of the System Event Tracker 401, and connecting execution graphs to identify intra-host trail continuation. Such trail continuation can include direct continuation due to intra-host process communication, as well as indirect setting membership of intra-host trails based on file/directory manipulation (e.g., a process in trail A uses a file generated by trail B).
Event Compactor 403 is an in-memory graph compactor that assists in reducing the volume of graph events that are forwarded to the central service 100. The Event Compactor 403, along with the System Event Tracker 401, is responsible for event flow control from the agent 400. Embedded Persistence 404 assists with faster recovery of In-memory Trail Processor 402 on user space failures, maintaining constraints of storage footprint on the host. Event Forwarder 405 forwards events transactionally in a monotonically increasing sequence from In-memory Trail Processor 402 to central service 100 through a publisher/subscriber broker. Response Receiver 406 receives response events from the central service 100, and Response Handler 407 addresses such response events.
In addition to the foregoing primary components, agent 400 includes auxiliary components including Bootstrap 408, which bootstraps the agent 400 after deployment and/or recovery, as well as collects an initial snapshot of the host system state to assist in local trail identifier assignments. System Snapshot Forwarder 409 periodically forwards system snapshots to the central service 100 to identify live entities in (distributed) execution trails. Metrics Forwarder 410 periodically forwards agent metrics to the central service 100 to demonstrate agent resource consumption to end users. Discovery Event Forwarder 411 forwards a heartbeat to the central service 100 to assist in agent discovery, failure detection, and recovery.
Publisher/Subscriber Broker 501 provides horizontally scalable persistent logging of execution trail events published from agents and third-party solutions that forward events tagged with host operating system information. In-memory Local Trail Processor 502 is a horizontally scalable in-memory component that is responsible for the consumption of local trail events that are associated with individual agents and received via the Publisher/Subscriber Broker 501. In-memory Local Trail Processor 502 also consumes third party solution events, which are applied to local trails. In-memory Local Trail Processor 502 further includes an in-memory local trail deep processor subcomponent with advanced IoC processing, in which complex behavior detection functions are used to determine IoCs at multi-depth sub-local trail levels. Such deep processing also includes sub-partitioning of local trails to assist in lightweight visualizations, risk scoring of IoC subpartitions, and re-scoring of local trails as needed. In addition, In-memory Local Trail Processor 502 includes a trending trails cache that serves a set of local trail data (e.g., for top N local trails) in multiple formats, as needed for front end data visualization.
Trail Merger 503 performs stateful unification of local trails across multiple agents to form global trails. This can include the explicit continuation of trails (to form global trails) based on scenarios of inter-host operating system process communication and scenarios of inter-host operating system manipulation of artifacts (e.g., process in <“host”:“B”, “local trail”:“123”> uses a network shared file that is part of <“host”:“A”, “local trail”:“237”>). Trail Merger 503 assigns unique identifiers to global trails and assigns membership to the underlying local trails.
Transactional Storage and Access Layer 504 is a horizontally-scalable, consistent, transactional, replicated source of truth for local and global execution trails, provision for flexible schema, flexible indexing, low latency Create/Read/Update operations, time to live semantics, and time range partitioning. In-memory Global Trail Processor 505 uses change data captured from underlying transactional storage to rescore global trails when their underlying local trails are rescored. This module is responsible for forwarding responses to agents on affected hosts, and also maintains a (horizontally-scalable) retain-best cache for a set of global trails (e.g., top N trails). API Server 506 follows a pull model to periodically retrieve hierarchical representations of the set of top N trails (self-contained local trails as well as underlying local trails forming global trails). API Server 506 also serves as a spectator of the cache and storage layer control plane. Frontend Server 507 provides a user-facing web application that provides the visualization functionality described herein.
Central service 100 further includes Offline Frameworks 508, including a behavioral model builder, which ingests incremental snapshots of trail edges from a storage engine and creates probabilistic n-gram models of intra-host process executions, local and network file manipulations, intra- and cross-host process connections. This framework supports API parallelization as well as horizontal scalability. Offline Frameworks 508 further include search and offline reports components to support search and reporting APIs, if required. This framework supports API parallelization as well as horizontal scalability.
Auxiliary Modules 509 in the central service 100 include a Registry Service that serves as a source of truth configuration store for global and local execution trail schemas, static IoC functions, and learned IoC behavioral models; a Control Plane Manager that provides automatic assignment of in-memory processors across multiple servers, agent failure detection and recovery, dynamic addition of new agents, and bootstrapping of in-memory processors; and a third party Time Synchronization Service that provides consistent and accurate time references to a distributed transactional storage and access layer, if required.
Because attacks progress gradually across multiple systems, it is difficult to map which security violations are related on distributed infrastructure. Whereas human analysts would normally manually stitch risk signals together through a labor-intensive process, the presently described attack progression tracking system facilitates the identification of connected events.
In modern systems, a process often communicates with another process via connection-oriented protocols. This involves (1) an initiator creating a connection and (2) a listener accepting the request. Once a connection is established, the two processes can send and/or receive data between them. An example of this is the TCP connection protocol. One powerful way to monitor an attacker’s movement across infrastructure is to closely follow the connections between processes. In other words, the connections between processes can be identified, it is possible to determine how the attacker has advanced through the infrastructure.
Agents match connecting processes by instrumenting connect and accept system calls on an operating system. These events are represented in an execution graph as edges. Such edges are referred to herein as “atomic” edges, because there is a one-to-one mapping between a system call and an edge. Agents are able to follow two kinds of connections: local and network. Using a TCP network connection as an example, an agent from host A instruments a connect system call from process X, producing a mapping:
The agent from host B instruments an accept system call from process Y, producing a mapping:
The central service, upon receiving events from both agents A and B, determines that there is a matching relationship between the connect and accept calls, and records the connection mapping between X→Y.
Now, using a Unix domain socket local host connection as an example, an agent from host A instruments a connect system call from process X, producing a mapping:
Here, kaddr refers to the kernel address of the internal address struct, each unique per sender and receiver at the time of connection. The agent from the same host A instruments an accept system call from process Y, producing a mapping:
The central service, upon receiving both events from agent A, determines that there is a matching relationship between the connect and accept calls, and records the connection mapping between X→Y.
Many network-facing processes follow the pattern of operating as a server. A server process accepts many connections simultaneously and performs actions that are requested by the clients. In this particular case, there is a multiplexing relationship between incoming connections and their subsequent actions. As shown in
There are two implied edge types that are produced by agents: hands-off implied edges and session-for implied edges. A hands-off implied edge is produced when an agent observes that a parent process clones a child process with an intent to handing over a network socket that it received. More specifically, an agent looks for the following behaviors using its state machine:
A session-for implied edge is produced when an agent observes a worker thread taking over a network socket that has been received by another thread (typically, the main thread). More specifically, an agent looks for the following behaviors using its state machine:
The central service can consume the atomic and the implied edges to create a trail that tracks the movement of an attacker, which is, in essence, a subset of all the connections that are occurring between processes. The central service has an efficient logic which follows a state transition, as well. By employing both of the techniques above, it can advance the following state machine:
The execution graphs each agent produces can be extensive in depth and width, considering they track events for a multitude of processes executing on an operating system. To emphasize this,
A large execution graph is difficult to process for two reasons. First, the virtually unbounded number of vertices and edges prevents efficient pattern matching. Second, grouping functionally unrelated tasks together may produce false signals during security analysis. To process the execution graph more effectively, the present system partitions the graph into one or more execution trails. In some implementations, the graph is partitioned such that each execution trail (subgraph) represents a single intent or a single unit of work. An “intent” can be a particular purpose, for example, starting a file transfer protocol (FTP) session to download a file, or applying a set of firewall rules. A “unit of work” can be a particular action, such as a executing a scheduled task, or executing a process in response to a request.
“Apex points” are used to delineate separate, independent partitions in an execution graph. Because process relationships are hierarchical in nature, a convergence point can be defined in the graph such that any subtree formed afterward is considered a separate independent partition (trail). As such, an Apex point is, in essence, a breaking point in an execution graph.
A process is determined to be an Apex point if it produces sub-graphs that are independent of each other. In one implementation, the following rules are used to determine whether an Apex point exists: (1) the process is owned directly by the initialization process for the operating system (e.g., the “init” process); or (2) the process has accepted a connection (e.g., the process has called accept ( ) on a socket (TCP, UDP, Unix domain, etc.)). If a process meets one of the foregoing qualification rules, it is likely to be servicing an external request. Heuristically speaking, it is highly that such processes would produce subgraphs with different intents (e.g., independent actions caused by different requests).
After the execution graphs are partitioned as individual trails, security risks associated with each subgraph can be identified. Risk identification can be performed by the central service and/or individual agents.
Risks can be identified using predefined sets of rules, heuristics, machine learning, or other techniques. Identified risky behavior (e.g., behavior that matches a particular rule, or is similar to a learned malicious behavior) can have an associated risk score, with behaviors that are more suspicious or more likely to malicious having higher risk scores than activities that may be relatively benign. In one implementation, rules provided as input to the system are sets of one or more conditional expressions that express system level behaviors based on operating system call event parameters. These conditions can be parsed into abstract syntax trees. In some instances, when the conditions of a rule are satisfied, the matching behavior is marked as an IoC, and the score associated with the rule is applied to the marked behavior. The score can be a predefined value (see examples below). The score can be defined by a category (e.g., low risk, medium risk, high risk), with higher risk categories having higher associated risk scores.
The rules can be structured in a manner that analyzes system level activities on one or more of the above dimensions. For example, a frequency rule can include a single conditional expression that expresses a source process invoking a certain event multiple times aggregated within a single time bucket and observed across a window comprising multiple time buckets. As graph events are received at the central service from individual agents, frequencies of events matching the expressions can be cached and analyzed online. Another example is an event (edge) rule, which can include a single conditional expression that expresses an event between two entities, such as process/thread manipulating process, process/thread manipulating file, process/thread manipulating network addresses, and so on. As graph events are streamed from individual sensors to the central service, each event can be subjected to such event rules for condition match within time buckets. As a further example, a path rule includes multiple conditional expressions with the intent that a subset of events taking place within a single path in a graph demonstrate the behaviors encoded in the expressions. As events are streamed into the central service, a unique algorithm can cache the prefix expressions. Whenever an end expression for the rule is matched by an event, further asynchronous analysis can be performed over all cached expressions to check whether they are on the same path of the graph. An identified path can be, for example, process A executing process B, process C executing process D, and so on. Another example is a cluster rule, which includes multiple conditional expressions with the intent that a subset of events taking place across different paths in a graph demonstrates the behaviors encoded in the expressions. Lowest common ancestors can be determined across the events matching the expressions. One of skill will appreciate the numerous ways in which risks can be identified and scored.
As risks are identified, the central service tracks the risk score at the trail level. Table 1 presents a simple example of how a risk score accumulates over time, using simple edge risks, resulting in a total risk for the execution trail of 0.9.
In some implementations, risk scores for IoCs are accumulated to the underlying trails as follows. Certain IoCs are considered “anchor” IoCs (i.e., IoCs that are independently associated with risk), and the risk scores of such anchor IoCs are added to the underlying trail when detected. The scores of “dependent” IoCs are not added to the underlying trail if an anchor IoC has not previously been observed for the trail. A qualifying anchor IoC can be observed on the same machine or, if the trail has laterally moved, on a different machine. For example, the score of a privilege escalation function like sudo su may not get added to the corresponding trail unless the trail has seen an anchor IoC. Finally, the scores of “contextual” IoCs are not accumulated to a trail until the score of the trail has reached a particular threshold.
Using the connection matching techniques described above, the central service can form a larger context among multiple systems in an infrastructure. That is, the central service can piece together the connected trails to form a larger aggregated trail (i.e., a global trail). For example, referring back to
The partitioned trails in the execution graphs are independent in nature, but this is not to say that they do not interact with each other. On the contrary, the risk score of one trail can be affected by the “influence” of another trail. With reference to
In one implementation, a trail is “influenced” by the risk score associated with another trail when the first trail executes or opens an artifact produced by the other trail (in some instances, opening an artifact includes accessing, modifying, copying, moving, deleting, and/or other actions taken with respect to the artifact). When the influence-by relationship is formed, the following formula is used so that the risk score of influencer is absorbed.
In the above formula, RB is the risk score associated with Trail B, Rinfuencer is the risk score associated with the influencer (malware script), and α is a weighting factor between 0 and 1.0. The exact value of α can be tuned per installation and desired sensitivity. The general concept of the foregoing is to use a weighted running average (e.g., exponential averaging) to retain a certain amount of the risk score of the existing trail (here, Trail B), and absorb a certain amount of risk score from the influencer (here, malware.sh).
Two risk transfers occur in
To further understand how trail risk transfer is performed, the concept of “risk momentum” will now be explained. Risk momentum is a supplemental metric that describes the risk that has accumulated thus far beyond a current local trail. In other words, it is the total combined score for the global trail. An example of risk momentum is illustrated in
It is possible that a local execution trail does not exhibit any risky behavior, but its preceding trails have accumulated substantial risky behaviors. In that situation, the local execution trail has a low (or zero) risk score but has a high momentum. For example, referring back to
That is, the base risk score for an artifact (ArtifactBase) is calculated by multiplying a constant β to the sum of the current risk momentum (RiskMomentum) and risk score of the current execution trail (RiskScore). β is a weighting factor, typically between 0.0 and 1.0. Using the above equation, a local execution trail may not exhibit risky behavior as a given moment, but such trail can still produce a non-zero artifact base score in the risk momentum is non-zero.
A trail that then accesses or executes an artifact is influenced by the base score of the artifact, per Equation 1, above (Rinfluencer is the artifact base score). Accordingly, although trails are partitioned in nature, risk scores are absorbed and transferred to each other through influence-by relationships, which results in the system providing an accurate and useful depiction of how risk behaviors propagate through infrastructure.
Using the techniques described herein, an attacker’s lateral movement from one or more source machines to one or more target machines over Remote Desktop Protocol (RDP) can be identified and tracked in execution trails. Multiple RDP sessions can source from different clients for the same logon, and the hub (central service) can track this behavior to detect lateral movement and construct continuing execution trails representing a sequence of attacks.
In one implementation, detection of RDP lateral movement is a two-part process. In part one, RDP and logon events are collected in real-time. As earlier discussed, agents listen for various events on local systems. These events can include remote network connection events, such as events indicating the occurrence of an RDP logon or an RDP reconnect to an existing session. In part two, the hub uses the events and/or local execution trails built by the agents to construct a remote network connection activity map. This map, in combination with other system events, is used to build an execution graph representing historical attack progression and trail continuation when an attacker moves from one client to another, establishing multiple remote network connection (e.g., RDP) sessions over a period of time.
With respect to part one, an agent can generate an RDP logon or RDP reconnect event after processing a set of RDP and logon events. An RDP logon can be indicated by the following set of Microsoft Windows events: TCP Accept, RDP Event Id 131, 65, 66, Logon Event Id 4624-1, 4624-2. Using example connection data for purposes of illustration, the data fields for these events can include the following information.
RDP Event Id 65: This event immediately follows RDP Event Id 131 and can be used to connect IP/port to ConnectionName.
<Data Name=“ConnectionName”>RDP-Tcp#3</Data>
RDP Event Id 66: This event indicates the RDP connection is complete.
Logon Events 4624: Two logon events are generated. The events can be evaluated based on the “LogonType” field. LogonType = 10 (Remote logon) or 3 (Network) indicates a remote logon.
By connecting data from the foregoing events (TcpAccept, RDP Event Id 131, 65 and 66, and Logon Events 4624), it can be determined that an RDP logon event has been initiated with the following attributes:
An RDP reconnect event includes the same events as an RDP logon event, with the addition of a session reconnect event (Event Id 4778). The session reconnect event describes the previous logon session that has been taken over by the new RDP connection, and can include the following data fields:
Based on this event (Event Id 4778), the agent obtains the LogonID and Elevated LogonID for the previously existing session which has been taken over by the new RDP connection.
Because the nature of RDP-based lateral movements is unique compared to typical client-server based movements, an execution trail continuation algorithm is used to union (merge) execution graphs tracking RDP-based activity. For purposes of illustration,
Moving forward in time, an RDP client executing on Host A issues a process connect communication event (e.g., for an inter-process connection between hosts) to connect to Host B. The agent operating on Host A identifies the process connect communication event and transmits a representation of the event to the hub, which receives and caches the event representation through In-memory Local Trail Processor 502. To illustrate the present example, the connect event representation can have the following properties:
An RDP server executing on Host B hands off the incoming connection from Host A to a new logon session. The agent operating on Host B identifies the new session event and transmits a representation of the event to the hub, which receives and caches the event representation through In-memory Local Trail Processor 502. The new session event representation can have the following properties:
The hub creates a local trail vertex in the form of host:TargetLogonId-ElevatedLogonId-ConnectionName. Trail Merger 503 in the hub then performs a distributed graph union find to create a graph edge 1310 between local trail A:4178909 and local trail B:0x8822de-0x8822cc-RDP-Tcp#3 (depicted in
In one implementation, upon the creation of a new process in the new logon session on Host B, the following can occur. The hub receives an event from the agent on Host B identifying a process start edge event (i.e., an event associated with the creation of a graph edge between a parent process vertex and a child process vertex, signifying the launching of a new process). Local Trail Processor 502 caches the event until it receives a Windows audit event, AuditProcessCreate, signifying the creation of a process, from the same agent for the same process identifier associated with the process start edge event. The AuditProcessCreate event provides an ElevatedLogonId or a TargetLogonId, as well as an RDP session name (RDP-Tcp#3). A Window KProcessStart event associated with the creation of the process is also received from the agent. Following the arrival of both events, the hub consults the in-memory key-value store to retrieve logon metadata (TargetLogonId-ElevatedLogonId) and populates the same (in this example, 0x8822de-0x8822cc) in a vertex in the local execution trail (here, local trail B:0x8822de-0x8822cc-RDP-Tcp#3) associated with the process created in the new logon session. The current RDP connection identifier is assigned the local execution trail identifier (B:0x8822de-0x8822cc-RDP-Tcp#3) for the KProcessStart event.
The new process can continue execution within the logon session on Host B. Further execution continuation from the process (e.g., system activities relating to files, network connections, etc.) results in the creation of edges within the execution graph, and metadata from the graph vertex associated with the process is used to assign the local execution trail identifier (B:0x8822de-0x8822cc-RDP-Tcp#3) to the edges. The resulting distributed execution graph from the above events is illustrated in
Moving forward in time, an RDP client executing on Host C issues a process connect communication event (e.g., for an inter-process connection between hosts) to connect to Host B. The agent operating on Host C identifies the process connect communication event and transmits a representation of the event to the hub, which receives and caches the event representation through In-memory Local Trail Processor 502. To illustrate the present example, the connect event representation can have the following properties:
The RDP server executing on Host B hands off the incoming connection from Host C to the currently existing logon session with Host A. The agent operating on Host C identifies the initiation of the reconnect event and transmits a representation of the event to the hub, which receives and caches the reconnect event representation through In-memory Local Trail Processor 502. The reconnect event representation can have the following properties (because the existing logon session is reused, both TargetLogonId and ElevatedLogonId values remain the same):
The hub creates a local trail vertex in the form of host:TargetLogonId-ElevatedLogonId-ConnectionName. Trail Merger 503 in the hub then performs a distributed graph union find to create a graph edge 1350 between local trail C:2316781 and local trail B:0x8822de-0x8822cc-RDP-Tc#12 (depicted in
After the session reconnect, upon the creation of a new process in the session on Host B, the following can occur. The hub receives an event from the agent on Host B identifying a process start edge event. Local Trail Processor 502 caches the event until it receives AuditProcessCreate and KProcessStart events from the same agent for the same process identifier associated with the process start edge event. The AuditProcessCreate event provides an ElevatedLogonId or a TargetLogonId, and provides an RDP session name (RDP-Tcp#12). Following the arrival of both events, the hub consults the in-memory key-value store to retrieve logon metadata (TargetLogonId-ElevatedLogonId) and populates the same (in this example, 0x8822de-0x8822cc) in a vertex in the local execution trail (here, local trail B:0x8822de-0x8822cc-RDP-Tcp#12) associated with the process created in the existing session. The current RDP connection identifier is assigned the local execution trail identifier (B:0x8822de-0x8822cc-RDP-Tcp#12) for the KProcessStart event.
The new process can continue execution within the existing session on Host B. Further execution continuation from the process (e.g., system activities relating to files, network connections, etc.) results in the creation of edges within the execution graph, and metadata from the graph vertex associated with the process is used to assign the local execution trail identifier (B:0x8822de-0x8822cc-RDP-Tcp#12) to the edges. The resulting distributed execution graph from the above events is illustrated in
Using the techniques described herein, an attacker’s lateral movement from one or more source machines to one or more target machines using a remote execution function can be identified and tracked in execution trails. Remote execution functions include tools that allow an attacker to perform actions on a remote host, such as executing commands or creating processes. PsExec.exe and WMI.exe are two of the most commonly used tools by attackers for lateral movement. PsExec and WMI are also popular tools used by system administrators and, as such, are readily available to attackers.
PsExec is a component of the Windows Sysinternals suite of tools provided by Microsoft. It allows attackers to execute commands or create processes on a remote host. PsExec relies on communication over Server Message Block (SMB) port 445 using named pipes. It connects to ADMIN$ share, uploads PEXECSVC.exe and uses Service Control Manager’s (SCM) remote procedure calls (RPC) services on port 135 for remote execution. The newly created process creates a named pipe that can be used to interact with a remote attacker.
Windows Management Instrumentation (WMI) is a Microsoft Windows administration mechanism to provide a uniform environment to manage local and remote Windows system components. WMI relies on WMI service, SMB (port 445) and RPC services (port 135) to execute commands or create processes on a remote host. The hub (central service) can detect lateral movement involving remote execution functions, including PsExec and WMI, and construct execution trails representing a sequence of attacks across multiple hosts in an enterprise network.
In one implementation, detection of remote execution function lateral movement is a two-part process. In part one, various relevant events are collected in real-time. As earlier discussed, agents listen for and capture various events on local systems. These events can include TCP connects, TCP accepts, logon events, and process creation events. The events can be linked together to detect lateral movements. In part two, the hub uses the events and/or local execution trails built by the agents to construct an execution graph representing lateral movement attack progression and trail continuation when an attacker moves from one host to another over a period of time. Examples of lateral movement events will now be described for PsExec and WMI; however, one will appreciate that similar events can be captured and similar techniques applied for other remote execution functions that operate in like manners.
In the case of PsExec, agents can capture the following events useful in determining PsExec lateral movement trail continuation.
TCP Connect to a remote server: This event represents the initiation of a TCP connection on a client to a remote server. Consider, for example, that PsExec attempts to connect to a remote server using the command “.\PsExec \\research-02 ipconfig”. Following this command, the PsExec client requests svchost.exe (Windows Service Host process) to establish a TCP connection to a remote server. Svchost.exe then delegates this connection to the PsExec process running locally. Using example connection data for purposes of illustration, the data fields for the TCP Connect event captured by the agent on the client system can include the following information:
TCP Accept on remote server: This event represents a server accepting the TCP connection from a remote client. Continuing with the above example connection information, data fields captured in the event by the agent on the server can include:
Authentication on remote server: The authentication of the remote client generates a Windows log event ID 4624 (successful logon) on the server. Information associated with the event captured by the agent on the server can include:
Remote process creation using PsExec: The creation of a new process on the server generates a Windows log event ID 4688 (new process creation) on the server. Information associated with the event captured by the agent on the server can include:
In the case of WMI, agents can capture the following events useful in determining WMI lateral movement trail continuation.
TCP Connect to a remote server: This event represents the initiation of a TCP connection on a client to a remote server. Consider, for example, that a WMI client attempts to connect to a remote server using the command “wmic /NODE:<ip-address> /USER: “Administrator” process call create “ipconfig””. Using example connection data for purposes of illustration, the data fields for the TCP Connect event captured by the agent on the client system can include the following information:
TCP Accept on remote server: This event represents a server accepting the TCP connection from a remote client. Continuing with the above example connection information, data fields captured in the event by the agent on the server can include:
Authentication on remote server: The authentication of the remote client generates a Windows log event ID 4624 (successful logon) on the server. Information associated with the event captured by the agent on the server can include:
Remote process creation using WMI: The creation of a new process on the server generates a Windows log event ID 4688 (new process creation) on the server. Information associated with the event captured by the agent on the server can include:
The steps for performing the above mentioned execution trail continuation algorithm involving remote execution functions will now be described.
On Host B, a remote execution function client (e.g., PsExec.exe or WMIC.exe) issues an interprocess connect communication event. The Local Trail Processor at the hub receives and caches a CONNECT event from the agent executing on Host B. Using example connection data, the CONNECT event can include the following properties:
As a result of the of the remote execution function client connection from Host B to Host C, the hub receives from the agent executing on Host C the TCP Accept, successful logon 4624, and process creation 4688 events, as earlier described. It should be noted that, while the 4688 event is expected to arrive at the hub after the 4624 event, the ordering among the TCP Accept event and the other two events is not guaranteed.
The following actions are performed by the hub. The hub receives a TCP Accept event from the agent on Host C, including information identifying the relevant TCP/IP tuple (192.168.137.1:54461:192.168.137.10:445). It generates a synthetic trail identifier based on remote host:remote port. For example, the synthetic trail identifier can take the form of “Synthetic trail id: C:t1”. The Local Trail Processor sends an Accept event to the Trail Merger, for example, as follows:
On receiving the successful logon 4624 event, the hub maps the remote source IP address and port (here, 192.168.137.1:54461, on Host B) to the logon identifier in the remoteIpLogonMap cache. The logon identifier is also reverse mapped to the same source IP address and port combination in another key-value store (referred to hereinafter as “logonTupleMap”). On receiving the process creation 4688 event resulting from the creation of the remote process with local trail identifier C:t2, the hub maps the logon identifier to the local trail identifier (C:t2) in the logonTrailsMap cache. Then, logonTupleMap is queried with the logon identifier to retrieve a remote host:remote port combination. If such combination exists in logonTupleMap, AcceptMap is queried with such combination to identify a corresponding valid synthetic trail identifier. In the instant case, querying AcceptMap with 192.168.137.1:54461 retrieves the synthetic trail identifier C:t1. If a valid trail (e.g., C:t1) exists, events in the following form are sent to the Trail Merger:
The Trail Merger in the hub receives the following events:
The resulting distributed execution graph is depicted in
In one implementation, the present system includes a multimodal security middleware architecture that enhances execution graphs by supplementing the graphs with detection function results derived from multiple sources rather than a single source (e.g., events identified by agents executing on host systems). The multimodal security middleware is responsible for enhancing activity postures into security postures, in online, real-time, as well as near-real time fashion. Multimodal sources can include (1) rule based online graph processing analytics, (2) machine learning based anomaly detection, (3) security events reported from host operating systems, (4) external threat intelligence feeds, and (5) preexisting silo security solutions in an infrastructure. Detection results from each of these sources can be applied to the underlying trails, thereby contributing to the riskiness of an execution sequence developing towards an attack progression. Being multimodal, if an activity subset within an execution trail is detected as an indicator of compromise by multiple sources, the probability of false positives on that indicator of compromise is lowered significantly. Moreover, the multimodal architecture ensures that the probability of overlooking an indicator of compromise is low, as such indicators will often be identified by multiple sources. A further advantage of the multimodal architecture is that specific behaviors that cannot be expressed generically, such as whether a host should communicate to a particular target IP address, or whether a particular user should ever log in to a particular server, can be reliability detected by the system.
In one implementation, the multimodal middleware includes an online component and a nearline component. Referring back to
Security information from external solutions are ingested by the nearline component, and the middleware contextualizes the information with data obtained from sensors. For example, a firewall alert can take the form source ip:source port to target ip:target port traffic denied. The middleware ingests this alert and searches for a process network socket relationship from the subgraph, where the network socket matches the above source ip:source port, target ip:target port. From this, the middleware is able to determine to which trail to map the security event. The score of the event can be derived from the priority of the security information indicated by the external solution from which the information was obtained. For example, if the priority is “high”, a high risk score can be associated with the event and accumulated to the associated trail.
Operating systems generally have internal detection capabilities. The middleware can ingest security events reported from host operating systems in the same manner described above with respect to the security information obtained from external solutions. The nearline component of the middleware is also able to ingest external threat intelligence feeds, such as alerts identifying process binary names, files, or network IP addresses as suspicious. The middleware can contextualize information received from the feeds by querying entity relationships to determine which events in which trails are impacted by the information. For example, if a particular network IP address is blacklisted, each trail containing an event associated with the IP (e.g., process connects to a socket where the remote IP address is the blacklisted address) can be rescored based on a priority set by the feed provider.
Within the online component, the rule-based graph stream processing analytics subcomponent works inline with streams of graph events that are emitted by system event tracking sensors executing on operating systems. This subcomponent receives a set of rules as input, where each rule is a set of one or more conditional expressions that express system level behaviors based on OS system call event parameters. The rules can take various forms, as described above.
The machine learning based anomaly detection subcomponent will now be described. In some instances, depending on workloads, certain behavioral rules cannot be generically applied on all hosts. For example, launching a suspicious network tool may be a malicious event generally, but it may be the case that certain workloads on certain enterprise servers are required to launch the tool. This subcomponent attempts to detect anomalies as well as non-anomalies by learning baseline behavior from each individual host operating system over time. It is to be appreciated that various known machine learning and heuristic techniques can be used to identify numerous types of anomalous and normal behaviors. Behaviors detected by the subcomponent can be in the form of, for example, whether a set of events are anomalous or not (e.g., whether process A launching process B is an anomaly when compared against the baseline behavior of all process relationships exhibited by a monitored machine). This detection method is useful in homogenous workload environments, where deviation from fixed workloads is not expected. Detected behaviors can also be in the form of network traffic anomalies (e.g., whether a host should communicate or receive communicate from a particular IP address) and execution anomalies (e.g., whether a source binary A should directly spawn a binary B, whether some descendant of source binary A should ever spawn binary B, etc.). The machine learning based anomaly detection subcomponent provides a score for anomalies based on the standard deviation from a regression model. The score of a detected anomaly can be directly accumulated to the underlying trail.
In one implementation, the present system aims at detecting an attacker’s vertical movement from one or more source machines to one or more target cloud roles through a metadata instance credential. The present system aims to capture the attack trail-continuation when the attack is performed using metadata instance credentials.
The only publicly known vertical movement technique from network/operating system (OS) to a cloud environment is stealing an instance metadata credential from the endpoint and using the credential in the cloud environment. An attacker can use stolen instance credentials to gain access to all cloud resources accessible by the instance role. When compute instances are created, a role is created in the cloud identity and access management system can be assigned to the compute instance. The role is identified by the metadata instance credentials. Each compute instance in the cloud such as AWS EC2, Lambda, and ECR can access its own instance credential through the metadata database service. Similar services exists on Azure and GCP and the access mechanisms are similar. This present system detects an attacker with access to a compromised compute instance obtaining the instance credential and accessing cloud resources using the instance credential.
In one implementation, the present system may extend a distributed execution graph as described herein to include cloud native events and present execution trails that navigate across cloud infrastructure instances and services.
The metadata service may provide and/or return instance credentials to the Host C (represented by connector 1604). The agent on Host C may detect and collect the returned instance credentials. The hub may receive the collected instance metadata credential URL requests and the returned instance credentials from the agent on Host C. If the collection of the instance metadata credential URL requests is done by third-party agents, the hub may filter the instance metadata credential URLs.
The Host C may provide and/or return the instance credential to the attacker machine. The attacker may use the instance credential to access the corresponding cloud service (represented by connector 1606). In part two, the hub may identify the instance credential being used in the cloud server. The hub may monitor cloud native logs on a cloud application programming interface of the cloud service to identify use of the instance credential. Examples of monitored cloud native logs on cloud APIs include AWS CloudTrail, Guarduty, CloudWatch and corresponding data sources in other cloud providers such as GCP and Azure. In part three, the hub may use the collected events to construct a credential usage map. The credential usage map may be used in combination with other events on the cloud infrastructure to construct historic attack progression and execution trail continuation in a distributed execution graph as an attacker moves from one compute instance (e.g., Host C) in a cloud infrastructure to a cloud service (e.g., Cloud Service).
The steps for performing the above mentioned execution trail continuation algorithm involving cloud service functions will now be described.
On Host C, the attacker may query a metadata service (represented as node 1820) for security credentials. In some implementations, prior to querying for security credentials, the attacker may query the metadata service for a role (e.g., permissions) of Host C (if applicable). After (e.g., once) the attacker queries the metadata service to access security credentials for Host C, the hub may identify the query (e.g., the host/instance metadata credential URL query) and store (e.g., persists) the identified query as a key-value pair between a host identifier (ID) and a local trail identifier (ID) corresponding to the Host C. As described with respect to
In one implementation, before the attacker issues cloud API calls with the stolen credentials to connect to the Cloud Service, the hub may process and construct a distributed execution graph to model the progression corresponding to the distributed execution trail# TrailA:X as shown in
At a later time (e.g., after acquiring the security credentials), the attacker can use the stolen credentials to access a cloud service. The attacker may access the cloud service through cloud native APIs. In one implementation, to identify connections to cloud services and to maintain cloud infrastructure to cloud service trail continuation, a threat detection service corresponding to the cloud service provider of the cloud service may identify the connection to the cloud service by the attacker. The threat detection service may determine (e.g., flag) the action of the attacker to be suspicious. The threat detection service may be configured to interface and/or communicate with the hub and/or agents operating on Hosts in the cloud infrastructure. The hub may cause and/or be configured to cause the threat detection service to store and/or provide detection data (e.g., threat detection data and/or suspicious data) to an object data store (or any other suitable data store). The object data store that stores the detection data from the threat detection service may send and/or provide the detection data to the hub.
In one implementation, to identify connections to cloud services and to maintain cloud infrastructure to cloud service trail continuation, the hub may monitor cloud-native logs associated with a cloud service (and corresponding cloud API). The hub may receive detection data indicative of credentials used to connect to the cloud service via the corresponding cloud API. The hub may compare a security credential inventory of the cloud service to the cloud-native logs to determine credentials used to connect to the cloud service (mapping as described below).
In one implementation, the hub may receive the detection data that is indicative of the attacker attempting to connect to the cloud service. The hub may receive the detection data from the threat detection system (and object data store) and/or the cloud-native log as described herein. The detection data may include metadata and a host ID indicating the Host corresponding to the stolen security credentials (e.g., whose role is used by the attacker). The hub may compare the host ID to the stored key-value mapping between the host ID (Host C) and the local trail ID (C: 1786514) to determine that the local trail C: 1786514 (and event of stealing the security credentials) corresponds to and/or is the cause of the connection to the cloud service. The hub assigns this cloud-native determination to the local trail C:1786514 and maintains trail continuation of distributed trail#A:X from Host A to Host B to Host C within the cloud infrastructure and then to the cloud service.
The resulting distributed execution graph including the connection from the cloud infrastructure to the cloud service is depicted in
In some examples, some or all of the processing described above can be carried out on a personal computing device, on one or more centralized computing devices, or via cloud-based processing by one or more servers. In some examples, some types of processing occur on one device and other types of processing occur on another device. In some examples, some or all of the data described above can be stored on a personal computing device, in data storage hosted on one or more centralized computing devices, or via cloud-based storage. In some examples, some data are stored in one location and other data are stored in another location. In some examples, quantum computing can be used. In some examples, functional programming languages can be used. In some examples, electrical memory, such as flash-based memory, can be used.
The memory 1920 stores information within the system 1900. In some implementations, the memory 1920 is a non-transitory computer-readable medium. In some implementations, the memory 1920 is a volatile memory unit. In some implementations, the memory 1920 is a non-volatile memory unit.
The storage device 1930 is capable of providing mass storage for the system 1900. In some implementations, the storage device 1930 is a non-transitory computer-readable medium. In various different implementations, the storage device 1930 may include, for example, a hard disk device, an optical disk device, a solid-date drive, a flash drive, or some other large capacity storage device. For example, the storage device may store long-term data (e.g., database data, file system data, etc.). The input/output device 1940 provides input/output operations for the system 1900. In some implementations, the input/output device 1940 may include one or more of a network interface device, e.g., an Ethernet card, a serial communication device, e.g., an RS-232 port, and/or a wireless interface device, e.g., an 802.11 card, a 3G wireless modem, or a 4G wireless modem. In some implementations, the input/output device may include driver devices configured to receive input data and send output data to other input/output devices, e.g., keyboard, printer and display devices 1960. In some examples, mobile computing devices, mobile communication devices, and other devices may be used.
In some implementations, at least a portion of the approaches described above may be realized by instructions that upon execution cause one or more processing devices to carry out the processes and functions described above. Such instructions may include, for example, interpreted instructions such as script instructions, or executable code, or other instructions stored in a non-transitory computer readable medium. The storage device 1930 may be implemented in a distributed way over a network, such as a server farm or a set of widely distributed servers, or may be implemented in a single computing device.
Although an example processing system has been described in
The term “system” may encompass all kinds of apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. A processing system may include special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit). A processing system may include, in addition to hardware, code that creates an execution environment for the computer program in question, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.
A computer program (which may also be referred to or described as a program, software, a software application, a module, a software module, a script, or code) can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and it can be deployed in any form, including as a standalone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program may, but need not, correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub programs, or portions of code). A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.
The processes and logic flows described in this specification can be performed by one or more programmable computers executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus can also be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).
Computers suitable for the execution of a computer program can include, by way of example, general or special purpose microprocessors or both, or any other kind of central processing unit. Generally, a central processing unit will receive instructions and data from a read-only memory or a random access memory or both. A computer generally includes a central processing unit for performing or executing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto optical disks, or optical disks. However, a computer need not have such devices. Moreover, a computer can be embedded in another device, e.g., a mobile telephone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a Global Positioning System (GPS) receiver, or a portable storage device (e.g., a universal serial bus (USB) flash drive), to name just a few.
Computer readable media suitable for storing computer program instructions and data include all forms of nonvolatile memory, media and memory devices, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.
To provide for interaction with a user, embodiments of the subject matter described in this specification can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, or tactile input. In addition, a computer can interact with a user by sending documents to and receiving documents from a device that is used by the user; for example, by sending web pages to a web browser on a user’s user device in response to requests received from the web browser.
Embodiments of the subject matter described in this specification can be implemented in a computing system that includes a back end component, e.g., as a data server, or that includes a middleware component, e.g., an application server, or that includes a front end component, e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the subject matter described in this specification, or any combination of one or more such back end, middleware, or front end components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”) and a wide area network (“WAN”), e.g., the Internet.
The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.
The phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting.
The term “approximately”, the phrase “approximately equal to”, and other similar phrases, as used in the specification and the claims (e.g., “X has a value of approximately Y” or “X is approximately equal to Y”), should be understood to mean that one value (X) is within a predetermined range of another value (Y). The predetermined range may be plus or minus 20%, 10%, 5%, 3%, 1%, 0.1%, or less than 0.1%, unless otherwise indicated.
The indefinite articles “a” and “an,” as used in the specification and in the claims, unless clearly indicated to the contrary, should be understood to mean “at least one.” The phrase “and/or,” as used in the specification and in the claims, should be understood to mean “either or both” of the elements so conjoined, i.e., elements that are conjunctively present in some cases and disjunctively present in other cases. Multiple elements listed with “and/or” should be construed in the same fashion, i.e., “one or more” of the elements so conjoined. Other elements may optionally be present other than the elements specifically identified by the “and/or” clause, whether related or unrelated to those elements specifically identified. Thus, as a non-limiting example, a reference to “A and/or B”, when used in conjunction with open-ended language such as “comprising” can refer, in one embodiment, to A only (optionally including elements other than B); in another embodiment, to B only (optionally including elements other than A); in yet another embodiment, to both A and B (optionally including other elements); etc.
As used in the specification and in the claims, “or” should be understood to have the same meaning as “and/or” as defined above. For example, when separating items in a list, “or” or “and/or” shall be interpreted as being inclusive, i.e., the inclusion of at least one, but also including more than one, of a number or list of elements, and, optionally, additional unlisted items. Only terms clearly indicated to the contrary, such as “only one of or “exactly one of,” or, when used in the claims, “consisting of,” will refer to the inclusion of exactly one element of a number or list of elements. In general, the term “or” as used shall only be interpreted as indicating exclusive alternatives (i.e. “one or the other but not both”) when preceded by terms of exclusivity, such as “either,” “one of,” “only one of,” or “exactly one of.” “Consisting essentially of,” when used in the claims, shall have its ordinary meaning as used in the field of patent law.
As used in the specification and in the claims, the phrase “at least one,” in reference to a list of one or more elements, should be understood to mean at least one element selected from any one or more of the elements in the list of elements, but not necessarily including at least one of each and every element specifically listed within the list of elements and not excluding any combinations of elements in the list of elements. This definition also allows that elements may optionally be present other than the elements specifically identified within the list of elements to which the phrase “at least one” refers, whether related or unrelated to those elements specifically identified. Thus, as a non-limiting example, “at least one of A and B” (or, equivalently, “at least one of A or B,” or, equivalently “at least one of A and/or B”) can refer, in one embodiment, to at least one, optionally including more than one, A, with no B present (and optionally including elements other than B); in another embodiment, to at least one, optionally including more than one, B, with no A present (and optionally including elements other than A); in yet another embodiment, to at least one, optionally including more than one, A, and at least one, optionally including more than one, B (and optionally including other elements); etc.
The use of “including,” “comprising,” “having,” “containing,” “involving,” and variations thereof, is meant to encompass the items listed thereafter and additional items.
Use of ordinal terms such as “first,” “second,” “third,” etc., in the claims to modify a claim element does not by itself connote any priority, precedence, or order of one claim element over another or the temporal order in which acts of a method are performed. Ordinal terms are used merely as labels to distinguish one claim element having a certain name from another element having a same name (but for use of the ordinal term), to distinguish the claim elements.
While this specification contains many specific implementation details, these should not be construed as limitations on the scope of what may be claimed, but rather as descriptions of features that may be specific to particular embodiments. Certain features that are described in this specification in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable sub-combination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a sub-combination or variation of a sub-combination.
Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.
Particular embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results. As one example, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In certain implementations, multitasking and parallel processing may be advantageous. Other steps or stages may be provided, or steps or stages may be eliminated, from the described processes. Accordingly, other implementations are within the scope of the following claims.
This application claims priority to and the benefit of U.S. Provisional Pat. Application No. 63/309,276, filed on Feb. 11, 2022, titled “DETECTION AND TRAIL-CONTINUATION FOR VERTICAL MOVEMENT ENDPOINT-TO-CLOUD-ACCOUNT ATTACKS”, the contents of which are incorporated by reference herein in their entirety.
| Number | Date | Country | |
|---|---|---|---|
| 63309276 | Feb 2022 | US |
