Utiliser des données enrichies de contexte dans les règles
Pour aider les analystes de sécurité lors d'une enquête, Google Security Operations ingère des données contextuelles provenant de différentes sources, effectue une analyse des données ingérées et fournit un contexte supplémentaire sur les artefacts dans un environnement client. Ce document fournit des exemples de la façon dont les analystes peuvent utiliser des données enrichies de contexte dans les règles du moteur de détection.
Pour en savoir plus sur l'enrichissement des données, consultez Comment Google Security Operations enrichit les données sur les événements et les entités.
Utiliser des champs enrichis de prévalence dans les règles
Les exemples suivants montrent comment utiliser les champs enrichis liés à la prévalence dans le moteur de détection. Pour référence, consultez la liste des champs enrichis liés à la prévalence.
Identifier l'accès aux domaines à faible prévalence
Cette règle de détection génère un événement de détection, et non une alerte de détection, lorsqu'une correspondance est détectée. Il s'agit principalement d'un indicateur secondaire lors de l'examen d'un composant. Par exemple, d'autres alertes de gravité plus élevée ont déclenché un incident.
$enrichment.graph.metadata.entity_type = "FILE"
$enrichment.graph.metadata.product_name = "VirusTotal Relationships"
$enrichment.graph.metadata.vendor_name = "VirusTotal"
Pour en savoir plus sur l'ajout d'un filtre afin d'améliorer les performances des règles, consultez Ajouter un filtre de type d'événement.
Pour en savoir plus sur chaque type d'enrichissement, consultez Comment Google Security Operations enrichit les données sur les événements et les entités.
Utiliser des champs enrichis de prévalence dans les règles
Les exemples suivants montrent comment utiliser les champs enrichis liés à la prévalence dans le moteur de détection. Pour référence, consultez la liste des champs enrichis liés à la prévalence.
Identifier l'accès aux domaines avec un faible score de prévalence
Cette règle permet de détecter les accès à des domaines dont le score de prévalence est faible. Pour être efficace, une référence de scores de prévalence pour les artefacts doit exister. L'exemple suivant utilise des listes de référence pour ajuster le résultat et applique une valeur de prévalence seuil.
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
}
Identifier les domaines à faible prévalence avec une correspondance IOC
Cette règle de détection génère une alerte de détection et fournit une correspondance haute fidélité en comparant un domaine à faible prévalence qui est également un IOC connu.
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
}
Utiliser la date et l'heure de première apparition d'une entité dans une règle
Vous pouvez écrire des règles qui incluent les champs first_seen_time ou last_seen_time des enregistrements d'entités.
Les champs first_seen_time et last_seen_time sont renseignés avec des entités qui décrivent un domaine, une adresse IP et un fichier (hachage). Pour les entités qui décrivent un utilisateur ou un composant, seul le champ first_seen_time est renseigné. Ces valeurs ne sont pas calculées pour les entités qui décrivent d'autres types, tels qu'un groupe ou une ressource.
Pour obtenir la liste des champs UDM renseignés, consultez Calculer la date et l'heure de la première et de la dernière fois qu'une entité a été vue.
Voici un exemple montrant comment utiliser first_seen_time dans une règle:
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
}
Utiliser des champs enrichis de géolocalisation dans les règles
Les champs UDM qui stockent des données enrichies de géolocalisation peuvent être utilisés dans les règles du moteur de détection. Pour obtenir la liste des champs UDM renseignés, consultez la section Enrichir les événements avec des données de géolocalisation.
L'exemple suivant montre comment détecter si une entité utilisateur s'authentifie à partir de plusieurs états distincts.
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
}
Utiliser des champs enrichis par la navigation sécurisée dans les règles
Google Security Operations ingère les données des listes de menaces associées aux hachages de fichiers. Ces informations enrichies sont stockées en tant qu'entités dans Google Security Operations.
Pour obtenir la liste des champs UDM renseignés, consultez la section Enrichir les entités avec des informations provenant des listes de menaces de la navigation sécurisée.
Vous pouvez créer des règles de moteur de détection pour identifier les correspondances avec les entités ingérées à partir de la navigation sécurisée. Voici un exemple de règle du moteur de détection qui interroge ces informations enrichies pour créer des analyses contextuelles.
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
}
Utiliser des champs enrichis WHOIS dans une règle
Vous pouvez écrire des règles qui recherchent des champs enrichis WHOIS dans des entités représentant un domaine. Le champ entity.metadata.entity_type de ces entités est défini sur DOMAIN_NAME. Pour obtenir la liste des champs UDM renseignés, consultez la section Enrichir les entités avec des données WHOIS.
Voici un exemple de règle qui montre comment procéder. Cette règle inclut les champs de filtre suivants dans la section events pour optimiser les performances de la règle.
$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
}
Interroger les données Google Cloud Threat Intelligence
Google Security Operations ingère des données provenant de sources de données Google Cloud Threat Intelligence (GCTI) qui vous fournissent des informations contextuelles que vous pouvez utiliser pour examiner l'activité dans votre environnement. Vous pouvez interroger les sources de données suivantes:
- Nœuds de sortie Tor GCTI
- Fichiers binaires bénins GCTI
- Outils d'accès à distance GCTI
Pour en savoir plus sur ces flux de menaces et tous les champs renseignés, consultez la page Ingérer et stocker des données Google Cloud Threat Intelligence.
Dans ce document, l'espace réservé <variable_name> représente le nom de variable unique utilisé dans une règle pour identifier un enregistrement UDM.
Interroger les adresses IP des nœuds de sortie Tor
L'exemple de règle suivant renvoie une détection lorsqu'un événement NETWORK_CONNECTION contient une adresse IP stockée dans le champ target.ip qui se trouve également dans la source de données Tor Exit Nodes GCTI. Veillez à inclure les champs <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name et <variable_name>.graph.metadata.product_name dans la règle.
Il s'agit d'une source de données temporelle. Les événements correspondent à l'instantané de la source de données à ce moment-là.
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
}
Rechercher des fichiers de système d'exploitation inoffensifs
L'exemple de règle suivant combine les sources de données Benign Binaries et Tor Exit Nodes pour renvoyer une alerte lorsqu'un binaire bénin contacte un nœud de sortie Tor. La règle calcule un score de risque à l'aide des données de géolocalisation que Google Security Operations a enrichies à l'aide de l'adresse IP cible. Veillez à inclure <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name et <variable_name>.graph.metadata.threat.threat_feed_name pour les sources de données Benign Binaries et Tor Exit Nodes dans la règle.
Il s'agit d'une source de données intemporelle. Les événements correspondent toujours au dernier instantané de la source de données, quelle que soit l'heure.
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
}
Interroger les données sur les outils d'accès à distance
L'exemple de règle suivant renvoie une détection lorsqu'un type d'événement PROCESS_LAUNCH contient un hachage qui se trouve également dans la source de données des outils d'accès à distance de Google Cloud Threat Intelligence.
Il s'agit d'une source de données intemporelle. Les événements correspondent toujours au dernier instantané de la source de données, quelle que soit l'heure.
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
}
Utiliser des champs de métadonnées enrichies VirusTotal dans des règles
La règle suivante détecte la création de fichiers ou le lancement de processus d'un type de fichier spécifique, ce qui indique que certains hachages de la liste de surveillance se trouvent sur le système. Le score de risque est défini lorsque les fichiers sont tagués comme exploit à l'aide de l'enrichissement des métadonnées de fichier VirusTotal.
Pour obtenir la liste de tous les champs UDM renseignés, consultez Enrichir les événements avec les métadonnées de fichiers 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
}
Utiliser les données de relation VirusTotal dans les règles
Google Security Operations ingère les données des connexions associées à VirusTotal. Ces données fournissent des informations sur la relation entre les hachages de fichiers et les fichiers, les domaines, les adresses IP et les URL. Ces informations enrichies sont stockées en tant qu'entités dans Google Security Operations.
Vous pouvez créer des règles de moteur de détection pour identifier les correspondances avec les entités ingérées à partir de VirusTotal. La règle suivante envoie une alerte lors du téléchargement d'un hachage de fichier connu à partir d'une adresse IP connue avec des relations VirusTotal. Le score de risque est basé sur le type de fichier et les balises des métadonnées de fichier VirusTotal.
Ces données ne sont disponibles que pour certaines licences VirusTotal et Google Security Operations. Vérifiez vos droits d'accès auprès de votre responsable de compte. Pour obtenir la liste de tous les champs UDM renseignés, consultez Enrichir les entités avec des données de relation 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
}
Étape suivante
Pour savoir comment utiliser les données enrichies avec d'autres fonctionnalités Google Security Operations, consultez les ressources suivantes:
- Utilisez des données enrichies de contexte dans la recherche UDM.
- Utiliser des données enrichies de contexte dans les rapports