Cette page a été traduite par l'API Cloud Translation.

Utiliser des données enrichies par le contexte dans les règles

Compatible avec :

Google SecOps SIEM

Pour aider les analystes en sécurité lors d'une investigation, Google Security Operations ingère des données contextuelles provenant de différentes sources, effectue des analyses sur les données ingérées et fournit un contexte supplémentaire sur les artefacts dans un environnement client. Ce document fournit des exemples de la façon dont les analystes utilisent les données enrichies contextuellement 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 aux domaines à 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. Il s'agit principalement d'un indicateur secondaire lors de l'examen d'un élément. 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 savoir comment ajouter un filtre afin d'améliorer les performances des règles, 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 aux domaines ayant un faible score de prévalence

Cette règle peut être utilisée pour détecter l'accès à des domaines présentant un faible score de prévalence. Pour être efficace, une référence de scores de prévalence pour les artefacts doit exister. L'exemple suivant utilise des listes de référence pour ajuster 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 d'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 observation 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és.

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 élément, 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, comme un groupe ou une ressource.

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

Voici un exemple d'utilisation de 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 géolocalisation peuvent être utilisés dans les règles du moteur de détection. 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 les champs enrichis de la navigation sécurisée dans les règles

Google SecOps ingère les données des 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 depuis la navigation sécurisée. Voici un exemple de règle Detection Engine qui interroge ces informations enrichies pour créer des analyses contextuelles.

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 WHOIS dans une règle

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

Voici un exemple de règle qui montre comment procéder. Cette règle inclut les champs de filtre suivants dans la section events pour vous aider à 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 Google Cloud sur les renseignements sur les menaces

Google SecOps ingère les données des sources de données Google Cloud Threat Intelligence (GCTI) qui vous fournissent des informations contextuelles que vous pouvez utiliser lorsque vous examinez l'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 renseignements sur les menaces et de tous les champs renseignés, consultez Ingérer et stocker des données Google Cloud sur les renseignements sur les menaces.

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 Tor Exit Nodes de GCTI. Veillez à inclure les champs <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name et <variable_name>.graph.metadata.product_name dans la règle.

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

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
}

Rechercher 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 <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, quelle que soit l'heure.

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 Outils d'accès à distance de Threat Intelligence.

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

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 les champs de métadonnées enrichies 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 de la liste de surveillance 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 les métadonnées de fichiers 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 relations VirusTotal dans les règles

Google SecOps ingère les données des 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 depuis 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 d'accès auprès de votre responsable de compte. Pour obtenir la liste de tous les champs UDM renseignés, consultez Enrichir les entités avec les données de relations 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. Cette cohérence à terme est attendue. Elle signifie que, même si des incohérences initiales peuvent exister, 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.

Étapes suivantes

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

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