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

Pour permettre aux analystes de sécurité lors d'une investigation, Google Security Operations d'ingérer des données contextuelles provenant de différentes sources, d'analyser les données ingérées et de fournir des informations supplémentaires sur les artefacts d'un environnement client. Ce document fournit des exemples montrant comment les analystes peuvent utiliser des données enrichies en contexte dans les règles de détection Engine.

Pour en savoir plus sur l'enrichissement des données, consultez Comment Google Security Operations enrichit les données d'événement et d'entité.

Utiliser des champs avec surenrichissement des prévalences 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 les 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'une indication 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 la section Ajouter un filtre de type d'événement.

Pour en savoir plus sur chaque type d'enrichissement, consultez Comment Google Security Operations enrichit les données d'événement et d'entité.

Remarque :Google Security Operations effectue une analyse de cinq jours lorsqu'il crée des données de contexte d'entité. Cela gère les données arrivant tardivement et crée une durée de vie implicite sur les données de contexte d'entité si le end_time de entity.metatdata.interval est omis. Par exemple, si vous stockez un enregistrement de contexte d'entité avec un interval.start_time le 1er mai et que interval.end_time est omis, l'enregistrement est stocké du 1er au 5 mai inclus. L'enregistrement ne sera plus visible à compter du 6 mai.

Utiliser des champs avec surenrichissement des prévalences 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 aux domaines ayant un score de prévalence faible. Pour être efficace, il doit exister une base de scores de prévalence pour les artefacts. L'exemple suivant utilise des listes de référence pour ajuster le résultat et applique une valeur de prévalence seuil.

Remarque :Les statistiques de prévalence de chaque entité sont stockées dans une entité contextuelle distincte qui peut être utilisée par Detection Engine, mais ne sont pas affichées dans les vues ni dans la recherche Google Security Operations.

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, i.e., 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 grâce à une correspondance IOC

Cette règle de détection génère une alerte de détection et fournit une correspondance haute fidélité 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, e.g., 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 la date de première occurrence d'une entité dans une règle

Vous pouvez écrire des règles incluant les champs first_seen_time ou last_seen_time à partir d'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, tels qu'un groupe ou une ressource.

Pour obtenir la liste des champs UDM renseignés, consultez Calculer l'heure de la première et de la dernière occurrence d'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 en fonction de 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 de détection Engine. Pour obtenir la liste des champs UDM renseignés, consultez la section 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 Security Operations 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 Security Operations.

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

Vous pouvez créer des règles de détection 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 de détection 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 définir des règles pour rechercher les champs enrichis WHOIS dans les entités qui représentent 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 la section Enrichir les entités avec des données WHOIS.

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

$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 Threat Intelligence

Google Security Operations ingère des données à partir de 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 GCTI Tor
• 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 Ingérer et stocker des données Google Cloud 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 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 planifiée. Les événements correspondent à 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
}

Requête pour des fichiers inoffensifs du système d'exploitation

L'exemple de règle suivant combine les sources de données Benign Binaries et Tor Exit Nodes pour renvoyer une alerte lorsqu'un binaire inoffensif 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 Security Operations 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 correspondent toujours au dernier instantané de la source de données, quel 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 concernant 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 des outils d'accès à distance Google Cloud Threat Intelligence.

Il s'agit d'une source de données intemporelle. Les événements correspondent toujours au dernier instantané de la source de données, quel 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 de VirusTotal dans les règles

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

Pour obtenir la liste de tous les champs UDM renseignés, consultez la section Enrichir les événements avec des 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 relationnelles VirusTotal dans les règles

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

Vous pouvez créer des règles de détection Engine pour identifier les correspondances avec les entités ingérées à partir de VirusTotal. La règle suivante envoie une alerte concernant le 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 Security Operations. 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 la section 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
}

Étapes suivantes

Pour en savoir plus sur l'utilisation des données enrichies avec d'autres fonctionnalités Google Security Operations, consultez les pages suivantes:

• Utilisez des données enrichies en contexte dans la recherche UDM.
• Utilisez des données enrichies en contexte dans vos rapports.