Données enrichies par le contexte dans les règles

Compatible avec :

Pour aider les analystes de sécurité lors d'une investigation, Google Security Operations ingère des données contextuelles provenant de différentes sources, les analyse et fournit un contexte supplémentaire sur les artefacts présents dans l'environnement du client. Ce document fournit des exemples d'utilisation de données enrichies par le contexte dans les règles Detection Engine.

Pour en savoir plus sur l'enrichissement des données, consultez Comment Google SecOps enrichit les données d'événements et d'entités.

Utiliser des champs enrichis par la prévalence dans les règles

Les exemples suivants montrent comment utiliser les champs enrichis liés à la prévalence dans Detection Engine. Pour référence, consultez la liste des champs enrichis liés à la prévalence.

Identifier l'accès à un domaine à faible prévalence

Cette règle de détection génère un événement de détection, et non une alerte de détection, lorsqu'une correspondance est trouvée. Elle est principalement destinée à servir d'indicateur secondaire lors de l'investigation d'un actif. Par exemple, d'autres alertes de gravité plus élevée ont déclenché un incident.

$enrichment.graph.metadata.entity_type = "FILE"
$enrichment.graph.metadata.product_name = "VirusTotal Relationships"
$enrichment.graph.metadata.vendor_name = "VirusTotal"

Pour en savoir plus sur l'ajout d'un filtre afin d'améliorer les performances d'une règle, consultez Ajouter un filtre de type d'événement.

Pour en savoir plus sur chaque type d'enrichissement, consultez Comment Google SecOps enrichit les données d'événements et d'entités.

Utiliser des champs enrichis par la prévalence dans les règles

Les exemples suivants montrent comment utiliser les champs enrichis liés à la prévalence dans Detection Engine. Pour référence, consultez la liste des champs enrichis liés à la prévalence.

Identifier l'accès à des domaines avec un score de prévalence faible

Cette règle peut être utilisée pour détecter l'accès à des domaines avec un score de prévalence faible. Pour être efficace, une référence des scores de prévalence des artefacts doit exister. L'exemple suivant utilise des listes de référence pour affiner le résultat et applique une valeur de prévalence seuil.

rule network_prevalence_low_prevalence_domain_access {
  meta:
    author = "Google Security Operations"
    description = "Detects access to a low prevalence domain. Requires baseline of prevalence be in place for effective deployment."
    severity = "LOW"

  events:
        $e.metadata.event_type = "NETWORK_HTTP"
        $e.principal.ip = $ip

        // filter out URLs with RFC 1918 IP addresses, internal assets
        not re.regex($e.target.hostname, `(127(?:\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$)|(10(?:\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$)|(192\.168(?:\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){2}$)|(172\.(?:1[6-9]|2\d|3[0-1])(?:\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){2})`)

        // used an explicit exclusion reference list
        not $e.target.hostname in %exclusion_network_prevalence_low_prevalence_domain_access

        // only match valid FQDN, filter out background non-routable noise
        re.regex($e.target.hostname, `(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]`)

        $domainName = $e.target.hostname

        //join event ($e) to entity graph ($d)
        $e.target.hostname = $d.graph.entity.domain.name

        $d.graph.metadata.entity_type = "DOMAIN_NAME"

        // tune prevalence as fits your results
        $d.graph.entity.domain.prevalence.rolling_max > 0
        $d.graph.entity.domain.prevalence.rolling_max <= 10

  match:
        $ip over 1h

  outcome:
    $risk_score = max(
        // increment risk score based upon rolling_max prevalence
        if ( $d.graph.entity.domain.prevalence.rolling_max >= 10, 10) +
        if ( $d.graph.entity.domain.prevalence.rolling_max >= 2 and $d.graph.entity.domain.prevalence.rolling_max <= 9 , 20) +
        if ( $d.graph.entity.domain.prevalence.rolling_max = 1, 30)
    )

    $domain_list = array_distinct($domainName)
    $domain_count = count_distinct($domainName)

  condition:
    $e and #d > 10
}

Identifier les domaines à faible prévalence avec une correspondance IOC

Cette règle de détection génère une alerte de détection et fournit une correspondance de haute fidélité en comparant un domaine à faible prévalence qui est également un IOC connu.

