Utilizza dati arricchiti del contesto nelle regole

Per abilitare gli analisti della sicurezza durante un'indagine, Google Security Operations importa dati contestuali provenienti da origini diverse, esegue analisi sui dati importati e fornisce un contesto aggiuntivo sugli artefatti in un ambiente del cliente. Questo fornisce esempi di come gli analisti possono utilizzare i dati arricchiti in base al contesto nelle regole di Detection Engine.

Per saperne di più sull'arricchimento dei dati, vedi In che modo Google Security Operations arricchisce i dati di eventi ed entità.

Utilizza campi arricchiti con prevalenza nelle regole

I seguenti esempi dimostrano come utilizzare i formati di prova in Detection Engine. Come riferimento, consulta l'elenco dei campi estesi correlati alla prevalenza.

Identificare l'accesso a domini a bassa prevalenza

Questa regola di rilevamento genera un evento di rilevamento, non un avviso di rilevamento, quando viene trovata una corrispondenza. È inteso principalmente come indicatore secondario quando esaminare una risorsa. Ad esempio, esistono altri avvisi di gravità più elevata che hanno attivato un incidente.

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

Consulta Aggiungere un filtro per tipo di evento per saperne di più sull'aggiunta di un filtro per migliorare le prestazioni delle regole.

Per informazioni su ogni tipo di arricchimento, consulta In che modo Google Security Operations arricchisce i dati di eventi ed entità.

Nota: Google Security Operations esegue una finestra temporale di cinque giorni quando crea i dati relativi al contesto dell'entità. Questo gestisce i dati arrivati in ritardo e crea una durata implicita sui dati di contesto dell'entità se end_time di entity.metatdata.interval viene omesso. Ad esempio, se archivi un record di contesto dell'entità con un interval.start_time il 1° maggio e con interval.end_time omesso, il record viene archiviato dal 1° maggio al 5 maggio inclusi. Il record non sarà più visibile a partire dal 6 maggio.

Utilizza campi arricchiti con prevalenza nelle regole

I seguenti esempi dimostrano come utilizzare i formati di prova in Detection Engine. Come riferimento, consulta l'elenco dei campi estesi correlati alla prevalenza.

Identificare l'accesso ai domini con un punteggio di prevalenza basso

Questa regola può essere utilizzata per rilevare l'accesso ai domini con un punteggio di prevalenza basso. Per essere efficace, deve esistere una base di punteggi di prevalenza per gli artefatti. La L'esempio seguente utilizza gli elenchi di riferimento per ottimizzare il risultato e applica una di prevalenza della soglia.

Nota: le statistiche di prevalenza per ogni entità vengono archiviate in un entità contestuale che può essere utilizzata da Detection Engine, ma non viene mostrata in Visualizzazione o ricerca di 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
}

Identificare i domini a bassa prevalenza con una corrispondenza IOC

Questa regola di rilevamento genera un avviso di rilevamento e fornisce un un dominio a bassa prevalenza che è anche un IOC noto.

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
}

Utilizza l'ora della prima visualizzazione di un'entità in una regola

Puoi scrivere regole che includono i campi first_seen_time o last_seen_time dai record delle entità.

I campi first_seen_time e last_seen_time sono compilati con entità che descrivono un dominio, un indirizzo IP e un file (hash). Per le entità che descrivono un utente o asset, viene compilato solo il campo first_seen_time. Questi valori non sono calcolate per entità che descrivono altri tipi, ad esempio un gruppo o una risorsa.

Per un elenco dei campi UDM compilati, vedi Calcolare l'ora della prima visualizzazione e dell'ultima occorrenza delle entità.

Ecco un esempio che mostra come utilizzare first_seen_time in una regola:

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
}

Utilizza campi arricchiti di geolocalizzazione nelle regole

I campi UDM che archiviano dati estesi di geolocalizzazione possono essere utilizzati nelle regole di Detection Engine. Per un elenco dei campi UDM compilati, vedi Arricchire gli eventi con i dati di geolocalizzazione.

L'esempio seguente illustra come rilevare se un'entità utente è in fase di autenticazione da più stati distinti.

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
}

Utilizzare i campi estesi di Navigazione sicura nelle regole

Google Security Operations importa i dati dagli elenchi di minacce correlati agli hash dei file. Queste informazioni avanzate vengono archiviate come Entità in Google Security Operations.

Per un elenco dei campi UDM compilati, vedi Arricchisci le entità con informazioni provenienti dagli elenchi delle minacce di Navigazione sicura.

Puoi creare regole di Detection Engine per identificare le corrispondenze con le entità importati da Navigazione sicura. Di seguito è riportato un esempio di motore di rilevamento che esegue query su queste informazioni avanzate per creare analisi sensibili al contesto.

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
}

