Interroger le graphique d’exposition d’entreprise

Utilisez le graphique d’exposition d’entreprise dans Sécurité Microsoft - Gestion de l’exposition pour rechercher de manière proactive les menaces d’exposition d’entreprise dans la chasse avancée dans le portail Microsoft Defender.

Cet article fournit des exemples, des conseils et des conseils pour construire des requêtes dans le graphique d’exposition d’entreprise.

Configuration requise

• En savoir plus sur la gestion de la surface d’attaque.
• Passez en revue les autorisations requises pour utiliser le graphique.

Créer des requêtes de chasse avancées

• Passez en revue les meilleures pratiques pour créer des requêtes de chasse avancées
• Bien démarrer avec Langage de requête Kusto (KQL)

Utiliser l’opérateur make-graph

L’opérateur de make-graph Kusto charge les données des nœuds et des arêtes en mémoire.

• Étant donné que Kusto charge uniquement les colonnes utilisées, il n’est pas nécessaire de sélectionner explicitement des colonnes.
• Toutefois, la NodeProperties colonne contient toutes les informations de nœud et est donc volumineuse.
• Dans la plupart des scénarios, il est utile d’extraire uniquement les informations requises avant de les alimenter dans l’opérateur make-graph .

Exemple

let FilteredNodes = ExposureGraphNodes
| extend ContainsSensetiveData = NodeProperties has "containsSensitiveData"
| project Id, ContainsSensetiveData, Label, EntityIds, Categories;
Edges
| make-graph SourceNodeId --> TargetNodeId with FilteredNodes on Id
..

Utiliser des colonnes dynamiques et l’indexation intelligente

NodeProperties et Categories sont des colonnes dynamiques.