rule network_prevalence_uncommon_domain_ioc_match {

  meta:
    author = "Google Security Operations"
    description = "Lookup Network DNS queries against Entity Graph for low prevalence domains with a matching IOC entry."
    severity = "MEDIUM"

  events:
    $e.metadata.event_type = "NETWORK_DNS"
    $e.network.dns.questions.name = $hostname

    //only match FQDNs, such as: exclude chrome dns access tests and other internal hosts
    $e.network.dns.questions.name = /(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]/

    //prevalence entity graph lookup
    $p.graph.metadata.entity_type = "DOMAIN_NAME"
    $p.graph.entity.domain.prevalence.rolling_max > 0
    $p.graph.entity.domain.prevalence.rolling_max <= 3
    $p.graph.entity.domain.name = $hostname

    //ioc entity graph lookup
    $i.graph.metadata.vendor_name = "ET_PRO_IOC"
    $i.graph.metadata.entity_type = "DOMAIN_NAME"
    $i.graph.entity.hostname = $hostname

  match:
    $hostname over 10m

  outcome:
    $risk_score = max(
        //increment risk score based upon rolling_max prevalence
        if ( $p.graph.entity.domain.prevalence.rolling_max = 3, 50) +
        if ( $p.graph.entity.domain.prevalence.rolling_max = 2, 70) +
        if ( $p.graph.entity.domain.prevalence.rolling_max = 1, 90)
    )

  condition:
    $e and $p and $i
}

Utiliser l'heure de première apparition d'une entité dans une règle

Vous pouvez écrire des règles qui incluent les champs first_seen_time ou last_seen_time des enregistrements d'entité.

Les champs first_seen_time et last_seen_time sont renseignés avec des entités qui décrivent un domaine, une adresse IP et un fichier (hachage). Pour les entités qui décrivent un utilisateur ou un actif, seul le champ first_seen_time est renseigné. Ces valeurs ne sont pas calculées pour les entités qui décrivent d'autres types, tels qu'un groupe ou une ressource.

Pour obtenir la liste des champs UDM renseignés, consultez Calculer l'heure de première et de dernière apparition des entités.

Voici un exemple montrant comment utiliser first_seen_time dans une règle :

rule first_seen_data_exfil {
    meta:
        author = "Google Security Operations"
        description = "Example usage first_seen data"
        severity = "LOW"

    events:
        $first_access.metadata.event_type = "NETWORK_HTTP"
        $ip = $first_access.principal.ip

        // Join first_access event with entity graph to use first/last seen data.
        $ip = $first_last_seen.graph.entity.ip
        $first_last_seen.graph.metadata.entity_type = "IP_ADDRESS"

        // Check that the first_access UDM event is the first_seen occurrence in the enterprise.
        $first_last_seen.graph.entity.artifact.first_seen_time.seconds = $first_access.metadata.event_timestamp.seconds
        $first_last_seen.graph.entity.artifact.first_seen_time.nanos   = $first_access.metadata.event_timestamp.nanos

        // Check for another access event that appears shortly after the first_seen event,
        // where lots of data is being sent.
        $next_access_data_exfil.metadata.event_type = "NETWORK_CONNECTION"
        // Next access event goes to the same IP as the first.
        $next_access_data_exfil.principal.ip = $ip

        // Next access occurs within 60 seconds after first access.
        $next_access_data_exfil.metadata.event_timestamp.seconds > $first_access.metadata.event_timestamp.seconds
        60 > $next_access_data_exfil.metadata.event_timestamp.seconds  - $first_access.metadata.event_timestamp.seconds

        // Lots of data is being sent over the next access event.
        $next_access_data_exfil.network.sent_bytes > 10 * 1024 * 1024 * 1024 // 10GB

        // Extract hostname of next access event, for match section.
        $hostname = $next_access_data_exfil.principal.hostname

    match:
        $hostname over 1h

    condition:
        $first_access and $next_access_data_exfil and $first_last_seen
}

Utiliser des champs enrichis par la géolocalisation dans les règles

Les champs UDM qui stockent des données enrichies par la géolocalisation peuvent être utilisés dans les règles Detection Engine. Pour obtenir la liste des champs UDM renseignés, consultez Enrichir les événements avec des données de géolocalisation.

L'exemple suivant montre comment détecter si une entité utilisateur s'authentifie à partir de plusieurs États distincts.

