Mit Kontext angereicherte Daten in Regeln

Unterstützt in:

Um Sicherheitsanalysten bei einer Untersuchung zu unterstützen, nimmt Google Security Operations Kontextdaten aus verschiedenen Quellen auf, analysiert die aufgenommenen Daten und liefert zusätzlichen Kontext zu Artefakten in einer Kundenumgebung. In diesem Dokument finden Sie Beispiele dafür, wie Analysten mit Kontext angereicherte Daten in Detection Engine-Regeln verwenden.

Weitere Informationen zur Datenanreicherung finden Sie unter So reichert Google SecOps Ereignis- und Entitätsdaten an.

Mit Häufigkeit angereicherte Felder in Regeln verwenden

Die folgenden Beispiele zeigen, wie Sie die mit Häufigkeit angereicherten Felder in Detection Engine verwenden. Eine Referenz finden Sie in der Liste der mit Häufigkeit angereicherten Felder.

Zugriff auf Domains mit niedriger Häufigkeit identifizieren

Diese Erkennungsregel generiert ein Erkennungsereignis, aber keine Erkennungsbenachrichtigung, wenn eine Übereinstimmung gefunden wird. Sie ist in erster Linie als sekundärer Indikator bei der Untersuchung eines Assets gedacht. Beispiel: Es gibt andere Benachrichtigungen mit höherem Schweregrad, die einen Vorfall ausgelöst haben.

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

Weitere Informationen zum Hinzufügen eines Filters zur Verbesserung der Regelleistung finden Sie unter Filter für Ereignistypen hinzufügen.

Informationen zu den einzelnen Anreicherungstypen finden Sie unter So reichert Google SecOps Ereignis- und Entitätsdaten an.

Mit Häufigkeit angereicherte Felder in Regeln verwenden

Die folgenden Beispiele zeigen, wie Sie die mit Häufigkeit angereicherten Felder in Detection Engine verwenden. Eine Referenz finden Sie in der Liste der mit Häufigkeit angereicherten Felder.

Zugriff auf Domains mit niedriger Häufigkeit identifizieren

Mit dieser Regel kann der Zugriff auf Domains mit niedriger Häufigkeit erkannt werden. Damit sie effektiv ist, muss eine Baseline der Häufigkeitswerte für Artefakte vorhanden sein. Im folgenden Beispiel werden Referenzlisten verwendet, um das Ergebnis zu optimieren, und ein Schwellenwert für die Häufigkeit angewendet.

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
}

Domains mit niedriger Häufigkeit mit einer IOC-Übereinstimmung identifizieren

Diese Erkennungsregel generiert eine Erkennungsbenachrichtigung und liefert eine hochgenaue Übereinstimmung, indem sie eine Domain mit niedriger Häufigkeit vergleicht, die auch ein bekannter IOC ist.

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
}

Erste Erkennungszeit einer Entität in einer Regel verwenden

Sie können Regeln schreiben, die die Felder first_seen_time oder last_seen_time aus Entitätseinträgen enthalten.

Die Felder first_seen_time und last_seen_time werden mit Entitäten gefüllt, die eine Domain, eine IP-Adresse und eine Datei (Hash) beschreiben. Bei Entitäten, die einen Nutzer oder ein Asset beschreiben, wird nur das Feld first_seen_time gefüllt. Diese Werte werden nicht für Entitäten berechnet, die andere Typen beschreiben, z. B. eine Gruppe oder eine Ressource.

Eine Liste der gefüllten UDM-Felder finden Sie unter Erste und letzte Erkennungszeit von Entitäten berechnen.

Hier ein Beispiel für die Verwendung von first_seen_time in einer Regel:

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
}

Mit geografischen Daten angereicherte Felder in Regeln verwenden

UDM-Felder, in denen mit geografischen Daten angereicherte Daten gespeichert sind, können in Detection Engine-Regeln verwendet werden. Eine Liste der gefüllten UDM-Felder finden Sie unter Ereignisse mit geografischen Daten anreichern.

Das folgende Beispiel zeigt, wie Sie erkennen können, ob sich eine Nutzerentität von mehreren verschiedenen Standorten aus authentifiziert.

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
}

Mit Safe Browsing angereicherte Felder in Regeln verwenden

Google SecOps nimmt Daten aus Bedrohungslisten auf, die sich auf Dateihashes beziehen. Diese angereicherten Informationen werden in Google SecOps als Entitäten gespeichert.

Eine Liste der gefüllten UDM-Felder finden Sie unter Entitäten mit Informationen aus Safe Browsing-Bedrohungslisten anreichern.

Sie können Detection Engine-Regeln erstellen, um Übereinstimmungen mit Entitäten zu identifizieren, die aus Safe Browsing aufgenommen wurden. Das folgende Beispiel zeigt eine Detection Engine-Regel, die diese angereicherten Informationen abfragt, um kontextbezogene Analysen zu erstellen.

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
}

Mit WHOIS angereicherte Felder in einer Regel verwenden

Sie können Regeln schreiben, die mit WHOIS angereicherte Felder in Entitäten durchsuchen, die eine Domain darstellen. Für diese Entitäten ist das Feld entity.metadata.entity_type auf DOMAIN_NAME gesetzt. Eine Liste der gefüllten UDM-Felder finden Sie unter Entitäten mit WHOIS-Daten anreichern.

Das folgende Beispiel zeigt, wie das geht. Diese Regel enthält die folgenden Filterfelder im Abschnitt events, um die Leistung der Regel zu optimieren.

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

Threat Intelligence-Daten Google Cloud abfragen

