Usar dados enriquecidos com contexto nas regras

Compatível com:

Google SecOps SIEM

Para ajudar os analistas de segurança durante uma investigação, o Google Security Operations captura dados contextuais de diferentes fontes, realiza análises nos dados coletados e fornece mais contexto sobre artefatos em um ambiente do cliente. Este documento apresenta exemplos de como os analistas podem usar dados enriquecidos contextualmente nas regras do Detection Engine.

Para mais informações sobre o enriquecimento de dados, consulte Como o Google Security Operations enriquece dados de eventos e entidades.

Usar campos enriquecidos de prevalência nas regras

Os exemplos a seguir demonstram como usar os campos enriquecidos relacionados à prevalência no Detection Engine. Para referência, consulte a lista de campos enriquecidos relacionados à prevalência.

Identificar o acesso a domínios de baixa prevalência

Essa regra de detecção gera um evento de detecção, não um alerta de detecção, quando uma correspondência é encontrada. Ele é principalmente um indicador secundário ao investigar um recurso. Por exemplo, há outros alertas de maior gravidade que acionaram um incidente.

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

Consulte Adicionar um filtro de tipo de evento para mais informações sobre como adicionar um filtro para melhorar a performance da regra.

Para informações sobre cada tipo de enriquecimento, consulte Como o Google Security Operations enriquece dados de eventos e entidades.

Observação: as Operações de segurança do Google realizam uma análise de cinco dias quando criam dados de contexto de entidade. Isso processa dados que chegam atrasados e cria um tempo de vida útil implícito nos dados de contexto da entidade se o end_time do entity.metatdata.interval for omitido. Por exemplo, se você armazenar um registro de contexto de entidade com um interval.start_time em 1º de maio e com o interval.end_time omitido, o registro será armazenado de 1º a 5 de maio. O registro não vai ficar visível a partir de 6 de maio.

Usar campos enriquecidos de prevalência nas regras

Os exemplos a seguir demonstram como usar os campos enriquecidos relacionados à prevalência no Detection Engine. Para referência, consulte a lista de campos enriquecidos relacionados à prevalência.

Identificar o acesso a domínios com uma pontuação de prevalência baixa

Essa regra pode ser usada para detectar acesso a domínios com uma pontuação de prevalência baixa. Para ser eficaz, é necessário ter uma referência de pontuações de prevalência para artefatos. O exemplo a seguir usa listas de referência para ajustar o resultado e aplica um valor de prevalência de limite.

Observação: as estatísticas de prevalência de cada entidade são armazenadas em uma entidade contextual separada que pode ser usada pelo mecanismo de detecção, mas não é mostrada nas visualizações ou na pesquisa do 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
}

Identificar domínios de baixa prevalência com uma correspondência de IOC

Essa regra de detecção gera um alerta de detecção e fornece uma correspondência de alta fidelidade comparando um domínio de baixa prevalência que também é um IOC conhecido.

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
}

Usar o horário de primeira aparição de uma entidade em uma regra

É possível escrever regras que incluem os campos first_seen_time ou last_seen_time dos registros de entidade.

Os campos first_seen_time e last_seen_time são preenchidos com entidades que descrevem um domínio, endereço IP e arquivo (hash). Para entidades que descrevem um usuário ou recurso, apenas o campo first_seen_time é preenchido. Esses valores não são calculados para entidades que descrevem outros tipos, como um grupo ou recurso.

Para conferir uma lista de campos do UDM que são preenchidos, consulte Calcular o horário da primeira e da última visualização de entidades.

Confira um exemplo de como usar o first_seen_time em uma regra:

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
}

Usar campos enriquecidos com geolocalização nas regras

Os campos do UDM que armazenam dados enriquecidos com geolocalização podem ser usados nas regras do mecanismo de detecção. Para conferir uma lista de campos do UDM que são preenchidos, consulte Enriquecer eventos com dados de geolocalização.

O exemplo a seguir ilustra como detectar se uma entidade de usuário está se autenticando de vários estados distintos.

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
}

Usar campos enriquecidos da Navegação segura em regras

O Google Security Operations ingere dados de listas de ameaças relacionadas a hashes de arquivos. Essas informações enriquecidas são armazenadas como entidades nas Operações de segurança do Google.

Para conferir uma lista de campos do UDM que são preenchidos, consulte Enriquecer entidades com informações das listas de ameaças da Navegação segura.

É possível criar regras do mecanismo de detecção para identificar correspondências com entidades encontradas na navegação segura. Confira a seguir um exemplo de regra do mecanismo de detecção que consulta essas informações enriquecidas para criar análises com base no contexto.

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
}