rule geoip_user_login_multiple_states_within_1d {

  meta:
    author = "Google Security Operations"
    description = "Detect multiple authentication attempts from multiple distinct locations using geolocation-enriched UDM fields."
    severity = "INFORMATIONAL"

  events:
    $geoip.metadata.event_type = "USER_LOGIN"
    (
      $geoip.metadata.vendor_name = "Google Workspace" or
      $geoip.metadata.vendor_name = "Google Cloud Platform"
    )
    /* optionally, detect distinct locations at a country */
    (
      $geoip.principal.ip_geo_artifact.location.country_or_region != "" and
      $geoip.principal.ip_geo_artifact.location.country_or_region = $country
    )
    (
      $geoip.principal.ip_geo_artifact.location.state != "" and
      $geoip.principal.ip_geo_artifact.location.state = $state
    )

    $geoip.target.user.email_addresses = $user

  match:
    $user over 1d

  condition:
    $geoip and #state > 1
}

Utiliser des champs enrichis par la navigation sécurisée dans les règles

Google SecOps ingère des données provenant de listes de menaces liées aux hachages de fichiers. Ces informations enrichies sont stockées en tant qu'entités dans Google SecOps.

Pour obtenir la liste des champs UDM renseignés, consultez Enrichir les entités avec des informations provenant des listes de menaces de la navigation sécurisée.

Vous pouvez créer des règles Detection Engine pour identifier les correspondances avec les entités ingérées à partir de la navigation sécurisée. Voici un exemple de règle Detection Engine qui interroge ces informations enrichies pour créer des analyses tenant compte du contexte.

rule safe_browsing_file_execution {
    meta:
        author = "Google Security Operations"
        description = "Example usage of Safe Browsing data, to detect execution of a file that's been deemed malicious"
        severity = "LOW"

    events:
        // find a process launch event, match on hostname
        $execution.metadata.event_type = "PROCESS_LAUNCH"
        $execution.principal.hostname = $hostname

        // join execution event with Safe Browsing graph
        $sb.graph.entity.file.sha256 = $execution.target.process.file.sha256

        // look for files deemed malicious
        $sb.graph.metadata.entity_type = "FILE"
        $sb.graph.metadata.threat.severity = "CRITICAL"
        $sb.graph.metadata.product_name = "Google Safe Browsing"
        $sb.graph.metadata.source_type = "GLOBAL_CONTEXT"

    match:
        $hostname over 1h

    condition:
        $execution and $sb
}

Utiliser des champs enrichis par WHOIS dans une règle

Vous pouvez écrire des règles qui recherchent des champs enrichis par WHOIS dans des entités représentant un domaine. Le champ entity.metadata.entity_type de ces entités est défini sur DOMAIN_NAME. Pour obtenir la liste des champs UDM renseignés, consultez Enrichir les entités avec des données WHOIS.

Voici un exemple de règle montrant comment procéder. Cette règle inclut les champs de filtre suivants dans la section events pour optimiser ses performances.

$whois.graph.metadata.entity_type = "DOMAIN_NAME"
$whois.graph.metadata.product_name = "WHOISXMLAPI Simple Whois"
$whois.graph.metadata.vendor_name = "WHOIS"

rule whois_expired_domain_executable_download {
 meta:
   author = "Google Security Operations"
   description = "Example usage of WHOIS data, detecting an executable file download from a domain that's recently expired"
   severity = "LOW"

 events:
        $access.metadata.event_type = "NETWORK_HTTP"
        $hostname = $access.principal.hostname

        // join access event to entity graph to use WHOIS data
        $whois.graph.entity.domain.name = $access.target.hostname

        // use WHOIS data to look for expired domains
        $whois.graph.metadata.entity_type = "DOMAIN_NAME"
        $whois.graph.metadata.product_name = "WHOISXMLAPI Simple Whois"
        $whois.graph.metadata.vendor_name = "WHOIS"
        $whois.graph.entity.domain.expiration_time.seconds < $access.metadata.event_timestamp.seconds

        // join access event with executable file creation event by principal hostname
        $creation.principal.hostname = $access.principal.hostname
        $creation.metadata.event_type = "FILE_CREATION"
        $creation.target.file.full_path = /exe/ nocase

        // file creation comes after expired domain access
        $creation.metadata.event_timestamp.seconds >
           $access.metadata.event_timestamp.seconds

   match:
       $hostname over 1h

 condition:
        $access and $whois and $creation
}

Interroger les données de Threat Intelligence Google Cloud

Google SecOps ingère des données provenant de Google Cloud sources de données Threat Intelligence (GCTI) qui vous fournissent des informations contextuelles que vous pouvez utiliser lorsque vous investiguez une activité dans votre environnement. Vous pouvez interroger les sources de données suivantes :

  • Nœuds de sortie Tor GCTI
  • Fichiers binaires bénins GCTI
  • Outils d'accès à distance GCTI

Pour obtenir une description de ces flux de menaces et de tous les champs renseignés, consultez Ingest and store Google Cloud Threat Intelligence data (Ingérer et stocker les données de Threat Intelligence).

Dans ce document, l'espace réservé <variable_name> représente le nom de variable unique utilisé dans une règle pour identifier un enregistrement UDM.

Interroger les adresses IP des nœuds de sortie Tor

L'exemple de règle suivant renvoie une détection lorsqu'un événement NETWORK_CONNECTION contient une adresse IP stockée dans le champ target.ip qui se trouve également dans la source de données GCTI Tor Exit Nodes. Veillez à inclure les <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name, et <variable_name>.graph.metadata.product_name champs dans la règle.

Il s'agit d'une source de données temporelle. Les événements correspondront à l'instantané de la source de données à ce moment précis.

rule gcti_tor_exit_nodes {
  meta:
    author = "Google Cloud Threat Intelligence"
    description = "Alert on known Tor exit nodes."
    severity = "High"

  events:
    // Event
    $e.metadata.event_type = "NETWORK_CONNECTION"
    $e.target.ip = $tor_ip

    // Tor IP search in GCTI Feed
    $tor.graph.entity.artifact.ip = $tor_ip
    $tor.graph.metadata.entity_type = "IP_ADDRESS"
    $tor.graph.metadata.threat.threat_feed_name = "Tor Exit Nodes"
    $tor.graph.metadata.source_type = "GLOBAL_CONTEXT"
    $tor.graph.metadata.vendor_name = "Google Cloud Threat Intelligence"
    $tor.graph.metadata.product_name = "GCTI Feed"

  match:
    $tor_ip over 1h

  outcome:
    $tor_ips = array_distinct($tor_ip)
    $tor_geoip_country = array_distinct($e.target.ip_geo_artifact.location.country_or_region)
    $tor_geoip_state = array_distinct($e.target.ip_geo_artifact.location.state)

  condition:
    $e and $tor
}

Interroger les fichiers de système d'exploitation bénins

L'exemple de règle suivant combine les sources de données Benign Binaries et Tor Exit Nodes pour renvoyer une alerte lorsqu'un fichier binaire bénin contacte un nœud de sortie Tor. La règle calcule un score de risque à l'aide des données de géolocalisation que Google SecOps a enrichies à l'aide de l'adresse IP cible. Veillez à inclure les <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name, et <variable_name>.graph.metadata.threat.threat_feed_name pour les sources de données Benign Binaries et Tor Exit Nodes dans la règle.

Il s'agit d'une source de données intemporelle. Les événements correspondront toujours au dernier instantané de la source de données, quel que soit le moment.