Google SecOps nimmt Daten aus Google Cloud Threat Intelligence-Datenquellen (GCTI) auf, die Ihnen Kontextinformationen liefern, die Sie bei der Untersuchung von Aktivitäten in Ihrer Umgebung verwenden können. Sie können die folgenden Datenquellen abfragen:

  • GCTI-Tor-Exit-Knoten
  • GCTI-Gutartige Binärprogramme
  • GCTI-Tools für den Remotezugriff

Eine Beschreibung dieser Bedrohungsfeeds und aller gefüllten Felder finden Sie unter Google Cloud Threat Intelligence-Daten aufnehmen und speichern.

In diesem Dokument steht der Platzhalter <variable_name> für den eindeutigen Variablennamen der in einer Regel verwendet wird, um einen UDM-Eintrag zu identifizieren.

IP-Adressen von Tor-Exit-Knoten abfragen

Die folgende Beispielregel gibt eine Erkennung zurück, wenn ein NETWORK_CONNECTION-Ereignis eine IP-Adresse enthält, die im Feld target.ip gespeichert ist und auch in der GCTI-Datenquelle Tor Exit Nodes gefunden wird. Stellen Sie sicher, dass die Felder <variable_name>.graph.metadata.threat.threat_feed_name, <variable_name>.graph.metadata.vendor_name, und <variable_name>.graph.metadata.product_name in die Regel aufgenommen werden.

Dies ist eine zeitabhängige Datenquelle. Ereignisse werden mit dem Snapshot der Datenquelle zu diesem Zeitpunkt abgeglichen.

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
}

Weitere erweiterte Beispiele, einschließlich der Anwendung von Häufigkeitsschwellenwerten auf fehlgeschlagene Anmeldungen aus Tor-Netzwerken, finden Sie unter Mehrere fehlgeschlagene Anmeldungen aus dem Tor-Netzwerk.

Nach gutartigen Betriebssystemdateien suchen

Die folgende Beispielregel kombiniert die Datenquellen Benign Binaries und Tor Exit Nodes, um eine Benachrichtigung zurückzugeben, wenn ein gutartiges Binärprogramm einen Tor-Exit-Knoten kontaktiert. Die Regel berechnet einen Risikowert anhand der geografischen Daten , die Google SecOps mit der Ziel-IP-Adresse angereichert hat. Fügen Sie die Felder <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name, und <variable_name>.graph.metadata.threat.threat_feed_name für die Datenquellen Benign Binaries und Tor Exit Nodes in die Regel ein.

Dies ist eine zeitlose Datenquelle. Ereignisse werden immer mit dem neuesten Snapshot der Datenquelle abgeglichen, unabhängig von der Zeit.

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
}

Daten zu Tools für den Remotezugriff abfragen

Die folgende Beispielregel gibt eine Erkennung zurück, wenn ein PROCESS_LAUNCH Ereignistyp einen Hash enthält, der auch in der Google Cloud Threat Intelligence Datenquelle „Remote Access Tools“ gefunden wird.

Dies ist eine zeitlose Datenquelle. Ereignisse werden immer mit dem neuesten Snapshot der Datenquelle abgeglichen, unabhängig von der Zeit.

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

}

Mit VirusTotal angereicherte Metadatenfelder in Regeln verwenden

Die folgende Regel erkennt die Erstellung von Dateien oder den Start von Prozessen eines bestimmten Dateityps, was darauf hindeutet, dass sich einige auf der Beobachtungsliste stehende Hashes auf dem System befinden. Der Risikowert wird festgelegt, wenn die Dateien mit der Anreicherung von VirusTotal-Dateimetadaten als exploit gekennzeichnet werden.

Eine Liste aller gefüllten UDM-Felder finden Sie unter Ereignisse mit VirusTotal-Dateimetadaten anreichern.

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
}

VirusTotal-Beziehungsdaten in Regeln verwenden

Google SecOps nimmt Daten aus VirusTotal-bezogenen Verbindungen auf. Diese Daten enthalten Informationen zur Beziehung zwischen Dateihashes und Dateien, Domains, IP-Adressen und URLs. Diese angereicherten Informationen werden in Google SecOps als Entitäten gespeichert.

Sie können Detection Engine-Regeln erstellen, um Übereinstimmungen mit Entitäten zu identifizieren, die aus VirusTotal aufgenommen wurden. Die folgende Regel sendet eine Benachrichtigung, wenn ein bekannter Dateihash von einer bekannten IP-Adresse mit VirusTotal-Beziehungen heruntergeladen wird. Der Risikowert basiert auf dem Dateityp und den Tags aus den VirusTotal-Dateimetadaten.

Diese Daten sind nur für bestimmte VirusTotal- und Google SecOps-Lizenzen verfügbar. Fragen Sie Ihren Account Manager nach Ihren Berechtigungen. Eine Liste aller gefüllten UDM-Felder finden Sie unter Entitäten mit VirusTotal-Beziehungsdaten anreichern.

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
}

Eventual Consistency

Regeln, die von der Anreicherung abhängen, erfordern die Verarbeitung zusätzlicher Daten, bevor eine Regel vollständig ausgewertet werden kann. Im Laufe der Zeit wird der Anreicherungsprozess abgeschlossen und die Regel wird mit den neuesten, genauen Daten neu ausgewertet. Dieser Prozess der Eventual Consistency ist zu erwarten und bedeutet, dass es zwar anfängliche Inkonsistenzen geben kann, das System aber dafür sorgt, dass alle Ereignisse schließlich vollständig angereichert werden und Regeln genau ausgewertet werden. Informationen zum Anreichern von Ereignis- und Entitätsdaten in Google SecOps .

Nächste Schritte

Informationen zur Verwendung angereicherter Daten mit anderen Google SecOps-Funktionen finden Sie unter:

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten