Reuse of groups in security policy

Description

BACKGROUND

Micro-segmentation techniques allow a system to observe flows in a network and generate recommended security policies for a network (or a portion of that network, e.g., relating to a particular application). This works well for a network that does not have existing policies. However, if an administrator, consultant, or other entity has previously written policies for the network, generating a new policy that respects these existing policies is more complicated and has traditionally needed to be done manually. However, for a large network with many network endpoints and many flows, manual updating of policies can be extremely time-consuming, so automated techniques for updating policies is needed.

BRIEF SUMMARY

Some embodiments provide a network analysis appliance that automatically updates (or automatically provides recommendations for updating) an existing security policy (e.g., a set of firewall rules) implemented in a network based on observed flows, while respecting the rules in the existing policy. Based on the set of existing firewall rules and a set of flows observed in the network that do not match the firewall rules (e.g., flows that are allowed based on a default rule, also referred to as “leaks”), the analysis appliance identifies an optimized set of modifications to the set of firewall rules to generate a set of modified firewall rules. The modified set of firewall rules has the property that (i) any flows that matched firewall rules allowing traffic in the set of existing firewall rules still match firewall rules allowing traffic in the modified firewall rules and (ii) any flows in the set of observed flows also match firewall rules allowing traffic in the modified firewall rules.

In some embodiments, the security policy being updated is a security policy for a particular application, as defined by an administrator or other user. The application definition specifies a set of machines (e.g., a set of web servers, a set of database servers, a combination of web servers and database servers, or another group of machines that collectively implement the application) and in some embodiments the security policy specifies types of traffic that are allowed to be sent to the machines of the application (or a subset of the machines), from the machines of the application (or a subset of the machines), and between the machines of the application (or between subsets of the machines), as well as the machines and/or network addresses that the machines of the application are allowed to communicate with. This security policy is expressed as a set of firewall rules.

Each “allow” firewall rule (i.e., a rule specifying a type of traffic that is allowed by the security policy) includes a set of match conditions having one or more source groups, one or more destination groups, and a set of one or more services. The source groups for a rule map to a set of source addresses associated with the rule, the destination groups map to a set of destination addresses associated with the rule, and each service maps to a transport layer protocol (e.g., TCP, UDP, etc.) and a transport layer port number (i.e., corresponding to a particular application layer service, such as port 80 for http). Flows are allowed by a particular firewall rule if the source address (e.g., source IP address) of the flow matches one of the source addresses associated with the rule, the destination address of the flow matches one of the destination addresses associated with the rule, and the transport layer protocol and port number (e.g., destination port number) of the flow match the protocol and port number associated with the rule.

To generate the modifications to the set of existing firewall rules based on a set of observed flows that do not match the firewall rules (that are sent to, from, or between the machines of the application), the analysis appliance first separates the flows into different types of flows: intra-application flows, ingress flows, and egress flows. Intra-application flows are between two machines that are part of the application, ingress flows are flows sent from sources outside the application to machines of the application, and egress flows are flows sent from machines of the application to destinations outside of the application. In general, the rule modification process maps intra-application flows to intra-application rules (i.e., rules for which both the associated source and destination addresses are associated with the application), ingress flows to ingress rules (i.e., rules for which the associated destination addresses are associated with the application), and egress flows to egress rules (i.e., rules for which the associated source addresses are associated with the application).

For each flow in the set of flows (the leaks), the analysis appliance identifies a closest matching firewall rule in the corresponding set of existing firewall rules (i.e., in the intra-application, ingress, or egress rules). There should not be any firewall rule that is a perfect match (source, destination, and service) because the flow would have matched that firewall rule in the network and thus not appeared as a leak. However, different embodiments may use different variations to determine which firewall rule is the closest to a match.

First, some embodiments identify any rules for the service on which the flow is communicating (i.e., rules for which the flow matches the protocol and port number). If there are no such matching rules, then some embodiments create a new rule. If there is only one rule for which the flow matches the protocol and port number, then this rule is designated as the closest matching rule for the flow.

If multiple rules are found for which the flow matches the protocol and port number, then preference is given to any such rules for which one of the source and destination addresses of the flow matches the source or destination addresses associated with the rule, as compared to rules for which neither the source nor destination addresses of the flow matches the source or destination addresses associated with the rule. If multiple rules still remain as possibilities, then the rule with the highest priority (e.g., the lowest sequence number, assuming that lower sequence numbers indicate higher priorities) is selected as the closest matching rule. This process is performed for each of the flows in some embodiments to identify the closest matching rule for each flow.

Any of the firewall rules that are identified as a closest matching rule for at least one flow are identified for modification, with the non-matching source and/or destination addresses of the corresponding flows added to the associated source and destination address sets for the flow. In some embodiments, new groups are created (or recommended for creation) to include the newly-added addresses. Other embodiments perform a group selection process to determine existing groups that should be added to the source and/or destination match conditions for each rule.

Specifically, for each rule that is identified for modification (any rule identified as a closest matching rule for one or more flows), some embodiments use an optimization problem driven by user-specified settings to determine an optimal set of groups to add to the source and/or destination match conditions. For a given match condition of the rule (i.e., either source or destination match condition), the optimization problem identifies a set of compute machines to be added to the match condition (i.e., the set of compute machines corresponding to the addresses of the flows for which the rule is a closest matching rule) and selects a set of groups from existing groups to encompass this identified set of compute machines.

The selection of the set of groups is based, in part, on a user-specified threshold that indicates tolerance for the inclusion of compute machines that are not in the identified set of compute machines in the selected groups. This threshold balances the desire to use existing groups (as opposed to creating new groups for every rule modification) against the inclusion in the match condition of additional compute machines that are not part of the set of compute machines identified for addition to the match condition. In some embodiments, the higher the threshold, the more of the compute machines in the group that need to be part of the set of compute machines identified for addition to the match condition. Specifically, in some embodiments, the threshold specifies a minimum percentage of the compute machines in a group that are required to be in the set of compute machines identified for addition to the match condition. Groups falling below the threshold are not considered as candidates for inclusion in the set of selected set of groups.

In some embodiments, the selection process, after identifying candidate groups with the percentage of compute machines that are in the identified set for addition above the user-specified threshold, orders these based on this percentage (with the groups having the highest percentage first). Ties in percentage are broken based on the number of compute machines in the identified set for addition that are in the group. Based on this ordering, the process selects groups (in order) that include at least one compute machine in the identified set of compute machines that has not yet been included in a selected group, until all compute machines in the identified set are included in at least one group. Some embodiments also create new groups for any compute machines that are not included in any of the selected groups.

The preceding Summary is intended to serve as a brief introduction to some embodiments of the invention. It is not meant to be an introduction or overview of all inventive subject matter disclosed in this document. The Detailed Description that follows and the Drawings that are referred to in the Detailed Description will further describe the embodiments described in the Summary as well as other embodiments. Accordingly, to understand all the embodiments described by this document, a full review of the Summary, Detailed Description and the Drawings is needed. Moreover, the claimed subject matters are not to be limited by the illustrative details in the Summary, Detailed Description and the Drawings, but rather are to be defined by the appended claims, because the claimed subject matters can be embodied in other specific forms without departing from the spirit of the subject matters.

BRIEF DESCRIPTION OF THE DRAWINGS

The novel features of the invention are set forth in the appended claims. However, for purpose of explanation, several embodiments of the invention are set forth in the following figures.

FIG. 1 conceptually illustrates an analysis appliance of some embodiments.

FIG. 2 conceptually illustrates a host computer of some embodiments.

FIG. 3 conceptually illustrates a process of some embodiments for providing recommendations for an existing security policy that is implemented in a network.

FIG. 4 illustrates a firewall rule and recommended modifications to the firewall rule based on a set of observed flows.

FIG. 5 conceptually illustrates a process of some embodiments for identifying the closest matching rule for a flow.

FIG. 6 illustrates the identification of a closest matching rule for a flow.

FIG. 7 conceptually illustrates a process of some embodiments for selecting a set of existing groups to add to a set of match conditions for a firewall rule.

FIGS. 8 and 9 illustrate an example of selecting a set of groups to add to a set of match conditions.

FIG. 10 conceptually illustrates an electronic system with which some embodiments of the invention are implemented.

DETAILED DESCRIPTION

In the following detailed description of the invention, numerous details, examples, and embodiments of the invention are set forth and described. However, it will be clear and apparent to one skilled in the art that the invention is not limited to the embodiments set forth and that the invention may be practiced without some of the specific details and examples discussed.

To identify the observed flows, some embodiments leverage a data flow collection system for the datacenter that collects and reports attributes of data flows associated with compute machines executing in the datacenter (e.g., virtual machines (VMs), containers, bare metal computing devices, etc.). Agents on host computers (or operating directly on bare metal computing devices) collect and export data flow information for the compute machines, also referred to as data compute nodes (DCNs) to the analysis appliance (which may operate, e.g., as a single server or cluster of servers). Agents on the host computers (e.g., different agents than those that export the data flow information) also export context information to the analysis appliance.

FIG. 1 conceptually illustrates the analysis appliance 100 of some embodiments, as well as network managers 107 and host computers 105. The analysis appliance 100 includes a processing pipeline 110 for flow data (e.g., flow attribute sets received from host computers), a set of data storages 120 for storing received data, a set of real-time anomaly detectors 150 for performing regular anomaly detection on incoming flow data from the processing pipeline 110, and a set of data processing engines 130 (e.g., a rule modification engine 131, a visualization engine 132, and other engines 133).

The host computers 105 will be described in greater detail below by reference to FIG. 2. As shown, these host computers execute one or more DCNs 155 (e.g., virtual machines (VMs), containers, etc.) that can run services, applications, etc. These DCNs 155 send and receive data traffic, which are organized as data message flows. Each host computer 105 also executes (e.g., within virtualization software) a context exporter 160 and a flow exporter 165, which are associated with the analysis appliance 100. The context exporter 160 collects context data regarding the DCNs 155 and provides this data to the analysis appliance 100. The flow exporter 165 collects information about data flows to and from the DCNs 155 and provides this data to the analysis appliance 100.

The network managers 107 provide configuration data to the analysis appliance 100, including management plane configuration data and policy configuration data. In addition, the analysis appliance 100 communicates control messages (e.g., updates to service rule policies, updated keys, updated group memberships validated by a user, etc.) through the network managers 107. In some embodiments, a user (e.g., an administrator, not shown) can interact with the analysis appliance 100 directly (e.g., to initiate the security policy update, set a group use threshold value).

The processing pipeline 110, in some embodiments, processes flow data (e.g., flow attribute sets, also referred to as flow group records) received from the host computers in the system for analysis by other elements of the appliance (e.g., the anomaly detector 150). When two DCNs 155 within the datacenter communicate with each other and their respective host computers 105, both provide flow attribute sets for the flow to the analysis appliance 100. The processing pipeline 110 deduplicates these flow attribute sets (i.e., into a single flow attribute set). This deduplication process matches these flows (e.g., based on flow keys) and, in some embodiments, generates a new flow attribute set for the data flow that includes all unique attributes from both the source and destination host computer flow attribute sets. The processing pipeline 110 stores these flow attribute sets in the data storages 120 (e.g., the flow group records 121). In some embodiments, in addition to deduplication, the processing pipeline 110 also identifies and groups corresponding flow attribute sets (e.g., for reverse direction flows, or otherwise-related flows). These flow attribute sets are also combined and stored in, e.g., the flow group records 121.