rule gcti_benign_binaries_contacts_tor_exit_node {
 meta:
   author = "Google Cloud Threat Intelligence"
   description = "Alert on Benign Binary contacting a Tor IP address."
   severity = "High"

 events:
   // Event
   $e.metadata.event_type = "NETWORK_CONNECTION"
   $e.principal.process.file.sha256 = $benign_hash
   $e.target.ip = $ip
   $e.principal.hostname = $hostname

   // Benign File search in GCTI Feed
   $benign.graph.entity.file.sha256 = $benign_hash
   $benign.graph.metadata.entity_type = "FILE"
   $benign.graph.metadata.threat.threat_feed_name = "Benign Binaries"
   $benign.graph.metadata.source_type = "GLOBAL_CONTEXT"
   $benign.graph.metadata.vendor_name = "Google Cloud Threat Intelligence"
   $benign.graph.metadata.product_name = "GCTI Feed"

   // Tor IP search in GCTI Feed
   $tor.graph.entity.artifact.ip = $ip
   $tor.graph.metadata.entity_type = "IP_ADDRESS"
   $tor.graph.metadata.threat.threat_feed_name = "Tor Exit Nodes"
   $tor.graph.metadata.source_type = "GLOBAL_CONTEXT"
   $tor.graph.metadata.vendor_name = "Google Cloud Threat Intelligence"
   $tor.graph.metadata.product_name = "GCTI Feed"

 match:
   $hostname over 1h

 outcome:
   $risk_score = max(
       if($tor.graph.metadata.threat.confidence = "HIGH_CONFIDENCE", 70) +
       // Unauthorized target geographies
       if($e.target.ip_geo_artifact.location.country_or_region = "Cuba", 20) +
       if($e.target.ip_geo_artifact.location.country_or_region = "Iran", 20) +
       if($e.target.ip_geo_artifact.location.country_or_region = "North Korea", 20) +
       if($e.target.ip_geo_artifact.location.country_or_region = "Russia", 20) +
       if($e.target.ip_geo_artifact.location.country_or_region = "Syria", 20)
   )
   $benign_hashes = array_distinct($benign_hash)
   $benign_files = array_distinct($e.principal.process.file.full_path)
   $tor_ips = array_distinct($ip)
   $tor_geoip_country = array_distinct($e.target.ip_geo_artifact.location.country_or_region)
   $tor_geoip_state = array_distinct($e.target.ip_geo_artifact.location.state)

 condition:
   $e and $benign and $tor
}

Interroger les données sur les outils d'accès à distance

L'exemple de règle suivant renvoie une détection lorsqu'un type d'événement PROCESS_LAUNCH contient un hachage qui se trouve également dans la source de données Google Cloud Threat Intelligence Remote Access Tools.

Il s'agit d'une source de données intemporelle. Les événements correspondront toujours au dernier instantané de la source de données, quel que soit le moment.

rule gcti_remote_access_tools {
 meta:
   author = "Google Cloud Threat Intelligence"
   description = "Alert on Remote Access Tools."
   severity = "High"

 events:
    // find a process launch event
    $e.metadata.event_type = "PROCESS_LAUNCH"
    $e.target.process.file.sha256 != ""
    $rat_hash = $e.target.process.file.sha256

    // join graph and event hashes
    $gcti.graph.entity.file.sha256 = $rat_hash

    // look for files identified as likely remote access tools
    $gcti.graph.metadata.entity_type = "FILE"
    $gcti.graph.metadata.vendor_name = "Google Cloud Threat Intelligence"
    $gcti.graph.metadata.product_name = "GCTI Feed"
    $gcti.graph.metadata.threat.threat_feed_name = "Remote Access Tools"

  match:
    $rat_hash over 5m

 outcome:
   $remote_hash = array_distinct($e.target.process.file.sha256)

  condition:
    $e and $gcti

}

Utiliser des champs de métadonnées enrichis par VirusTotal dans les règles

La règle suivante détecte la création de fichiers ou le lancement de processus d'un type de fichier spécifique, ce qui indique que certains hachages surveillés se trouvent sur le système. Le score de risque est défini lorsque les fichiers sont tagués comme exploit à l'aide de l'enrichissement des métadonnées de fichier VirusTotal.

Pour obtenir la liste de tous les champs UDM renseignés, consultez Enrichir les événements avec des métadonnées de fichier VirusTotal.

rule vt_filemetadata_hash_match_ioc {
 meta:
   author = "Google Cloud Threat Intelligence"
   description = "Detect file/process events that indicate watchlisted hashes are on a system"
   severity = "High"

 events:
   // Process launch or file creation events
   $process.metadata.event_type = "PROCESS_LAUNCH" or $process.metadata.event_type ="FILE_CREATION"
   $process.principal.hostname = $hostname
   $process.target.file.sha256 != ""
   $process.target.file.sha256 = $sha256
   $process.target.file.file_type = "FILE_TYPE_DOCX"

   // IOC matching
   $ioc.graph.metadata.product_name = "MISP"
   $ioc.graph.metadata.entity_type = "FILE"
   $ioc.graph.metadata.source_type = "ENTITY_CONTEXT"
   $ioc.graph.entity.file.sha256 = $sha256

 match:
   $hostname over 15m

 outcome:
   $risk_score = max(
       // Tag enrichment from VirusTotal file metadata
       if($process.target.file.tags = "exploit", 90)
   )
   $file_sha256 = array($process.target.file.sha256)
   $host = array($process.principal.hostname)

 condition:
   $process and $ioc
}

