Patent Publication Number: US-11381587-B2

Title: Data segmentation

Description:
RELATED APPLICATIONS 
     The present application claims priority to U.S. Provisional Appl. Nos. 62/794,681 filed Jan. 20, 2019; the application is incorporated by reference herein in its entirety. 
    
    
     BACKGROUND 
     Technical Field 
     This disclosure relates generally to a data management system. 
     Description of the Related Art 
     The amount of data used by and accessible to computer systems is extremely large, and growing quickly. One estimate is that in 2016, there is approximately 11,000 exabytes of such information, which was expected to climb to around 52,000 Exabytes in 2020. Rizzatti, Dr. Lauro. “Digital Data Storage Is Undergoing Mind-Boggling Growth.”  EETimes,  14 Sep. 2016. This article states that unstructured data (e.g., documents, photos, videos, etc.) accounts for most of the available data. In addition to typically being unstructured, data is often scattered around layers of a network (e.g., a cloud network, a data center network, a corporate network, etc.) with poor structuring and visibility. Given that data is often scattered and unstructured, this makes ensuring proper handling of the data quite difficult. 
     That data often includes certain classes of information that is either legally required to be treated in a particular manner (as in the case of government regulation) or is desired to be treated in some fashion (as in the case with an enterprise data management policy). But since data is often scattered and unstructured, protecting that data or even ensuring that it is properly handled is impractical as the necessary understanding of what data is stored, how it is stored, where it is stored, and/or how it is used is simply not there or severely limited. 
     In some cases, such as the health care context, certain data handling is legally mandated. Health care enterprises commonly store records for their patients that identify personal health information (PHI) such as demographic information, medical histories, insurance information, etc. These health care enterprises often need to exchange records with other enterprises, while also complying with Health Insurance Portability and Accountability Act (HIPPA) provisions that set out requirements for protecting that health information. These records, however, are usually in an unstructured format (e.g., photos, videos, e-mail messages, WORD documents, portable document format (PDF), etc.), making it easy for an employee to store those records without identifying what content that they store. Thus, all possible locations where PHI might be stored in an on-premise file system or in cloud storage is not known. As an example, a PDF document that is incorrectly named might include PHI, but an enterprise may be unaware that the document does, in fact, store PHI. In such a scenario, a health care enterprise may unknowingly provide another enterprise with access to a database that includes records (e.g., PDFs) with PHI that should not be accessed by that other enterprise simply because the health care enterprise lacks an understanding of its data. 
     Even aside from legal mandates, data security is also of paramount importance. Data security management is normally performed by controlling access on the boundaries of a network. But once the network&#39;s perimeter defenses such as firewalls are breached, there may be little (if any) interior defense to prevent malware (e.g., a virus) from roaming and attacking the network by damaging or stealing sensitive data. In some cases, an “interior defense” strategy may involve an agent-based defense that requires every susceptible device in the network to run a local security process. But this approach presents multiple points of weakness within the network. Thus, if a single local process is out of date, disabled by a user, or has already been compromised, this could lead to a significant data breach. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram illustrating example elements of a system that includes a data-defined network (DDN) system, according to some embodiments. 
         FIG. 2  is a block diagram illustrating example elements of a DDN system, according to some embodiments. 
         FIG. 3  is a block diagram illustrating example elements of a DDN data structure and a data collection engine of a DDN system, according to some embodiments. 
         FIG. 4  is a block diagram illustrating example behavioral features, according to some embodiments 
         FIG. 5  is a block diagram illustrating example elements of a DDN manager, according to some embodiments. 
         FIG. 6  is a block diagram illustrating example elements of a learning workflow, according to some embodiments. 
         FIG. 7  is a block diagram illustrating example elements of an enforcement engine, according to some embodiments. 
         FIG. 8  is a block diagram illustrating example elements of an enforcement workflow, according to some embodiments. 
         FIGS. 9-11  are flow diagrams illustrating example methods relating to managing data, according to some embodiments. 
         FIG. 12  is a block diagram illustrating example elements of data segmentations, according to some embodiments. 
         FIGS. 13 and 14  are flow diagrams illustrating example methods relating to implementing data segmentation, according to some embodiments. 
         FIG. 15  is a block diagram illustrating an example computer system, according to some embodiments. 
     
    
    
     This disclosure includes references to “one embodiment” or “an embodiment.” The appearances of the phrases “in one embodiment” or “in an embodiment” do not necessarily refer to the same embodiment. Particular features, structures, or characteristics may be combined in any suitable manner consistent with this disclosure. 
     Within this disclosure, different entities (which may variously be referred to as “units,” “circuits,” other components, etc.) may be described or claimed as “configured” to perform one or more tasks or operations. This formulation—[entity] configured to [perform one or more tasks]—is used herein to refer to structure (i.e., something physical, such as an electronic circuit). More specifically, this formulation is used to indicate that this structure is arranged to perform the one or more tasks during operation. A structure can be said to be “configured to” perform some task even if the structure is not currently being operated. A “network interface configured to communicate over a network” is intended to cover, for example, an integrated circuit that has circuitry that performs this function during operation, even if the integrated circuit in question is not currently being used (e.g., a power supply is not connected to it). Thus, an entity described or recited as “configured to” perform some task refers to something physical, such as a device, circuit, memory storing program instructions executable to implement the task, etc. This phrase is not used herein to refer to something intangible. Thus, the “configured to” construct is not used herein to refer to a software entity such as an application programming interface (API). 
     The term “configured to” is not intended to mean “configurable to.” An unprogrammed FPGA, for example, would not be considered to be “configured to” perform some specific function, although it may be “configurable to” perform that function and may be “configured to” perform the function after programming. 
     Reciting in the appended claims that a structure is “configured to” perform one or more tasks is expressly intended not to invoke 35 U.S.C. § 112(f) for that claim element. Accordingly, none of the claims in this application as filed are intended to be interpreted as having means-plus-function elements. Should Applicant wish to invoke Section 112(f) during prosecution, it will recite claim elements using the “means for” [performing a function] construct. 
     As used herein, the terms “first,” “second,” etc. are used as labels for nouns that they precede, and do not imply any type of ordering (e.g., spatial, temporal, logical, etc.) unless specifically stated. For example, in a data structure that has multiple classes, the terms “first” class and “second” class can be used to refer to any class of the data structure. In other words, the first and second classes are not limited to the initial two classes of a data structure. 
     As used herein, the term “based on” is used to describe one or more factors that affect a determination. This term does not foreclose the possibility that additional factors may affect a determination. That is, a determination may be solely based on specified factors or based on the specified factors as well as other, unspecified factors. Consider the phrase “determine A based on B.” This phrase specifies that B is a factor is used to determine A or that affects the determination of A. This phrase does not foreclose that the determination of A may also be based on some other factor, such as C. This phrase is also intended to cover an embodiment in which A is determined based solely on B. As used herein, the phrase “based on” is thus synonymous with the phrase “based at least in part on.” 
     DETAILED DESCRIPTION 
     Managing data from the vantage point of the network perimeter is increasingly challenging, particularly with the current and expected further proliferation in governmental data usage regulations worldwide. To address such problems, the present disclosure sets forth a “data-defined” approach to data management. In this approach, data management problems can largely be seen as anomalous behavior of data, which can be addressed by classifying data in a network, defining “normal behavior” (or “anomalous behavior,” which refers to any improper use of data relative to some standard or data policy, whether or not that use is malicious), and then instituting an enforcement mechanism that ensures that anomalous data usage is controlled. 
     The current content and nature of data within a given computer network is typically poorly understood. Conventional infrastructure-driven approaches to network organization and data management are not concerned with what different types of data are present within a network and how that data normally behaves (whether that data is in use, at rest, or in transit), which puts such data management paradigms at a severe disadvantage when dealing with novel threats. 
     Data management broadly refers to the concept of ensuring that data is used in accordance with a policy objective. (Such “use” of the data includes the manner in which the data is stored, accessed, or moved.) The concept of data management thus includes data security (e.g., protecting data from malware attacks), data compliance (e.g., ensuring control of personal data is managed in accordance with a policy that may be established by a governmental organization), as well as permissioning that enforces entity-specific policies (e.g., certain groups in a company can access certain projects). The present disclosure describes a “data-defined” approach to data management, resulting in what is described as a “data-defined network” (DDN)—that is, a network (or portion of a network) that implements this data-defined approach. 
     Broadly speaking, a DDN stores one or more data structures in which data in a network is organized and managed on the basis of observed attributes of the data, rather than infrastructure-driven factors, such as the particular physical devices or locations where that data is stored. In this manner, a group of DDN data structures may form the building block of a DDN and incorporate multiple dimensions of relevant data attributes to facilitate capturing the commonality of data in a network. In some embodiments, a given one of the group of DDN data structures in a particular network may correspond to a set of data objects that have similar content (e.g., as defined by reference to some similarity metric) and indicate baseline behavior for that set of objects. As used herein, the term “observed behavior” refers to how data objects are observed to be used within a network; observed behavior may be determined through a learning or training phase as described in this disclosure. For example, if a document is exchanged between two computer systems, then exchanging that document between those two systems is said to be an example of observed behavior for that document. 
     When describing the behavior of data, the term “behavior” refers to actions performed on data, characteristics of those actions, and characteristics of those entities involved in the actions. Actions performed on the data may include without limitation reading, writing, deleting, transmitting, etc. Characteristics of those actions refers to properties of the actions being performed beyond the types of actions being performed on the data. Such characteristics may include without limitation the protocols used in those actions, the time when the action was initiated, the specific data involved in the action, parameters passed as part of the action, etc. Finally, data behavior also includes the identity and/or characteristics of the entities involved in the actions. Thus, if observed data behavior includes the transmission of data from user A to user B from a software entity C, data behavior can include information about user A, user B, and software entity C. Characteristics of the entities involved in the actions may include without limitation type of application transmitting the data, the type of system (e.g., client, server, etc.) running the application, etc. Accordingly, data behavior is intended to broadly encompass any information that can be extracted by a computer system when an operation is performed on a data object. 
     Once the observed behavior of a data object is determined, this information may be used to define the baseline behavior of the data object. The term “baseline behavior” (alternatively, “normal behavior” or “typical behavior”) refers to how a data object is expected to behave within a network, which, in many cases, is specified by observed behavior, as modified by any user-defined rules. Baseline behavior may thus be the observed behavior, or the observed behavior plus modifications specified by the user. Consider an example in which one observed behavior of a document is that the document is exchanged between three computer systems A, B, and C. The baseline behavior may be that the document can be exchanged between the three computer systems (which matches the observed behavior) or, because of user-intervention for example, the baseline behavior may also be that the document can be exchanged between computer systems A and B and D. When later evaluating data behavior, the term “anomalous behavior” refers to behavior of a data objects that deviates from the baseline behavior of that data object. A given DDN data structure may, in some cases, indicate policies for handling anomalous usage (e.g., preventing such usage or generating a message). 
     The organization of a DDN data structure that indicates content and behavior information is described herein as including a “content class” and a “behavior class.” This description is to be interpreted broadly to include any information that indicates a set of data objects that have similar content, in addition to baseline or typical behaviors for those data objects. As used herein, the term “class” refers to a collection of related information derived from a classification process. For example, a content class may identify individual data objects that are determined to be related to one another based on their content, and may further include features that describe the data objects and/or attributes of their content. A behavioral class may indicate a behavior of a data object, and may include specific behavioral features that define the associated behavior. These terms are not intended to be limited to any particular data structure format such as a “class” in certain object-oriented programming languages, but rather are intended to be interpreted more broadly. 
     In various embodiments that are described below, one or more DDN data structures are generated utilizing artificial intelligence (AI) algorithms (e.g., machine learning algorithms) to associate or link data objects having similar data content with their behavioral features and are then deployed to detect anomalous behavior and/or non-compliance with policy objectives. In various cases, the generation and deployment of DDN data structures may occur in two distinct operational phases. 
     During a learning phase, similarity detection and machine learning techniques may be used to associate data objects having similar data content and to identify the behavioral features of those data objects in order to generate a DDN data structure. In various embodiments, a user provides data object samples to be used in the learning phase. The data object samples that are provided by a user may be selected to achieve a particular purpose. In many cases, a user may select data object samples that have data that is deemed critical or important by the user. For example, a user may provide data object samples that have payroll information. Each of these samples may form the initial building block of a DDN data structure. After the data object samples have been received and processed, network traffic may be evaluated to extract data objects that may then be classified (e.g., using a similarity detection technique or a content classification model) in order to identify at least one of the data object samples with which the extracted data object shares similar content attributes. The content and behavioral features of that extracted data object may be collected and then provided to a set of AI algorithms to train the content classification model and a behavioral classification model. A DDN data structure, in various embodiments, is created to include a content class (of the content classification model) that corresponds to a sample and extracted data objects that are similar to that sample and to include one or more behavioral classes (of the behavioral classification model) that are associated with the behavioral features exhibited by those data objects. 
     During an enforcement phase, network traffic may be evaluated to extract data objects and to determine if those extracted data objects are behaving anomalously. In a similar manner to the learning phase, extracted data objects may be classified to determine if they fall within a content class of one of the DDN data structures—thus ascertaining whether they include content that is similar to previously classified content. In some embodiments, if a data object is associated with a content class, then its behavioral features are collected and classified in order to identify whether the current behavior of that data object falls within any of the behavioral classes associated with that content class. If the current behavior falls within one of the behavioral classes, then that data object can be said to exhibit normal or typical behavior; otherwise, that data object is behaving anomalously and thus a corrective action may be taken (e.g., prevent the data object from reaching its destination and log the event). In various cases, however, a data object may not comply with a policy objective and thus a corrective action may also be taken in such cases. 
     These techniques may be advantageous over prior approaches as these techniques allow for better data management based on a better understanding of the behavior of data. More specifically, in using these techniques, a baseline behavior may be identified for data objects (e.g., files) along with other information such as the relationships between those data objects. By understanding how a data object is routinely used, anomalous behavior may be more easily detected as the current behavior of a data object may be compared against how it is routinely used. This approach is distinct from, and complementary to, traditional perimeter-based solutions. 
     Because a DDN data structure may be used to identify data objects and their associated behavior and to enforce policy objectives against those data objects, this may enable a user to modify or refine the behavior of those data objects. As an example, subsequent to discovering a data management issue involving the misuse of certain data objects, a user may alter a policy to narrow the acceptable uses of those data objects. After mitigating a data management issue, a DDN data structure may adjust (or a new one may be generated) to identify the new baseline behavior of the data objects in view of the data management issue being mitigated. As such, a DDN data structure may continue to be used to track data behavior and identify any anomalous behavior, thereby helping to protect data from known and unknown data management issues. 
     Additionally, the techniques of the present disclosure may be used to discover previously unknown locations in a user&#39;s network where data of interest is stored. As such, a user may benefit from a greater insight into where data is located and/or the relationships that exist among data, users, applications, and/or networks that is provided by these techniques. As another example, users may be able to more easily comply with governmental regulations that attempt to control how certain data (e.g., PHI) should be handled because these techniques may establish the behavior of data and permit those users to conform that behavior in accordance with those governmental regulations. Various embodiments for implementing these techniques will now be discussed. 
     Turning now to  FIG. 1 , a block diagram of a system  100  that incorporates multiple data-defined network systems  140  is depicted. In the illustrated embodiment, system  100  includes computing devices  110 , data stores  111 , network appliances  120 , and a firewall  130 . As further depicted, each network appliance  120  includes a DDN system  140 . While system  100  is shown as a single network of computing systems enclosed by a firewall, in some embodiments, system  100  expands across multiple networks that each have computing systems that are enclosed by their own respective firewalls. In some embodiments, system  100  is implemented differently than shown—e.g., system  100  may include DDN systems  140 , but not firewall  130 . 
     System  100 , in various embodiments, is a network of components that are implemented via hardware or a combination of hardware and software routines. As an example, system  100  may be a database center housing database servers, storage systems, network switches, routers, etc., all of which may comprise an internal network separate from external network  105  such as the Internet. In some embodiments, system  100  includes components that may be located in different geological areas and thus may comprise multiple networks. For example, system  100  may include multiple database centers located around the world. Broadly speaking, however, system  100  may include a subset or all of the components associated with a given entity (e.g., an individual, a company, an organization, etc.). 
     Computing devices  110 , in various embodiments, are devices that perform a wide range of tasks by executing arithmetic and logical operations (via computer programming). Examples of computing devices  110  may include, but are not limited to, desktops, laptops, smartphones, tablets, embedded systems, and server systems. While computing devices  110  are depicted as residing behind firewall  130 , a computing device  110  may be located outside firewall  130  (e.g., a user may access a data store  111  from their laptop using their home network) while still being considered part of system  100 . In various embodiments, computing devices  110  are configured to communicate with other computing devices  110 , data stores  111 , and devices that are located on external network  105 , for example. That communication may result in intra-network traffic  115  that is routed through network appliances  120 . 
     Network appliances  120 , in various embodiments, are networking systems that support the flow of intra-network traffic  115  among the components of system  100 , such as computing devices  110  and data stores  111 . Examples of network appliances  120  may include, but are not limited to, a network switch (e.g., a Top-of-Rack (TOR) switch, a core switch, etc.), a network router, and a load balancer. Since intra-network traffic  115  flows through network appliances  120 , they may serve as a deployment point for a DDN system  140  or at least portions of a DDN system  140  (e.g., an enforcement engine that determines whether to block intra-network traffic  115 ). In various embodiments, network appliances  120  include a firewall application (and thus serve as a firewall  130 ) and a DDN system  140 ; however, they may include only a DDN system  140 . 
     Firewall  130 , in various embodiments, is a network security system that monitors and controls inbound and outbound network traffic based on predetermined security rules. Firewall  130  may establish, for example, a boundary between the internal network of system  100  and an untrusted external network, such as the Internet. During operation, in various cases, firewall  130  may filter the network traffic that passes between the internal network of system  100  and networks external to system  100  by dropping the network traffic that does not comply with the ruleset provided to firewall  130 . For example, if firewall  130  is designed to block telnet access, then firewall  130  will drop data packets destined to Transmission Control Protocol (TCP) port number  23 , which is used for telnet. While firewall  130  filters the network traffic passing into and out of system  100 , in many cases, firewall  130  provides no internal defense against attacks that have breached firewall  130  (i.e., have passed through firewall  130  without being detected by firewall  130 ). Accordingly, in various embodiments, system  100  includes one or more DDN systems  140  that serve as part of an internal defense mechanism. 
     DDN systems  140 , in various embodiments, are data management systems that monitor and control the flow of network traffic (e.g., intra-network traffic  115 ) and provide information that describes the behavior of data and its relationships with other data, applications, and users in order to assist users in better managing that data. As mentioned earlier, a DDN system  140  may use DDN data structures to group data objects that have similar content and to establish a baseline behavior for those data objects against which policies may be applied to modify the baseline behavior in some manner. The generation and deployment of a DDN data structure may occur in two operational phases. 
     In a learning phase, in various embodiments, a DDN system  140  (or a collection of DDN systems) learns the behavior of data objects by inspecting intra-network traffic  115  to gather information about the content and behaviors of data objects in traffic  115  and by training content and behavioral models utilizing that gathered information. Accordingly, through continued inspection of intra-network traffic  115 , baseline or typically behaviors of data objects may be learned, against which future intra-network traffic  115  observations may be evaluated to determine if they conform to the expected behavior, or instead represent anomalous behavior that might warrant protective action. The set of typical behaviors may be altered by a user such as a system administrator in some embodiments, resulting in an updated baseline set of operations permissible for a given group of data objects. That is, if a user finds that the typical behavior of a data object is undesirable, then the user may restrict that behavior by defining policies in some cases. 
     In an enforcement phase, in various embodiments, a DDN system  140  determines if a data object is exhibiting anomalous behavior by gathering information in a similar manner to the learning phase and by classifying that gathered information to determine whether that data object corresponds to a particular DDN data structure and whether its behavior is in line with the behavior baseline and the policy objectives identified by that DDN data structure. If there is a discrepancy between how the data object is being used and how it is expected to be used, then a DDN system  140  may perform a corrective action. It is noted that a data object may be determined to exhibit anomalous behavior based on either its content or its detected behavior attributes, or a combination of these. Anomalous behavior may include use of malicious content (e.g., a virus) as well as unexpected use of benign (but possibly sensitive) content. Thus, the techniques described herein can be used to detect content that should not be in the system, as well as content that is properly within the system, but is either in the wrong location or being used by users without proper permissions or in an improper manner. 
     By identifying a baseline behavior for a data object and then taking corrective actions (e.g., dropping that data object from intra-network traffic  115 ) for anomalous behavior, a DDN system  140  may enforce policy objectives. For example, if malware is copying PHI records to an unauthorized remote server, a DDN system  140  can drop those records from intra-network traffic  115  upon determining that copying those records to that unauthorized remote server is not baseline behavior or in line with HIPPA policies, for example. Moreover, by continually observing data, a DDN system may provide users with an in-depth understanding of how their data is being used, where it is being stored, etc. With such knowledge, users may learn of other issues pertaining to how data is being used in system  100  and thus may be able to curtail those issues by providing new policies or altering old policies. The particulars of a DDN system  140  will now be discussed in greater detail below. 
     Turning now to  FIG. 2 , a block diagram of an example DDN system  140  is shown. In the illustrated embodiment, DDN system  140  includes a data manager  210 , a data store  220 , and a DDN manager  230 . As shown, data manager  210  includes a data collection engine  212  and an enforcement engine  214 ; data store  220  includes a DDN library  222  (which in turn has a set of DDN data structures  225 ) and models  227 ; and DDN manager  230  includes a learning engine  235 . While DDN systems  140  are shown as residing at network appliances  120  in  FIG. 1 , some components of a DDN system  140  may reside at other locations—e.g., because learning engine  235  may not need to inspect intra-network traffic  115 , it may be located at a different place in system  100 . In some embodiments, DDN system  140  may be implemented differently than is shown—e.g., data manager  210  and DDN manager  230  may be the same component. 
     Data manager  210 , in various embodiments, is a set of software routines that monitors and controls the flow of data in intra-network traffic  115 . For example, data manager  210  may monitor intra-network traffic  115  for data objects that are behaving anomalously and drop the data objects from intra-network traffic  115 . To monitor and control the flow of data, in various embodiments, data manager  210  includes data collection engine  212  that identifies and collects the content and behavioral features (examples of which are discussed with respect to  FIG. 4 ) of data objects that correspond to data samples provided by users of DDN system  140 . (Such samples may be those types of data deemed important from the standpoint of an entity—for example, Social Security numbers or a user&#39;s private health information.) The content and behavioral features may then be stored in data store  220  for analysis by DDN manager  230 . Data collection engine  212  is described in greater detail below with respect to  FIG. 3 . 
     Data store  220 , in various embodiments, is a repository that stores DDN data structures  225  and models  227 . In a sense, data store  220  may be considered a communication mechanism between data manager  210  and DDN manager  230 . As an example, the content and behavioral features extracted from data objects may be stored in data store  220  so that learning engine  235  may later use those features to train machine learning models  227  and to create a DDN library  222  of DDN data structures  225 . Moreover, enforcement engine  214  may retrieve models  227  and DDN data structures  225  from data store  220  in order to control the flow of intra-network traffic  115 . 
     DDN manager  230 , in various embodiments, is a set of software routines that facilitates the generation and maintenance of DDN data structures  225 . Accordingly, the features that are collected from data objects may be passed to learning engine  235  for training models  227 . For example, as described below, machine learning classification algorithms may be performed to classify data objects by their content, their behavior, or both. The content classes that are created, in various embodiments, are each included in (or indicated by) a respective DDN data structure  225 . Accordingly, when identifying a particular DDN data structure  225  to which a data object belongs, a general content model  227  may be used to classify the data object into a DDN data structure  225  based on its content class. The behavioral classes that are created, for a given behavioral model  227  (as there might, in some cases, be a behavioral model  227  for each DDN data structure  225 ), may all be included in the same DDN data structure  225 . Thus, in various embodiments, a DDN data structure  225  includes a content class and one or more behavioral classes. The contents of a DDN data structure  225  are discussed in greater detail with respect to  FIG. 2  and learning engine  235  is discussed in greater detail with respect to  FIG. 5 . 
     After DDN data structures  225  are created and the behavior baselines are learned (and potentially updated by a user), for any data objects detected within intra-network traffic  115 , the content and behavioral features of that data object along with DDN data structures  225  may be pushed to enforcement engine  214  to detect possible anomalous behavior. The machine learning classification algorithms that were mentioned earlier may be performed on the content and behavioral features to ascertain if that data object is similar to established data objects (e.g., based on its content) and whether its behavior conforms to what is normal for those established data objects (e.g., in compliance with specified policy objectives), or what is instead anomalous. 
     In the discussions that follow, examples of how the learning phase is implemented are discussed (with an example of a learning workflow presented in  FIG. 6 ), followed by examples of how the enforcement phase is implemented (with an example of an enforcement workflow presented in  FIG. 8 ). 
     Turning now to  FIG. 3 , a block diagram of an example data manager  210  and data store  220  in the learning phase are shown. In the illustrated embodiment, data manager  210  includes a data collection engine  212 , and data store  220  includes a DNN data structure  225  and models  227 . As further depicted, data collection engine  212  includes network scanner  310  and external scanner  320 . Also as shown, DDN data structure  225  includes a content class  330 , data objects  335 , behavioral classes  340 , behavioral features  345 , and user-defined policies  350 ; models  227  include content classification model  360  and behavioral classification model  370 . In some embodiments, data manager  210  and/or data store  220  may be implemented differently than is shown—e.g., external scanner  320  may be omitted. 
     The learning phase, in various embodiments, starts with a user providing data samples  305  that the user identifies. In some cases, these may be types of data deemed important to a particular organization. Data samples  305  may include, for example, documents that contain PHI, business secrets, user information, and other personal information. By providing data samples  305 , the user may establish a baseline of the types of data that the user wishes to monitor and protect. That is, a user may not care, for example, about advertisements being improperly used, but may care about protecting Social Security numbers from being leaked and thus the user may provide data samples  305  in order to initially teach a DDN system  140  about the types of data that it should be monitoring and controlling. 
     Moreover, data samples  305  (which include content that user is aware of) may be used to discover similar or even the same content in locations that the user does not know store such content. For example, system  100  may store large amounts of unstructured data (e.g., PDFs, WORD documents, etc.) and thus files containing data that is relevant to the user may be buried in a directory that the user has forgotten about or did not know included this type of data. Accordingly, data samples  305  may be used to identify that a particular type of data is stored in previously unknown network locations. Furthermore, DDN data structures  225  (which may be built upon data samples  305 ), in some embodiments, may be used to discover data exhibiting similar properties to the data samples. This approach may provide a user with knowledge about data that is similar to the data samples. 
     Users provide data samples  305 , in various embodiments, by granting access to the file storage (e.g., a network file system, a file transfer protocol server, or an application data store, each of which may be implemented by a data store  111 ) where those samples (e.g., data objects  335 ) are located. Data objects  335  may include files defined within a file system, which may be stored on storage systems (e.g., data stores  111 ) that are internal to the network of system  100 , within the cloud (e.g., storage external to the network that may or may not be virtualized to appear as local storage), or in any other suitable manner. Although the following discussion refers to files, any type of data objects  335  may be employed, and it is not necessary that data objects  335  be defined within the context of a file system. Instead of granting access to a file storage, in some embodiments, users may directly upload data samples  305  to data manager  210 . 
     After accessing or receiving data samples  305 , data collection engine  212  may generate a respective root hash value  337  (also referred to as a “similarity hash value”) for one or more of the provided data samples  305 . In various embodiments, when generating a root hash value  337 , a data sample  305  is passed into a similarity algorithm that hashes that data sample using a piecewise hashing technique such as fuzzy hashing (or a rolling hash) to produce root hash values  337 . The piecewise hashing technique may produce similar hash values for data objects  335  that share similar content and thus may serve as a way to identify data objects  335  that are relatively similar. Accordingly, each root hash value  337  may represent or correspond to a set or group of data objects  335 . That is, each root hash value  337  may serve to identify the same and/or similar data objects  335  to a corresponding data sample  305  and may be used as a label for those data objects  335  (as illustrated) in order to group those data objects  335  with that data sample. In some embodiments, root hash values  337  are stored in data store  220  in association with their corresponding data sample  305  for later use. In some cases, data collection engine  212  may continuously monitor the provided data samples  305 , and update the root hash value  337  when a corresponding data sample  305  is updated. 
     Once root hash values  337  have been calculated for the provided data samples  305 , in various embodiments, data collection engine  212  may begin evaluating intra-network traffic  115  to identify data objects  335  that are similar to provided data samples  305 . In some embodiments, this data collection process used in the learning phase only monitors intra-network traffic  115  without actually modifying it. (For this reason, enforcement engine  214  has been omitted from  FIG. 3 ). In contrast, the data collection process used in the enforcement phase may operate to discard or otherwise prevent the transmission of intra-network traffic  115  that is determined to exhibit anomalous behavior. (In some cases, the enforcement phase can include taking some other action other than discarding or preventing transmission of a data object.) 
     Network scanner  310 , in various embodiments, evaluates intra-network traffic  115  and attempts to reassemble the data packets into data objects  335  (e.g., files). Because data objects  335  are in transition to an endpoint that is assumedly going to use those data objects, network scanner  310  (and DNN system  140  as whole) may learn the behavioral features  345  (e.g., who uses those data objects, how often are they used, what types of applications request them, etc.) of those data objects. This approach provides greater visibility relative to only observing data objects  335  that are stored. For each data object  335  extracted from intra-network traffic  115 , network scanner  310  may generate a root hash value  337  (e.g., using a piecewise hashing technique). If the root hash value  337  matches any root hash value  337  of the provided data samples  305  (note that a root hash value  337 , in some embodiments, matches another root hash value  337  even if they are not exactly the same, but instead satisfy a similarity threshold (e.g., they are 80% the same root hash value  337 )) and thus the corresponding data object  335  is at least similar to one of the provided data samples  305 , then network scanner  310 , in various embodiments, extracts the content and behavioral features  345  of that data object  335  and stores that information in data store  220 . The content of that data object  335  (which may include a subset or all of a data object  335 ) may be labeled with the matching root hash value  337  (as illustrated with data object  335  having a root hash value  337 ) and associated with a content class  330  that may be labeled with the matching root hash value  337 . (Note that the relationship between data objects  335  and content class  330  is depicted by data objects  335  being within content class  330 , although data objects  335  are not necessarily stored in content class  330 . In other words, content class  330  may simply include an indication of what data objects  335  correspond to this class.) 
     In some cases, network scanner  310  may not be able to evaluate data objects  335  from intra-network traffic  115  as those data objects may be, for example, encrypted. It is noted that if a data object  335  is encrypted, then the piecewise hashing technique may not be effective in determining if that data object is similar to a data sample  305 . Accordingly, network scanner  310  may evaluate intra-network traffic  115  to identify, for data objects  335  in that traffic, where those data objects are stored (in addition to extracting their behavioral features  345 ). Network scanner  310  may then cause external scanner  320  to obtain the appropriate credentials and scan the repository where those data objects are stored to determine if they contain information that is relevant to users of DDN system  140 . For example, if network scanner  310  extracts query results from intra-network traffic  115  that were sent by a MYSQL server, but the query results were encrypted by the MYSQL server, then external scanner  320  may be used to notify a user about the query results and to ask for access credentials so that it may scan the repository that is associated with that MYSQL server for relevant data. As shown, external scanner  320  may retrieve data  325  from locations where relevant data might be stored. Thus, external scanner  320 , in various embodiments, is used when network scanner  310  cannot fully understand the contents of data objects  335 . 
     While data objects  335  that have similar content to particular data samples  305  may be discovered by extracting them directly from intra-network traffic  115 , in various embodiments, network scanner  310  and external scanner  320  may identify locations where data objects  335  are stored and then scan those locations to determine if there are data objects  335  of interest. In order to identify these locations, network scanner  310  may first discover a data object  335  that has similar content to a data sample  305  and then may determine the location where that data object is stored. That location may be subsequently scanned by, e.g., external scanner  320  for other matching data objects  335  (e.g., by determining if their root hash value  337  matches one of the root hash values  337  for samples  305 ). In some embodiments, users of DDN system  140  may direct data collection engine  212  to scan particular data repositories (e.g., data stores  111 ). Thus, instead of reactively discovering data objects  335  that have desired information by extracting them from intra-network traffic  115 , content classification engine  212  may proactively find such data objects  335  by scanning data repositories. The content (e.g., data object  335 ) obtained through external scanner  320  and behavioral features  345  obtained through network scanner  310  may be stored in data store  220  for later processing. This process of identifying locations and scanning the locations may assist in identifying areas where relevant data is stored that are unknown to users of DDN system  140 . 
     When a particular data object  335  matches a data object  335  (e.g., a data sample  305 ) already in data store  220  and its contents and behavioral features  345  have been extracted, then those contents and behavioral features  345  may be processed for training content classification model  360  and behavioral classification model  370 , respectively. In various embodiments, this involves the application of unsupervised machine learning techniques to perform both content classification and identification of baseline behaviors of data objects  335 , as discussed in more detail below. After content classification model  370  has been trained, this model may assist (or be used in place of) the piecewise hashing technique to identify data objects  335  that have similar content to data objects  335  associated with DDN data structures  225 . For example, the piecewise hashing technique may not identify a desired data object  335  if that data is arranged or ordered in a significantly different manner than, e.g., data samples  305 . But content classification model  360  may still be able to identify that such a data object  335  includes data of interest (e.g., by using a natural language processing (NLP)-based approach). Content classification model  360  may further allow for different types of data objects  335  (e.g., PDFs versus WORD documents) to be classified. 
     Moreover, after a possible location of specified data has been determined (in some embodiments, data collection engine  212  drives machine learning algorithms (that utilize an NLP-based content classification model  360 ) to classify data objects  335  at that location to determine whether they correspond to a content class  330  of a DDN data structure  225 . If a data object  335  contains data of interest, then its behavioral features  345  may be used by machine learning algorithms to train behavioral classification model  370  as part of building a behavioral baseline. Before providing the content and behavioral features  345  of a data object  335  to data store  220  and/or DDN manager  230 , data collection engine  212  may normalize that information (e.g., by converting it into a text file). The normalized data object  335  may then be stored at data store  220  and a data ready message may be sent to the DDN manager  230  so that DDN manager may download that data object  335  and train content classification model  360 . 
     While the resulting classes (e.g., content classes  330  and behavioral classes  340 ) from trained content and behavioral classifications models  360  and  370 , respectively, may form a portion of the DDN data structures  225  stored at data store  220 , a DDN data structure  225  may also include user-defined policies  350 . These user-defined policies  350  refer to user-supplied data that is used to supplement or modify the baseline set of behaviors set forth by model  370 —this may form a new baseline behavior. In some instances, user-defined policies  350  may be included with other policies that are derived (e.g., by a DDN system  140 ) by translating model  370  into those other policies, which may be used to detect abnormal behavior. 
     As an example, consider a scenario in which model  370  records the transmission of PHI outside system  100 . A user-defined policy may remove this operation from the set of baseline behaviors that are permitted for the PHI. In this manner, a user-defined policy  350  may take an initial set of baseline behaviors from model  370  and produce a final set of baseline behaviors (which may of course be further altered as desired). Note that in some embodiments, the set of baseline behaviors as modified by user-defined policies  350  may all have an implicit action—for example, all baseline behaviors are permitted, and any non-baseline behavior is not permitted. In other embodiments, additional information may be associated with the set of baseline behaviors that specifies a particular action to be performed in response to a particular behavior. 
     As will be discussed below, because DDN system  140  collects the contents and behavioral features  345  of data objects  335 , DDN system  140  may provide users with an understanding of how data is being used along with other insightful information (e.g., the relationships between data objects  335 ). A user may realize that certain data is being used in a manner that is not desirable to the user based on the baseline behavior exposed to the user by DDN system  140 . For example, a user may become aware that banking data is accessed by applications that should not have access to it. Accordingly, a user may provide a user-defined policy  350  that curtails the baseline behavior by preventing particular aspects of that behavior such as not allowing the banking data to be accessed by those applications that should not have access to it. 
     A DDN data structure  225 , in various embodiments, is built by a DDN system  140  to contain a content class  330 , behavioral classes  340 , and user-defined policies  350  that allow data to be managed in an effective manner. A DDN data structure  225  may be metadata that is maintained by a DDN system  140 . It is noted that a DDN data structure  225  is intended to not have any dependency on the underlying physical infrastructure built to store, transport or access data. Rather, it presents a logical view of all the data and their features for the same content class  330 . Examples of behavioral features  345  will now be discussed. 
     Turning now to  FIG. 4 , a block diagram of example behavioral features  345  that might be collected for data objects  335  are shown. In the illustrated embodiment, behavioral features  345  include network traffic information  410 , application information  420 , device information  430 , API information  440 , and content features  450 . In some embodiments, other types of behavioral features may be collected in addition to the behavioral features  345  discussed below. All of these types of behavioral features need not be collected in all embodiments. 
     As explained earlier, a piecewise hashing algorithm and/or content classification model  360  may be used to identify data objects  335  (e.g., files) for further analysis. Once a data object  335  matches a root hash value  337  of, e.g., a data sample  305  or corresponds to a content class  330 , then that data object  335  itself (its contents) may be collected and then used for training content classification model  360 . But in addition to collecting the content of a data object  335 , behavioral features  345  related to that data object  335  may further be collected to help inform the expected behavior of that data object  335 . Any combination of the behavioral features  345  discussed below along with other features may be collected and stored with the content of a data object  335  for subsequent training of behavioral classification models  370 . 
     Network traffic information  410 , in various embodiments, includes information about the transmission of a data object  335 . When a data object  335  is extracted from intra-network traffic  115 , that data object  335  is nearly always in transit from some origin to some destination, either of which may or may not be within the boundary of system  100 . As such, the origin and destination of a data object  335  in transit may be collected as part of network traffic information  410 . Different protocols and applications may have different ways to define the origin and the destination and thus the information that is collected may vary. Examples of information that may be used to define the origin or the destination may include internet protocol (IP) addresses or other equivalent addressing schemes. 
     Information identifying any combination of the various open system interconnect (OSI) layer protocols associated with the transmission of a data object  335  may be collected as part of network traffic information  410 . As an example, whether a data object  335  is sent using the transmission control protocol (TCP) or the user datagram protocol (UDP) in the transport layer of the OSI model may be collected. 
     Application information  420 , in various embodiments, includes information about the particular application receiving and/or sending a data object  335 . For example, the information may include the name of an application and the type of the application. Moreover, a data object  335  may be routinely accessed by a certain group of applications that may share configuration parameters. Such parameters may be reflected in, for example, command-lines options and/or other application or protocol-related metadata that is conveyed along with a data object  335  in traffic  115 . These parameters may be collected to the extent that they can be identified. 
     An application associated with a data object  335  may be associated with a current data session that may be related to other network connections. When there are related sessions, the behavioral features  345  from the related sessions may further be collected, as they may inform the behavior of that data object. Within a given data session, there may be many queries and responses for access to a certain data object  335 . The frequency of access of that certain data object  335  over time may be collected as part of application information  420 . Related to access frequency, the volume of data throughput may also be collected since, for example, an anomaly in the volume of data transfer may be indicative of a data breach. 
     Device information  430 , in various embodiments, includes information about the agent or device requesting a data object  335 . Examples of such information may include whether the device is a server or a client system, its hardware and/or operating system configurations, and any other available system-specific information. In some instances, the particular data storage being accessed to transfer a data object  335  may present a known level of risk (e.g., as being accessible by a command and control server, and thus more vulnerable than storage accessible by a less privileged system, etc.). Accordingly, information regarding the level of security risk associated with data storage may be collected as part of device information  430 . 
     API information  440 , in various embodiments, includes information about application programming interfaces (API) that are used to access a data object  335 . As an example, a data object  335  may be accessed using the hypertext transfer protocol (HTTP) GET command, the file transfer protocol (FTP) GET command, or the server message block (SMB) read command and thus such information may be collected as part of API information  440 . An anomaly in the particular API calls or their sequence can be an indicator of a data breach. Accordingly, API sequence information may be collected as a behavioral feature  345 . 
     Content features  450  may include information that identifies properties of the content of a data object  335 . For example, for a WORD document, content features  450  may identify the length of the document (e.g., the number of words in the document), the key words used in the document, the language in which the document is written (e.g., English), the layout of the document (e.g., introduction-&gt;body-&gt;conclusion), etc. Content features  450  may also identify the type of a data object  335  (e.g., PDF, MP4, etc.), the size of a data object  335  (e.g., the size in bytes), whether a data object  335  is in an encrypted format, etc. Content features  450 , in various embodiments, are used to detect abnormal behavior. For example, if a data object  335  is normally in an unencrypted format, then obtaining a content feature  450  that indicates that the data object  335  is in an encrypted format may be an indication of abnormal behavior. In some embodiments, content features  450  may be used to train a content classification model  360  and to determine to which content class  330  that a data object  335  belongs. 
     It is noted that not all of the aforementioned features  345  are necessarily used together in each embodiment. In some embodiments, the particular features  345  that are collected may be dynamically altered during system operation, e.g., by removing some features and/or adding others. The particulars of one embodiment of DDN manager  230  will now be discussed with respect to  FIG. 5 . 
     Turning now to  FIG. 5 , a block diagram of an example DDN manager  230  is shown. In the illustrated embodiment, DDN manager  230  includes a learning engine  235  (having machine learning and deep learning algorithms  510 ) and a user interface  520 . In some embodiments, a DDN manager  230  may be implemented differently than shown—e.g., user interface  520  may be separate from DDN manager  230 . 
     As explained earlier, to collect data for machine learning training purposes, a piecewise hashing algorithm may initially be used to discover, based on evaluating intra-network traffic  115 , data objects  335  with content similar to provided data samples  305 . Under this approach, the assumption is that data objects  335  sharing enough content similarity should be in the same content class  330 . The piecewise hashing algorithm may be further assisted, however, by using machine learning content classification methods to help identify more data objects  335  that are similar to provided data samples  305 . As an example, machine learning content classification may facilitate similarity detection in cases that are difficult for the piecewise hashing algorithm to handle such as content that is contextually the same, but is ordered in a reasonably different manner than the provided data samples  305 . It is noted, however, that in various embodiments, machine learning content classification may be omitted (e.g., in the cases where the piecewise hashing algorithm provides sufficient coverage and accuracy). 
     Learning engine  235 , in various embodiments, trains content classification models  360  using machine learning and deep learning algorithms  510 . For example, learning engine  235 , in some embodiments, uses algorithms  510  such as support vector machine (SVM) algorithms and convolutional neural network (CNN) algorithms to train content classification models  360  such as a set of SVM models in conjunction with a set of CNN models, although many other architectures that use different algorithms  510  are possible and contemplated. Root hash values  337  (discussed above) may serve as labels for the content classes  330  that result from content classification models  360 . 
     In some embodiments, learning engine  235  uses machine learning and deep learning algorithms  510  to identify specific types of data objects  335  and to generate pattern matching rules (e.g., regex expressions) or models that may be used on a specific type of data object  335  to identify whether that data object  335  includes data of interest. More specifically, discovering information of interest (e.g., PHI) in different types of unstructured data (e.g., PDFs, pictures, etc.) may be challenging for, e.g., a piecewise hashing algorithm. Accordingly, learning engine  235  may train a set of natural language processing (NLP) content classification models (which are examples of content classification models  360 ) to classify a data object  335  to determine if that data object  335  is part of a content class  330 . If that data object  335  belongs to a content class  330  within DDN system  140 , then pattern matching rules (which may be generated using algorithms  510 ) may be used on that data object  335  to extract any information of interest. For example, content classification models  360  may classify a credit card PDF form as belonging to a PII content class  330  and thus regular expressions (which may be selected specific to PDFs) may be used to identify whatever PII is in that credit card PDF form. 
     Learning engine  235 , in various embodiments, further trains behavioral classification models  370  using machine learning and deep learning algorithms  510 . For example, learning engine  235 , in some embodiments, uses algorithms  510  such as convolutional neural network (CNN) algorithms and recurrent neural networks (RNN) algorithms to train behavioral classification model  370  such as a set of CCN models in conjunction with a set of RNN models, although many other architectures that use different algorithms  510  are possible and contemplated. In some cases, RNN models may be used for tracking time series behavior (e.g., temporal sequences of events) while CNN models may be used for classifying behavior that is not time-dependent. Behavioral class  340 , in some embodiments, are labeled with a unique identifier and associated with a content class  330 . Accordingly, a single content class  330  may be associated with a set of behavioral classes  340 . Together, a content class  330  and behavioral classes  340  may define the behavioral benchmark of a data object  335  (i.e., the baseline behavior, which may be based on the observed behavior of that data object  335  within intra-network traffic  115 ). 
     Thus, the collected content and behavioral features  345  may be used by learning engine  235  for training content classification models  360  and behavioral classification models  370  to perform content and behavioral classification, respectively. The process of classification may result in classes, such as content classes  330  and behavioral classes  340 . It is noted, however, that although machine learning classification techniques may be used to generate classes, any suitable classification technique may be employed. 
     When machine learning classification training is complete, in various embodiments, the resulting models  227  may be deployed for real-time enforcement, either in the network device that completed the learning phase, or in other devices within the network. As an example, models  227  may be packed into Python objects and pushed to data manager  210  that can perform real-time enforcement (e.g., which, as discussed earlier, may be situated within a network appliance  120  in such a manner that it may intercept anomalous traffic and preventing it from being further transmitted within the network of system  100 ). In order to support real-time enforcement, in various embodiments, DDN data structures  225  are provided to data manager  210 . 
     User interface  520 , in various embodiments, provides information maintained by DDN system  140  to users for better understanding their data. That information may include the data objects  335 , content classes  330 , behavioral features  345 , behavioral classes  340 , and policies  350  of DDN data structures  225  maintained at data store  220  in addition to models  227 . Thus, interface  520 , in various embodiments, issues different query commands to the data stores  220  to collect information and present DDN data structure  225  details to users. DDN data structure  225  information may be presented to users in a variety of ways. 
     User interface  520  may provide users with access and history information (e.g., users, their roles, their location, the infrastructure used, the actions performed, etc.). This information may be presented in, e.g., tables, graphs, or maps, and may indicate whether an access involves one DDN data structure  225  or multiple difference DDN data structures  225 . This information may, in various cases, be based on collected behavioral features  345 . 
     User interface  520  may provide users with content information that presents a measure of distance (or similarity) between different data objects  335 . For example, two different data objects  335  may have a certain level of content similarity (e.g., 80% similar), but have different behavioral features  345 . By viewing content information in this manner, users may be enabled to evaluate related DDN data structures  225  and modify data usage patterns. For example, if two data objects  335  are quite similar in content but have divergent behaviors, administrators may intervene to change the data access structure (e.g., by changing rules or policies  350 ) to bring those data objects into better conformance, which may help improve performance and/or security, for example. 
     User interface  520  may provide users with data dependency information that presents the data dependencies among various objects (e.g., in order to display a web page, the database record x in table z needs to be accessed). This dependency information may span across DDN data structures  225 , creating a content dependency relationship between them. If an anomaly is detected with respect to one DDN data structure  225 , dependency information may facilitate determination of the potential scope of that anomaly. For example, if the data objects  335  that are associated with a DDN data structure  225  are to be isolated after detection of an anomaly, then dependency information may facilitate determining how widespread the impact of such isolation might be. The dependency information may be part of the behavioral information that is collected for a data object  335 . For example, a data object  335  may be observed on multiple occasions to be in transit with another object  335  or may be observed in response to particular requests that are extracted from network traffic. Accordingly, the behavior of that data object  335  may indicate that it depends on that other data object  335  or that the object depends on it. Also, when investigating an actual attack or malicious event, considering the lateral impact may be more comprehensively performed from a content or even application dependency level than from just the network level. This information may also be extended to include application dependencies (e.g., application A uses data C that has a content dependency on data D that is also created/managed by application B). 
     User interface  520  may provide users with security information, such as information regarding security best practices for certain types of data and the status of security compliance of various data objects  335 . User interface  520  may also provide users with user-defined rule information. As noted elsewhere, users may provide their own policies  350  used for similarity detection, content classification, behavioral classification, and enforcement. Accordingly, user interface  520  may enable users to view, change, and create rules 
     Thus, user interface  520  may provide users with a better understanding of their data, and based on that understanding, allow them to improve their data protection and optimize data usage. Particularly, it may help users to construct a data usage flow across different DDN data structures  225 , and map these into user-defined business intents—enabling a user to evaluate how data is being used at various steps of the flow, and whether those steps present security risks. An example learning workflow will now be discussed. 
     Turning now to  FIG. 6 , a block diagram of an example learning workflow  600  is shown. In the illustrated embodiment, learning workflow  600  involves a data manager  210 , a data store  220 , and a DDN data structure  230 . As shown, the illustrated embodiment includes numerical markers indicating one possible ordering of the steps of learning workflow  600 . 
     As illustrated, data samples  305 , in various embodiments, are initially provided to data manager  210  (e.g., by a user of DDN system  140 ). Those data samples  305  may be copied to a local or external storage that is accessible to data manager  210  or may be directly uploaded to data manager  210 . Once data samples  305  have been obtained, in various embodiments, data manger  210  uses a piecewise hashing algorithm (as explained earlier) to generate a root hash value  337  for each of the provided data samples  305 , and then stores those root hash values  337  along with those data samples in data store  220 . 
     Thereafter, data manager  210  may begin monitoring intra-network traffic  115  and may extract a data object  335  from that traffic. Accordingly, in various embodiments, data manager  210  normalizes that data object  335 , generates a root hash value  337  for it, and compares the generated root hash value  337  with the root hash values  337  associated with the provided data samples  305 . If the generated root hash value  337  meets some specified matching criteria (e.g., 80% correspondence) for a root hash value  337  of a data sample  305 , then data manager  210  may store the corresponding data object  335  and its behavioral features  345  in association with the same set as the matching data sample  305 . In some instances, that data object  335  and its behavioral features  345  may be labeled with the root hash value  337  of the relevant data sample  305 . 
     The data object  335  and its behavioral features  345 , in various embodiments, are passed through DDN manager  230  in order to create a DDN data structure  225  and thus, to create the initial baseline behavior for that data object  335 . If a DDN data structure  225  already exists for the group corresponding to that data object  335 , then the DDN data structure  225  and models  227  may also be retrieved and trained using that data object  335  and its behavioral features  345 . In various embodiments, once a DDN data structure  225  and models  227  are created or updated, DDN manager  230  stores them in data store  220 . Thereafter, data manager  210  may retrieve the DDN structure  225  and models  227  to be used for future learning or enforcement. As discussed, the initial baseline behavior set for a data object may be modified by user-defined policies in order to create an updated baseline behavior set. 
     Accordingly, once sufficient information has been collected during the learning phase, the enforcement may be enabled. (In some embodiments, the learning phase may continue to operate during enforcement, enabling enforcement to dynamically adapt to data behavior over time.) 
     As shown in  FIG. 1 , system  100  may include multiple DDN systems  140 , each of which may implement the learning phase as discussed above. In some cases, the information obtained by one DDN system  140  during its learning phase may be passed to another DDN system  140  for use. As an example, a DDN data structure  225  generated by one DDN system  140  may be provided to another DDN system  140  to be used during its enforcement phase. In this manner, the learning performed by one DDN system  140  augment the learning of another DDN system  140 . Moreover, the learning phases between DDN systems  140  may be different. For example, one DDN system  140  may receive a user-defined policy  350  that is different than one received by another DDN system  140 . Particular embodiments of the enforcement phase based on data created and modified in the learning phase will be discussed next. 
     Turning now to  FIG. 7 , a block diagram of an example data manager  210  implementing an enforcement phase is shown. In the illustrated embodiment, data manager  210  includes data collection engine  212  and enforcement engine  214 . As further shown, enforcement engine  214  includes an enforcer module  710  and a log  720 . For illustrative purposes, two different types of intra-network traffic are depicted: intra-network traffic  115 A that is normal (i.e., expected or permissible) and intra-network traffic  115 B that exhibits anomalous or unwanted behavior. In some embodiments, data manager  210  may be implemented differently than shown—e.g., enforcement engine  214  may not include log  720 . 
     Similar to the learning phase, in various embodiments, the enforcement phase involves collecting content and behavioral features  345  from the data objects  335  that are extracted from intra-network traffic  115 . Accordingly, as shown, intra-network traffic  115  may pass through data collection engine  212  so that content and behavioral features  345  can be collected before that traffic passes through enforcement engine  214 . The content and/or behavioral features  345  that are collected may be provided to enforcer module  710  for further analysis. In some embodiments, behavioral features  345  collected for enforcement may be the same as those features collected for the learning phase, although in other embodiments the features may differ. 
     Enforcer module  710 , in various embodiments, monitors and controls the flow of intra-network traffic  115  (e.g., by permitting data objects  335  to pass or dropping them) based on user-defined policies  350 . Accordingly, enforcer module  710  may obtain DDN data structures  225  and models  227  from data store  220  and use them to control traffic flow. In various embodiments, content and behavioral features  345  are classified using models  227  that were trained in the learning phase into a content class  330  and a behavioral class  340 , respectively, in order to determine whether the corresponding data object  335  is associated with normal or anomalous behavior. Enforcer module  710  may first classify a data object  335 , based on its content, into a content class  330  in order to determine whether that data object  335  belongs to a particular DDN data structure  225 . If a data object  335  falls into a content class  330  that is not associated with any DDN data structure  225 , then it may be assumed that the data object  335  does not include content that is of interest to the users of DDN system  140  and thus the data object  335  may be allowed to be transmitted its destination, but may also be logged in log  720  for analytical purposes. But if a data object  335  falls into a content class  330  that is associated with a certain DDN data structure  225 , then its behavioral features  345  may be classified. As such, behavioral classification in some embodiments may be performed only on data objects  335  identified during content classification. In other embodiments, however, it is contemplated that content and behavioral classification may occur concurrently. Moreover, in yet some embodiments, enforcement decisions may be made solely on the basis of behavioral classification. 
     Behavioral features  345 , in various embodiments, are classified by using the behavioral classification model  370 , which may then produce a behavioral classification output, e.g., in the form of a list of behavior class scores. If the classification of the behavioral features  345  of the data object  335  falls into a behavioral class  340  of the corresponding DDN data structure  225 , then the behavior of that data object  335  may be deemed normal and the data object  335  may be allowed to pass, but a record may be stored in log  720 . If, however, the classification does not fall into any behavioral classes  340  of the corresponding DDN data structure  225  (i.e., the DDN data structure  225  that the data object  335  belongs to by virtue of its content being classified into the content class  330  of that DDN data structure  225 ), then the behavior of the data object  335  may be deemed anomalous and a corrective action may be taken. In various embodiments, a data object  335  exhibiting anomalous behavior is dropped from intra-network traffic  115  (as illustrated by intra-network traffic  115 B not passing beyond enforcer module  710 ) and a record is committed to log  720 . Log  720 , in various embodiments, records activity pertaining to whether data objects  335  are allowed to pass or dropped from traffic and can be reviewed by users of DDN system  140 . 
     User-defined policies  350 , in various embodiments, may permit the behavior of a data object  335  to be narrowed or broadened. For example, even if a data object is not indicated to be anomalous based on the content and/or behavioral classifications, it may fail to satisfy one or more user-defined policies  350 , and may consequently be identified as anomalous. Such a data object  335  may be handled in the same manner as data objects  335  that otherwise fail the machine learning classification process, or it may be handled in a user-defined fashion. For example, if a data object  335  has been regularly used by a group of users and an administrator learns of this behavior via DDN system  140  and updates a policy  350  preventing that group of users from using that data object  335 , then when that data object  335  is classified by enforcer module  710 , it will still appear to be behaving normally. Enforcer module  710 , however, may drop the data object  335  from intra-network traffic  115  because of a policy  350  (and/or a policy derived by a DDN system  140  based on behavioral features  345 ). 
     Thus, in various embodiments, using content and behavioral classification results along with policies  350 , enforcer module  710  can verify if a data object  335  has the desired behavior and/or content. If the results of classification or policies  350  indicate that the data object is anomalous (either with respect to its content or its behavior, or both) further transmission of the data object will be prevented (e.g., by discarding or otherwise interdicting the traffic associated with that data object  335 ). 
     In some embodiments, in order to enable consistent data management at different areas of system  100 , the data (e.g., DDN data structure  225  and models  227 ) maintained at data store  220  may be spread around to different components of system  100  (e.g., copies may be sent to each DDN system  140  in system  100 ). Accordingly, enforcers  710  at different areas in system  100  may each monitor and control intra-network traffic  115  using the same DDN information; however, in some cases, each DDN system  140  may maintain variations of that information or its own DDN information. As an example, a DDN system  140  that receives traffic from a data store  111  that stores PHI and PII may monitor that traffic for those types of information while another DDN system  140  in the same system  100  that receives traffic from another data store  111  that stores PII and confidential information may monitor that traffic for those types. These DDN systems  140 , however, may in some cases share DDN information relevant to controlling PII since they both monitor and control that type of information. 
     In various embodiments, data-based segmentation may be used in which logical perimeters are built around data of interest to protect that data in many cases. These perimeters allow for policies to be employed against that data. Enforcer modules  710  may, in some cases, be deployed at locations near data of interest and ensure that anomalous use of that data (e.g., the data is not being used in accordance with a particular policy  350  and/or a policy that may be derived from behavioral classification model  370 ) is prevented. For example, a user may wish to protect Social Security numbers. Accordingly, using DDN data structures  225  and enforcer modules  710 , a logical, protective perimeter may be established around areas where Social Security numbers are stored, despite those numbers possibly being stored within different data stores that are remote to each other. The user may define a set of policies  350  that are distributed to the enforcer modules  710  for preventing behavior that is not desired by the user. In various embodiments, DDN information (e.g., DDN data structures  225 ) may be shared between enforcer modules  710  that are protecting the same data of interest. Data-based segmentation is discussed in greater detail with respect to  FIG. 12 . An example enforcement workflow will now be discussed. 
     Turning now to  FIG. 8 , a block diagram of an example enforcement workflow  800  is shown. In the illustrated embodiment, enforcement workflow  800  involves a data manager  210  and a data store  220 . As shown, the illustrated embodiment includes numerical markers that indicate one possible ordering of the steps of enforcement workflow  800 . 
     As illustrated, data manager  210 , in various embodiments, initially retrieves DDN data structures  225  and models  227  from data store  220 . Thereafter, data manager  210  may monitor intra-network traffic  115  and may extract a data object  335  from that traffic  115 . As such, data manager  210 , in some embodiments, classifies that data object  335  using content classification model  360  into a content class  330 . That content class  330  may then be used determine if the data object  335  falls into a content class  330  associated with a DDN data structure  225 . If not, then that data object  335  may be allowed to reach its destination; otherwise, data manager  210 , in some embodiments, classifies that data object  335  using behavioral classification model  370  into a behavioral class  340 . That behavioral class  340  may then be used to determine if the data object  335  falls into a behavioral class  340  that is corresponds to the content class  330  in which the data object  335  has been classified. If it does, then one or more policies  350  may be applied to that data object  335  and if it satisfies those policies, then it may be allowed to pass. But if the data object&#39;s behavioral class  340  does not match behavioral class  340  in the corresponding DDN data structure  225 , then, in various embodiments, it is prevented from passing (e.g., it is dropped from intra-network traffic  115 ) and the incident is recorded in log  720 . 
     Similar to the learning phase, information gathered during the enforcement phase may be shared between DDN systems  140 . In various instances, a particular DDN system  140  may be responsible for monitoring and controlling a particular type of data (e.g., PHI) while another DDN system  140  may be responsible for monitoring and controlling a different type of data (e.g., PII). Moreover, in some embodiments, a system  100  may employ DDN systems  140  that implement different roles (e.g., one may implement the learning phase while another may only implement the enforcement phase). As such, those DDN system  140  may communicate data between each other to help each other implement their own respective roles. 
     Turning now to  FIG. 9 , a flow diagram of a method  900  is shown. Method  900  is one embodiment of a method performed by a computer system (e.g., DDN system  140 ) to control data within a computing network (e.g., network of system  100 ). In some embodiments, method  900  may include additional steps—e.g., the computer system may present a user interface (e.g., user interface  520 ) to a user for configuring different aspects (e.g., user-defined policies  350 ) of the computer system. 
     Method  900  begins in step  910  with the computer system evaluating network traffic (e.g., intra-network traffic  115 ) to extract and group data objects (e.g., data objects  335 ) based on their content satisfying a set of similarity criteria, and to identify baseline data behavior with respect to the data objects. In some embodiments, the computer system receives one or more user-provided data samples (e.g., data samples  305 ), generates respective root hash values (e.g., root hash values  337 ) corresponding to the one or more user-provided data samples, and then stores the root hash values in a database (e.g., data store  220 ). Accordingly, the computer system may determine that the content of a given one of the data objects satisfies the set of similarity criteria by generating a data object hash value of the given data object and then by determining that the data object hash value matches a given one of the root hash values stored in the database. In some embodiments, subsequent to determining that a given one of the one or more data objects satisfies the set of similarity criteria, the computer system stores a record of behavioral features (e.g., behavioral features  345 ) associated with the given data object. 
     In step  920 , the computer system generates a set of data-defined network (DDN) data structures (e.g., DDN library  222  of DDN data structures  225 ) that logically group data objects independent of physical infrastructure via which those data objects are stored, communicated, or utilized. A given one of the set of DDN data structures may include a content class (e.g., content class  330 ) and one or more behavioral classes (e.g., behavioral classes  340 ). The content class may be indicative of one or more of the data objects that have been grouped based on the one or more data objects satisfying the set of similarity criteria and the one or more behavioral classes may indicate baseline network behavior of the one or more data objects within the content class as determined from evaluation of the network traffic. In some embodiments, the content class of a given DDN data structure may be based upon a machine learning content classification of content of a given data object. In some embodiments, the one or more behavioral classes of the given DDN data structure may be based upon a machine learning behavioral classification the record of behavioral features associated with the given data object. The machine learning behavioral classification may involve training a set of convolutional neural networks (CNN) and recurrent neural networks (RNN) using the record of behavioral features associated with the given data object. In some cases, other networks may be used instead of CNN and RNN, such as long short-term memory (LSTM) networks. 
     In step  930 , the computer system detects anomalous data behavior within network traffic based on the content classes and the behavioral classes of the generated set of DDN data structures. In some embodiments, the computer system may detect anomalous data behavior by identifying an extracted data object from the network traffic and evaluating the extracted data object with respect to the content class and the one or more behavioral classes of ones of the DDN data structures. Such an evaluation may include determining, based upon the machine learning behavioral classification, that the extracted data object does not exhibits expected behavior and then indicating that the extracted data object exhibits anomalous behavior based upon the extracted data object failing to exhibit the expected behavior. 
     In step  940 , in response to detecting the anomalous data behavior, the computer system prevents network traffic corresponding to the anomalous data behavior from being communicated via the computing network. 
     Turning now to  FIG. 10 , a flow diagram of a method  1000  is shown. Method  1000  is one embodiment of a method performed by a computer system (e.g., DDN system  140 ) to manage data. Method  1000  may, in some instances, be performed by executing a set of program instructions stored on a non-transitory computer-readable medium. In some embodiments, method  1000  may include additional steps—e.g., the computer system may present a user interface (e.g., user interface  520 ) to a user for configuring different aspects (e.g., user-defined policies  350 ) of the computer system. 
     Method  1000  begins in step  1010  with the computer system evaluating network traffic (e.g., intra-network traffic  115 ) within a computing network (e.g., a network across multiple systems  100 ) to group data objects (e.g., data objects  335 ) based on their content satisfying a set of similarity criteria, and to identify baseline network behavior with respect to the data objects. In some embodiments, the computer system retrieves a plurality of data samples (e.g., data samples  305 ) from one or more storage devices, generates a respective plurality of root hash values (e.g., root hash values  337 ) using the plurality of data samples; and then stores the plurality of root hash values within a database (e.g., data store  220 ). Accordingly, determining that content of a given one of the data objects satisfies the set of similarity criteria may include generating a data object hash value for the given data object and then determining that the data object hash value matches a given one of the root hash values stored in the database. 
     In step  1020 , the computer system generates a data structure (e.g., DDN data structure  225 ) that includes a content class (e.g., content class  330 ) based on machine learning content classification and one or more behavioral classes (e.g., behavioral classes  340 ) based on machine learning behavioral classification. The content class may be indicative of one or more of the data objects that have been grouped based on the one or more data objects having a set of similar content and the one or more behavioral classes may be indicative of baseline network behavior of the one or more data objects within the content class as determined from evaluation of the network traffic. 
     In step  1030 , the computer system detects anomalous data behavior within network traffic utilizing the data structure. Detecting anomalous data behavior may include identifying an extracted data object from the network traffic and evaluating the extracted data object with respect to the content class and the one or more behavioral classes of the data structure. In some cases, evaluating the extracted data object with respect to the content class and the one or more behavioral classes of the data structure may further comprise: determining, based upon the machine learning behavioral classification, that the extracted data object does not exhibits expected behavior; and indicating that the extracted data object exhibits anomalous behavior based upon the extracted data object failing to exhibit the expected behavior. In some instances, the computer system may obtain one or more user-defined rules (e.g., user-defined policies  350 ) regarding content or behavior of data objects and may store the one or more user-defined rules in association with the data structure. Accordingly, evaluating the extracted data object with respect to the content class and the one or more behavioral classes of the data structure may further comprise: determining, based upon the machine learning behavioral classification, that the extracted data object exhibits expected behavior; and in response to determining that the extracted data exhibits expected behavior, determining that the extracted data object fails to satisfy the one or more user-defined rules included in the data structure; and indicating that the extracted data object exhibits anomalous behavior based upon the extracted data object failing to satisfy the one or more of the user-defined rules. 
     In step  1040 , in response to detecting the anomalous data behavior, the computer system prevents the network traffic corresponding to the anomalous data behavior from being communicated via the computing network. 
     Turning now to  FIG. 11 , a flow diagram of a method  1100  is shown. Method  1100  is one embodiment of a method performed by a computer system (e.g., a network appliance  120 ) to manage data. The computer system may include a plurality of network ports configured to communicate packetized network traffic, one or more processors configured to route the packetized network traffic among the plurality of network ports; and a memory that stores program instructions executable by the one or more processors to perform method  1100 . The computer system may be a network switch or a network router. In some embodiments, method  1100  includes additional steps such as implementing a firewall (e.g., firewall  130 ) that prevents network traffic from being transmitted to a device coupled to the network appliance based on that network traffic failing to satisfy one or more port-based rules. 
     Method  1100  begins in step  1110  with the computer system evaluating packetized network traffic (e.g., intra-network traffic  115 ) to identify data objects (e.g., data objects  335 ) that satisfy a set of similarity criteria with respect to one or more user-provided data samples (e.g., data samples  305 ). Determining that a given one of the set of data objects satisfies the set of similarity criteria may comprise generating a data object hash value (e.g., root hash value  337 ) of the given data object and determining that the data object hash value matches a given root hash value stored in a database, which may store one or more root hash values respectively generated from one or more user-provided data samples. 
     In step  1120 , in response to identifying a set of data objects that satisfy the set of similarity criteria, the computer system stores content and behavioral features (e.g., behavioral features  345 ) associated with the set of data objects in a database. 
     In step  1130 , the computer system generates a plurality of data-defined network (DDN) data structures (e.g., DDN data structures  225 ) based on the stored content and behavioral features associated with the set of data objects. A given one of the plurality of DDN data structures may include a content class (e.g., content class  330 ) and one or more behavioral classes (e.g., behavioral classes  340 ). The content class may be indicative of one or more of the set of data objects that have been grouped based on the one or more data objects having a set of similar content. The one or more behavioral classes may indicate baseline network behavior of the one or more data objects within the content class as determined from evaluation of the network traffic. 
     In step  1140 , the computer system detects, using content and behavioral classes of the plurality of DDN data structures, anomalous data behavior within network traffic. Detecting anomalous data behavior within network traffic based upon the plurality of DDN data structures may comprise: (1) identifying an extracted data object and one or more behavioral features associated with the extracted data object from network traffic and (2) evaluating the extracted data object with respect to a content class and one or more behavioral classes of one of the plurality of DDN data structures. Determining that the extracted data object exhibits anomalous behavior may be based upon a machine learning content classification indicating that the content of the extracted data object differs from expected content. 
     In step  1150 , the computer system prevents the network traffic corresponding to the anomalous data behavior from being transmitted to a device coupled to the network appliance. 
     An example use case for the techniques discussed above is presented here. It is noted that this use case is merely an example subject to numerous variations in implementation. 
     Many organizations have sensitive data that has a long shelf life. This data is usually formatted as structured files and stored in a local storage or in the cloud. Such files are often downloaded, accessed, and shared among the employees of the organization or sometimes with entities outside of the organization. Accordingly, it may be desirable to track the use of those files and ensure that they are handled correctly. 
     DDN system  140  may provide a data management solution that utilizes unsupervised machine learning to learn about data objects  335  and their behavioral features  345 . By doing that, DDN system  140  may help businesses to continuously discover sensitive data usage inside their organizations, discover misuse of that sensitive data, and prevent data leakage caused by, e.g., an intentional attack or unintended misuse. 
     As described above, a DDN system  140  may learn about the sensitive data usage inside a customer&#39;s network environment by analyzing a set of data samples  305  and then continuing to discover the data usage and time series data updates inside the customer&#39;s networks by using a piecewise hashing algorithm or a content classification model  360 . While new data is being discovered, DDN system  140  may continue to learn the usage behavior of the data through the machine learning models. Once the data use behaviors are identified, DDN system  140  may provide the protection to the sensitive data, by detecting and intercepting anomalous network traffic. The DDN architecture described above may facilitate the decoupling of data tracking and protection functions from underlying network infrastructure and further allow continuing protection of data while the underlying network infrastructure is changing. 
     Inside an enterprise, there are typically records of PII or sensitive personal information (SPI), e.g., of employees and customers. Such information may include, for example, address and phone number information, Social Security numbers, banking information, etc. Usually, records of this type of information are created in enterprise data storage when the customer or employee initially associates with the enterprise, although it could be created or updated at any time during the business relationship. PII/SPI-based records are normally shared by a number of different enterprise applications (e.g., Zendesk, Workday, other types of customer analytics systems or customer relationship management systems) and may be stored inside plain text files, databases, unstructured big data records, or other types of storage across the on-premise file systems or in cloud storage. 
     Accordingly, a DDN system  140  may classify the PII/SPI data objects  335  into DDN data structures  225  based on the observed data usage behavior. This can enable enterprise users to gain deep visibility into their PII/SPI data usage. The DDN data structures  225 , along with other system  140  features such as user interface  520 , may assist users in identifying PII/SPI data that may be improperly stored or used, to measure data privacy risk, to verify regulatory compliance, and to learn data relationships across data stores  111 . DDN system  140  may continually refine the PII/SPI data usage behavior benchmark based on unsupervised machine learning models (e.g., models  227 ). Once an accurate behavioral benchmark is established, the enforcement workflow may help customers to control and protect the PII/SPI data from misuse and malicious accesses. 
     Turning now to  FIG. 12 , a block diagram depicting example data-based segmentations of a system  100 . In the illustrated embodiment, system  100  includes data stores  111 A-D, data managers  210 A-D, and a DDN manager  230 . As further illustrated, a data segmentation  1220 A includes data  1210 A maintained in data stores  111 A and  111 B, and a data segmentation  1220 B includes data  1210 B maintained in data stores  111 A,  111 C, and  111 D. Data  1210 A and  1210 B may include various data objects  335  that may be used to build DDN data structures  225 . Also as illustrated, data managers  210 A and  210 B include DDN data structure  225 A and models  227 , and data managers  210 A,  210 C, and  210 D include DDN data structure  225 B and models  227 . In some embodiments, system  100  may be implemented differently than shown. As an example, data stores  111 A-D may include different data  1210  than shown. 
     As mentioned earlier, the various techniques discussed in the present disclosure may be used for implementing data-based segmentation. For the sake of context, a small amount of background information about the general concept of segmentation may be useful. Many large-scale systems (or even single computer systems) include a firewall that implements a defensive perimeter around the entire system. The firewall aims to prevent malicious attacks originating from outside a system from affecting the system; however, once an attack breaches the firewall, the firewall may then be ineffective to contain the attack internally. That is, a malicious virus, for example, may move unopposed through the various systems within a large-scale system once it has passed through the firewall that protects the large-scale system. 
     Some individuals have turned to implementing segmentation-based concepts in which internal perimeters are built around portions of a system that protect those portions from other portions of the same system. By segmenting a system into different portions, a second layer of protection is built that can protect the system even when the firewall fails. A well-known form of segmentation is network-based segmentation. In a very traditional large-scale system, most or all of the servers and workstations of the large-scale system were located on the same local area network. This, however, allowed for a malicious actor such as malware to pivot from one system to another fairly easily. To help resolve this security issue, servers and/or workstations were segmented by physically or virtually locating those systems on different networks. As an example, servers that handle financial transactions may be located on one virtual network while servers that handle website requests may be located on another virtual network. Accordingly, if a malicious actor successfully infiltrated the virtual network of the website servers, the actor may not be able to infiltrate the virtual network of the financial servers as it can neither see nor reach the financial servers from the former virtual network. Thus, network-based segmentation allows for a second layer of protection by segmenting the internal components of a system into different networks. 
     Network-based segmentation (and the other known forms of segmentation), however, has drawbacks. For example, network-based segmentation suffers from scalability issues that occur when increasing the numbers of servers of a system as the restructuring of the physical connections to accommodate new servers can be overly burdensome. Accordingly, it may be desirable to perform segmentation in a way that overcomes some or all of the downsides of the currently known forms of segmentation. 
     The various techniques discussed in the present disclosure may be used to implement data-based segmentation in which logical perimeters are built based on and around data. Such perimeters may serve to protect data (e.g., data objects  335  in data  1210 A or  1210 B) from malicious attacks or unintentional misuses (for example, use of personal data that would contravene governmental privacy regulations or company policies). In contrast to the network-based segmentation where systems are segmented by placing them on different networks, data-based segmentation, in various embodiments, segments data by using DDN data structures  225  (which may include protection policies discussed below) and models  227  to manage access to data. In order to accomplish this, in some embodiments, data managers  210  are instantiated in logical proximity to data such as by being hosted on the same hypervisor as, for example, a database server that manages requests for data. Accordingly, a data manager  210  may monitor network traffic in/out of the hypervisor and detect abnormal use of data based on DDN data structures  225  and models  227  that have been pushed to that data manager by a DDN manager  230 . In various cases, the logical perimeters that are built around particular data may be independent of the physical infrastructure that stores that data. As shown for example, data segmentation  1220 A is built around data  1210 A stored at different data stores  111  (which may be different physical storage drives that are associated with different networks). 
     The process for building a data segmentation  1220  may start, in various embodiments, with the learning phase/workflow explained earlier. Accordingly, a user may initially identify types of data (e.g., by providing or identifying data samples  305 ) that the user wishes to build a data segmentation  1220  around. For example, a user may ask DDN system  140  (which may include data managers  210 A-D and DDN manager  230 ) to create a logical perimeter around personal financial information (PFI). For the sake of the following discussion, assume that data  1210 A includes PFI. Accordingly, a user may initially identify PFI in data  1210 A at data store  111 A. DDN system  140  may analyze data  1210 A as discussed earlier to identify other locations in system  100  where the same type of data is stored. DDN system  140  may learn of data  1210 A at data store  111 B. 
     Data managers  210 A and  210 B of DDN system  140  may monitor network traffic that enters and leaves data stores  111 A and  111 B, respectively, in order to collect information about the content and behavioral features  345  of data objects  335  having the relevant data for which the data segmentation  1220  is being built. As an example, data managers  210 A and  210 B may each identify, for their data store  111 , the applications that are requesting data objects that have PFI. The information collected by data managers  210  (which may include behavioral features  345 ), in various embodiments, is sent to DDN manager  230  for further analysis. As discussed earlier, DDN manager  230  may generate DDN data structures  225  and train models  227  based on the information collected by data managers  210 . 
     In some embodiments, when generating DDN data structures  225  and training models  227 , DDN manager  230  may analyze differences in the information collected by different data managers  210 . As an example, the information collected by data manager  210 A may identify a particular automated teller machine (ATM) application that accesses data  1210 A in data store  111 A while the information collected by data manager  210 B may identify a particular online banking application that accesses data  1210 A in data store  111 B. Accordingly, DDN manager  230  may determine that the baseline behavior exhibited by data  1210 A should include being accessed by both the ATM and online banking applications. That is, DDN manager  230  may consolidate the information that is collected by different data managers  210  to generate DDN data structures  225  and to train models  227  that incorporate the various, different aspects found in that information. 
     After generating DDN data structures  225  and training models  227 , data manager  230  may push portions or all of that information to the appropriate data managers  210 . This may include storing such information in data stores  220 . Continuing the example from above, data manager  230  may send DDN data structures and models  227  to data managers  210 A and  210 B to allow for those data managers to protect data  1210 A. In some embodiments, a set of protection policies may be derived by DDN manager  230  based on DDN data structures  225  and models  227 . Such protection policies might, for example, include: 
     Bank-customer-PFI-access-group has (online-banking-app, atm-app) 
     Bank-customer-PFI allows access from bank-customer-pii-access-group 
     These protection policies may indicate that for the places where PFI data is located (e.g., data stores  111 A and  111 B), only two applications (i.e., the ATM and online banking applications) are allowed to access that PFI data, access attempts by other applications will be prevented. In various embodiments, data manager  225  sends the protection policies (which may be a part of a DDN data structure  225  and may include user-defined policies  350 ) and models  227  to data managers  210 . In some cases, such information may be sent to only data managers  210  that are monitoring network traffic of data stores  111  that include the relevant data around which a data segmentation  1220  is built. Those data managers may then enforce those policies on any traffic that travels through them. Thus, a data segmentation  1220  may be built around data. That is, by dropping network traffic that deviates from the baseline behavior observed for a particular type of data, a perimeter may effectively be built around that type of data. Furthermore, by distributing DDN data structures  225  and models  227  associated with a particular type of data to the enforcement points throughout system  100  that are relevant to that type of data, that type of data may become segmented from other components including other data, even when that type of data is distributed throughout system  100 . 
     In various embodiments, multiple data segmentations  1220  may be built for the same system  100 . As shown in  FIG. 12  for example, system  100  includes a data segmentation  1220 A (which contains data  1210 A) and a data segmentation  1220 B (which contains data  1210 B). In various cases, data segmentations  1220  may each be associated with DDN data structures  225  and models  227  that are different from other data segmentations  1220 . Accordingly, as shown by data manager  210 A in  FIG. 12 , a data manager  210  may store different DDN data structures  225  (and/or models  227 ). In various cases, when a particular data segmentation  1220  (e.g., data segmentation  1220 A) is compromised, other data segmentations  1220  (e.g., data segmentation  1220 B) may remain intact. For example, if a malicious actor gains access to data  1210 A stored at data store  111 A, the malicious actor may not gain access to data  1210 B that is stored at data store  111 A since it may be segmented separately from data  1210 A. 
     In some embodiments, DDN system  140  calculates an impact of distributing a certain DDN data structure  225  (or a portion of which that corresponds to the protection policies noted above) and/or model  227  to data managers  210 . For example, PFI may be co-located with some other type of data (e.g., personal medical information) on the same data store  111 . Accordingly, in some cases, a policy that limits access to the PFI to a list of systems may inadvertently limit access to the personal medical information. That is, the data store  111  may communicate with only systems on the list; all other data accesses by systems not on the list may be rejected and as such, a system that is not on the list that attempts to access the personal medical information, but not the PFI may still be rejected. This type of impact may be presented to a user so that the user may, for example, adjust the policy. 
     Implementing data-based segmentation may be advantageous over prior segmentation approaches as data-based segmentation may allow for easier scalability. For example, because data usage is relatively static when compared to workload usage inside of a modern data center, a user may need only a relatively small amount of data managers, which might not need to be moved between host systems very often. Moreover, segmenting systems into various networks while ensuring that those systems have access to the appropriate communication channels (as done in network-based segmentation) can be difficult and time consuming. In contrast, data-based segmentation does not have the issues of moving systems around to different networks, especially when new systems are constantly being added or removed. 
     Turning now to  FIG. 13 , a flow diagram of a method  1300  is shown. Method  1300  is one embodiment of a method performed by a computer system (e.g., system  100 ) to implement data segmentation. Method  1300  may be performed by executing a set of program instructions stored on a non-transitory computer-readable medium. In some embodiments, method  1300  may include additional steps such as implementing a firewall (e.g., firewall  130 ) that prevents network traffic from being transmitted to devices within the computer system based on that network traffic failing to satisfy one or more port-based rules. 
     Method  1300  begins in step  1310  with the computer system generating a set of data-defined network (DDN) data structures (e.g., DDN data structures  225 ) that logically group data objects (e.g., data objects  335 ) independent of physical infrastructure via which those data objects are stored, communicated, or utilized. In various embodiments, generating the set of DDN data structures is performed based on one or more machine learning models (e.g., models  227 . The one or more machine learning models may include models (e.g., content classification models  360 ) that are capable of performing content classification of data objects. The one or more machine learning models may include models (e.g., behavior classification models  370 ) that are capable of performing behavior classification of data objects. In some embodiments, generating the set of data-defined network (DDN) data structures is based at least in part on data behavior (e.g., based on behavioral features  345 ) reported by one or more data managers (e.g., data managers  210 ). 
     In step  1320 , using the set of DDN data structures, the computer system identifies a plurality of data objects to be grouped into a data segmentation (e.g., a data segmentation  1220 ). The plurality of data objects may be stored in one or more data stores (e.g., data stores  111 ), and the data segmentation may be independent of the physical locations of the plurality of data objects. In various cases, identifying the plurality of data objects to be grouped into a data segmentation may be further based on user-supplied samples (e.g., data samples  305 ) distinct from the DDN data structures. 
     In step  1330 , the computer system generates a set of protection policies associated with the data segmentation. In various embodiments, the set of protection policies defines permissible types of access to data objects within the data segmentation; 
     In step  1340 , the computer system sends identifying information (e.g., DDN data structures  225 ) for the data segmentation and the set of protection policies to one or more data managers respectively associated with the one or more data stores. In various embodiments, sending the identifying information for the data segmentation includes sending the set of DDN data structures and the one or more machine learning models. 
     In step  1350 , the computer system determines that an attempt to access one or more data objects within the data segmentation is inconsistent with the set of protection policies. In step  1360 , based at least in part on the determining, the computer system prevents the attempt to access the one or more data objects within the data segmentation. The one or more data stores may include one or more databases having respective database servers. Accordingly, the preventing may include the one or more data managers monitoring input/output traffic of the database servers. 
     Turning now to  FIG. 13 , a flow diagram of a method  1300  is shown. Method  1300  is one embodiment of a method performed by a computer system (e.g., system  100 ) to implement data segmentation. Method  1300  may be performed by executing a set of program instructions stored on a non-transitory computer-readable medium. In some embodiments, method  1300  may include additional steps such as implementing a firewall (e.g., firewall  130 ) that prevents network traffic from being transmitted to devices within the computer system based on that network traffic failing to satisfy one or more port-based rules. 
     Turning now to  FIG. 14 , a flow diagram of a method  1400  is shown. Method  1400  is one embodiment of a method performed by a computer system (e.g., system  100  having data managers  210 ) to implement data segmentation. Method  1400  may be performed by executing a set of program instructions stored on a non-transitory computer-readable medium. In some embodiments, method  1400  may include additional steps such as implementing a firewall (e.g., firewall  130 ) that prevents network traffic from being transmitted to devices within the computer system based on that network traffic failing to satisfy one or more port-based rules. 
     Method  1400  begins in step  1410  with the computer system receiving information (e.g., DDN data structures  225 ) identifying a data segmentation (e.g., a data segmentation  1220 ) and a set of protection policies associated with the data segmentation. In some cases, the data segmentation groups a plurality of data objects (e.g., data objects  335  of data  1210 ) that are stored in one or more data stores (e.g., data stores  111 ). The data segmentation may be independent of the physical locations of the plurality of data objects. 
     In some embodiments, receiving the identifying information for the data segmentation includes receiving a set of data-defined network (DDN) data structures. The DDN data structures may logically group data objects independent of physical infrastructure via which those data objects are stored, communicated, or utilized. Receiving the identifying information for the data segmentation may include receiving one or more machine learning models (e.g., models  227 ) used in the generation of the DDN data structures. The one or more machine learning models may include models (e.g., content classification models  360 ) that are capable of performing content classification of data objects. The one or more machine learning models may include models (e.g., behavioral classification models  370 ) that are capable of performing behavior classification of data objects. 
     In step  1420 , the computer system determines that an attempt to access one or more data objects within the data segmentation are inconsistent with the set of protection policies. In step  1430 , based at least in part on the determining, the compute system prevents the attempt to access the one or more data objects within the data segmentation. The one or more data stores may include one or more databases having respective database servers. Accordingly, the preventing may include the one or more data managers monitoring input/output traffic of the database servers. 
     Exemplary Computer System 
     Turning now to  FIG. 15 , a block diagram of an exemplary computer system  1500 , which may, for example, implement a computing device  110 , a data store  111 , a data store  220 , and/or a network appliance  120  is depicted. Computer system  1500  includes a processor subsystem  1580  that is coupled to a system memory  1520  and I/O interfaces(s)  1540  via an interconnect  1560  (e.g., a system bus). I/O interface(s)  1540  is coupled to one or more I/O devices  1550 . Computer system  1500  may be any of various types of devices, including, but not limited to, a server system, personal computer system, desktop computer, laptop or notebook computer, mainframe computer system, tablet computer, handheld computer, workstation, network computer, a consumer device such as a mobile phone, music player, or personal data assistant (PDA). Although a single computer system  1500  is shown in  FIG. 15  for convenience, system  1500  may also be implemented as two or more computer systems operating together. 
     Processor subsystem  1580  may include one or more processors or processing units. In various embodiments of computer system  1500 , multiple instances of processor subsystem  1580  may be coupled to interconnect  1560 . In various embodiments, processor subsystem  1580  (or each processor unit within  1580 ) may contain a cache or other form of on-board memory. 
     System memory  1520  is usable store program instructions executable by processor subsystem  1580  to cause system  1500  perform various operations described herein. System memory  1520  may be implemented using different physical memory media, such as hard disk storage, floppy disk storage, removable disk storage, flash memory, random access memory (RAM-SRAM, EDO RAM, SDRAM, DDR SDRAM, RAMBUS RAM, etc.), read only memory (PROM, EEPROM, etc.), and so on. Memory in computer system  1500  is not limited to primary storage such as memory  1520 . Rather, computer system  1500  may also include other forms of storage such as cache memory in processor subsystem  1580  and secondary storage on I/O Devices  1550  (e.g., a hard drive, storage array, etc.). In some embodiments, these other forms of storage may also store program instructions executable by processor subsystem  1580 . In some embodiments, program instructions that when executed implement data manager  210  and/or DDN manager  230  may be included/stored within system memory  1520 . 
     I/O interfaces  1540  may be any of various types of interfaces configured to couple to and communicate with other devices, according to various embodiments. In one embodiment, I/O interface  1540  is a bridge chip (e.g., Southbridge) from a front-side to one or more back-side buses. I/O interfaces  1540  may be coupled to one or more I/O devices  1550  via one or more corresponding buses or other interfaces. Examples of I/O devices  1550  include storage devices (hard drive, optical drive, removable flash drive, storage array, SAN, or their associated controller), network interface devices (e.g., to a local or wide-area network), or other devices (e.g., graphics, user interface devices, etc.). In one embodiment, computer system  1500  is coupled to a network via a network interface device  1550  (e.g., configured to communicate over WiFi, Bluetooth, Ethernet, etc.). 
     Although specific embodiments have been described above, these embodiments are not intended to limit the scope of the present disclosure, even where only a single embodiment is described with respect to a particular feature. Examples of features provided in the disclosure are intended to be illustrative rather than restrictive unless stated otherwise. The above description is intended to cover such alternatives, modifications, and equivalents as would be apparent to a person skilled in the art having the benefit of this disclosure. 
     The scope of the present disclosure includes any feature or combination of features disclosed herein (either explicitly or implicitly), or any generalization thereof, whether or not it mitigates any or all of the problems addressed herein. Accordingly, new claims may be formulated during prosecution of this application (or an application claiming priority thereto) to any such combination of features. In particular, with reference to the appended claims, features from dependent claims may be combined with those of the independent claims and features from respective independent claims may be combined in any appropriate manner and not merely in the specific combinations enumerated in the appended claims.