The processing pipeline 110 of some embodiments also fills in missing information for flow attribute sets, if needed (e.g., DCN identifiers for remote DCNs, etc.) using other flow attribute sets or other information (e.g., by matching DCN identifiers to network addresses already present in the flow attribute sets). Correlation of flow attribute sets can again be performed after this missing information is filled in. Additional description of the processing pipeline 110 is found in U.S. Patent Publication 2021/0029050, which is incorporated herein by reference.

The data storages 120 include, in some embodiments, a data storage for each different type of data received (e.g., a correlated flow group record data storage 121, a contextual attribute data storage 122, a configuration data storage 123, and a time series data storage 124). The contextual attribute data storage 122, in some embodiments, stores received contextual attribute data from multiple host computers and uses that data for populating the time series data storage 124 with contextual attribute data (e.g., in a contextual attribute topic). In some embodiments, the contextual attribute data storage 122 is used in correlating contextual attributes with flow group records for display. The time series data storage 124 is used additionally, or alternatively, in other embodiments, for correlating contextual attribute data to flow group record data.

The contextual attribute data storage 122, in some embodiments, receives contextual attribute data sets including any, or all, of: data regarding guest metadata, guest events, and guest DCN metrics. In some embodiments, the guest metadata includes any or all of DCN details (a universally unique identifier [uuid], a bios uuid, and a vmxpath), operating system details (type of OS and version information), and process details (e.g., process ID, creation time, hash, name, command line, security ID [sid], user ID [uid], loaded library or module information, process metrics [e.g., memory usage and CPU usage], process version, parent process ID, etc.). Guest events, in some embodiments, include DCN events (e.g., power on and power off), user login events (e.g., login, logoff, connect, and disconnect events, a session ID, a timestamp, a DCN IP, and a connected client IP), and service process events (e.g., event type [e.g., listen start, listen stop], timestamp, destination DCN IP, destination port number, and process details). Guest DCN metrics, in some embodiments, include memory usage and CPU usage. It should be understood that many additional pieces of information may be provided to a contextual attribute data storage and that the partial list above serves only as an example.

In some embodiments, the set of data storages 120 includes a flow group record data storage 121. In some embodiments, this data storage 121 stores flow attribute sets after aggregation and correlation with configuration data stored in the configuration data storage 123. The flow group record data storage 121, in some embodiments, also stores learned pairings of IP addresses and DCN identifiers. In some embodiments, the learning is based on previously processed flow record groups. The correlated flow group record data storage 121, in some embodiments, provides processed (e.g., aggregated and correlated) flow group records to the time series data storage. In some embodiments, flow group records may also indicate any firewall rules that were matched by the data messages of the flow.

The configuration data storage 123, in some embodiments, receives configuration data (e.g., management plane configuration and/or policy configuration) from a network manager controller. The management plane configuration data includes information relating to group membership (in terms of DCN), and the policy configuration data sets include information about service rules (e.g., firewall rules), in some embodiments. The service rules, in some embodiments, are expressed in terms of any of IP addresses, ports, protocols, groups (e.g., groups of compute machines or IP addresses), etc., in any combination. In some embodiments, an initial set of configuration data is sent at startup or reboot of either the network manager computer or the analysis appliance, while subsequent configuration data sets include only changes to the last configuration data set.

A time series data storage 124, in some embodiments, stores flow group records, configuration data, and context data. In some embodiments, the time series data storage 124 is organized by topic with each different type of data stored in a different topic. Additionally, in some embodiments, each topic is organized in a time series fashion by use of an index that is appended to each set of data and is coordinated among all the producers of data for the topic. The time series data storage 124 is organized at multiple levels of temporal granularity, in some embodiments. In some embodiments, the different levels of granularity include some combination of hourly, daily, weekly, and monthly. The different levels of temporal granularity are used, in some embodiments, for data collected for a previous 24 hours (e.g., organized on an hourly basis), data for a previous 6 days (e.g., organized on a daily basis), data for a previous 30 days (e.g., organized on a daily or weekly basis), and data received more than 30 days earlier (e.g., organized on a monthly basis). The data organized based on the various levels of temporal granularity are, in some embodiments, periodically (e.g., daily, hourly, etc.) rolled up into the next level of granularity.

Real-time (or near-real-time) anomaly detectors 150, in some embodiments, analyze the correlated flow attribute sets as this flow information is received and correlated by the processing pipeline 110 (as opposed to retrieving data from the storages 120). In some embodiments, the processing pipeline 110 provides the flow information (possibly also correlated to contextual attribute information) to the real-time anomaly detectors 150 as batches of flow attribute sets are correlated and processed. These anomaly detectors 150 detect various types of anomalies (e.g., port sweeps, suspicious network connections, etc.) and store records of each detected anomalous event in an anomaly storage (e.g., a database, not shown in the figure). In some embodiments, each record of an anomalous event indicates at least a start and end time for the event, one or more associated DCNs, and a description of the event. The anomaly detectors 150 also provide at least a subset of the anomalous event records (e.g., records for particular types of anomalous events) directly to the data processing engines 130.

The data processing engines 130 include a rule modification recommendation engine 131, a visualization engine 132, and a set of other engines 133. In some embodiments, these various data processing engines 130 analyze the time series data 124 to perform various types of analysis for the datacenter at regular intervals (e.g., every 10 minutes, every 30 minutes, every hour, etc.) or in response to a user request (e.g., to detect various types of anomalous events in the datacenter network, to analyze a set of micro-segmentation policies for an application implemented in the datacenter). For instance, anomaly detectors might look for anomalous amounts of dropped traffic, the presence of malicious files on a DCN, vertical port scans, password and/or hash collection taking place on a DCN, etc.

The rule modification recommendation engine 131 is one example of such a data processing engine. Upon request from a user (and specification of a particular application for which to perform analysis), the rule modification engine 131 identifies flows sent to, from, or between DCNs of the application that are not matched by existing security policy rules for the application. Based on these identified flows, the rule modification recommendation engine 131 either automatically modifies the rules or provides recommendations to the user to modify the rules. In some embodiments, the rule modification recommendation engine 131 receives an application definition and a security group use threshold from a user (e.g., either through the visualization engine 132 or through the network managers 107) in addition to the security policy, a set of existing security groups, and the flow information (e.g., from the configuration and flow data stored in the time series data 124 or directly from the network managers 107). Details of the operations of the rule modification recommendation engine 131 will be described below.

The visualization engine 132 of some embodiments generates a graphical user interface through which an administrator can interact with and control the analysis appliance 100. In some embodiments, input to the rule modification recommendation engine 131 is provided by a user (e.g., a security administrator) through the visualization engine. The other engines 133 perform various other tasks, including detection of various anomalous events. Additional information about the analysis appliance 100 can be found in U.S. Patent Publication 2021/0029050, which is incorporated by reference herein.

FIG. 2 conceptually illustrates a host computer 200 (e.g., one of the host computers 105) of some embodiments in more detail, specifically focusing on the context exporter 240 and flow exporter 270 that collect, aggregate, and publish aggregated data to the analysis appliance. As shown, the host computer 200 also executes several data compute nodes (DCNs) 205, a set of service engines 215, a threat detector/deep packet inspection (DPI) module 232, a set of third-party processes 233, a MUX (multiplexer) 227, an anomaly detector 222, a machine learning (ML) engine 224, and a software forwarding element (SFE) 212.

Guest introspection agents 250 execute on the DCNs 205 and extract context data from the DCNs 205. For example, a guest introspection agent 250, in some embodiments, detects that a new data flow has been initiated (e.g., by sending a SYN packet in a data flow using TCP) and collects introspection data (e.g., a set of attributes of the data flow and DCN). The introspection data, in some embodiments, includes any, or all, of data regarding (i) guest metadata, (ii) guest events, and (iii) guest DCN metrics. In some embodiments, the guest metadata includes any, or all, of data regarding DCN 205 (a universally unique identifier [uuid], a bios uuid, and a vmxpath), operating system data (type of OS and version information), and process data (e.g., process ID, creation time, hash, name, command line, security ID [sid], user ID [uid], loaded library or module information, process metrics [e.g., memory usage and CPU usage], process version, parent process ID, etc.). Guest events, in some embodiments, include DCN events (e.g., power on and power off), user login events (e.g., login, logoff, connect, and disconnect events, a session ID, a timestamp, a DCN IP, and a connected client IP), and service process events (e.g., event type [e.g., listen start, listen stop], timestamp, destination DCN IP, destination port number, and process details). Guest DCN metrics, in some embodiments, include memory usage and CPU usage. It should be understood that much of the context data, in some embodiments, is not included in L2-L7 headers of a flow and that many additional pieces of information may be collected by guest introspection agent 250. The partial list above serves only as an example of the types of information that can be gathered by guest introspection agent 250.

In some embodiments, the guest introspection agents 250 send the collected context information to the context exporter 240 (specifically to the context engine 210) through a multiplexer 227. The context exporter 240 includes the context engine 210, a contextual attribute storage 245, a context publisher timer 246, and a context publisher 247. The context exporter 240 processes context data (e.g., contextual attribute data sets) at the host computer 200 and publishes the context data to the analysis appliance. The context engine 210 also provides the received context information to other elements operating in the host computer 200 and correlates this context data with context data received from other sources.

In some embodiments, the other sources include the set of service engines 215, the threat detector/DPI module 232, third-party software (processes) 233, the anomaly detector 222, and the ML engine 224. The context engine 210, in some embodiments, correlates the context data from the multiple sources for providing the correlated context data (e.g., sets of correlated contextual attributes) to the context publisher 247 (e.g., through context attribute storage 245).

As shown, each DCN 205 also includes a virtual network interface controller (VNIC) 255 in some embodiments. Each VNIC is responsible for exchanging messages between its respective DCN and the SFE 212 (which may be, e.g., a virtual switch or a set of virtual switches). Each VNIC 255 connects to a particular port 260-265 of the SFE 212. The SFE 212 also connects to a physical network interface controller (PNIC) (not shown) of the host. In some embodiments, the VNICs are software abstractions of one or more physical NICs (PNICs) of the host created by the virtualization software of the host (within which the software forwarding element 212 executes).

In some embodiments, the SFE 212 maintains a single port 260-265 for each VNIC of each DCN. The SFE 212 connects to the host PNIC (through a NIC driver [not shown]) to send outgoing messages and to receive incoming messages. In some embodiments, the SFE 212 is defined to include one or more ports that connect to the PNIC driver to send and receive messages to and from the PNIC. The SFE 212 performs message-processing operations to forward messages that it receives on one of its ports to another one of its ports. For example, in some embodiments, the SFE 212 tries to use data in the message (e.g., data in the message header) to match a message to flow-based rules, and upon finding a match, to perform the action specified by the matching rule (e.g., to hand the message to one of its ports, which directs the message to be supplied to a destination DCN or to the PNIC).

