Usar datos enriquecidos con contexto en reglas

Disponible en:

SecOps de Google SIEM

Para ayudar a los analistas de seguridad durante una investigación, Google Security Operations ingiere datos contextuales de diferentes fuentes, analiza los datos ingeridos y proporciona contexto adicional sobre los artefactos en un entorno de cliente. En este documento se ofrecen ejemplos de cómo usan los analistas los datos enriquecidos contextuales en las reglas de Detection Engine.

Para obtener más información sobre el enriquecimiento de datos, consulta el artículo Cómo enriquece Google SecOps los datos de eventos y entidades.

Usar campos enriquecidos de prevalencia en las reglas

En los siguientes ejemplos se muestra cómo usar los campos enriquecidos relacionados con la prevalencia en Detection Engine. Para obtener más información, consulta la lista de campos enriquecidos relacionados con la prevalencia.

Identificar el acceso a dominios de prevalencia baja

Esta regla de detección genera un evento de detección, no una alerta de detección, cuando se encuentra una coincidencia. Su función principal es servir como indicador secundario al investigar un recurso. Por ejemplo, hay otras alertas de mayor gravedad que han activado un incidente.

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

Consulta Añadir un filtro de tipo de evento para obtener más información sobre cómo añadir un filtro para mejorar el rendimiento de las reglas.

Para obtener información sobre cada tipo de enriquecimiento, consulta Cómo enriquece Google SecOps los datos de eventos y entidades.

Nota: Google SecOps realiza un análisis retrospectivo de cinco días cuando crea datos de contexto de entidad. De esta forma, se gestionan los datos que llegan tarde y se crea un tiempo de vida implícito en los datos de contexto de la entidad si se omite el end_time del entity.metatdata.interval. Por ejemplo, si almacena un registro de contexto de entidad con un interval.start_time el 1 de mayo y omite el interval.end_time, el registro se almacenará del 1 al 5 de mayo, ambos incluidos. El registro no estará visible el 6 de mayo ni después.

Usar campos enriquecidos de prevalencia en las reglas

En los siguientes ejemplos se muestra cómo usar los campos enriquecidos relacionados con la prevalencia en Detection Engine. Para obtener más información, consulta la lista de campos enriquecidos relacionados con la prevalencia.

Identificar el acceso a dominios con una puntuación de prevalencia baja

Esta regla se puede usar para detectar el acceso a dominios con una puntuación de prevalencia baja. Para que sea eficaz, debe haber una base de puntuaciones de prevalencia de los artefactos. En el siguiente ejemplo se usan listas de referencia para ajustar el resultado y se aplica un valor de prevalencia de umbral.

Nota: Las estadísticas de prevalencia de cada entidad se almacenan en una entidad contextual independiente que puede usar Detection Engine, pero no se muestra en las vistas ni en las búsquedas de 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
}

Identificar dominios de prevalencia baja con una coincidencia de IOC

Esta regla de detección genera una alerta de detección y proporciona una coincidencia de alta fidelidad comparando un dominio de baja prevalencia que también es un IOC conocido.

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
}

Usar la hora de primera detección de una entidad en una regla

Puedes escribir reglas que incluyan los campos first_seen_time o last_seen_time de los registros de entidades.

Los campos first_seen_time y last_seen_time se rellenan con entidades que describen un dominio, una dirección IP y un archivo (hash). En el caso de las entidades que describen un usuario o un recurso, solo se rellena el campo first_seen_time. Estos valores no se calculan para las entidades que describen otros tipos, como un grupo o un recurso.

Para ver una lista de los campos de UDM que se rellenan, consulta Calcular la hora de la primera y la última vez que se han visto las entidades.

A continuación, se muestra un ejemplo de cómo usar first_seen_time en una regla:

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 con geolocalización en reglas

Los campos de UDM que almacenan datos enriquecidos con geolocalización se pueden usar en reglas de Detection Engine. Para ver una lista de los campos de UDM que se rellenan, consulta el artículo Enriquecer eventos con datos de geolocalización.

En el siguiente ejemplo se muestra cómo detectar si una entidad de usuario se está autenticando desde varios 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 de Navegación segura en reglas

Google SecOps ingiere datos de listas de amenazas relacionadas con hashes de archivos. Esta información enriquecida se almacena como entidades en Google SecOps.

Para ver una lista de los campos de UDM que se rellenan, consulta Enriquecer entidades con información de listas de amenazas de Navegación segura.

Puedes crear reglas de Detection Engine para identificar coincidencias con entidades ingresadas desde Navegación segura. A continuación se muestra un ejemplo de una regla de Detection Engine que consulta esta información enriquecida para crear analíticas contextuales.

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 de WHOIS en una regla

Puedes escribir reglas que busquen campos enriquecidos de WHOIS en entidades que representen un dominio. Estas entidades tienen el campo entity.metadata.entity_type definido como DOMAIN_NAME. Para ver una lista de los campos de UDM que se rellenan, consulta Enriquecer entidades con datos de WHOIS.

