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

Compatible avec :

Google SecOps SIEM

Pour aider les analystes de sécurité lors d'une enquête, Google Security Operations ingère des données contextuelles provenant de différentes sources, effectue une analyse des 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 peuvent utiliser des données enrichies de contexte dans les règles du moteur de détection.

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

Utiliser des champs avec surenrichissement des prévalences dans les règles

Les exemples suivants montrent comment utiliser le modèle enrichi lié à la prévalence dans le moteur de détection. 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'un indicateur secondaire lors de l'examen d'un composant. 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"

Consultez Ajouter un filtre de type d'événement. pour en savoir plus sur l'ajout d'un filtre afin d'améliorer les performances des règles.

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

Remarque : Google Security Operations effectue une analyse rétrospective 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 à partir du 6 mai.

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

Les exemples suivants montrent comment utiliser les champs enrichis liés à la prévalence dans le moteur de détection. Pour référence, consultez la liste des champs enrichis liés à la prévalence.

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

Cette règle permet de détecter les accès à des domaines dont le score de prévalence est faible. Pour être efficace, une référence de scores de prévalence pour les artefacts doit exister. La L'exemple suivant utilise des listes de référence pour ajuster le résultat et applique une de prévalence du seuil.

Remarque :Les statistiques de prévalence de chaque entité sont stockées dans un bucket entité contextuelle pouvant être utilisée par le moteur de détection, mais qui n'est pas affichée dans Vues ou 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 génère une alerte de détection et fournit un flux de données comparer 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 et 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é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é 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 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 de géolocalisation dans les règles

Les champs UDM qui stockent des données enrichies de 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 provenant 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 Enrichir les entités avec les informations issues des listes de menaces de la navigation sécurisée

Vous pouvez créer des règles de moteur de détection pour identifier les correspondances avec les entités ingérées à partir de la navigation sécurisée. Voici un exemple de moteur de détection 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. Ces entités comportent le champ entity.metadata.entity_type. définie 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 qui montre 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 provenant de sources de données Google Cloud Threat Intelligence (GCTI) qui vous fournissent des informations contextuelles que vous pouvez utiliser pour examiner 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érez et stockez les 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 Tor Exit Nodes GCTI. Veillez à inclure le paramètre <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 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
}

Rechercher des fichiers de système d'exploitation inoffensifs

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 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 Security Operations a enrichies à l'aide de l'adresse IP cible. Veillez à inclure le paramètre <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name et <variable_name>.graph.metadata.threat.threat_feed_name pour Benign Binaries et Tor Exit Nodes sources de données de 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 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 de Google Cloud 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, à n'importe quel 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 les champs de métadonnées enrichies de 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 portent le tag exploit à l'aide des métadonnées de fichier VirusTotal ou d'enrichissement.

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

Google Security Operations ingère les données des connexions associées à VirusTotal. Ces données fournit 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 Security Operations.

Vous pouvez créer des règles de moteur de détection pour identifier les correspondances avec les entités ingérées à partir de VirusTotal. La règle suivante envoie une alerte en cas de 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 une liste de tous les champs UDM renseignés, reportez-vous à la section Enrichir les entités avec des données relationnelles 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
}

Étape suivante

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

• Utilisez des données enrichies en contexte dans la recherche UDM.
• Utiliser des données enrichies de contexte dans les rapports