Utilizza dati arricchiti dal contesto nelle regole

Per consentire agli analisti della sicurezza durante un'indagine, Chronicle importa i dati contestuali da origini diverse, esegue l'analisi sui dati importati e fornisce contesto aggiuntivo sugli artefatti in un ambiente di tipo cliente. Questo documento fornisce esempi di come gli analisti possono utilizzare dati arricchiti nelle regole di rilevamento del motore.

Per ulteriori informazioni sull'arricchimento dei dati, vedi Come Chronicle arricchisce i dati di eventi e entità.

Utilizza campi arricchiti di prevalenza nelle regole

I seguenti esempi mostrano come utilizzare i campi arricchiti relativi alla prevalenza in Detection Engine. Come riferimento, consulta l'elenco dei campi arricchiti relativi alla prevalenza.

Identifica l'accesso ai domini a bassa prevalenza

Questa regola di rilevamento genera un evento di rilevamento, non un avviso di rilevamento, quando viene trovata una corrispondenza. Serve principalmente come indicatore secondario quando si esamina una risorsa. Ad esempio, ci sono altri avvisi di gravità maggiore che hanno attivato un incidente.

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

Vedi Aggiungere un filtro tipo di evento per ulteriori informazioni su come aggiungere un filtro per migliorare il rendimento delle regole.

Per informazioni su ciascun tipo di arricchimento, consulta Come Chronicle arricchisce i dati di eventi e entità.

Nota: Chronicle esegue una ricerca di cinque giorni durante la creazione dei dati di contesto delle entità. In questo modo vengono gestiti i dati in arrivo in ritardo e viene creata una durata implicita dei dati relativi al contesto dell'entità se end_time di entity.metatdata.interval viene omesso. Ad esempio, se memorizzi un record di contesto entità con interval.start_time per 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 dal 6 maggio in poi.

Utilizza campi arricchiti di prevalenza nelle regole

I seguenti esempi mostrano come utilizzare i campi arricchiti relativi alla prevalenza in Detection Engine. Come riferimento, consulta l'elenco dei campi arricchiti relativi alla prevalenza.

Identifica 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 riferimento dei punteggi di prevalenza degli artefatti. Nel seguente esempio vengono utilizzati gli elenchi di riferimento per perfezionare il risultato e applicare una soglia di prevalenza.

Nota: le statistiche sulla prevalenza per ogni entità sono archiviate in un'entità contestuale separata che può essere utilizzata da Detection Engine, ma non viene mostrata nelle ricerche o nelle visualizzazioni Chronicle.

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
}

Di seguito è riportato uno screenshot che mostra gli esempi di rilevamento generati da questa regola.

Visualizza immagine in una nuova finestra

Identifica i domini a bassa prevalenza con una corrispondenza di IOC

Questa regola di rilevamento genera un avviso di rilevamento e fornisce una corrispondenza ad alta fedeltà confrontando un dominio a bassa prevalenza noto anche come IOC.

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
}

Ecco un esempio che mostra i rilevamenti generati da questa regola.

Utilizza il tempo di 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 vengono completati con le entità che descrivono un dominio, un indirizzo IP e un file (hash). Per le entità che descrivono un utente o un asset, viene completato solo il campo first_seen_time. Questi valori non vengono calcolati per le entità che descrivono altri tipi, ad esempio un gruppo o una risorsa.

Per un elenco dei campi UDM compilati, consulta l'articolo Calcolare la prima visualizzazione e l'ora dell'ultimo rilevamento delle entità.

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

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
}

Utilizza i campi con arricchimento di geolocalizzazione nelle regole

I campi UDM che archiviano dati arricchiti di geolocalizzazione possono essere utilizzati nelle regole di rilevamento del motore. Per un elenco dei campi UDM completati, consulta Arricchire gli eventi con i dati di geolocalizzazione.

L'esempio seguente illustra come rilevare se un'entità utente esegue l'autenticazione da più stati distinti.

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
}

Utilizza i campi estesi di Navigazione sicura nelle regole

Chronicle importa i dati da elenchi di minacce relativi ad hash di file. Queste informazioni avanzate vengono archiviate come entità in Chronicle.

Per un elenco dei campi UDM completati, consulta Arricchire le entità con le informazioni degli elenchi delle minacce di Navigazione sicura.

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

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
}

Utilizza campi estesi con WHOIS in una regola

Puoi scrivere regole che eseguono ricerche in campi arricchiti di WHOIS in entità che rappresentano un dominio. Il campo entity.metadata.entity_type di queste entità è impostato su DOMAIN_NAME. Per un elenco dei campi UDM completati, consulta Arricchire le entità con i dati WHOIS.

Di seguito è riportato un esempio di regola da seguire. Questa regola include i seguenti campi filtro nella sezione events per ottimizzare il rendimento 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 = "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
}

Esegui una query sui dati di Google Cloud Threat Intelligence

Chronicle importa i dati da origini dati di Google Cloud Threat Intelligence (GCTI) che forniscono informazioni contestuali da utilizzare per esaminare l'attività nel tuo ambiente. Puoi eseguire query sulle seguenti origini dati:

• Nodi di uscita GCTI Tor
• Programmi binari benigni GCTI

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

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

Indirizzi IP dei nodi di uscita della query

La seguente regola di esempio restituisce un rilevamento quando un evento NETWORK_CONNECTION contiene un indirizzo IP memorizzato nel campo target.ip che si trova anche nell'origine dati Tor Exit Nodes GCTI. 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.

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 per 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 programma binario innocuo contatta un nodo di uscita Tor. La regola calcola un punteggio di rischio utilizzando i dati di geolocalizzazione che Chronicle ha arricchito con l'indirizzo IP di destinazione. Assicurati di includere nella regola sia le origini dati <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 sia per Tor Exit Nodes.

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
}

Utilizzare i campi di metadati estesi di VirusTotal nelle regole

La seguente regola rileva la creazione di file o l'avvio di un tipo di file specifico, a indicare che sul sistema sono presenti alcuni hash aggiunti alla lista di titoli. Il punteggio di rischio viene impostato quando i file vengono contrassegnati come exploit utilizzando l'arricchimento dei metadati di VirusTotal.

Per un elenco di tutti i campi UDM completati, consulta Arricchire gli eventi con i metadati di 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 delle relazioni di VirusTotal nelle regole

Chronicle importa i dati dalle connessioni correlate a VirusTotal. Questi dati forniscono informazioni sulla relazione tra hash di file e file, domini, indirizzi IP e URL. Le informazioni avanzate vengono memorizzate come entità in Chronicle.

Puoi creare regole di Detection Engine per identificare corrispondenze con entità importate da VirusTotal. La regola seguente invia un avviso relativo al download di un hash di file noto da un indirizzo IP noto con relazioni VirusTotal. Il punteggio di rischio si basa sul tipo di file e sui tag dai metadati del file di VirusTotal.

Questi dati sono disponibili solo per i clienti con licenza VirusTotal Enterprise o VirusTotal DUET. Per un elenco di tutti i campi UDM completati, consulta Arricchire le entità con i dati della relazione 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 funzionalità di Chronicle, consulta quanto segue:

• Utilizza dati arricchiti dal contesto nella ricerca UDM.
• Utilizza dati arricchiti dal contesto nei report.