Use dados enriquecidos com contexto em regras

Compatível com:

Google secops SIEM

Para permitir que os analistas de segurança durante uma investigação, o Google Security Operations carrega dados contextuais de diferentes origens, realiza análises aos dados carregados e fornece contexto adicional sobre artefactos num ambiente do cliente. Este documento fornece exemplos de como os analistas usam dados enriquecidos contextualmente nas regras do motor de deteção.

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

Use campos enriquecidos com prevalência nas regras

Os exemplos seguintes demonstram como usar os campos enriquecidos relacionados com a prevalência no motor de deteção. Para referência, consulte a lista de campos enriquecidos relacionados com a prevalência.

Identifique o acesso ao domínio de baixa prevalência

Esta regra de deteção gera um evento de deteção, e não um alerta de deteção, quando é encontrada uma correspondência. Destina-se principalmente a ser um indicador secundário quando investiga um recurso. Por exemplo, existem outros alertas de gravidade mais elevada que acionaram um incidente.

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

Consulte o artigo Adicione um filtro de tipo de evento para mais informações sobre como adicionar um filtro para melhorar o desempenho das regras.

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

Nota: o Google SecOps realiza uma análise retrospetiva de cinco dias quando cria dados de contexto de entidades. Isto processa os dados que chegam com atraso e cria um tempo de vida implícito nos dados de contexto da entidade se o end_time do entity.metatdata.interval for omitido. Por exemplo, se armazenar um registo de contexto de entidade com um interval.start_time a 1 de maio e com o interval.end_time omitido, o registo é armazenado de 1 a 5 de maio, inclusive. O registo não vai estar visível a 6 de maio nem depois.

Use campos enriquecidos com prevalência nas regras

Os exemplos seguintes demonstram como usar os campos enriquecidos relacionados com a prevalência no motor de deteção. Para referência, consulte a lista de campos enriquecidos relacionados com a prevalência.

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

Esta regra pode ser usada para detetar o acesso a domínios com uma pontuação de prevalência baixa. Para ser eficaz, tem de existir uma base de pontuações de prevalência para os artefactos. O exemplo seguinte usa listas de referência para ajustar o resultado e aplica um valor de prevalência de limite.

Nota: as estatísticas de prevalência de cada entidade são armazenadas numa entidade contextual separada que pode ser usada pelo motor de deteção, mas não é apresentada nas vistas nem na pesquisa do Google SecOps.

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
}

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

Esta regra de deteção gera um alerta de deteção e fornece uma correspondência de alta fidelidade que compara 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, 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
}

Use a hora da primeira visualização de uma entidade numa regra

Pode escrever regras que incluam os campos first_seen_time ou last_seen_time dos registos de entidades.

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

Para ver uma lista dos campos UDM preenchidos, consulte o artigo Calcule a hora da primeira e da última visualização de entidades.

Segue-se um exemplo que mostra como usar o operador first_seen_time numa 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
}

Use campos enriquecidos com geolocalização em regras

Os campos da UDM que armazenam dados enriquecidos com geolocalização podem ser usados em regras do motor de deteção. Para ver uma lista dos campos de UDM preenchidos, consulte o artigo Enriqueça eventos com dados de geolocalização.

O exemplo seguinte ilustra como detetar se uma entidade de utilizador está a autenticar-se a partir 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
}

Use campos enriquecidos da Navegação Segura em regras

O Google SecOps carrega dados de listas de ameaças relacionadas com hashes de ficheiros. Estas informações enriquecidas são armazenadas como entidades no Google SecOps.

Para ver uma lista dos campos UDM preenchidos, consulte o artigo Enriqueça entidades com informações das listas de ameaças da Navegação Segura.

Pode criar regras do Detection Engine para identificar correspondências com entidades carregadas a partir da Navegação Segura. Segue-se um exemplo de uma regra do motor de deteção que consulta estas informações enriquecidas para criar estatísticas sensíveis ao 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
}

Use campos enriquecidos do WHOIS numa regra

Pode escrever regras que pesquisam campos enriquecidos do WHOIS em entidades que representam um domínio. Estas entidades têm o campo entity.metadata.entity_type definido como DOMAIN_NAME. Para ver uma lista dos campos UDM preenchidos, consulte o artigo Enriqueça entidades com dados WHOIS.

Segue-se um exemplo de regra que mostra como o fazer. Esta regra inclui os seguintes campos de filtro na secçã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 Google Cloud dados de informações sobre ameaças

