Kontextangereicherte Daten in Regeln verwenden

Um Sicherheitsanalysten bei einer Prüfung zu unterstützen, nimmt Google Security Operations kontextbezogene Informationen auf Daten aus verschiedenen Quellen analysieren, die aufgenommenen Daten analysieren bietet zusätzlichen Kontext zu Artefakten in der Kundenumgebung. Dieses Dokument enthält Beispiele dafür, wie Fachkräfte für Datenanalyse kontextbezogene Daten verwenden können in den Regeln der Erkennungs-Engine.

Weitere Informationen zur Datenanreicherung finden Sie unter Wie Google Security Operations Ereignis- und Entitätsdaten anreichert.

Angereicherte Felder in Regeln verwenden

Die folgenden Beispiele veranschaulichen, wie die angereicherte in der Erkennungs-Engine. Weitere Informationen finden Sie in der Liste der auf Prävalenz bezogenen angereicherten Felder.

Domainzugriff mit geringer Prävalenz ermitteln

Diese Erkennungsregel generiert ein Erkennungsereignis, keine Erkennungswarnung, wenn eine Übereinstimmung gefunden wird. Er ist primär als sekundärer Indikator gedacht, der Untersuchung eines Assets. Es gibt beispielsweise 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 finden Sie unter Ereignistypfilter hinzufügen. finden Sie weitere Informationen dazu, wie Sie einen Filter hinzufügen, um die Regelleistung zu verbessern.

Weitere Informationen zu den einzelnen Anreicherungstypen finden Sie unter So werden Ereignis- und Entitätsdaten durch Google Security Operations angereichert.

Hinweis: Google Security Operations führt ein Lookback-Window von fünf Tagen durch, wenn Entitätskontextdaten erstellt werden. Damit werden spät ankommende Daten verarbeitet und eine implizite Lebensdauer für Entitätskontextdaten erstellt, wenn end_time von entity.metatdata.interval weggelassen wird. Wenn Sie beispielsweise einen Entitätskontexteintrag mit einem interval.start_time am 1. Mai und ohne interval.end_time speichern, wird der Datensatz vom 1. bis einschließlich 5. Mai gespeichert. Der Eintrag wird ab dem 6. Mai nicht mehr sichtbar sein.

Angereicherte Felder in Regeln verwenden

Die folgenden Beispiele veranschaulichen, wie die angereicherte in der Erkennungs-Engine. Weitere Informationen finden Sie in der Liste der auf Prävalenz bezogenen angereicherten Felder.

Ermitteln des Zugriffs auf Domains mit einem niedrigen Prävalenzwert

Diese Regel kann verwendet werden, um den Zugriff auf Domains mit einem niedrigen Prävalenzwert zu ermitteln. Damit die Anwendung effektiv ist, muss eine Referenz der Prävalenzwerte für Artefakte vorhanden sein. Die Im folgenden Beispiel wird das Ergebnis mithilfe von Referenzlisten abgestimmt und ein Grenzwertprävalenzwert.

Hinweis: Die Verbreitungsstatistiken werden für jede Entität in einem separaten kontextbezogene Entität, die von der Detection Engine verwendet werden kann, aber nicht in Google Security Operations-Ansichten oder -Suche.

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
}

Domains mit niedriger Prävalenz und IOC-Übereinstimmung identifizieren

Diese Erkennungsregel generiert eine Erkennungswarnung und bietet eine hohe Genauigkeit Vergleich mit Domains mit geringer Verbreitung, die auch als IOC bekannt sind.

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
}

Zeitpunkt der erstmaligen Erfassung einer Entität in einer Regel verwenden

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

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

Eine Liste der UDM-Felder, die ausgefüllt werden, finden Sie unter Zeitpunkt der ersten und letzten Erfassung von Entitäten berechnen.

Das folgende Beispiel zeigt, wie die first_seen_time in einer Regel verwendet wird:

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 der Standortbestimmung angereicherte Felder in Regeln verwenden

UDM-Felder, die mit der Standortbestimmung angereicherte Daten speichern, können in Detection Engine-Regeln verwendet werden. Eine Liste der UDM-Felder, die ausgefüllt werden, finden Sie unter Ereignisse mit Geolocation-Daten anreichern

Das folgende Beispiel veranschaulicht, wie ermittelt werden kann, ob eine Nutzerentität sich authentifizieren. aus verschiedenen Bundesstaaten.

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
}

Angereicherte Safe Browsing-Felder in Regeln verwenden

Google Security Operations nimmt Daten aus Bedrohungslisten auf, die mit Datei-Hashes zusammenhängen. Diese angereicherten Informationen werden als Entitäten in Google Security Operations gespeichert.

Eine Liste der UDM-Felder, die ausgefüllt werden, finden Sie unter Entitäten mit Informationen aus Safe Browsing-Bedrohungslisten anreichern:

Sie können Erkennungs-Engine-Regeln erstellen, um Übereinstimmungen mit Entitäten zu ermitteln die aus Safe Browsing aufgenommen wurden. Hier sehen Sie ein Beispiel für eine Erkennungs-Engine. die diese angereicherten Informationen abfragt, um kontextsensitive 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 erstellen, mit denen nach WHOIS-angereicherten Feldern in Entitäten gesucht wird, für eine Domain stehen. Diese Entitäten haben das Feld entity.metadata.entity_type auf DOMAIN_NAME festgelegt. Eine Liste der UDM-Felder, die ausgefüllt werden, finden Sie unter Entitäten mit WHOIS-Daten anreichern:

Die folgende Beispielregel zeigt, wie das funktioniert. Diese Regel umfasst die den Filterfeldern im Abschnitt events folgen, 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
}

Google Cloud Threat Intelligence-Daten abfragen

Google Security Operations nimmt Daten aus Google Cloud Threat Intelligence (GCTI) auf Datenquellen, die Kontextinformationen liefern, die Sie für Aktivitäten in Ihrer Umgebung untersuchen. Sie können die folgenden Datenquellen abfragen:

• GCTI-Tor-Exit-Knoten
• Benigne GCTI-Binärprogramme
• GCTI-Remotezugriff-Tools

Eine Beschreibung dieser Bedrohungsfeeds und aller ausgefü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. die in einer Regel zur Identifizierung eines UDM-Eintrags verwendet werden.

IP-Adressen von Exit-Knoten des Abfragetors

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

Dies ist eine zeitgesteuerte Datenquelle. Ereignisse stimmen mit dem Snapshot der Datenquelle unter zu einem bestimmten Zeitpunkt zu kommen.

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
}

Abfrage nach harmlosen Betriebssystemdateien

Mit der folgenden Beispielregel werden die Datenquellen Benign Binaries und Tor Exit Nodes kombiniert , um eine Warnung zurückzugeben, wenn ein harmloses Binärprogramm einen Tor-Ausstiegsknoten kontaktiert. Die Regel berechnet Risikobewertung mithilfe der Daten zur Standortbestimmung die Google Security Operations mit der Ziel-IP-Adresse anreichert. Achten Sie darauf, <variable_name>.graph.metadata.vendor_name, <variable_name>.graph.metadata.product_name, und <variable_name>.graph.metadata.threat.threat_feed_name für Benign Binaries und Tor Exit Nodes Datenquellen in der Regel.

Dies ist eine zeitlose Datenquelle. Ereignisse stimmen immer mit der aktuellen Momentaufnahme überein der Datenquelle 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

Mit der folgenden Beispielregel wird eine Erkennung zurückgegeben, wenn der Ereignistyp PROCESS_LAUNCH enthält einen Hash, der auch in der Google Cloud Threat Intelligence-Bibliothek enthalten ist Datenquelle für Remotezugriff-Tools.

Dies ist eine zeitlose Datenquelle. Ereignisse stimmen immer mit dem letzten Snapshot von Datenquelle 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

Mit der folgenden Regel wird die Dateierstellung oder der Start einer bestimmten Datei erkannt -Typ, was darauf hinweist, dass sich einige Hashes auf der Merkliste im System befinden. Risikobewertung wird festgelegt, wenn die Dateien unter Verwendung von VirusTotal-Dateimetadaten als exploit getaggt sind die Bereicherung sind.

Eine Liste aller UDM-Felder, die ausgefüllt werden, 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 Security Operations nimmt Daten aus VirusTotal-Verbindungen auf. Diese Daten Informationen zur Beziehung zwischen Datei-Hashes und Dateien, Domains, IP-Adressen und URLs. Diese angereicherten Informationen werden als Entitäten in Google Security Operations gespeichert.

Sie können Erkennungs-Engine-Regeln erstellen, um Übereinstimmungen mit aufgenommenen Entitäten zu ermitteln von VirusTotal. Mit der folgenden Regel wird eine Benachrichtigung zum Herunterladen eines bekannten Datei-Hashs gesendet von einer bekannten IP-Adresse mit VirusTotal-Beziehungen. Die Risikobewertung basiert auf den Dateityp und die Tags aus den Metadaten der VirusTotal-Datei.

Diese Daten sind nur für bestimmte VirusTotal- und Google Security Operations-Lizenzen verfügbar. Prüfe deine Berechtigungen mit deinem Account Manager. Für eine Liste aller UDM-Felder, die ausgefüllt werden, 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
}

Nächste Schritte

Informationen dazu, wie Sie angereicherte Daten mit anderen Google Security Operations verwenden finden Sie hier:

• Kontextangereicherte Daten in der UDM-Suche verwenden
• Verwenden Sie in Berichten mit Kontext angereicherte Daten.