Usar campos enriquecidos do WHOIS em uma regra

É possível escrever regras que pesquisam campos enriquecidos do WHOIS em entidades que representam um domínio. Essas entidades têm o campo entity.metadata.entity_type definido como DOMAIN_NAME. Para conferir uma lista de campos do UDM que são preenchidos, consulte Aprimorar entidades com dados WHOIS.

Confira a seguir um exemplo de regra que mostra como fazer isso. Essa regra inclui os campos de filtro a seguir na seção events para ajudar a otimizar o desempenho da regra.

$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
}

Consultar dados do Google Cloud Threat Intelligence

O Google Security Operations ingere dados de fontes de dados do Google Cloud Threat Intelligence (GCTI) que fornecem informações contextuais que podem ser usadas ao investigar atividades no seu ambiente. É possível consultar as seguintes fontes de dados:

• Nós de saída do GCTI no Tor
• Binários benignos do GCTI
• Ferramentas de acesso remoto do GCTI

Para uma descrição desses feeds de ameaças e todos os campos preenchidos, consulte Ingerir e armazenar dados da Threat Intelligence do Google Cloud.

Neste documento, o marcador de posição <variable_name> representa o nome da variável exclusiva usada em uma regra para identificar um registro do UDM.

Consultar endereços IP de nós de saída do Tor

A regra de exemplo a seguir retorna uma detecção quando um evento NETWORK_CONNECTION contém um endereço IP armazenado no campo target.ip que também é encontrado na fonte de dados Tor Exit Nodes da GCTI. Inclua os campos <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name e <variable_name>.graph.metadata.product_name na regra.

Esta é uma origem de dados com tempo. Os eventos vão corresponder ao instantâneo da fonte de dados naquele momento.

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
}

Consulta de arquivos benignos do sistema operacional

A regra de exemplo a seguir combina as fontes de dados Benign Binaries e Tor Exit Nodes para retornar um alerta quando um binário benigno entra em contato com um nó de saída do Tor. A regra calcula uma pontuação de risco usando os dados de geolocalização que o Google Security Operations enriqueceu usando o endereço IP de destino. Inclua <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name e <variable_name>.graph.metadata.threat.threat_feed_name para as fontes de dados Benign Binaries e Tor Exit Nodes na regra.

Essa é uma fonte de dados atemporal. Os eventos sempre vão corresponder ao snapshot mais recente da fonte de dados, independentemente do horário.

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
}

Consultar dados sobre ferramentas de acesso remoto

A regra de exemplo a seguir retorna uma detecção quando um tipo de evento PROCESS_LAUNCH contém um hash que também é encontrado na fonte de dados das ferramentas de acesso remoto da Threat Intelligence do Google Cloud.

Essa é uma fonte de dados atemporal. Os eventos sempre vão corresponder ao snapshot mais recente da fonte de dados, independentemente do horário.

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

}

Usar campos de metadados enriquecidos do VirusTotal em regras

A regra a seguir detecta a criação de arquivos ou a inicialização de processos de um tipo de arquivo específico, indicando que alguns hashes da lista de observação estão no sistema. A pontuação de risco é definida quando os arquivos são marcados como exploit usando o enriquecimento de metadados de arquivos do VirusTotal.

Para conferir uma lista de todos os campos do UDM que são preenchidos, consulte Enriquecer eventos com metadados de arquivos do 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
}

Usar dados de relacionamento do VirusTotal em regras

O Google Security Operations ingere dados de conexões relacionadas ao VirusTotal. Esses dados fornecem informações sobre a relação entre hashes de arquivos e arquivos, domínios, endereços IP e URLs. Essas informações enriquecidas são armazenadas como entidades nas Operações de segurança do Google.

É possível criar regras do mecanismo de detecção para identificar correspondências com entidades ingeridas do VirusTotal. A regra a seguir envia um alerta sobre o download de um hash de arquivo conhecido de um endereço IP conhecido com relações do VirusTotal. A pontuação de risco é baseada no tipo de arquivo e nas tags dos metadados do arquivo do VirusTotal.

Esses dados estão disponíveis apenas para algumas licenças do VirusTotal e do Google Security Operations. Verifique seus direitos com o gerente da sua conta. Para conferir uma lista de todos os campos do UDM que são preenchidos, consulte Enriquecer entidades com dados de relacionamento do 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
}

A seguir

Para saber como usar dados enriquecidos com outros recursos do Google Security Operations, consulte:

• Usar dados enriquecidos com contexto na pesquisa do UDM.
• Usar dados enriquecidos com contexto nos relatórios.