In some embodiments, the SFE 212 is a software switch (e.g., a virtual switch), while in other embodiments it is a software router or a combined software switch/router, and may represent multiple SFEs (e.g., a combination of virtual switches and virtual routers). The SFE 212, in some embodiments, implements one or more logical forwarding elements (e.g., logical switches or logical routers) with SFEs 212 executing on other hosts in a multi-host environment. A logical forwarding element, in some embodiments, can span multiple hosts to connect DCNs that execute on different hosts but belong to one logical network. Different logical forwarding elements can be defined to specify different logical networks for different users, and each logical forwarding element can be defined by multiple software forwarding elements on multiple hosts. Each logical forwarding element isolates the traffic of the DCNs of one logical network from the DCNs of another logical network that is serviced by another logical forwarding element. A logical forwarding element can connect DCNs executing on the same host and/or different hosts, both within a datacenter and across datacenters. In some embodiments, the SFE 212 extracts from a data message a logical network identifier (e.g., a VNI) and a MAC address. The SFE 212, in such embodiments, uses the extracted VNI to identify a logical port group or logical switch, and then uses the MAC address to identify a port within the port group or logical switch.

The ports of the SFE 212, in some embodiments, include one or more function calls to one or more modules that implement special input/output (I/O) operations on incoming and outgoing messages that are received at the ports 260-265. Examples of I/O operations that are implemented by the ports 260-265 include ARP broadcast suppression operations and DHCP broadcast suppression operations, as described in U.S. Pat. No. 9,548,965. Other I/O operations (such as firewall operations, load-balancing operations, network address translation operations, etc.) can be so implemented in some embodiments of the invention. By implementing a stack of such function calls, the ports 260-265 can implement a chain of I/O operations on incoming and/or outgoing messages in some embodiments. Also, in some embodiments, other modules in the data path (such as the VNICs 255 and the ports 260-265, etc.) implement the I/O function call operations instead of, or in conjunction with, the ports 260-265. In some embodiments, one or more of the function calls made by the SFE ports 260-265 can be to service engines 215, which query the context engine 210 for context information that the service engines 215 use (e.g., to generate context headers that include context used in providing a service and to identify service rules applied to provide the service). In some embodiments, the generated context headers are then provided through the ports 260-265 of SFE 212 to flow exporter 270 (e.g., flow identifier and statistics collector 271).

The service engines 215 can include a distributed firewall engine of some embodiments that implements distributed firewall rules configured for the datacenter network. These distributed firewall rules are, in some embodiments, defined in terms of rule identifiers, and specify whether to drop or allow traffic from one group of DCNs to another group of DCNs. The firewall rules can be specified in terms of source and destination network addresses (e.g., IP and/or MAC addresses) and/or security groups (which are converted to network addresses). For instance, a firewall rule might be defined at the network manager level as allowing any traffic from a set of web server VMs running the Linux operating system (a first security group) to a set of database server VMs running the Windows operating system (a second security group). This firewall rule is then translated into a set of more specific rules based on the membership of the DCNs in the first and second security groups using the IP and/or MAC addresses of these DCNs.

The flow exporter 270 monitors flows, collects flow data and statistics, aggregates flow data into flow group records, and publishes flow attribute sets (also referred to as flow group records) for consumption by the analysis appliance. In some embodiments, the flow exporter 270 generally aggregates statistics for individual flows identified during multiple time periods, and for each time period identifies multiple groups of flows with each group including one or more individual flows. For each identified flow group, the flow exporter 270 identifies a set of attributes by aggregating one or more subsets of attributes of one or more individual flows in the group as described below in greater detail. In some embodiments, the subset of attributes of each individual flow in each group is the aggregated statistics of the individual flow. After the multiple time periods, flow exporter 270 provides the set of attributes for each group identified in the multiple time periods to the analysis appliance for further analysis of the identified flows.

As shown, the flow exporter 270 includes a flow identifier/statistics collector 271, a flow identifier and statistics storage 272, a flow collector timer 273, a flow collector 274, a first-in first-out (FIFO) storage 275, a configuration data storage 276, a flow aggregator 277, a flow group record storage 278, a flow publisher timer 279, and a flow group record publisher 280. These modules collectively collect and process flow data to produce and publish flow attribute sets.

The flow exporter 270 receives flow information, including flow identifiers and statistics, at the flow identifier/statistics collector 271. In some embodiments, the received flow information is derived from individual data messages that make up the flow and includes context data used in making service decisions at service engines 215. In some embodiments, the flow information also specifies which firewall rules are applied to each flow (e.g., using firewall rule identifiers). The flow exporter 270 stores the received information associated with particular flows in the flow identifier and statistics storage 272. The statistics, in some embodiments, are summarized (accumulated) over the life of the particular flow (e.g., bytes exchanged, number of packets, start time, and duration of the flow).

The flow collector 274, in some embodiments, monitors the flows to determine which flows have terminated (e.g., timeouts, FIN packets, RST packets, etc.) and collects the flow identifiers and statistics and pushes the collected data to FIFO storage 275. In some embodiments, the flow collector 274 collects additional configuration data from configuration data storage 276 and includes this additional configuration data with the data collected from flow identifier and statistics storage 272 before sending the data to FIFO storage 275.

Additionally, the flow collector 274, in some embodiments, collects data for long-lived active flows (e.g., flows lasting longer than half a publishing period) from the flow identifier and statistics storage 272 before the end of a publishing period provided by flow publisher timer 279. In some embodiments, the data collected for a long-lived active flow is different from the data collected for terminated flows. For example, active flows are reported using a start time but without a duration in some embodiments. Some embodiments also include flows that are initiated but dropped/blocked based on firewall rules.

Only flows meeting certain criteria are collected by the flow collector 274 in some embodiments. For example, only information for flows using a pre-specified set of transport layer protocols (e.g., TCP, UDP, ESP, GRE, SCTP) are collected, while others are dropped or ignored. In some embodiments, additional types of traffic, such as broadcast and multicast, safety check (e.g., having ruleID=0 or 0 rx and tx byte/packet counts), L2 flows, flows which are not classified as one of (i) inactive, (ii) drop, or (iii) reject, are dropped (i.e., not collected or not placed into FIFO storage 275).

In some embodiments, the FIFO storage 275 is a circular or ring buffer such that only a certain number of sets of flow identifiers and flow statistics can be stored before old sets are overwritten. In order to collect all the data placed into FIFO storage 275, or at least to not miss too much (e.g., miss less than 5% of the data flows), the flow aggregator 277 pulls data stored in FIFO storage 275 based on a flow collection timer 273 and aggregates the pulled data into aggregated flow group records. Some embodiments pull data from the FIFO storage 275 based on a configurable periodicity (e.g., every 10 seconds), while other embodiments, alternatively or in addition to the periodic collection, dynamically determine when to collect data from FIFO storage 275 based on a detected number of data flows (e.g., terminated data flows, a total number of active data flows, etc.) and the size of FIFO storage 275. Each set of flow data pulled from FIFO storage 275 for a particular flow, in some embodiments, represents a unidirectional flow from a first endpoint (e.g., machine or DCN) to a second endpoint. If the first and second endpoints both execute on the same host computer 200, in some embodiments, a same unidirectional flow is captured at different ports 260-265 of the software forwarding element 212. To avoid double counting a same data message provided to the flow identifier 271 from the two ports 260-265, the flow identifier 271 uses a sequence number or other unique identifier to determine if the data message has been accounted for in the statistics collected for the flow. Even if duplicate data messages for a single unidirectional flow have been accounted for, the flow aggregator 277 additionally combines sets of flow data received for the separate unidirectional flows into a single set of flow data in some embodiments. This deduplication (deduping) of flow data occurs before further aggregation in some embodiments and, in other embodiments, occurs after an aggregation operation.

The flow aggregator 277, in some embodiments, receives a set of keys from the analysis appliance through the network manager computer that specify how the flow data sets are aggregated. After aggregating the flows, the flow aggregator 277 performs a deduplication process to combine aggregated flow group records for two unidirectional flows between two DCNs 205 executing on host machine 200 into a single aggregated flow group record and stores the aggregated records in flow group record storage 278. From flow group record storage 278, flow group record publisher 280 publishes the aggregated flow group records to an analysis appliance according to a configurable timing provided by flow publisher timer 279. After publishing the aggregated flow group records (and, in some embodiments, receiving confirmation that the records were received), the records stored for the previous publishing time period are deleted and a new set of aggregated flow group records are generated.

In some embodiments, one of the flow aggregator 277 and the context engine 210 performs another correlation operation to associate the sets of correlated contextual attributes stored in contextual attribute storage 245 with the aggregated flow group records stored in the flow group record storage 278. In some embodiments, the correlation includes generating new flow attribute sets with additional attribute data included in existing attribute fields or appended in new attribute fields. In other embodiments, the sets of correlated contextual attributes and aggregated flow group records are tagged to identify related sets of aggregated flow group records and contextual attribute data. In some embodiments, the generated new flow group records are published from one of the publishers (e.g., flow group record publisher 280 or context publisher 247). In other embodiments, flow group record publisher 280 publishes the tagged aggregated flow group records and the context publisher 247 publishes the tagged sets of correlated contextual attributes.

The anomaly detection engine 222, in some embodiments, receives flow data (from any of flow identifier and statistics storage 272, FIFO storage 275, or flow group record storage 278) and context data from context engine 210 and detects, based on the received data, anomalous behavior associated with the flows. For example, based on context data identifying the application or process associated with a flow, anomaly detection engine 222 determines that the source port is not the expected source port and is flagged as anomalous. The detection, in some embodiments, includes stateful detection, stateless detection, or a combination of both. Stateless detection does not rely on previously collected data at the host, while stateful detection, in some embodiments, maintains state data related to flows and uses the state data to detect anomalous behavior. For example, a value for a mean round trip time (RTT) or other attribute of a flow and a standard deviation for that attribute may be maintained by anomaly detection engine 222 and compared to values received in a current set of flow data to determine that the value deviates from the mean value by a certain number of standard deviations that indicates an anomaly. In some embodiments, anomaly detection engine 222 appends a field to the set of context data that is one of a flag bit that indicates that an anomaly was detected or an anomaly identifier field that indicates the type of anomaly detected (e.g., a change in the status of a flow from allowed to blocked [or vice versa], a sloppy or incomplete TCP header, an application/port mismatch, or an insecure version of an application). In some embodiments, the additional context data is provided to context engine 210 separately to be correlated with the other context data received at context engine 210. As will be understood from the discussion above, the anomaly detection process may use contextual attributes not in L2-L4 headers such as data included in L7 headers and additional context values not found in headers.