O SecOps da Google introduz dados de origens de dados de Google Cloud informações sobre ameaças (GCTI) que lhe fornecem informações contextuais que pode usar quando investiga a atividade no seu ambiente. Pode consultar as seguintes origens de dados:

• GCTI Tor Exit Nodes
• GCTI Benign Binaries
• Ferramentas de acesso remoto da GCTI

Para ver uma descrição destes feeds de ameaças e de todos os campos preenchidos, consulte o artigo Carregue e armazene Google Cloud dados de informações sobre ameaças.

Neste documento, o marcador de posição <variable_name> representa o nome da variável exclusivo usado numa regra para identificar um registo do UDM.

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

A regra de exemplo seguinte devolve uma deteção quando um evento contém um endereço IP armazenado no campo target.ip que também se encontra na origem de dados Tor Exit Nodes do GCTI.NETWORK_CONNECTION Certifique-se de que inclui 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 cronometrada. Os eventos vão corresponder ao instantâneo da origem de dados nesse 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
}

Consultar ficheiros benignos do sistema operativo

A regra de exemplo seguinte combina as origens de dados Benign Binaries e Tor Exit Nodes para devolver um alerta quando um binário benigno contacta um nó de saída do Tor. A regra calcula uma pontuação de risco com os dados de geolocalização que o Google SecOps enriqueceu com o endereço IP de destino. Certifique-se de que inclui os campos <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name e <variable_name>.graph.metadata.threat.threat_feed_name para as origens de dados Benign Binaries e Tor Exit Nodes na regra.

Esta é uma origem de dados intemporal. Os eventos correspondem sempre ao instantâneo mais recente da origem de dados, independentemente da hora.

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 seguinte devolve uma deteção quando um PROCESS_LAUNCHtipo de evento contém um hash que também se encontra na origem de dados de Google Cloud Threat Intelligence Ferramentas de acesso remoto.

Esta é uma origem de dados intemporal. Os eventos correspondem sempre ao instantâneo mais recente da origem de dados, independentemente da hora.

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

}

Use campos de metadados enriquecidos do VirusTotal em regras

A seguinte regra deteta a criação de ficheiros ou o lançamento de processos de um tipo de ficheiro específico, o que indica que existem alguns hashes na lista de observação no sistema. A pontuação de risco é definida quando os ficheiros são etiquetados como exploit através do enriquecimento dos metadados dos ficheiros do VirusTotal.

Para ver uma lista de todos os campos de UDM preenchidos, consulte o artigo Enriqueça eventos com metadados de ficheiros 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
}

Use dados de relações do VirusTotal em regras

O Google SecOps carrega dados de ligações relacionadas com o VirusTotal. Estes dados fornecem informações sobre a relação entre hashes de ficheiros e ficheiros, domínios, endereços IP e URLs. Estas informações enriquecidas são armazenadas como entidades no Google SecOps.

Pode criar regras do Detection Engine para identificar correspondências com entidades carregadas a partir do VirusTotal. A regra seguinte envia um alerta quando é transferido um hash de ficheiro conhecido a partir de um endereço IP conhecido com relações do VirusTotal. A pontuação de risco baseia-se no tipo de ficheiro e nas etiquetas dos metadados de ficheiros do VirusTotal.

Estes dados só estão disponíveis para determinadas licenças do VirusTotal e do Google SecOps. Verifique as suas autorizações junto do gestor de contas. Para ver uma lista de todos os campos de UDM preenchidos, consulte o artigo Enriqueça entidades com dados de relações 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
}

Consistência eventual

As regras dependentes do enriquecimento baseiam-se em dados adicionais a serem processados antes de uma regra poder ser totalmente avaliada. Ao longo do tempo, o processo de enriquecimento é concluído e a regra é reavaliada com os dados mais recentes e precisos. Este processo de consistência eventual é esperado e significa que, embora possam existir inconsistências iniciais, o sistema garante que todos os eventos acabam por ser totalmente enriquecidos e que as regras são avaliadas com precisão. Saiba como o Google SecOps enriquece os dados de eventos e entidades.

O que se segue?

Para obter informações sobre como usar dados enriquecidos com outras funcionalidades do Google SecOps, consulte o seguinte:

• Use dados enriquecidos com contexto na UDM Search.
• Use dados enriquecidos com contexto nos relatórios.

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais da Google SecOps.