Utilizzare i campi arricchiti WHOIS in una regola

Puoi scrivere regole che cercano i campi arricchiti WHOIS nelle entità che rappresentano un dominio. Queste entità hanno il campo entity.metadata.entity_type impostato su DOMAIN_NAME. Per un elenco dei campi UDM compilati, vedi Arricchire le entità con i dati WHOIS.

Di seguito è riportato un esempio di regola che mostra come eseguire questa operazione. Questa regola include seguenti campi filtro nella sezione events per ottimizzare le prestazioni della regola.

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

Eseguire query sui dati di Google Cloud Threat Intelligence

Google Security Operations importa i dati da Google Cloud Threat Intelligence (GCTI) origini dati che forniscono informazioni contestuali che puoi utilizzare delle attività nel tuo ambiente. Puoi eseguire query sulle seguenti origini dati:

• Nodi di uscita di GCTI Tor
• Binari benigni GCTI
• Strumenti per l'accesso remoto di GCTI

Per una descrizione di questi feed delle minacce e di tutti i campi compilati, consulta Importare e archiviare i dati di Google Cloud Threat Intelligence.

In questo documento, il segnaposto <variable_name> rappresenta il nome univoco della variabile utilizzata in una regola per identificare un record UDM.

Query sugli indirizzi IP dei nodi di uscita Tor

La seguente regola di esempio restituisce un rilevamento quando NETWORK_CONNECTION contiene un indirizzo IP memorizzato nel campo target.ip, anch'esso disponibile nell'origine dati GCTI Tor Exit Nodes. Assicurati di includere i campi <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name, e <variable_name>.graph.metadata.product_name nella regola.

Questa è un'origine dati a tempo. Gli eventi corrisponderanno all'istantanea dell'origine dati in data in quel momento specifico.

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
}

Query su file di sistema operativo innocui

La seguente regola di esempio combina le origini dati Benign Binaries e Tor Exit Nodes per restituire un avviso quando un binario benigno contatta un nodo di uscita Tor. La regola calcola Un punteggio di rischio utilizzando i dati di geolocalizzazione che Google Security Operations ha arricchito usando l'indirizzo IP di destinazione. Assicurati di includere i campi <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name, e <variable_name>.graph.metadata.threat.threat_feed_name sia per Benign Binaries che per Tor Exit Nodes le origini dati nella regola.

Si tratta di un'origine dati senza tempo. Gli eventi corrisponderanno sempre all'istantanea più recente dell'origine dati, indipendentemente dall'ora.

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
}

Query sui dati degli strumenti di accesso remoto

La seguente regola di esempio restituisce un rilevamento quando un tipo di evento PROCESS_LAUNCH contiene un hash presente anche in Google Cloud Threat Intelligence Origine dati di Remote Access Tools.

Si tratta di un'origine dati senza tempo. Gli eventi corrisponderanno sempre all'istantanea più recente all'origine dati, a prescindere dal tempo.

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

}

Utilizzare i campi di metadati estesi di VirusTotal nelle regole

La seguente regola rileva la creazione o l'avvio di un processo di un file specifico che indica la presenza di alcuni hash elencati nella lista di titoli nel sistema. Il punteggio di rischio viene impostato quando i file sono contrassegnati come exploit utilizzando i metadati dei file di VirusTotal arricchimento.

Per un elenco di tutti i campi UDM compilati, vedi Arricchisci gli eventi con i metadati dei file di 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
}

Utilizzare i dati sulle relazioni di VirusTotal nelle regole

Google Security Operations importa i dati dalle connessioni correlate a VirusTotal. Questi dati fornisce informazioni sulla relazione tra hash e file di file, domini, indirizzi IP e URL. Queste informazioni avanzate vengono archiviate come Entità in Google Security Operations.

Puoi creare regole di Detection Engine per identificare le corrispondenze con le entità importate di VirusTotal. La seguente regola invia un avviso quando viene scaricato un hash di file noto da un indirizzo IP noto con relazioni di VirusTotal. Il punteggio di rischio si basa su e i tag dei metadati del file VirusTotal.

Questi dati sono disponibili solo per determinate licenze di VirusTotal e Google Security Operations. Verifica la presenza di diritti con il tuo account manager. Per una lista di tutti i campi UDM compilati, vedi Arricchire le entità con i dati sulle relazioni di 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
}

Passaggi successivi

Per informazioni su come utilizzare i dati estesi con altre operazioni di sicurezza di Google vedi le funzioni seguenti:

• Utilizzare dati arricchiti di contesto nella ricerca UDM.
• Utilizzare dati arricchiti di contesto nei report.