In some embodiments, the anomaly detection engine 222 takes an action or generates a suggestion based on detecting the anomaly. For example, anomaly detection engine 222 can block an anomalous flow pending user review or suggest that a new firewall rule be added to a firewall configuration. In some embodiments, the anomaly detection engines 222 on each host computer 200 can report these anomalies (e.g., via the context publisher 247) to the analysis appliance for further analysis by the anomaly processing engine.

The machine learning engine 224, in some embodiments, receives flow data (from any of the flow identifier and statistics storage 272, the FIFO storage 275, and the flow group record storage 278) and context data from the context engine 210 and performs analysis on the received data. The received data (e.g., flow group records), in some embodiments, includes attributes normally recorded in a 5-tuple as well as additional L7 attributes and other contextual attributes such as user sid, process hash, URLs, appId, etc., that allow for better recommendations to be made (e.g., finer-grained firewall rules). In some embodiments, the analysis identifies possible groupings of DCNs 205 executing on the host computer 200. In some embodiments, the analysis is part of a distributed machine learning process, and the results are provided to the context engine 210 as an additional contextual attribute.

FIG. 3 conceptually illustrates a process 300 of some embodiments for providing recommendations for an existing security policy that is implemented in a network. The process 300 is performed, in some embodiments, by an analysis appliance such as that shown in FIG. 1 (e.g., by rule modification recommendation engine 131). In other embodiments, however, the process 300 may be performed by a network manager or other network management and control system entity with access to security policy and flow information. In some embodiments, the process 300 is performed based on a user command specifying that the recommendation process be initiated. In other embodiments, the process 300 runs on a regular (e.g., weekly, bi-weekly) basis. The process 300 will be described in part by reference to FIG. 4, which illustrates a firewall rule and recommended modifications to the firewall rule based on a set of observed flows.

As shown, the process 300 begins by receiving (at 305) an existing policy, a definition of an application boundary, and a set of observed flows that do not match the policy. In some embodiments, the security policy being updated is a security policy for a particular application, as defined by an administrator or other user. The application definition specifies a set of machines (e.g., a set of web servers, a set of database servers, a combination of web servers and database servers, or another group of machines that collectively implement the application). The example shown in FIG. 4 illustrates an application boundary 405 that includes four compute machines (e.g., VMs, containers, etc.) listed as {M10, M11, M12, M13}. In different embodiments, the application boundary may be specified in terms of compute machine identifiers (i.e., identifiers used by the network management and control system), network addresses (e.g., IP addresses), or other identifiers that uniquely identify the machines.

The security policy, in some embodiments, specifies types of traffic that are allowed to be sent to the machines of the application (or a subset of the machines), from the machines of the application (or a subset of the machines), and between the machines of the application (or between subsets of the machines), as well as the machines and/or network addresses that the machines of the application are allowed to communicate with. The security policy, in some embodiments, may have been written by an administrator or security consultant or automatically generated by a microsegmentation process. This security policy is expressed as a set of firewall rules that allow traffic, block traffic, etc. In some embodiments, the security policy may include a default rule (typically the lowest priority rule) specifying that any traffic not otherwise blocked or dropped (i.e., from any source, to any destination, on any service) is allowed.

As described above, in some embodiments an analysis appliance monitors the data message flows within a network (e.g., a datacenter network). These flows can be searched to identify only flows sent to, from, or between the compute machines of the application. In addition, the flow attribute information for each of these flows indicates which firewall rules were applied in the datapath to the data messages of the flow. Through this, the system (either the rule modification recommendation engine or a separate module that provides the flow information to the rule modification recommendation engine) can identify the flows that (i) relate to the application and (ii) were allowed based on a default rule rather than a more specific rule. In addition, some embodiments remove anomalous flows (i.e., flows detected as anomalous or flows to and/or from machines that have been detected as anomalous).

Having received inputs, the process 300 removes (at 310) any default rules in the security policy from consideration. The process, in some embodiments, does not recommend removal of the default rule from the policy, but rather removes the default rule from consideration during the modification recommendation process (i.e., because the default rule does not need modification).

In addition, the process 300 normalizes (at 315) each non-default rule (or at least each non-default rule specifying a type of traffic that is allowed) of the security policy to identify the match conditions of the rule as a set of source addresses, a set of destination address, a port number (e.g., a destination transport layer port number) and a transport layer protocol. Each firewall rule includes a set of match conditions having one or more source groups, one or more destination groups, and one or more services. The firewall rule is stored in the policy using groups and services, but in the datapath these are mapped to values that can be used to match packet headers, such as network addresses, port numbers, and protocol identifiers. In addition, it should be noted that the groups of compute machines are not divided into source or destination groups in the policy; the same group may be used for the source match conditions of one rule and the destination match conditions of another rule, or even for both the source and destination match conditions of the same rule (i.e., for rules allowing a group of machines to communicate with each other).

The source groups for a rule map to a set of source addresses associated with the rule, the destination groups map to a set of destination addresses associated with the rule, and each service maps to a transport layer protocol (e.g., TCP, UDP, etc.) and a transport layer port number (i.e., corresponding to a particular application layer service, such as port 80 for http). Flows are allowed by a particular firewall rule if the source address (e.g., source IP address) of the flow matches one of the source addresses associated with the rule, the destination address of the flow matches one of the destination addresses associated with the rule, and the transport layer protocol and transport layer port number (e.g., destination port number) of the flow match the protocol and port number associated with the rule. In the example of FIG. 4, a rule 410 is shown that matches on transport layer protocol TCP and port number 80 (i.e., for http traffic), source addresses M1, M2, and M3, and destination addresses M10, M11, and M12. That is, this rule specifies certain traffic that is allowed from outside the application boundary to be sent to certain machines that implement the application.

The process 300 additionally groups (at 320) the observed flows that do not match specific rules in the policy into intra-application flows, ingress flows, and egress flows. Intra-application flows are between two machines that are part of the application, ingress flows are flows sent from sources outside the application to machines of the application, and egress flows are flows sent from machines of the application to destinations outside of the application. The analysis appliance uses the specified application boundary to identify whether any machines of the application are specified in the source field (egress flows), destination field (ingress flows), or both source and destination fields (intra-application flows) of the received flows. The example of FIG. 4 shows two ingress flows 415, both of which are http flows (TCP flows on port 80). One of these is sent from M4 to M10 and another is sent from M5 to M13. Because these flows are sent from compute machines not in the group {M1, M2, M3} (and because the destination compute machine of the second flow is not in the group {M10, M11, M12}), these flows did not match the rule 410 in the data plane of the network.

After normalizing the rules and grouping the flows, the process selects (at 325) one of the groups of flows (i.e., the ingress, egress, or intra-application flows). In general, the rule modification process maps intra-application flows to intra-application rules (i.e., rules for which both the associated source and destination addresses are associated with the application), ingress flows to ingress rules (i.e., rules for which the associated destination addresses are associated with the application), and egress flows to egress rules (i.e., rules for which the associated source addresses are associated with the application). It should be understood that the process 300 is a conceptual process, and that the analysis appliance (or other component performing the rule modification recommendation process) does not necessarily perform analysis on each group serially. For instance, some embodiments perform analysis on each of the groups in parallel.

For each flow in the selected group, the process 300 identifies (at 330) a closest matching firewall rule in the set of existing firewall rules. In general, there should not be any firewall rule that is a perfect match (source, destination, and service) because the flow would have matched that firewall rule in the network and thus not appeared as a leak. However, different embodiments may use different variations to determine which firewall rule is the closest to a match. One such process for finding the closest matching rule for a flow is described below by reference to FIG. 5. In addition, some embodiments create new rules (or recommend creation of new rules) during this process, if there is not a rule in the corresponding group for the service (port and protocol number) on which a flow is communicating. In the example of FIG. 4, the rule 410 is identified as the closest matching rule for each of the flows 415.

After identifying the closest matching rule for each flow in the group, the process 300 determines (at 335) whether additional groups of flows remain (i.e., whether the intra-application, ingress, and egress flows have all been analyzed). If additional groups, remain, the process 300 returns to 325 to select another group of flows. To the extent the groups are selected sequentially, different embodiments may select the groups in different orders.

Once all of the flows have been analyzed and the closest matching rule identified for each flow (or new rules created, if necessary), the process 300 identifies the recommended modifications for each such rule. As shown, the process 300 selects (at 340) a rule that is the closest matching rule for at least one flow. As indicated above, the process 300 is a conceptual process, and in actuality this analysis might be performed in parallel for many firewall rules.

The process 300 modifies (at 345) the selected rule to include additional addresses in the source and/or destination match conditions so as to include (i) all addresses from the existing rule and (ii) all newly observed addresses of the flows for which the selected rule was identified as the closest matching rule. FIG. 4 illustrates that the modified rule 420 now includes source address match conditions of {M1, M2, M3, M4, M5} and destination address match conditions of {M10, M11, M12, M13}. As such, both of the flows 415 would match the new recommended rule 420 in addition to any flows that would have previously matched the existing rule 410.

In some embodiments, new groups are created (or recommended for creation) to include the newly-added addresses and/or existing groups used for the rule are modified (or recommended for modification). Other embodiments perform a group selection process to determine existing groups that should be added to the source and/or destination match conditions for each rule. Specifically, for each rule that is identified for modification, some embodiments use an optimization problem driven by user-specified settings to determine an optimal set of groups to add to the source and/or destination match conditions. This group selection process is described in more detail below by reference to FIG. 7.

After modifying the selected rule, the process 300 determines (at 350) whether any rule remain to be modified (i.e., whether there are any more rules identified as the closest matching rule for one or more flows). If additional such rules remain, the process returns to 340 to select another rule and modify that rule.

Once all of the rules have been analyzed, the process 300 provides (at 355) recommended modifications (e.g., modified and new rules, new groups of compute machines) to the policy, and ends. In some embodiments, the policy is automatically modified based on these recommendations. In other embodiments, however, additional safeguards are considered before modifying the policy. For instance, some embodiments perform verification processes to ensure that the rules specified for modification have not already been modified in some way during the interim (i.e., while the process 300 is running). In addition, some embodiments present the recommended modifications to a user (e.g., a security administrator) for verification (e.g., through a graphical user interface). The user can select which modifications to accept or reject in some such embodiments.

As mentioned, different embodiments may use different optimization techniques to find the closest matching rule for a given flow. FIG. 5 conceptually illustrates a process 500 of some embodiments for identifying the closest matching rule for a flow. In some embodiments, the process 500 is performed as part of a larger policy modification recommendation process (e.g., at operation 330 of the process 300). The process 500 will be described in part by reference to FIG. 6, which illustrates the identification of a closest matching rule for a flow 600.