• Kusto sait que ces colonnes contiennent du contenu json et applique l’indexation intelligente.
• Toutefois, tous les opérateurs Kusto n’utilisent pas l’index. Par exemple, set_has_element, isemptyisnotnull n’utilisez pas l’index lorsqu’ils sont appliqués à une colonne dynamique et isnotnull(Properties["containsSensitiveData"] n’utilisent pas l’index.
• Utilisez plutôt l’opérateur has() , qui utilise toujours l’index.

Exemple

Dans la requête suivante, l’opérateur has recherche la data chaîne et set_has_element recherche l’élément data .

L’utilisation des deux opérateurs est importante, car l’opérateur has() retourne true même pour une catégorie prefix_data.

Categories has('data') and set_has_element(Categories, 'data')

En savoir plus sur la compréhension des termes de chaîne.

Exemples de requêtes d’exposition

Les exemples suivants peuvent vous aider à écrire des requêtes pour comprendre les données d’exposition à la sécurité dans votre locataire.

Répertorier toutes les étiquettes de nœud dans votre locataire

La requête suivante regroupe les données de la table et utilise l’opérateur ExposureGraphNodes Kusto summarize pour les répertorier par NodeLabel.

ExposureGraphNodes
| summarize by NodeLabel

Répertorier toutes les étiquettes d’arête dans votre locataire

La requête suivante regroupe les données de la table et utilise l’opérateur ExposureGraphEdges Kusto summarize pour les répertorier par étiquettes d’arêtes (EdgeLabel).

ExposureGraphEdges
| summarize by EdgeLabel

Répertorier toutes les connexions à partir d’une étiquette de nœud spécifiée

La requête suivante regroupe les données de la ExposureGraphEdges table et, lorsque l’étiquette du nœud source est microsoft.compute/virtualmachines, elle résume le de la machine virtuelle par EdgeLabel. Il résume les arêtes qui connectent les ressources aux machines virtuelles dans votre graphique d’exposition de sécurité.

ExposureGraphEdges
| where SourceNodeLabel == "microsoft.compute/virtualmachines"
| summarize by EdgeLabel

Répertorier toutes les connexions à une étiquette de nœud spécifique

La requête suivante récapitule les arêtes qui connectent des machines virtuelles à d’autres ressources de graphique d’exposition de sécurité. Il regroupe les données dans la ExposureGraphEdges table et, lorsque l’étiquette du nœud cible est microsoft.compute/virtualmachines, il utilise l’opérateur kusto pour répertorier l’étiquette du summarize nœud cible par EdgeLabel.

ExposureGraphEdges
| where TargetNodeLabel == "microsoft.compute/virtualmachines"
| summarize by EdgeLabel

Répertorier les propriétés d’une étiquette de nœud spécifique

La requête suivante répertorie les propriétés de l’étiquette de nœud de machine virtuelle. Il regroupe les données de la ExposureGraphNodes table, filtrées pour afficher uniquement les résultats de l’étiquette de nœud « microsoft.compute/virtualmachines ». Avec l’opérateur project-keep , la requête conserve la NodeProperties colonne. Les données retournées sont limitées à une seule ligne.

ExposureGraphNodes
| where NodeLabel == "microsoft.compute/virtualmachines"
| project-keep NodeProperties
| take 1

Interroger le graphique d’exposition

Pour interroger le graphique d’exposition :

1. Dans le portail Microsoft Defender, sélectionnez chasse -> chasse avancée.

2. Dans la zone Requête, tapez votre requête. Utilisez le schéma de graphe, les fonctions et les tables d’opérateurs, ou les exemples suivants pour vous aider à créer votre requête.

3. Sélectionnez Exécuter la requête.

Exemples de requêtes orientées graphique

Utilisez ces exemples de requêtes orientés graphiques pour vous aider à écrire de meilleures requêtes d’exposition à la sécurité. Les exemples recherchent des modèles pour exposer les relations entre les entités qui peuvent révéler les risques. Ils vous montrent comment mettre en corrélation le contexte avec les signaux d’incident/d’alerte.

Répertorier toutes les étiquettes de nœud avec une arête à une étiquette de nœud spécifique

La requête suivante génère une liste de toutes les étiquettes de nœud entrantes avec un connecteur à l’étiquette de nœud de machine virtuelle. Il génère une structure de graphe en mappant les SourceNodeId données de colonne de la ExposureGraphEdges table à la TargetNodeId colonne de la ExposureGraphNodes table avec l’opérateur make-graph pour créer une structure de graphe.

Il utilise ensuite l’opérateur graph-match pour créer un modèle de graphe où le nœud TargetNode cible et correspondent NodeLabel à microsoft.compute/virtualmachines. L’opérateur project est utilisé pour conserver uniquement le IncomingNodeLabels. Il répertorie les résultats par IncomingNodeLabels.

ExposureGraphEdges
| make-graph SourceNodeId --> TargetNodeId with ExposureGraphNodes
on NodeId
| graph-match (SourceNode)-[edges]->(TargetNode)
       where TargetNode.NodeLabel == "microsoft.compute/virtualmachines"
       project IncomingNodeLabels = SourceNode.NodeLabel 
| summarize by IncomingNodeLabels

Répertorier toutes les étiquettes de nœud correspondant à une étiquette de nœud spécifique

La requête suivante génère une liste de toutes les étiquettes de nœuds sortants avec un connecteur à l’étiquette de nœud de machine virtuelle.

• Il génère une structure de graphe en mappant la SourceNodeId colonne utilise les données de la ExposureGraphEdges table à la TargetNodeId colonne de la ExposureGraphNodes table à l’aide de l’opérateur make-graph pour créer une structure de graphe.
• Il utilise ensuite l’opérateur graph-match pour faire correspondre le modèle de graphe où SourceNode et correspondent NodeLabel à microsoft.compute/virtualmachines.
• L’opérateur project est utilisé pour conserver uniquement le OutgoingNodeLabels. Il répertorie les résultats par OutgoingNodeLabels.

ExposureGraphEdges
| make-graph SourceNodeId --> TargetNodeId with ExposureGraphNodes
on NodeId
| graph-match (SourceNode)-[edges]->(TargetNode)
       where SourceNode.NodeLabel == "microsoft.compute/virtualmachines"
       project OutgoingNodeLabels = SourceNode.NodeLabel 
| summarize by OutgoingNodeLabels

Découvrir les machines virtuelles exposées à Internet avec une vulnérabilité RCE

La requête suivante vous permet de découvrir des machines virtuelles exposées à Internet et à une vulnérabilité d’exécution de code à distance (RCE).

• Il utilise la table de ExposureGraphNodes schéma.
• Lorsque et ont la valeur NodePropertiesexposedToInternet true, il vérifie que la catégorie (Categories) est des machines virtuelles (virtual_machine).vulnerableToRCE

ExposureGraphNodes
| where isnotnull(NodeProperties.rawData.exposedToInternet)
| where isnotnull(NodeProperties.rawData.vulnerableToRCE)
| where Categories has "virtual_machine" and set_has_element(Categories, "virtual_machine")

Découvrir les appareils accessibles sur Internet avec une vulnérabilité d’escalade de privilèges

La requête suivante recherche les appareils accessibles sur Internet exposés à une vulnérabilité d’escalade de privilèges, ce qui peut autoriser l’accès à des privilèges de niveau supérieur au sein du système.

• Il utilise la table de ExposureGraphNodes schéma.
• Quand NodeProperties est à la fois accessible sur Internet (IsInternetFacing) et VulnerableToPrivilegeEscalation, la requête vérifie que les éléments dans Categories sont en fait des appareils (device).

ExposureGraphNodes
| where isnotnull(NodeProperties.rawData.IsInternetFacing)
| where isnotnull(NodeProperties.rawData.VulnerableToPrivilegeEscalation)
| where set_has_element(Categories, "device")

Afficher tous les utilisateurs connectés à plusieurs appareils critiques

Cette requête génère une liste d’utilisateurs connectés à plusieurs appareils critiques, ainsi que le nombre d’appareils auxquels ils sont connectés.

• Il crée une table à l’aide IdentitiesAndCriticalDevicesExposureGraphNodes de données filtrées par des appareils dont le niveau de criticité est supérieur à 4 ou par identity.
• Il crée ensuite une structure de graphe avec l’opérateur make-graph , où est EdgeLabelCan Authenticate As.
• Il utilise l’opérateur graph-match pour mettre en correspondance les instances où correspond à device un identity.
• Ensuite, il utilise l’opérateur project pour conserver les ID d’identité et les ID d’appareil.
• L’opérateur mv-apply filtre les ID d’appareil et les ID d’identité par type. Il les résume et affiche les résultats dans un tableau avec les en-têtes , Number Of devices user is logged-in toet User Id.

let IdentitiesAndCriticalDevices = ExposureGraphNodes
| where
 // Critical Device
 (set_has_element(Categories, "device") and isnotnull(NodeProperties.rawData.criticalityLevel) and NodeProperties.rawData.criticalityLevel.criticalityLevel < 4)
 // or identity
 or set_has_element(Categories, "identity");
ExposureGraphEdges
| where EdgeLabel == "Can Authenticate As"
| make-graph SourceNodeId --> TargetNodeId with IdentitiesAndCriticalDevices on NodeId
| graph-match (Device)-[canConnectAs]->(Identity)
       where set_has_element(Identity.Categories, "identity") and set_has_element(Device.Categories, "device")
       project IdentityIds=Identity.EntityIds, DeviceIds=Device.EntityIds
| mv-apply DeviceIds on (
    where DeviceIds.type == "DeviceInventoryId")
| mv-apply IdentityIds on (
    where IdentityIds.type == "SecurityIdentifier")
| summarize NumberOfDevicesUserLoggedinTo=count() by tostring(IdentityIds.id)
| where NumberOfDevicesUserLoggedinTo > 1
| project ["Number Of devices user is logged-in to"]=NumberOfDevicesUserLoggedinTo, ["User Id"]=IdentityIds_id

Afficher les appareils clients avec une vulnérabilité critique/les utilisateurs qui ont accès à des serveurs de valeur élevée

La requête suivante génère une liste des appareils présentant des vulnérabilités RCE et leurs ID d’appareil, ainsi que des appareils présentant des vulnérabilités critiques élevées et leurs ID d’appareil.

• Il crée une IdentitiesAndCriticalDevices table qui inclut les appareils (device) avec des vulnérabilités RCE avec une criticité inférieure à quatre, et des identités (identity) qui, avec le filtrage et la correspondance de modèle, affichent les appareils présentant des vulnérabilités critiques.
• La liste est filtrée pour afficher uniquement les connexions qui ont des étiquettes Can Authenticate As d’arête et CanRemoteInteractiveLogonTo.

let IdentitiesAndCriticalDevices = ExposureGraphNodes // Reduce the number of nodes to match
| where 
 // Critical devices & devices with RCE vulnerabilities
 (set_has_element(Categories, "device") and 
    (
        // Critical devices
        (isnotnull(NodeProperties.rawData.criticalityLevel) and NodeProperties.rawData.criticalityLevel.criticalityLevel < 4)
        or 
        // Devices with RCE vulnerability
        isnotnull(NodeProperties.rawData.vulnerableToRCE)
    )
  )
 or 
 // identity
 set_has_element(Categories, "identity");
ExposureGraphEdges
| where EdgeLabel in~ ("Can Authenticate As", "CanRemoteInteractiveLogonTo") // Reduce the number of edges to match
| make-graph SourceNodeId --> TargetNodeId with IdentitiesAndCriticalDevices on NodeId
| graph-match (DeviceWithRCE)-[CanConnectAs]->(Identity)-[CanRemoteLogin]->(CriticalDevice)
       where 
             CanConnectAs.EdgeLabel =~ "Can Authenticate As" and
             CanRemoteLogin.EdgeLabel =~ "CanRemoteInteractiveLogonTo" and
             set_has_element(Identity.Categories, "identity") and 
             set_has_element(DeviceWithRCE.Categories, "device") and isnotnull(DeviceWithRCE.NodeProperties.rawData.vulnerableToRCE) and
             set_has_element(CriticalDevice.Categories, "device") and isnotnull(CriticalDevice.NodeProperties.rawData.criticalityLevel)
       project DeviceWithRCEIds=DeviceWithRCE.EntityIds, DeviceWithRCEName=DeviceWithRCE.NodeName, CriticalDeviceIds=CriticalDevice.EntityIds, CriticalDeviceName=CriticalDevice.NodeName

Fournir tous les chemins d’accès de l’ID de nœud spécifique à un nœud avec une étiquette spécifique

Cette requête affiche le chemin d’accès à partir d’un nœud IP spécifique, passant par jusqu’à trois ressources qui aboutissent à une connexion à l’étiquette de nœud de machine virtuelle.

• Il utilise les tables de ExposureGraphNodes schéma et et ExposureGraphEdges les make-graph opérateurs et graph-match pour créer une structure de graphe.
• Avec l’opérateur project , il affiche une liste d’ID IP, de propriétés IP, d’ID de machine virtuelle et de propriétés de machine virtuelle.

let IPsAndVMs = ExposureGraphNodes
| where (set_has_element(Categories, "ip_address") or set_has_element(Categories, "virtual_machine"));
ExposureGraphEdges
| make-graph SourceNodeId --> TargetNodeId with IPsAndVMs on NodeId
| graph-match (IP)-[anyEdge*1..3]->(VM)
       where set_has_element(IP.Categories, "ip_address") and set_has_element(VM.Categories, "virtual_machine")
       project IpIds=IP.EntityIds, IpProperties=IP.NodeProperties.rawData, VmIds=VM.EntityIds, VmProperties=VM.NodeProperties.rawData

Étapes suivantes

Explorez avec la carte de surface d’attaque.