A continuación, se muestra un ejemplo de regla que indica cómo hacerlo. Esta regla incluye los siguientes campos de filtro en la sección events para optimizar su rendimiento.

$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 datos de Google Cloud Inteligencia frente a amenazas

Google SecOps ingiere datos de fuentes de datos de Google Cloud Inteligencia de Amenazas de Google Cloud (GCTI) que le proporcionan información contextual que puede usar al investigar la actividad de su entorno. Puedes consultar las siguientes fuentes de datos:

• Nodos de salida de Tor de GCTI
• Binarios benignos de GCTI
• Herramientas de acceso remoto de GCTI

Para obtener una descripción de estos feeds de amenazas y de todos los campos rellenados, consulta el artículo Ingerir y almacenar datos de inteligencia frente a amenazas Google Cloud .

En este documento, el marcador de posición <variable_name> representa el nombre de variable único que se usa en una regla para identificar un registro de UDM.

Consultar direcciones IP de nodos de salida de Tor

La siguiente regla de ejemplo devuelve una detección cuando un evento NETWORK_CONNECTION contiene una dirección IP almacenada en el campo target.ip que también se encuentra en la fuente de datos Tor Exit Nodes de GCTI. Asegúrate de incluir los campos <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name y <variable_name>.graph.metadata.product_name en la regla.

Esta es una fuente de datos programada. Los eventos coincidirán con la captura de la fuente de datos en ese 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 archivos de sistema operativo benignos

La siguiente regla de ejemplo combina las fuentes de datos Benign Binaries y Tor Exit Nodes para devolver una alerta cuando un archivo binario benigno se ponga en contacto con un nodo de salida de Tor. La regla calcula una puntuación de riesgo a partir de los datos de geolocalización que Google SecOps ha enriquecido con la dirección IP de destino. Asegúrate de incluir <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name y <variable_name>.graph.metadata.threat.threat_feed_name en las fuentes de datos Benign Binaries y Tor Exit Nodes de la regla.

Esta fuente de datos no tiene fecha de vencimiento. Los eventos siempre coincidirán con la última instantánea de la fuente de datos, independientemente de la 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 datos sobre herramientas de acceso remoto

La siguiente regla de ejemplo devuelve una detección cuando un PROCESS_LAUNCHtipo de evento contiene un hash que también se encuentra en la fuente de datos Google Cloud Herramientas de acceso remoto de Inteligencia de amenazas.

Esta fuente de datos no tiene fecha de vencimiento. Los eventos siempre coincidirán con la última captura de la fuente de datos, independientemente de la 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

}

Usar campos de metadatos enriquecidos de VirusTotal en reglas

La siguiente regla detecta la creación de archivos o el inicio de procesos de un tipo de archivo específico, lo que indica que hay hashes incluidos en la lista de seguimiento en el sistema. La puntuación de riesgo se asigna cuando los archivos se etiquetan como exploit mediante el enriquecimiento de metadatos de archivos de VirusTotal.

Para ver una lista de todos los campos de UDM que se rellenan, consulte Enriquecer eventos con metadatos de archivos de 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 datos de relaciones de VirusTotal en reglas

Google SecOps ingiere datos de conexiones relacionadas con VirusTotal. Estos datos proporcionan información sobre la relación entre los hashes de archivos y los archivos, los dominios, las direcciones IP y las URLs. Esta información enriquecida se almacena como entidades en Google SecOps.

Puede crear reglas de Detection Engine para identificar coincidencias con entidades insertadas desde VirusTotal. La siguiente regla envía una alerta cuando se descarga un hash de archivo conocido desde una dirección IP conocida con relaciones de VirusTotal. La puntuación de riesgo se basa en el tipo de archivo y las etiquetas de los metadatos de archivos de VirusTotal.

Estos datos solo están disponibles para determinadas licencias de VirusTotal y Google SecOps. Consulta tus derechos con tu gestor de cuentas. Para ver una lista de todos los campos de UDM que se rellenan, consulta Enriquecer entidades con datos de relaciones de 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
}

Coherencia eventual

Las reglas dependientes del enriquecimiento se basan en datos adicionales que se deben procesar antes de que se pueda evaluar una regla por completo. Con el tiempo, el proceso de enriquecimiento se completa y la regla se vuelve a evaluar con los datos más recientes y precisos. Este proceso de coherencia final es el esperado y significa que, aunque pueda haber incoherencias iniciales, el sistema se asegura de que todos los eventos se enriquezcan por completo y de que las reglas se evalúen correctamente. Consulta cómo enriquece Google SecOps los datos de eventos y entidades.

Siguientes pasos

Para obtener información sobre cómo usar datos enriquecidos con otras funciones de Google SecOps, consulta los siguientes artículos:

• Usar datos enriquecidos con contexto en la búsqueda de UDM.
• Usar datos enriquecidos con contexto en los informes.

¿Necesitas más ayuda? Recibe respuestas de los miembros de la comunidad y de los profesionales de Google SecOps.