As shown, the process 500 begins by receiving (at 505) a flow and a set of existing rules for the flow group to which the flow belongs. That is, if the flow is an ingress flow, the process also receives the ingress rules; if the flow is an egress flow, the process also receives the egress rules; if the flow is an intra-application flow, the process receives the intra-application rules. As described above, in some embodiments, the process 500 is performed for each flow observed in the network (at least over a particular time period) that is sent to, from, or between compute machines of a specified application and does not match on any of the specific (microsegmented) firewall rules of the security policy for the application. In the example of FIG. 6, the flow is sent from a source M4 to a destination M10 and the service is http (protocol of TCP and port number 80). As described above by reference to FIG. 4, this is an ingress flow given the specification of the application boundary.

The process first determines (at 510) whether there are any existing rules for which the flow matches the protocol and port number. That is, the process identifies whether there are any existing rules for the service on which the flow is communicating. In general, while the source and destination addresses of rules can be modified to add additional machines/addresses, services should not be added to existing rules. In the example shown in FIG. 6, three ingress rules 605 are identified that match on port number 80 and protocol TCP (http service). The highest priority of these rules (priority number 2) matches on source addresses {M6, M7, M8} and destination addresses {M11}, the next highest priority rule (priority number 4, where lower numbers equal higher priority) matches on source addresses {M1, M2, M3} and destination addresses {M10, M11, M12}, and the lowest priority of these rules (priority number 7) matches on source addresses {M4, M5} and destination addresses {M12, M13}.

If there are no existing rules for which the flow matches the port number and protocol, the process 500 creates (at 515) a new rule for the port number and protocol and selects this as the closest matching rule, then ends. In some embodiments, the newly created rule is also eligible to be identified as the closest matching rule for subsequent flows. This way, if there are multiple flows for the same service in the same group of flows, these can be amalgamated into a single new rule rather than creating separate rules for each such flow.

If at least one rule is identified for which the flow matches the port number and protocol, the process 500 determines (at 520) whether any of these rules match one of the source and destination addresses of the flow. There should not be any rules that are a perfect match for the flow (source, destination, and service) because the flow would have matched that firewall rule in the network and thus not appeared as a leak. However, if multiple rules are found for which the flow matches the protocol and port number, then preference is given to any such rules for which one of the source and destination addresses of the flow matches the source or destination addresses associated with the rule, as compared to rules for which neither the source nor destination addresses of the flow matches the source or destination addresses associated with the rule.

If there are any rules for which the flow matches the protocol, port number, and one address, then the process 500 selects (at 525) the highest priority such rule as the closest matching rule for the flow, then ends. While highest priority is one possible tiebreaker criteria, other embodiments may use various different criteria. For instance, some embodiments prefer either source or destination matches, or (for ingress or egress flows) prefer matches on the application side as opposed to the non-application side. However, one benefit of using priority (or sequence number of the rule, which is typically inverse to priority) is that each rule in a policy has a unique priority (i.e., there are not two rules in a policy with the same priority).

If there are no rules for which the flow matches the protocol, port number, and either source or destination address, then the process 500 selects (at 530) the highest priority rule for which the flow matches the protocol and port number as the closest matching rule for the flow, then ends. Another benefit of using the priority or sequence number tiebreaker criteria is that this criterion also applies when there are no address matches. It should be noted that if there is only one rule for which the flow matches the protocol and port number, the operations 520-530 may not be performed and this single matching rule is automatically selected as the closest matching rule for the flow.

In the example of FIG. 6, the flow 600 matches all three of the rules 605 on port number and protocol. The flow 600 does not match the first rule (Rule 1) on either source or destination address side but matches the second rule (Rule 2) on the destination address side and matches the third rule (Rule 3) on the source address side. Because the second rule has a higher priority than the third rule (priority number 4 as compared to priority number 7), the second rule is selected as the closest matching rule for the flow 600 (as shown by the italics).

As indicated above, the process for modifying a rule that is identified as the closest matching rule for at least one flow involves identifying a set of groups to add to the source and/or destination match conditions of the flow. If the rules were expressed in the policy in terms of addresses, the modification process would be simple and would just involve adding the addresses from the flows to the match conditions. However, many rules may have hundreds or even thousands of compute machine addresses in the source and/or destination match conditions, and so storing the rules in terms of addresses is unwieldy. Another simplistic solution would be to simply create a group out of the addresses that need to be added to a given match condition and use that group. However, this could lead to a proliferation of groups in the policy, which would also become unnecessarily unwieldy.

Instead, some embodiments attempt to optimally reuse existing groups that are already defined in the policy. This group reuse, in some embodiments, is driven by a user-specified threshold that indicates tolerance for the inclusion of compute machines that are not in the identified set of compute machines in the selected groups. This threshold balances the desire to use existing groups (as opposed to creating new groups for every rule modification) against the inclusion in the match condition of additional compute machines that are not part of the set of compute machines identified for addition to the match condition.

FIG. 7 conceptually illustrates a process 700 of some embodiments for selecting a set of existing groups to add to a set of match conditions for a firewall rule. The match conditions could be either source or destination match conditions and, for some rules, both source and destination match conditions are modified (in separate iterations of the process 700). In some embodiments, the process 700 is performed as part of a larger policy modification recommendation process (e.g., at operation 345 of the process 300). This process 700 is performed, in some embodiments, for each firewall rule that is selected as the closest matching rule (e.g., by the process 500) for at least one flow (and, as noted, may be performed separately for both the source and destination match conditions of such a flow). The process 700 will be described in part by reference to FIGS. 8 and 9, which illustrate an example of selecting a set of groups to add to a set of match conditions.

As shown, the process 700 begins by receiving (at 705) (i) a set of machines (addresses) that are already in the existing match condition, (ii) a set of machines (addresses) to add to the match condition, (iii) a set of existing groups that are not already in the match condition, and (iv) a group use threshold. The set of machines already in the match condition are based on the normalization of the rule as described by reference to FIG. 3, while the set of machines to add to the match condition are based on the flows for which the current rule was identified as the closest matching rule. In some embodiments, the set of existing groups includes all groups defined within the policy that are not already used in the match condition. In some embodiments, these are pre-filtered so as to remove groups that do not include any of the machines to be added to the match condition (because such groups would not be useful).

The group use threshold is a user-specified threshold that indicates tolerance for the inclusion in the match conditions of machines that are not in either the set of machines already in the existing match condition or the set of machines to be added to the match condition. In some embodiments, as the threshold is increased more of the compute machines in a particular group are required to be part of the set of machines identified for addition to the match condition. Specifically, in some embodiments, the threshold specifies a minimum percentage of the machines in a group that are required to be in the set of machines identified for addition to the match condition in order for the group to be considered for use in the match condition. In some embodiments, the user specifies the group use threshold through a user interface mechanism, such as a slider. This user interface mechanism may be presented to the user when the user provides input to begin the policy modification recommendation process. In different embodiments, the group use threshold may be set to any value greater than 0 (and up to 100%) or may be limited to, e.g., 10% increments (e.g., 10%, 20%, . . . 100%). Setting the threshold to 100% means that no groups with compute machines outside of those that need to be added to the match condition will be selected. Some embodiments have a default group use threshold (e.g., 80%) in case the user does not provide a value.

FIG. 8 illustrates, in a first stage 805, an example set of inputs to the process 700. In this example, the existing match conditions 820 match on a single group (Group 8) that includes machines M9, M10, and M11, while the set 825 of machines to add to this match condition 820 based on analysis of the flows are M1, M2, M3, M4, M5, M6, M7, and M8. In addition, the group use threshold 830 is set to 80%, which is high but still allows for inclusion of some machines that are not specified for addition to the match conditions. Finally, the first stage 805 illustrates seven groups 835 that are possibilities for inclusion in the modified match conditions, with each of these groups 835 including at least one machine in the set 825 of machines to add to the match condition.

Returning to the FIG. 7, the process 700 removes (at 710) machines already in the existing match condition from the existing groups. It should be noted that this does not affect the groups as defined in the policy, as this removal is only for the consideration of group reuse. This removal prevents these machines, which can be added to the match conditions via group reuse without any consequence, from affecting decisions as to whether a group is eliminated from consideration based on the group use threshold. Other embodiments, rather than removing these machines from the existing groups, add these machines to the set of machines to be added to the match condition (while also resetting the match condition to not include any groups and moving the groups in the match condition into the set of potential groups).

After removing these machines from the existing groups, the process 700 computes (at 715), for each group, the percentage of machines left in the group that are also in the set of machines to add to the match condition (also referred to as a group match ratio). The second stage 810 of FIG. 8 illustrates each of the groups 835 with their respective group match ratios computed. The first group (Group 1) has had three of its members removed and now has a group match ratio of 80%. Groups 2, 5, and 6 have group match ratios of 100% with no removal of any members, while Group 3 has a group match ratio of 100% after removal of one of its two members. Group 4 has no members removed but only one member out of five in the set 825 of machines to add to the match conditions for a group match ratio of 20%. Finally, Group 7 has three members removed such that its group match ratio is only 33%.

The process 700 then removes (at 720) any groups with a computed group match ratio below the specified group use threshold. Removal of these groups prevents the use of groups with an unacceptably high percentage (as determined by the user-specified group use threshold) of machines that are not in the set of machines to be added to the match condition.

Next, the process 700 orders (at 725) the remaining groups (i.e., those groups that have not been removed). Some embodiments use group match ratio as the primary ordering criteria, followed by the absolute number of machines in the group that are in the set of machines to be added to the match condition. That is, a first group with six out of its eight machines in the set of machines to be added to the match condition will be ordered ahead of a second group with three out of its four machines to be added to the match conditions, but behind a third group with both of its two machines to be added to the match conditions. Other embodiments order groups with fewer machines that are not in the set of machines to be added to the match condition ahead of groups with more such machines (assuming the groups are tied on group match ratio). In case of the need for additional tiebreakers, some embodiments use group creation time (e.g., preferring more recent or less recent creation times).

The third stage 815 of FIG. 8 illustrates the remaining re-ordered groups 840 after (i) removal of groups with group match ratios below the group use threshold and (ii) ordering of the groups. Group 4 and Group 7 have been eliminated because these groups have group match ratios of 20% and 33%, below the group use threshold of 80%. Groups 2, 6, 5, and 3 all have group match ratios of 100%: Group 2 in this example has a more recent creation time than Group 6 and therefore is ranked first. Group 5 only has two members, while Group 3 has a single member, and thus these groups are ranked third and fourth. Finally, Group 1 has five members, but the group match ratio is only 80% and is thus ranked last of the remaining groups.

With the groups ordered, the process 700 iterates through the groups to determine whether each group should be added to the match condition. As shown, the process 700 selects (at 730) the next group in the order (i.e., starting with the first group) and determines whether to add this group to the match condition.

Specifically, the process 700 determines (at 735) whether the selected group includes at least one machine that (i) is in the set of machines to be added to the match condition and (ii) is not already in a group that has been added to the match condition. Some embodiments implement this by using a data structure that starts with the entire set of machines to be added to the match condition and removes machines from this data structure whenever a group including the machine is added to the match condition.

When the selected group meets these criteria, the process 700 adds (at 740) the group to the match condition (i.e., to the list of groups recommended to be added to the match condition). Based on these criteria, the first group in the order will always be added to the match condition, because it will have at least one machine to be added and that machine could not have already been added via a previous group.

