Usa datos enriquecidos con contexto en las reglas

Para habilitar a los analistas de seguridad durante una investigación, Chronicle transfiere datos contextuales de diferentes fuentes, realiza análisis de los datos transferidos y proporciona contexto adicional sobre los artefactos de un entorno de cliente. En este documento, se proporcionan ejemplos de cómo los analistas pueden usar datos enriquecidos de forma contextual en las reglas de detección de motores.

Para obtener más información sobre el enriquecimiento de datos, consulta Cómo Chronicle enriquece los datos de eventos y entidades.

Usar campos enriquecidos con prevalencia en las reglas

En los siguientes ejemplos, se muestra cómo usar los campos enriquecidos destacados en el motor de detección. Como referencia, consulta la lista de campos enriquecidos relacionados con la prevalencia.

Identifique el acceso de dominio de baja prevalencia

Esta regla de detección genera un evento de detección, no una alerta de detección, cuando se encuentra una coincidencia. Principalmente, es un indicador secundario cuando se investiga un activo. Por ejemplo, hay otras alertas de gravedad más alta que activaron un incidente.

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

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

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

Nota: Chronicle realiza una retrospectiva de cinco días cuando crea datos de contexto de la entidad. Esto controla los datos que llegan tarde y crea un tiempo de actividad implícito en los datos del contexto de la entidad si se omite el end_time de entity.metatdata.interval. Por ejemplo, si almacenas un registro de contexto de entidad con una interval.start_time el 1 de mayo y se omite interval.end_time, el registro se almacena del 1 al 5 de mayo, inclusive. El registro no será visible el 6 de mayo o después.

Usar campos enriquecidos con prevalencia en las reglas

En los siguientes ejemplos, se muestra cómo usar los campos enriquecidos destacados en el motor de detección. Como referencia, consulta la lista de campos enriquecidos relacionados con la prevalencia.

Identifique el acceso a los 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 efectivo, debe existir un modelo de referencia de las 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 el motor de detección, pero que no se muestra en las vistas de Chronicle ni en la búsqueda.

rule network_prevalence_low_prevalence_domain_access {
  meta:
    author = "Chronicle Security"
    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
}

Aquí se muestra una captura de pantalla que muestra las detecciones de ejemplo que generó esta regla.

Ver la imagen en una ventana nueva

Identifique los dominios de baja prevalencia con una coincidencia de IOC

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

rule network_prevalence_uncommon_domain_ioc_match {

  meta:
    author = "Chronicle Security"
    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
}

Este es un ejemplo que muestra las detecciones generadas por esta regla.

Usar el tiempo de primera vista de una entidad en una regla

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

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

Para obtener una lista de los campos UDM que se propagan, consulta Calcula el tiempo de la primera y la última vez que se vieron las entidades.

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

rule first_seen_data_exfil {
    meta:
        author = "Chronicle Security"
        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 con ubicación geográfica en las reglas

Los campos de UDM que almacenan datos enriquecidos con ubicación geográfica se pueden usar en las reglas de detección de motores. Para obtener una lista de los campos de UDM propagados, consulta Enriquece eventos con datos de ubicación geográfica.

En el siguiente ejemplo, se muestra cómo detectar si una entidad de usuario se autentica desde varios estados distintos.

rule geoip_user_login_multiple_states_within_1d {

  meta:
    author = "Chronicle Security"
    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 los campos enriquecidos con Navegación segura en las reglas

Chronicle transfiere datos de listas de amenazas relacionadas con los hash de archivos. Esta información enriquecida se almacena como entidades en Chronicle.

Para obtener una lista de los campos de UDM propagados, consulta Enriquece entidades con información de las listas de amenazas de la Navegación segura.

Puedes crear reglas de detección de motor para identificar coincidencias con entidades transferidas desde la Navegación segura. La siguiente es una regla de ejemplo del motor de detección que consulta esta información enriquecida para compilar estadísticas contextuales.

rule safe_browsing_file_execution {
    meta:
        author = "Chronicle Security"
        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 con WHOIS en una regla

Puedes escribir reglas que busquen campos enriquecidos con WHOIS en entidades que representan un dominio. Estas entidades tienen el campo entity.metadata.entity_type configurado como DOMAIN_NAME. Para obtener una lista de los campos de UDM que se propagan, consulta Enriquece entidades con datos de WHOIS.

La siguiente es una regla de ejemplo que muestra cómo hacerlo. Esta regla incluye los siguientes campos de filtro en la sección events para ayudar a 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 = "Chronicle Security"
   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
}

Consulta datos de Google Cloud Threat Intelligence

Chronicle transfiere datos de fuentes de datos de Google Cloud Threat Intelligence (GCTI) que te proporcionan información contextual que puedes usar cuando investigas la actividad en tu entorno. Puedes consultar las siguientes fuentes de datos:

• Nodos de salida de Tor de GCTI
• GCTI Benign Binaries

Para obtener una descripción de estos feeds de amenazas y todos los campos propagados, consulta Transfiere y almacena datos de inteligencia de amenazas de 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 UDM.

Direcciones IP del nodo de salida del Tor de consulta

En la siguiente regla de ejemplo, se muestra 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.

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 archivos de sistema operativo benignos

En la siguiente regla de ejemplo, se combinan las fuentes de datos Benign Binaries y Tor Exit Nodes para mostrar una alerta cuando un objeto binario benigno se comunica con un nodo de salida Tor. La regla calcula una puntuación de riesgo mediante los datos de ubicación geográfica que Chronicle enriqueció mediante la dirección IP de destino. Asegúrate de incluir los valores <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name y <variable_name>.graph.metadata.threat.threat_feed_name para las fuentes de datos Benign Binaries y Tor Exit Nodes en la regla.

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
}

Usa campos de metadatos enriquecidos enriquecidos con VirusTotal

La siguiente regla detecta la creación de archivos o el lanzamiento de procesos de un tipo de archivo específico, lo que indica que algunos hash incluidos en la lista para ver están en el sistema. La puntuación de riesgo se establece cuando los archivos se etiquetan como exploit mediante el enriquecimiento de metadatos de archivos de VirusTotal.

Para obtener una lista de todos los campos de UDM que se propagan, consulta Enriquece 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
}

Usa datos de relación de VirusTotal en reglas

Chronicle transfiere datos de conexiones relacionadas con VirusTotal. Estos datos proporcionan información sobre la relación entre los hash y los archivos, los dominios, las direcciones IP y las URL. Esta información enriquecida se almacena como entidades en Chronicle.

Puedes crear reglas de detección de motor para identificar coincidencias con entidades transferidas de VirusTotal. La siguiente regla envía una alerta sobre la descarga de un hash de archivo conocido de 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 del archivo VirusTotal.

Estos datos solo están disponibles para los clientes que tienen una licencia de VirusTotal Enterprise o VirusTotal DUET. Para obtener una lista de todos los campos de UDM propagados, consulta Enriquece entidades con datos de relación 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
}

¿Qué sigue?

Para obtener información sobre cómo usar los datos enriquecidos con otras funciones de Chronicle, consulta los siguientes vínculos:

• Usa datos enriquecidos con contexto en la Búsqueda de UDM.
• Usa datos enriquecidos con el contexto en los informes.