Utilizzare i dati arricchiti dal contesto nelle regole
Per supportare gli analisti della sicurezza durante un'indagine, Google Security Operations importa i dati contestuali da diverse origini, esegue analisi sui dati importati e fornisce un contesto aggiuntivo sugli elementi in un ambiente del cliente. Questo documento fornisce esempi di come gli analisti possono utilizzare i dati arricchiti dal contesto nelle regole del Detection Engine.
Per ulteriori informazioni sull'arricchimento dei dati, consulta In che modo Google Security Operations arricchisce i dati di eventi ed entità.
Utilizzare i campi con informazioni aggiuntive sulla prevalenza nelle regole
Gli esempi riportati di seguito mostrano come utilizzare i campi arricchiti correlati alla prevalenza in Detection Engine. Come riferimento, consulta l'elenco dei campi con informazioni aggiuntive correlate alla prevalenza.
Identificare 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. È pensato principalmente come indicatore secondario per esaminare una risorsa. Ad esempio, esistono altri avvisi di gravità superiore che hanno attivato un incidente.
$enrichment.graph.metadata.entity_type = "FILE"
$enrichment.graph.metadata.product_name = "VirusTotal Relationships"
$enrichment.graph.metadata.vendor_name = "VirusTotal"
Per ulteriori informazioni sull'aggiunta di un filtro per migliorare il rendimento delle regole, consulta Aggiungere un filtro per tipo di evento.
Per informazioni su ciascun tipo di arricchimento, consulta In che modo Google Security Operations arricchisce i dati su eventi ed entità.
Utilizzare i campi con informazioni aggiuntive sulla prevalenza nelle regole
Gli esempi riportati di seguito mostrano come utilizzare i campi arricchiti correlati alla prevalenza in Detection Engine. Come riferimento, consulta l'elenco dei campi con informazioni aggiuntive correlate alla prevalenza.
Identificare l'accesso ai domini con un punteggio di prevalenza basso
Questa regola può essere utilizzata per rilevare l'accesso a domini con un punteggio di prevalenza basso. Per essere efficace, deve esistere una base di punteggi di prevalenza per gli elementi. L'esempio seguente utilizza gli elenchi di riferimento per ottimizzare il risultato e applica un valore di prevalenza della soglia.
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
}
Identificare i domini a bassa prevalenza con una corrispondenza IOC
Questa regola di rilevamento genera un avviso di rilevamento e fornisce una corrispondenza ad alta fedeltà confrontando un dominio a bassa prevalenza che è anche un indicatore di compromissione 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, 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
}
Utilizzare la data e l'ora della prima apparizione 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 compilati con entità che descrivono un dominio, un indirizzo IP e un file (hash). Per le entità che descrivono un utente o un asset, viene compilato 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 che vengono compilati, consulta Calcolare la data e l'ora della prima 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
}
Utilizzare i campi con informazioni aggiuntive sulla geolocalizzazione nelle regole
I campi UDM che memorizzano dati arricchiti con la posizione geografica possono essere utilizzati nelle regole del Detection Engine. Per un elenco dei campi UDM che vengono compilati, consulta Arricchire gli eventi con i dati sulla geolocalizzazione.
L'esempio seguente illustra come rilevare se un'entità utente si autentica 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 arricchiti di Navigazione sicura nelle regole
Google Security Operations importa i dati dagli elenchi di minacce relativi agli hash dei file. Queste informazioni arricchite vengono memorizzate come entità in Google Security Operations.
Per un elenco dei campi UDM che vengono compilati, consulta Arricchire le entità con le informazioni degli elenchi di minacce di Navigazione sicura.
Puoi creare regole del motore di rilevamento per identificare le corrispondenze con le entità importate da Safe Browsing. Di seguito è riportato un esempio di regola del motore di rilevamento che esegue query su queste informazioni arricchite per creare analisi basate sul 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 con informazioni aggiuntive WHOIS in una regola
Puoi scrivere regole che cercano i campi arricchiti WHOIS nelle entità che rappresentano un dominio. Per queste entità il campo entity.metadata.entity_type è impostato su DOMAIN_NAME. Per un elenco dei campi UDM compilati, consulta
Arricchire le entità con i dati WHOIS.
Di seguito è riportata una regola di esempio che mostra come eseguire questa operazione. Questa regola include i seguenti campi di filtro nella sezione events per contribuire a 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 = "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
}
Esegui query sui Google Cloud dati di Threat Intelligence
Google Security Operations importa i dati dalle origini Google Cloud dati di intelligence sulle minacce (GCTI) Google Cloud che forniscono informazioni contestuali che puoi utilizzare per esaminare le attività nel tuo ambiente. Puoi eseguire query sulle seguenti origini dati:
- Nodi di uscita Tor del GCTI
- Binari benigni GCTI
- Strumenti di accesso remoto GCTI
Per una descrizione di questi feed di minacce e di tutti i campi compilati, consulta Importare e archiviare Google Cloud i dati di Threat Intelligence.
In questo documento, il segnaposto <variable_name> rappresenta il nome della variabile univoca
utilizzata in una regola per identificare un record UDM.
Esegui query sugli indirizzi IP dei nodi di uscita Tor
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.
Questa è un'origine dati a tempo. Gli eventi corrisponderanno allo snapshot dell'origine dati in quel determinato 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
}
Esegui query sui file del sistema operativo benigni
La seguente regola di esempio combina le origini dati Benign Binaries e Tor Exit Nodes per restituire un avviso quando un file binario attendibile contatta un nodo di uscita Tor. La regola calcola un punteggio di rischio utilizzando i dati sulla geolocalizzazione che Google Security Operations ha arricchito utilizzando l'indirizzo IP di destinazione. Assicurati di includere <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name e <variable_name>.graph.metadata.threat.threat_feed_name sia per le origini dati Benign Binaries che per quelle Tor Exit Nodes nella regola.
Si tratta di un'origine dati senza tempo. Gli eventi corrisponderanno sempre all'istantanea più recente dell'origine dati, indipendentemente dal momento.
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
}
Eseguire query sui dati relativi agli strumenti di accesso remoto
La seguente regola di esempio restituisce un rilevamento quando un tipo di evento PROCESS_LAUNCH contiene un hash che si trova anche nell'origine dati degli strumenti di accesso remoto Google Cloud Threat Intelligence.
Si tratta di un'origine dati senza tempo. Gli eventi corrisponderanno sempre all'istantanea più recente dell'origine dati, indipendentemente dal momento.
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 dei metadati arricchiti di VirusTotal nelle regole
La seguente regola rileva la creazione di file o l'avvio di un processo di un determinato tipo di file, indicando che alcuni hash nella lista di controllo sono presenti nel sistema. Il punteggio di rischio viene impostato quando i file vengono contrassegnati come exploit utilizzando l'arricchimento dei metadati dei file di VirusTotal.
Per un elenco di tutti i campi UDM compilati, consulta Arricchire 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 forniscono informazioni sulla relazione tra hash dei file e file, domini, indirizzi IP e URL. Queste informazioni arricchite vengono memorizzate come entità in Google Security Operations.
Puoi creare regole del Detection Engine per identificare le corrispondenze con le entità importate da VirusTotal. La seguente regola invia un avviso 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 dei metadati dei file di VirusTotal.
Questi dati sono disponibili solo per determinate licenze VirusTotal e Google Security Operations. Verifica i tuoi diritti con il tuo account manager. Per un elenco di tutti i campi UDM compilati, consulta Arricchire le entità con i dati delle 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
}
Coerenza finale
Le regole dipendenti dall'arricchimento richiedono l'elaborazione di dati aggiuntivi prima che una regola possa essere valutata completamente. Nel tempo, il processo di arricchimento viene completato e la regola viene rivalutata con i dati più recenti e accurati. Questa procedura di coerenza finale è prevista e significa che, anche se potrebbero esserci incoerenze iniziali, il sistema garantisce che tutti gli eventi verranno eventualmente arricchiti completamente e le regole verranno valutate con precisione. Scopri in che modo Google Security Operations arricchisce i dati su eventi ed entità.
Passaggi successivi
Per informazioni su come utilizzare i dati arricchiti con altre funzionalità di Google Security Operations, consulta quanto segue:
- Utilizza i dati arricchiti dal contesto nella ricerca UDM.
- Utilizzare i dati arricchiti dal contesto nei report.
Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.