Next, the process 700 determines whether to check additional groups. First, the process 700 determines (at 745) whether there are any remaining machines to add to the match condition (i.e., whether all of the machines have been removed from the data structure mentioned above). If all of the machines have been added to the match condition, then no additional groups need to be analyzed and the process proceeds to 760, described below.

If any machines remain to be added to the match condition, then the process 700 determines (at 750) whether any groups remain to be analyzed. If there are more groups that could potentially be added to the match condition, the process returns to 730 to select the next group in the order. However, if all groups have been analyzed and there are machines remaining to be added to the match condition, the process creates (at 755) a group for any remaining machines and adds this group to the match condition. If multiple machines remain to be added to the match condition, some embodiments create a single group for all of the machines, while other embodiments create a separate group for each remaining machine. Any newly added groups are also added to the set of existing groups so that these groups can be reused for subsequent match condition updates. For instance, a group used in a source match condition for egress flows might end up being useful in a destination match condition for ingress flows or on either side for intra-application flows.

FIG. 9 illustrates, in a first stage 905, the candidate groups 840 from the third stage 815 of FIG. 8. The second stage 910 illustrates the selected groups 925 according to the process 700. In this example, Group 2 is first analyzed and selected for the match condition. Group 6 is analyzed next and also added, because M6, M7, and M8 have not yet been included in the match condition. However, all of the machines in Group 5 and Group 3 have been added to the match condition based on the previous additions of Group 2 and Group 6. Finally, Group 1 is analyzed and added because M5 has not yet been otherwise added to the match condition. The third stage 915 illustrates the updated match condition 930, which includes newly added Groups 1, 2, and 6, the previous Group 8, as well as a newly created Group 9 for machine M4.

Returning to FIG. 7, after updating the match condition with any newly added and newly created groups, the process 700 eliminates (at 760) any redundant groups, then ends. Here, some embodiments check each group in the updated match condition and determine whether there is another group that (i) includes all of its required machines (i.e., machines either newly added or pre-existing in the match condition) and (ii) includes at least one other required machine. In this case, the group with fewer required machines is removed from the recommended match condition to eliminate redundancy. The fourth stage 920 of FIG. 9 illustrates a further updated match condition 935 in which Groups 6 and 8 are both removed because all of their machines {M6, M7, M8} and {M9, M10, M11} are included in Group 1. It should be noted that some embodiments do not allow or do not recommend the removal of any groups that were part of the match condition prior to the modification recommendation process.

FIG. 10 conceptually illustrates an electronic system 1000 with which some embodiments of the invention are implemented. The electronic system 1000 may be a computer (e.g., a desktop computer, personal computer, tablet computer, server computer, mainframe, a blade computer etc.), phone, PDA, or any other sort of electronic device. Such an electronic system includes various types of computer readable media and interfaces for various other types of computer readable media. Electronic system 1000 includes a bus 1005, processing unit(s) 1010, a system memory 1025, a read-only memory 1030, a permanent storage device 1035, input devices 1040, and output devices 1045.

The bus 1005 collectively represents all system, peripheral, and chipset buses that communicatively connect the numerous internal devices of the electronic system 1000. For instance, the bus 1005 communicatively connects the processing unit(s) 1010 with the read-only memory 1030, the system memory 1025, and the permanent storage device 1035.

From these various memory units, the processing unit(s) 1010 retrieve instructions to execute and data to process in order to execute the processes of the invention. The processing unit(s) may be a single processor or a multi-core processor in different embodiments.

The read-only-memory (ROM) 1030 stores static data and instructions that are needed by the processing unit(s) 1010 and other modules of the electronic system. The permanent storage device 1035, on the other hand, is a read-and-write memory device. This device is a non-volatile memory unit that stores instructions and data even when the electronic system 1000 is off. Some embodiments of the invention use a mass-storage device (such as a magnetic or optical disk and its corresponding disk drive) as the permanent storage device 1035.

Other embodiments use a removable storage device (such as a floppy disk, flash drive, etc.) as the permanent storage device. Like the permanent storage device 1035, the system memory 1025 is a read-and-write memory device. However, unlike storage device 1035, the system memory is a volatile read-and-write memory, such a random-access memory. The system memory stores some of the instructions and data that the processor needs at runtime. In some embodiments, the invention's processes are stored in the system memory 1025, the permanent storage device 1035, and/or the read-only memory 1030. From these various memory units, the processing unit(s) 1010 retrieve instructions to execute and data to process in order to execute the processes of some embodiments.

The bus 1005 also connects to the input and output devices 1040 and 1045. The input devices enable the user to communicate information and select commands to the electronic system. The input devices 1040 include alphanumeric keyboards and pointing devices (also called “cursor control devices”). The output devices 1045 display images generated by the electronic system. The output devices include printers and display devices, such as cathode ray tubes (CRT) or liquid crystal displays (LCD). Some embodiments include devices such as a touchscreen that function as both input and output devices.

Finally, as shown in FIG. 10, bus 1005 also couples electronic system 1000 to a network 1065 through a network adapter (not shown). In this manner, the computer can be a part of a network of computers (such as a local area network (“LAN”), a wide area network (“WAN”), or an Intranet, or a network of networks, such as the Internet. Any or all components of electronic system 1000 may be used in conjunction with the invention.

Some embodiments include electronic components, such as microprocessors, storage and memory that store computer program instructions in a machine-readable or computer-readable medium (alternatively referred to as computer-readable storage media, machine-readable media, or machine-readable storage media). Some examples of such computer-readable media include RAM, ROM, read-only compact discs (CD-ROM), recordable compact discs (CD-R), rewritable compact discs (CD-RW), read-only digital versatile discs (e.g., DVD-ROM, dual-layer DVD-ROM), a variety of recordable/rewritable DVDs (e.g., DVD-RAM, DVD-RW, DVD+RW, etc.), flash memory (e.g., SD cards, mini-SD cards, micro-SD cards, etc.), magnetic and/or solid state hard drives, read-only and recordable Blu-Ray® discs, ultra-density optical discs, any other optical or magnetic media, and floppy disks. The computer-readable media may store a computer program that is executable by at least one processing unit and includes sets of instructions for performing various operations. Examples of computer programs or computer code include machine code, such as is produced by a compiler, and files including higher-level code that are executed by a computer, an electronic component, or a microprocessor using an interpreter.

While the above discussion primarily refers to microprocessor or multi-core processors that execute software, some embodiments are performed by one or more integrated circuits, such as application specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs). In some embodiments, such integrated circuits execute instructions that are stored on the circuit itself.

As used in this specification, the terms “computer”, “server”, “processor”, and “memory” all refer to electronic or other technological devices. These terms exclude people or groups of people. For the purposes of the specification, the terms display or displaying means displaying on an electronic device. As used in this specification, the terms “computer readable medium,” “computer readable media,” and “machine readable medium” are entirely restricted to tangible, physical objects that store information in a form that is readable by a computer. These terms exclude any wireless signals, wired download signals, and any other ephemeral signals.

This specification refers throughout to computational and network environments that include virtual machines (VMs). However, virtual machines are merely one example of data compute nodes (DCNs) or data compute end nodes, also referred to as addressable nodes. DCNs may include non-virtualized physical hosts, virtual machines, containers that run on top of a host operating system without the need for a hypervisor or separate operating system, and hypervisor kernel network interface modules.

VMs, in some embodiments, operate with their own guest operating systems on a host using resources of the host virtualized by virtualization software (e.g., a hypervisor, virtual machine monitor, etc.). The tenant (i.e., the owner of the VM) can choose which applications to operate on top of the guest operating system. Some containers, on the other hand, are constructs that run on top of a host operating system without the need for a hypervisor or separate guest operating system. In some embodiments, the host operating system uses name spaces to isolate the containers from each other and therefore provides operating-system level segregation of the different groups of applications that operate within different containers. This segregation is akin to the VM segregation that is offered in hypervisor-virtualized environments that virtualize system hardware, and thus can be viewed as a form of virtualization that isolates different groups of applications that operate in different containers. Such containers are more lightweight than VMs.

Hypervisor kernel network interface modules, in some embodiments, is a non-VM DCN that includes a network stack with a hypervisor kernel network interface and receive/transmit threads. One example of a hypervisor kernel network interface module is the vmknic module that is part of the ESXi™ hypervisor of VMware, Inc.

It should be understood that while the specification refers to VMs, the examples given could be any type of DCNs, including physical hosts, VMs, non-VM containers, and hypervisor kernel network interface modules. In fact, the example networks could include combinations of different types of DCNs in some embodiments.

While the invention has been described with reference to numerous specific details, one of ordinary skill in the art will recognize that the invention can be embodied in other specific forms without departing from the spirit of the invention. In addition, a number of the figures (including FIGS. 3, 5, and 7) conceptually illustrate processes. The specific operations of these processes may not be performed in the exact order shown and described. The specific operations may not be performed in one continuous series of operations, and different specific operations may be performed in different embodiments. Furthermore, the process could be implemented using several sub-processes, or as part of a larger macro process. Thus, one of ordinary skill in the art would understand that the invention is not to be limited by the foregoing illustrative details, but rather is to be defined by the appended claims.

Claims