Utiliser les données de relation VirusTotal dans les règles

Google SecOps ingère des données provenant de connexions associées à VirusTotal. Ces données fournissent des informations sur la relation entre les hachages de fichiers et les fichiers, les domaines, les adresses IP et les URL. Ces informations enrichies sont stockées en tant qu'entités dans Google SecOps.

Vous pouvez créer des règles Detection Engine pour identifier les correspondances avec les entités ingérées à partir de VirusTotal. La règle suivante envoie une alerte lors du téléchargement d'un hachage de fichier connu à partir d'une adresse IP connue avec des relations VirusTotal. Le score de risque est basé sur le type de fichier et les tags des métadonnées de fichier VirusTotal.

Ces données ne sont disponibles que pour certaines licences VirusTotal et Google SecOps. Vérifiez vos droits auprès de votre responsable de compte. Pour obtenir la liste de tous les champs UDM renseignés, consultez Enrichir les entités avec des données de relation VirusTotal.

rule virustotal_file_downloaded_from_url {
  meta:
    author = "Google Cloud Threat Intelligence"
    description = "Alerts on downloading a known file hash from a known IP with VirusTotal relationships. The risk score is based on file type and tags from VirusTotal file metadata."
    severity = "High"

  events:
    // Filter network HTTP events
    $e1.metadata.event_type = "NETWORK_HTTP"
    $e1.principal.user.userid = $userid
    $e1.target.url = $url

    // Filter file creation events
    $e2.metadata.event_type = "FILE_CREATION"
    $e2.target.user.userid = $userid
    $e2.target.file.sha256 = $file_hash

    // The file creation event timestamp should be equal or greater than the network http event timestamp
    $e1.metadata.event_timestamp.seconds <= $e2.metadata.event_timestamp.seconds

    // Join event file hash with VirusTotal relationships entity graph
    $vt.graph.metadata.entity_type = "FILE"
    $vt.graph.metadata.source_type = "GLOBAL_CONTEXT"
    $vt.graph.metadata.vendor_name = "VirusTotal"
    $vt.graph.metadata.product_name = "VirusTotal Relationships"
    $vt.graph.entity.file.sha256 = $file_hash

    // Join network HTTP target URL with VirusTotal relationships entity graph
    $vt.graph.relations.entity_type = "URL"
    $vt.graph.relations.relationship = "DOWNLOADED_FROM"
    $vt.graph.relations.entity.url = $url

  match:
    $userid over 1m

  outcome:
      $risk_score = max(
        // Tag enrichment from VirusTotal file metadata
        if($e2.target.file.tags = "via-tor" or $e2.target.file.tags = "malware" or $e2.target.file.tags = "crypto", 50) +
        // File types enrichment from VirusTotal file metadata
        if($e2.target.file.file_type = "FILE_TYPE_HTML", 5) +
        if($e2.target.file.file_type = "FILE_TYPE_ELF", 10) +
        if($e2.target.file.file_type = "FILE_TYPE_PE_DLL",15) +
        if($e2.target.file.file_type = "FILE_TYPE_PE_EXE", 20)
    )

  condition:
    $e1 and $e2 and $vt and $risk_score >= 50
}

Cohérence à terme

Les règles dépendant de l'enrichissement reposent sur le traitement de données supplémentaires avant de pouvoir être entièrement évaluées. Au fil du temps, le processus d'enrichissement se termine et la règle est réévaluée avec les données les plus récentes et les plus précises. Ce processus de cohérence à terme est normal et signifie que, bien qu'il puisse y avoir des incohérences initiales, le système garantit que tous les événements seront finalement entièrement enrichis et que les règles seront évaluées avec précision. Découvrez comment Google SecOps enrichit les données d'événements et d'entités.

Étape suivante

Pour savoir comment utiliser des données enrichies avec d'autres fonctionnalités Google SecOps, consultez les pages suivantes :

Vous avez encore besoin d'aide ? Obtenez des réponses auprès des membres de la communauté et des professionnels Google SecOps.