1. A method for modifying a firewall rule of a security policy implemented in a network, the method comprising: identifying a set of compute machines to be added to a match condition for the firewall rule, wherein the match condition is expressed using one or more groups of compute machines;selecting a set of groups for the identified set of compute machines from a plurality of existing groups of compute machines based on a user-specified threshold indicating tolerance for inclusion of compute machines that are not in the identified set of compute machines in the selected groups; andusing the selected set of groups for the match condition of the firewall rule;wherein the user-specified threshold balances use of existing groups against inclusion in the match condition of compute machines that are not in the identified set of compute machines.
2. The method of claim 1, wherein the identified set of compute machines are based on observed flows in a network that do not match the firewall rule.
3. The method of claim 1, wherein a higher threshold excludes groups with fewer compute machines that are not in the identified set of compute machines.
4. The method of claim 1, wherein the set of compute machines is a set of network addresses and each group is a different collection of network addresses.
5. The method of claim 1, wherein using the selected set of groups comprises presenting the selected set of groups as a recommendation to a user for modifications to the match condition for the firewall rule.
6. The method of claim 1, wherein the match condition is one of source addresses of flows and destination addresses of flows.
7. The method of claim 1, wherein the user-specified threshold specifies a minimum percentage of the compute machines in a group that are required to be in the identified set of compute machines for the group to be included in the selected set of groups.
8. The method of claim 7, wherein the selected set of groups comprises, for each compute machine in the identified set of compute machines, at least one group that includes the compute machine unless there are no groups in the plurality of existing groups that include the compute machine.
9. The method of claim 8, wherein selecting the set of groups comprises creating a new group for any compute machines that are not included in any of the existing groups.
10. A non-transitory machine readable medium storing a program which when executed by at least one processing unit modifies a firewall rule of a security policy implemented in a network, the program comprising sets of instructions for: identifying a set of compute machines to be added to a match condition for the firewall rule, wherein the match condition is expressed using one or more groups of compute machines;selecting a set of groups for the identified set of compute machines from a plurality of existing groups of compute machines based on a user-specified threshold indicating tolerance for inclusion of compute machines that are not in the identified set of compute machines in the selected groups; andusing the selected set of groups for the match condition of the firewall rule;wherein the user-specified threshold balances use of existing groups against inclusion in the match condition of compute machines that are not in the identified set of compute machines.
11. The non-transitory machine readable medium of claim 10, wherein the identified set of compute machines are based on observed flows in a network that do not match the firewall rule.
12. The non-transitory machine readable medium of claim 1, wherein a higher threshold excludes groups with fewer compute machines that are not in the identified set of compute machines.
13. The non-transitory machine readable medium of claim 10, wherein the set of compute machines is a set of network addresses and each group is a different collection of network addresses.
14. The non-transitory machine readable medium of claim 10, wherein the set of instructions for using the selected set of groups comprises a set of instructions for presenting the selected set of groups as a recommendation to a user for modifications to the match condition for the firewall rule.
15. The non-transitory machine readable medium of claim 10, wherein the match condition is one of source addresses of flows and destination addresses of flows.
16. The non-transitory machine readable medium of claim 10, wherein the user-specified threshold specifies a minimum percentage of the compute machines in a group that are required to be in the identified set of compute machines for the group to be included in the selected set of groups.
17. The non-transitory machine readable medium of claim 16, wherein the selected set of groups comprises, for each compute machine in the identified set of compute machines, at least one group that includes the compute machine unless there are no groups in the plurality of existing groups that include the compute machine.
18. The non-transitory machine readable medium of claim 17, wherein the set of instructions for selecting the set of groups comprises a set of instructions for creating a new group for any compute machines that are not included in any of the existing groups.

US Referenced Citations (309)

Number	Name	Date	Kind
5636128	Sugimoto et al.	Jun 1997	A
7027411	Pulsipher et al.	Apr 2006	B1
7065079	Patra et al.	Jun 2006	B1
7352280	Rockwood	Apr 2008	B1
7580356	Mishra et al.	Aug 2009	B1
7739211	Coffman et al.	Jun 2010	B2
7908655	Bhattacharyya et al.	Mar 2011	B1
8005945	Cohen et al.	Aug 2011	B2
8359652	Bhagwan et al.	Jan 2013	B2
8495429	Fu et al.	Jul 2013	B2
8499348	Rubin	Jul 2013	B1
8605655	Sahai et al.	Dec 2013	B1
8762957	Cobb et al.	Jun 2014	B2
9166997	Guo et al.	Oct 2015	B1
9215213	Bansal	Dec 2015	B2
9218527	Lakshminarayan et al.	Dec 2015	B2
9223767	Powell et al.	Dec 2015	B1
9438560	Mohanty et al.	Sep 2016	B2
9438634	Ross et al.	Sep 2016	B1
9454444	Agarwal et al.	Sep 2016	B1
9467476	Shieh et al.	Oct 2016	B1
9497206	Bernstein et al.	Nov 2016	B2
9578050	Barabash et al.	Feb 2017	B1
9680877	Duffield et al.	Jun 2017	B2
9699049	Gupta et al.	Jul 2017	B2
9767197	Agarwal et al.	Sep 2017	B1
9787641	Bansal et al.	Oct 2017	B2
9792447	Thota et al.	Oct 2017	B2
9838354	Tulasi	Dec 2017	B1
9882713	Raza et al.	Jan 2018	B1
9891940	Feroz et al.	Feb 2018	B2
9998339	Brajkovic et al.	Jun 2018	B1
10063519	Zhao	Aug 2018	B1
10129162	Faulk, Jr.	Nov 2018	B1
10257227	Stickle et al.	Apr 2019	B1
10298505	Grant et al.	May 2019	B1
10298619	Nimmagadda et al.	May 2019	B2
10324746	Kumar et al.	Jun 2019	B2
10419321	Raman et al.	Sep 2019	B2
10425437	Bog et al.	Sep 2019	B1
10432707	Hosie et al.	Oct 2019	B2
10521584	Mehr	Dec 2019	B1
10581897	Natanzon et al.	Mar 2020	B1
10735282	Singh et al.	Aug 2020	B1
10812409	Tiwary et al.	Oct 2020	B2
10887337	Kim et al.	Jan 2021	B1
10911335	Mordani et al.	Feb 2021	B1
11057414	Giorgio et al.	Jul 2021	B1
11140090	Mordani et al.	Oct 2021	B2
11150976	Marwah et al.	Oct 2021	B1
11176157	Mordani et al.	Nov 2021	B2
11188570	Jain et al.	Nov 2021	B2
11269718	Chen et al.	Mar 2022	B1
11288256	Jain et al.	Mar 2022	B2
11296960	Wang et al.	Apr 2022	B2
11321213	Gunda et al.	May 2022	B2
11336620	Cook	May 2022	B2
11340931	Krishna et al.	May 2022	B2
11343262	Junod et al.	May 2022	B2
11347896	Brown, Jr. et al.	May 2022	B1
11349876	Krishna et al.	May 2022	B2
11374952	Coskun et al.	Jun 2022	B1
11374968	Colón et al.	Jun 2022	B1
11398987	Jain et al.	Jul 2022	B2
11425150	Emanuel et al.	Aug 2022	B1
11436075	Jain et al.	Sep 2022	B2
11593639	Garg et al.	Feb 2023	B1
11616708	Chraim et al.	Mar 2023	B1
11693688	Krishna et al.	Jul 2023	B2
11743135	Mordani et al.	Aug 2023	B2
20030120955	Bartal et al.	Jun 2003	A1
20030236677	Casati et al.	Dec 2003	A1
20040190724	Dettinger et al.	Sep 2004	A1
20050108444	Flauaus et al.	May 2005	A1
20050119001	Watanabe	Jun 2005	A1
20050262554	Brooks et al.	Nov 2005	A1
20050289219	Nazzal	Dec 2005	A1
20060085785	Garrett	Apr 2006	A1
20060168657	Baentsch et al.	Jul 2006	A1
20060174337	Bernoth	Aug 2006	A1
20060239203	Talpade et al.	Oct 2006	A1
20070011734	Balakrishnan et al.	Jan 2007	A1
20070016666	Duffield et al.	Jan 2007	A1
20070058632	Back et al.	Mar 2007	A1
20070147236	Lee	Jun 2007	A1
20080037423	Singh et al.	Feb 2008	A1
20080059596	Ogawa	Mar 2008	A1
20080196102	Roesch	Aug 2008	A1
20080196103	Lin et al.	Aug 2008	A1
20080263661	Bouzida	Oct 2008	A1
20080267186	Boukis et al.	Oct 2008	A1
20080281660	Sajja et al.	Nov 2008	A1
20080282335	Abzarian et al.	Nov 2008	A1
20090077663	Sun et al.	Mar 2009	A1
20090106228	Weinman, Jr.	Apr 2009	A1
20090300341	Buehler et al.	Dec 2009	A1
20100049968	Dimitrakos et al.	Feb 2010	A1
20100106764	Chadwick et al.	Apr 2010	A1
20100107085	Chadwick et al.	Apr 2010	A1
20100153316	Duffield et al.	Jun 2010	A1
20100211673	Kosbab et al.	Aug 2010	A1
20100241480	Rokhlin et al.	Sep 2010	A1
20100309812	Marquez et al.	Dec 2010	A1
20100325199	Park et al.	Dec 2010	A1
20100332262	Horvitz et al.	Dec 2010	A1
20110082962	Horovitz et al.	Apr 2011	A1
20110162039	Trace et al.	Jun 2011	A1
20110170413	Shi et al.	Jul 2011	A1
20120131591	Moorthi et al.	May 2012	A1
20120226808	Morgan	Sep 2012	A1
20120266231	Spiers et al.	Oct 2012	A1
20130041522	Mori et al.	Feb 2013	A1
20130067090	Batrouni et al.	Mar 2013	A1
20130085914	Mcpherson et al.	Apr 2013	A1
20130117567	Chang et al.	May 2013	A1
20130124753	Ansari et al.	May 2013	A1
20130185413	Beaty et al.	Jul 2013	A1
20130198459	Joshi et al.	Aug 2013	A1
20130212255	Chao et al.	Aug 2013	A1
20130227687	Lee	Aug 2013	A1
20130254766	Zuo et al.	Sep 2013	A1
20130297768	Singh	Nov 2013	A1
20140019964	Neuse et al.	Jan 2014	A1
20140075564	Singla et al.	Mar 2014	A1
20140089506	Naga et al.	Mar 2014	A1
20140207918	Kowalski et al.	Jul 2014	A1
20140230008	Feroz et al.	Aug 2014	A1
20140245423	Lee	Aug 2014	A1
20140282591	Stich et al.	Sep 2014	A1
20140310513	Barney et al.	Oct 2014	A1
20150113529	Zhong	Apr 2015	A1
20150124608	Agarwal et al.	May 2015	A1
20150135003	Cota-Robles et al.	May 2015	A1
20150156214	Kaminsky	Jun 2015	A1
20150180892	Balderas	Jun 2015	A1
20150181394	Zuniga et al.	Jun 2015	A1
20150207813	Reybok et al.	Jul 2015	A1
20150281056	Liljenstolpe	Oct 2015	A1
20150281065	Liljenstolpe	Oct 2015	A1
20150286783	Kumar et al.	Oct 2015	A1
20150304349	Bernstein et al.	Oct 2015	A1
20150355957	Steiner et al.	Dec 2015	A1
20150358391	Moon et al.	Dec 2015	A1
20160050589	Safavi	Feb 2016	A1
20160080404	Kohout et al.	Mar 2016	A1
20160087847	Krithivas et al.	Mar 2016	A1
20160087859	Kuan et al.	Mar 2016	A1
20160156591	Zhou et al.	Jun 2016	A1
20160191306	Gasparakis et al.	Jun 2016	A1
20160191413	Feroz et al.	Jun 2016	A1
20160191463	Mohanty et al.	Jun 2016	A1
20160191466	Pernicha	Jun 2016	A1
20160191521	Feroz et al.	Jun 2016	A1
20160216994	Sefidcon et al.	Jul 2016	A1
20160218951	Vasseur et al.	Jul 2016	A1
20160294800	Oppenheim, Jr. et al.	Oct 2016	A1
20160294987	Tian et al.	Oct 2016	A1
20160301603	Park et al.	Oct 2016	A1
20160308898	Teeple et al.	Oct 2016	A1
20160350683	Bester et al.	Dec 2016	A1
20160352765	Mermoud et al.	Dec 2016	A1
20160359759	Singh et al.	Dec 2016	A1
20160380812	Chanda et al.	Dec 2016	A1
20160380884	Sarikaya et al.	Dec 2016	A1
20170005986	Bansal et al.	Jan 2017	A1
20170078168	Harris et al.	Mar 2017	A1
20170126677	Kumar et al.	May 2017	A1
20170134247	Hoja et al.	May 2017	A1
20170149804	Kolbitsch et al.	May 2017	A1
20170180319	Nimmagadda	Jun 2017	A1
20170207968	Ficken et al.	Jul 2017	A1
20170212799	Konireddygari	Jul 2017	A1
20170214634	Li	Jul 2017	A1
20170223046	Singh	Aug 2017	A1
20170272452	Kraemer et al.	Sep 2017	A1
20170279687	Muntés-Mulero et al.	Sep 2017	A1
20170293994	Li et al.	Oct 2017	A1
20170324632	Arora	Nov 2017	A1
20170359217	Ahuja et al.	Dec 2017	A1
20170374102	Woolward	Dec 2017	A1
20170374106	Hamou et al.	Dec 2017	A1
20180007005	Chanda et al.	Jan 2018	A1
20180007008	Bansal	Jan 2018	A1
20180007127	Salapura et al.	Jan 2018	A1
20180027080	Yang et al.	Jan 2018	A1
20180032399	Johnson et al.	Feb 2018	A1
20180034856	Mallya	Feb 2018	A1
20180041578	Lee et al.	Feb 2018	A1
20180048623	Bansal et al.	Feb 2018	A1
20180054456	Ground et al.	Feb 2018	A1
20180063164	Balasubramanian et al.	Mar 2018	A1
20180063178	Jadhav et al.	Mar 2018	A1
20180077119	Fields et al.	Mar 2018	A1
20180077120	Baughman et al.	Mar 2018	A1
20180077189	Doppke et al.	Mar 2018	A1
20180084034	Netto et al.	Mar 2018	A1
20180088964	Hussain et al.	Mar 2018	A1
20180091485	Lee et al.	Mar 2018	A1
20180101371	Flanakin et al.	Apr 2018	A1
20180123907	Raman et al.	May 2018	A1
20180123939	Raman et al.	May 2018	A1
20180145999	Ertugrul et al.	May 2018	A1
20180167405	Comay et al.	Jun 2018	A1
20180176102	Bansal et al.	Jun 2018	A1
20180176252	Nimmagadda et al.	Jun 2018	A1
20180176261	Bansal et al.	Jun 2018	A1
20180181423	Gunda et al.	Jun 2018	A1
20180181754	Gunda	Jun 2018	A1
20180183757	Gunda et al.	Jun 2018	A1
20180183759	Gunda et al.	Jun 2018	A1
20180183761	Gunda et al.	Jun 2018	A1
20180189667	Tsou et al.	Jul 2018	A1
20180234333	Inamdar et al.	Aug 2018	A1
20180248904	Villella et al.	Aug 2018	A1
20180270189	Montenot et al.	Sep 2018	A1
20180270308	Shea et al.	Sep 2018	A1
20180287876	Strobel et al.	Oct 2018	A1
20180288063	Koottayi et al.	Oct 2018	A1
20180295036	Krishnamurthy et al.	Oct 2018	A1
20180316704	Durairaj et al.	Nov 2018	A1
20180324199	Crotinger et al.	Nov 2018	A1
20190007292	Nevo et al.	Jan 2019	A1
20190065739	Manadhata et al.	Feb 2019	A1
20190065762	Kim et al.	Feb 2019	A1
20190075056	Lu et al.	Mar 2019	A1
20190138423	Agerstam et al.	May 2019	A1
20190158520	DiValentin et al.	May 2019	A1
20190163900	Zhang et al.	May 2019	A1
20190166008	Gintis et al.	May 2019	A1
20190171474	Malboubi et al.	Jun 2019	A1
20190180141	Tiagi et al.	Jun 2019	A1
20190182276	Tiagi et al.	Jun 2019	A1
20190182281	Neil et al.	Jun 2019	A1
20190199599	Zavesky et al.	Jun 2019	A1
20190266004	Kumar et al.	Aug 2019	A1
20190280949	Wang et al.	Sep 2019	A1
20190303562	Masputra et al.	Oct 2019	A1
20190319863	Gupta et al.	Oct 2019	A1
20190342335	Ni et al.	Nov 2019	A1
20190373007	Salunke et al.	Dec 2019	A1
20190373052	Pollitt et al.	Dec 2019	A1
20190379612	Tiwary et al.	Dec 2019	A1
20190392329	Rangarajan et al.	Dec 2019	A1
20200028756	Hale et al.	Jan 2020	A1
20200084087	Sharma et al.	Mar 2020	A1
20200100145	Enqvist et al.	Mar 2020	A1
20200128043	Xie	Apr 2020	A1
20200162407	Tillotson	May 2020	A1
20200167258	Chattopadhyay et al.	May 2020	A1
20200167784	Kursun	May 2020	A1
20200183947	Reeve et al.	Jun 2020	A1
20200193031	Avraham et al.	Jun 2020	A1
20200210260	Prabhakar et al.	Jul 2020	A1
20200244676	Amit et al.	Jul 2020	A1
20200310884	Villalobos et al.	Oct 2020	A1
20200396075	Visegrady et al.	Dec 2020	A1
20200396254	Crabtree et al.	Dec 2020	A1
20210006642	He et al.	Jan 2021	A1
20210026677	Krishna et al.	Jan 2021	A1
20210026720	Jain et al.	Jan 2021	A1
20210026830	Jain et al.	Jan 2021	A1
20210026863	Mordani et al.	Jan 2021	A1
20210026870	Jain et al.	Jan 2021	A1
20210028996	Mordani et al.	Jan 2021	A1
20210029002	Mordani et al.	Jan 2021	A1
20210029050	Jain et al.	Jan 2021	A1
20210029051	Mordani et al.	Jan 2021	A1
20210029166	Krishna et al.	Jan 2021	A1
20210075789	Wen et al.	Mar 2021	A1
20210084074	Kirner et al.	Mar 2021	A1
20210099473	Fainberg et al.	Apr 2021	A1
20210110282	McCann et al.	Apr 2021	A1
20210110407	Albero et al.	Apr 2021	A1
20210136101	Ben-Yosef et al.	May 2021	A1
20210168125	Vemulpali	Jun 2021	A1
20210185073	Ewaida et al.	Jun 2021	A1
20210185085	Wang et al.	Jun 2021	A1
20210203684	Maor et al.	Jul 2021	A1
20210218770	Ben-Yosef et al.	Jul 2021	A1
20210219219	Sundararaj et al.	Jul 2021	A1
20210224179	Gunda et al.	Jul 2021	A1
20210243212	Bowman et al.	Aug 2021	A1
20210248240	Comish et al.	Aug 2021	A1
20210264025	Givental et al.	Aug 2021	A1
20210281591	Furtak	Sep 2021	A1
20210344689	Mehr	Nov 2021	A1
20210350248	Rogers et al.	Nov 2021	A1
20210367842	Guillou et al.	Nov 2021	A1
20210367923	Kaidi	Nov 2021	A1
20220014560	Crabtree et al.	Jan 2022	A1
20220070699	Thiyagarajan et al.	Mar 2022	A1
20220200993	Smith	Jun 2022	A1
20220210126	Keiser	Jun 2022	A1
20220215453	Achan et al.	Jul 2022	A1
20220224721	Bertiger et al.	Jul 2022	A1
20220239675	Panse et al.	Jul 2022	A1
20220239683	Kaliya et al.	Jul 2022	A1
20220253531	Kim et al.	Aug 2022	A1
20220261330	Gunda et al.	Aug 2022	A1
20220269577	Gechman et al.	Aug 2022	A1
20220365806	Krishna et al.	Nov 2022	A1
20220385647	Pabón et al.	Dec 2022	A1
20220407897	Raghuvanshi et al.	Dec 2022	A1
20220417096	Vutukuri et al.	Dec 2022	A1
20230011043	Panse et al.	Jan 2023	A1
20230011397	Panse et al.	Jan 2023	A1
20230011957	Panse et al.	Jan 2023	A1
20230131894	Panse et al.	Apr 2023	A1
20230179572	Ravi et al.	Jun 2023	A1

Foreign Referenced Citations (5)

Number	Date	Country
3422665	Jan 2019	EP
3716075	Sep 2020	EP
3767553	Jan 2021	EP
2006091175	Aug 2006	WO
2016003262	Jan 2016	WO

Non-Patent Literature Citations (17)

Entry
Arbuthnot, Tom, “What are Thresholds for Good and Poor Network Packet Loss, Jitter and Round Trip Time for Unified Communications?”, Tom Talks, May 17, 2018, 7 pages, retrieved from https://tomtalks.blog/what-are-thresholds-for-good-and-poor-network-packet-loss-jitter-and-round-trip-time-for-unified-communications/.
Abbes, Tarek, et al., “Detection of Firewall Configuration Errors with Updatable Tree,” International Journal of Information Security, May 2015, 17 pages, vol. 15, No. 3, Springer Verlag.
El-Atawy, Adel, et al., “Policy Segmentation for Intelligent Firewall Testing,” 1st IEEE ICNP Workshop on Secure Network Protocols, Nov. 6, 2005, 6 pages, IEEE, Boston, MA, USA.
Non-Published Commonly Owned U.S. Appl. No. 17/220,550, filed Apr. 1, 2021, 54 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/220,553, filed Apr. 1, 2021, 55 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/355,829, filed Jun. 23, 2021, 44 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/372,264, filed Jul. 9, 2021, 52 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/372,268, filed Jul. 9, 2021, 53 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/372,271, filed Jul. 9, 2021, 53 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/507,548, filed Oct. 21, 2021, 45 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 17/543,294, filed Dec. 6, 2021, 49 pages, VMware, Inc.
Oliveira, Ricardo M., et al., “Automatic Detection of Firewall Misconfigurations Using Firewall and Network Routing Policies,” Jan. 2009, 6 pages.
Ring, Markus, et al., “Detection of Slow Port Scans in Flow-Based Network Traffic,” PLOS ONE, Sep. 25, 2018, 18 pages, retrieved from https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0204507.
Turcotte, Melissa J. M., et al., “Unified Host and Network Data Set”, Aug. 24, 2017, 16 pages, arXiv:1708.07518v1, arXiv.org, Cornell University, Ithaca, NY, USA.
Waye, Lucas, et al., “Cryptographically Secure Information Flow Control on Key-Value Stores,” CCS '17: Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, Oct. 30-Nov. 3, 2017, 15 pages, ACM, Dallas, TX, USA.
Non-Published Commonly Owned U.S. Appl. No. 18/211,402, filed Jun. 19, 2023, 102 pages, VMware, Inc.
Non-Published Commonly Owned U.S. Appl. No. 18/226,771, filed Jul. 27, 2023, 94 pages, VMware, Inc.

Related Publications (1)

	Number	Date	Country
	20230179571 A1	Jun 2023	US

Reuse of groups in security policy

Information

Patent Number

Date Filed

Date Issued

Inventors

Original Assignees

Examiners

Agents

CPC

Field of Search

CPC

International Classifications