Parser – Übersicht

Unterstützt in:

In diesem Dokument wird beschrieben, wie Google Security Operations Logrohdaten in das UDM-Format (UDM) parst.

Google SecOps kann Logdaten aus den folgenden Aufnahmequellen empfangen:

In der Regel senden Kunden Daten als ursprüngliche Rohlogs. Google SecOps identifiziert das Gerät, das die Logs generiert hat, eindeutig anhand des LogType. Der LogType identifiziert beides:

  • den Anbieter und das Gerät, von dem das Protokoll generiert wurde, z. B. Cisco Firewall, Linux DHCP Server oder Bro DNS.
  • welcher Parser das Rohlog in ein strukturiertes UDM konvertiert. Es besteht eine 1:1-Beziehung zwischen einem Parser und einem LogType. Jeder Parser konvertiert Daten, die von einem einzelnen LogType empfangen werden.

Google SecOps bietet eine Reihe von Standardparsern, die die ursprünglichen Rohlogs lesen und strukturierte UDM-Einträge mit den Daten im ursprünglichen Rohlog generieren. Diese Parser werden von Google SecOps verwaltet. Kunden können auch benutzerdefinierte Anweisungen für den Datenabgleich definieren, indem sie einen kundenspezifischen Parser erstellen. Wenn Sie eine mehrzeilige Nutzlast senden, interpretiert das System jede Zeile als separaten Logeintrag.

Workflow für Aufnahme und Normalisierung

Der Parser enthält Anweisungen für den Datenabgleich. Sie definiert, wie Daten aus dem ursprünglichen Rohlog einem oder mehreren Feldern in der UDM-Datenstruktur zugeordnet werden.

Wenn keine Parsing-Fehler auftreten, erstellt Google SecOps einen UDM-strukturierten Datensatz mit Daten aus dem Rohlog. Der Prozess der Konvertierung eines Rohlogs in einen UDM-Eintrag wird als Normalisierung bezeichnet.

Ein Standardparser kann eine Teilmenge der Kernwerte aus dem Rohlog zuordnen. In der Regel sind diese Kernfelder die wichtigsten, um Sicherheitsstatistiken in Google SecOps bereitzustellen. Nicht zugeordnete Werte verbleiben im Rohprotokoll, werden aber nicht im UDM-Eintrag gespeichert.

Ein Kunde kann auch die Chronicle API-Methoden für die Datenaufnahme verwenden, um Daten im strukturierten UDM-Format zu senden. Informationen zur Migration von der Legacy-Ingestion API zur Chronicle API finden Sie unter Von der Legacy-SIEM API zur Chronicle API migrieren.

Parsen von aufgenommenen Daten anpassen

Google SecOps bietet die folgenden Funktionen, mit denen Kunden das Datenparsen für eingehende Original-Logdaten anpassen können. Weitere Informationen zum Verwalten dieser Parser finden Sie unter Vordefinierte und benutzerdefinierte Parser verwalten.

  • Kundenspezifische Parser: Kunden erstellen eine benutzerdefinierte Parserkonfiguration für einen bestimmten Logtyp, der ihren spezifischen Anforderungen entspricht. Ein kundenspezifischer Parser ersetzt den Standardparser für den jeweiligen LogType. Weitere Informationen finden Sie unter Vordefinierte und benutzerdefinierte Parser verwalten.
  • Parser-Erweiterungen: Kunden können zusätzlich zur Standard-Parser-Konfiguration benutzerdefinierte Zuordnungsanweisungen hinzufügen. Jeder Kunde kann eigene Anweisungen für die benutzerdefinierte Zuordnung erstellen. In diesen Zuordnungsanweisungen wird definiert, wie zusätzliche Felder aus ursprünglichen Rohlogs extrahiert und in UDM-Felder transformiert werden. Eine Parser-Erweiterung ersetzt nicht den Standard- oder kundenspezifischen Parser.

Beispiel mit einem Squid-Webproxy-Log

In diesem Abschnitt finden Sie ein Beispiel für ein Squid-Web-Proxy-Log und wird beschrieben, wie die Werte einem UDM-Eintrag zugeordnet werden. Eine Beschreibung aller Felder im UDM-Schema finden Sie in der Feldliste für das Unified Data Model.

Das Beispiel-Squid-Web-Proxy-Log enthält durch Leerzeichen getrennte Werte. Jeder Eintrag stellt ein Ereignis dar und enthält die folgenden Daten: Zeitstempel, Dauer, Client, Ergebniscode/Ergebnisstatus, übertragene Byte, Anfragemethode, URL, Nutzer, Hierarchiecode und Inhaltstyp. In diesem Beispiel werden die folgenden Felder extrahiert und einem UDM-Eintrag zugeordnet: Zeit, Client, Ergebnisstatus, Byte, Anfragemethode und URL.

1588059648.129 23 192.168.23.4 TCP_HIT/200 904 GET www.google.com/images/sunlogo.png - HIER_DIRECT/203.0.113.52 image/jpeg

Beispiel für einen Squid-Webproxy

Wenn Sie diese Strukturen vergleichen, werden Sie feststellen, dass nur ein Teil der ursprünglichen Protokolldaten im UDM-Eintrag enthalten ist. Bestimmte Felder sind erforderlich, andere sind optional. Außerdem enthält nur ein Teil der Abschnitte im UDM-Eintrag Daten. Wenn der Parser keine Daten aus dem ursprünglichen Log dem UDM-Eintrag zuordnet, wird dieser Abschnitt des UDM-Eintrags in Google SecOps nicht angezeigt.

UDM zugeordnete Logwerte

Im Abschnitt metadata wird der Zeitstempel des Ereignisses gespeichert. Der Wert wurde vom Epoch-Format in das RFC 3339-Format konvertiert. Diese Konvertierung ist optional. Der Zeitstempel kann im Epoch-Format gespeichert werden, wobei die Sekunden und Millisekunden durch Vorverarbeitung in separate Felder aufgeteilt werden.

Im Feld metadata.event_type wird der Wert NETWORK_HTTP gespeichert. Dies ist ein Aufzählungswert, der den Ereignistyp angibt. Der Wert von metadata.event_type bestimmt, welche zusätzlichen UDM-Felder erforderlich und welche optional sind. Die Werte product_name und vendor_name enthalten nutzerfreundliche Beschreibungen des Geräts, das das ursprüngliche Protokoll aufgezeichnet hat.

Der metadata.event_type in einem UDM-Ereignisdatensatz ist nicht mit dem log_type identisch, der beim Aufnehmen von Daten mit der Chronicle API definiert wird. In diesen beiden Attributen werden unterschiedliche Informationen gespeichert.

Der Abschnitt network enthält Werte aus dem ursprünglichen Logereignis. In diesem Beispiel wurde der Statuswert aus dem ursprünglichen Log aus dem Feld „result code/status“ geparst, bevor er in den UDM-Eintrag geschrieben wurde. Nur der result_code wurde in den UDM-Eintrag aufgenommen.

UDM zugeordnete Logwerte

Im Abschnitt principal werden die Clientinformationen aus dem ursprünglichen Protokoll gespeichert. Im Abschnitt target werden sowohl die vollständig qualifizierte URL als auch die IP-Adresse gespeichert.

Im Abschnitt security_result wird einer der Enum-Werte gespeichert, die die im ursprünglichen Log aufgezeichnete Aktion darstellen.

Dies ist der UDM-Eintrag im JSON-Format. Beachten Sie, dass nur Abschnitte mit Daten enthalten sind. Die Abschnitte src, observer, intermediary, about und extensions sind nicht enthalten.

{
        "metadata": {
            "event_timestamp": "2020-04-28T07:40:48.129Z",
            "event_type": "NETWORK_HTTP",
            "product_name": "Squid Proxy",
            "vendor_name": "Squid"
        },
        "principal": {
            "ip": "192.168.23.4"
        },
        "target": {
            "url": "www.google.com/images/sunlogo.png",
            "ip": "203.0.113.52"
        },
        "network": {
            "http": {
                "method": "GET",
                "response_code": 200,
                "received_bytes": 904
            }
        },
        "security_result": {
            "action": "UNKNOWN_ACTION"
        }
}

Schritte in Parseranweisungen

Anweisungen zur Datenzuordnung in einem Parser folgen einem gängigen Muster:

  1. Daten aus dem ursprünglichen Protokoll parsen und extrahieren.
  2. Extrahierte Daten bearbeiten Dazu gehört die Verwendung von bedingter Logik, um Werte selektiv zu parsen, Datentypen zu konvertieren, Teilstrings in einem Wert zu ersetzen, in Groß- oder Kleinbuchstaben umzuwandeln usw.
  3. Weisen Sie UDM-Feldern Werte zu.
  4. Geben Sie den zugeordneten UDM-Eintrag im Schlüssel @output aus.

Daten aus dem ursprünglichen Log parsen und extrahieren

Filteranweisung festlegen

Die filter-Anweisung ist die erste Anweisung in den Parsing-Anweisungen. Alle zusätzlichen Parsing-Anweisungen sind in der filter-Anweisung enthalten.

filter {

}

Variablen initialisieren, in denen extrahierte Werte gespeichert werden

Initialisieren Sie in der filter-Anweisung Zwischenvariablen, die der Parser zum Speichern von Werten verwendet, die aus dem Log extrahiert wurden.

Diese Variablen werden jedes Mal verwendet, wenn ein einzelnes Protokoll geparst wird. Der Wert in jeder Zwischenvariable wird später in den Parsing-Anweisungen auf ein oder mehrere UDM-Felder festgelegt.

  mutate {
    replace => {
      "event.idm.read_only_udm.metadata.product_name" => "Webproxy"
      "event.idm.read_only_udm.metadata.vendor_name" => "Squid"
      "not_valid_log" => "false"
      "when" => ""
      "srcip" => ""
      "action" => ""
      "username" => ""
      "url" => ""
      "tgtip" => ""
      "method" => ""
    }
  }

Einzelne Werte aus dem Protokoll extrahieren

Google SecOps bietet eine Reihe von Filtern, die auf Logstash basieren, um Felder aus ursprünglichen Logdateien zu extrahieren. Je nach Format des Logs verwenden Sie einen oder mehrere Extraktionsfilter, um alle Daten aus dem Log zu extrahieren. Wenn der String:

  • Die Parser-Syntax für natives JSON ähnelt der des JSON-Filters, der JSON-formatierte Logs unterstützt. Verschachteltes JSON wird nicht unterstützt.
  • XML-Format, die Parser-Syntax ähnelt dem XML-Filter, der XML-formatierte Logs unterstützt.
  • Schlüssel/Wert-Paare, die Parsersyntax ähnelt dem Kv-Filter, der Nachrichten im Schlüssel/Wert-Format unterstützt.
  • CSV-Format, die Parser-Syntax ähnelt dem CSV-Filter, der CSV-formatierte Nachrichten unterstützt.
  • Bei allen anderen Formaten ähnelt die Parser-Syntax dem GROK-Filter mit integrierten GROK-Mustern. Dabei werden Extraktionsanweisungen im Regex-Stil verwendet.

Google SecOps bietet eine Teilmenge der Funktionen, die in den einzelnen Filtern verfügbar sind. Google SecOps bietet auch eine benutzerdefinierte Syntax für den Datenabgleich, die in den Filtern nicht verfügbar ist. Eine Beschreibung der unterstützten Funktionen und benutzerdefinierten Funktionen finden Sie in der Referenz zur Parser-Syntax.

Im Beispiel des Squid-Web-Proxy-Logs enthält die folgende Datenextraktionsanweisung eine Kombination aus Logstash-Grok-Syntax und regulären Ausdrücken.

In der folgenden Extraktionsanweisung werden Werte in den folgenden Zwischenvariablen gespeichert:

  • when
  • srcip
  • action
  • returnCode
  • size
  • method
  • username
  • url
  • tgtip

In dieser Beispielanweisung wird auch das Schlüsselwort overwrite verwendet, um die extrahierten Werte in den einzelnen Variablen zu speichern. Wenn der Extraktionsprozess einen Fehler zurückgibt, wird not_valid_log von der on_error-Anweisung auf true gesetzt.

grok {
   match => {
     "message" => [
       "%{NUMBER:when}\\s+\\d+\\s%{SYSLOGHOST:srcip} %{WORD:action}\\/%{NUMBER:returnCode} %{NUMBER:size} %{WORD:method} (?P<url>\\S+) (?P<username>.*?) %{WORD}\\/(?P<tgtip>\\S+).*"
     ]
   }
   overwrite => ["when","srcip","action","returnCode","size","method","url","username","tgtip"]
   on_error => "not_valid_log"
}

Extrahierte Werte bearbeiten und transformieren

Google SecOps nutzt die Funktionen des Mutate-Filter-Plug-ins von Logstash, um die Bearbeitung von Werten zu ermöglichen, die aus dem ursprünglichen Log extrahiert wurden. Google SecOps bietet einen Teil der im Plug-in verfügbaren Funktionen. Eine Beschreibung der unterstützten Funktionen und benutzerdefinierten Funktionen finden Sie in der Parser-Syntax, z. B.:

  • Werte in einen anderen Datentyp umwandeln
  • Werte im String ersetzen
  • Zwei Arrays zusammenführen oder einen String an ein Array anhängen. Stringwerte werden vor dem Zusammenführen in ein Array konvertiert.
  • In Klein- oder Großbuchstaben umwandeln

In diesem Abschnitt finden Sie Beispiele für die Datentransformation, die auf dem zuvor vorgestellten Squid-Web-Proxy-Log basieren.

Zeitstempel des Ereignisses transformieren

Alle Ereignisse, die als UDM-Eintrag gespeichert werden, müssen einen Ereigniszeitstempel haben. In diesem Beispiel wird geprüft, ob ein Wert für die Daten aus dem Log extrahiert wurde. Anschließend wird die Grok-Datumsfunktion verwendet, um den Wert mit dem Zeitformat UNIX abzugleichen.

if [when] != "" {
  date {
    match => [
      "when", "UNIX"
    ]
   }
 }

Wert username transformieren

Im folgenden Beispiel wird der Wert in der Variable username in Kleinbuchstaben umgewandelt.

mutate {
   lowercase => [ "username"]
   }

Wert action transformieren

Im folgenden Beispiel wird der Wert in der Zwischenvariable action ausgewertet und in ALLOW, BLOCK oder UNKNOWN_ACTION geändert. Dies sind gültige Werte für das UDM-Feld security_result.action. Das UDM-Feld security_result.action ist ein Aufzählungstyp, in dem nur bestimmte Werte gespeichert werden.

if ([action] == "TCP_DENIED" or [action] == "TCP_MISS" or [action] == "Denied" or [action] == "denied" or [action] == "Dropped") {
      mutate {
        replace => {
          "action" => "BLOCK"
        }
      }
   } else if ([action] == "TCP_TUNNEL" or [action] == "Accessed" or [action] == "Built" or [action] == "Retrieved" or [action] == "Stored") {
     mutate {
        replace => {
          "action" => "ALLOW"
        }
     }
   } else {
      mutate {
        replace => {
          "action" => "UNKNOWN_ACTION" }
      }
   }

Ziel-IP-Adresse transformieren

Im folgenden Beispiel wird nach einem Wert in der Zwischenvariable tgtip gesucht. Wenn der Wert gefunden wird, wird er mithilfe eines vordefinierten Grok-Musters mit einem IP-Adressmuster abgeglichen. Wenn beim Abgleich des Werts mit einem IP-Adressmuster ein Fehler auftritt, setzt die Funktion on_error das Attribut not_valid_tgtip auf true. Wenn die Übereinstimmung erfolgreich ist, wird das Attribut not_valid_tgtip nicht festgelegt.

if [tgtip] not in [ "","-" ] {
   grok {
     match => {
       "tgtip" => [ "%{IP:tgtip}" ]
     }
     overwrite => ["tgtip"]
     on_error => "not_valid_tgtip"
   }

Datentyp von returnCode und size ändern

Im folgenden Beispiel wird der Wert in der Variable size in uinteger und der Wert in der Variable returnCode in uinteger umgewandelt. Dies ist erforderlich, da die Variable size im UDM-Feld network.received_bytes gespeichert wird, das einen int64-Datentyp enthält. Die Variable returnCode wird im UDM-Feld network.http.response_code gespeichert, das einen int32-Datentyp enthält.

mutate {
  convert => {
    "returnCode" => "integer"
    "size" => "uinteger"
  }
}

UDM-Feldern in einem Ereignis Werte zuweisen

Nachdem die Werte extrahiert und vorverarbeitet wurden, weisen Sie sie Feldern in einem UDM-Ereignisdatensatz zu. Sie können einem UDM-Feld sowohl extrahierte als auch statische Werte zuweisen.

Wenn Sie event.disambiguation_key angeben, muss dieses Feld für jedes Ereignis, das für das angegebene Log generiert wird, eindeutig sein. Wenn zwei verschiedene Ereignisse dieselbe disambiguation_key haben, führt dies zu unerwartetem Verhalten im System.

Die Parser-Beispiele in diesem Abschnitt bauen auf dem vorherigen Beispiel für ein Squid-Web-Proxy-Log auf.

Zeitstempel des Ereignisses speichern

Für jeden UDM-Ereignisdatensatz muss ein Wert für das UDM-Feld metadata.event_timestamp festgelegt sein. Im folgenden Beispiel wird der aus dem Log extrahierte Ereigniszeitstempel in der integrierten Variable @timestamp gespeichert. Google Security Operations speichert diese standardmäßig im UDM-Feld metadata.event_timestamp.

mutate {
  rename => {
    "when" => "timestamp"
  }
}

Ereignistyp festlegen

Für jeden UDM-Ereignisdatensatz muss ein Wert für das UDM-Feld metadata.event_type festgelegt sein. Dieses Feld ist ein Enum-Typ. Der Wert dieses Felds bestimmt, welche zusätzlichen UDM-Felder ausgefüllt werden müssen, damit der UDM-Eintrag gespeichert werden kann. Der Parsing- und Normalisierungsprozess schlägt fehl, wenn eines der Pflichtfelder keine gültigen Daten enthält.

replace => {
    "event.idm.read_only_udm.metadata.event_type" => "NETWORK_HTTP"
   }
}

Speichern Sie die Werte username und method mit der Anweisung replace.

Die Werte in den Zwischenfeldern username und method sind Strings. Im folgenden Beispiel wird geprüft, ob ein gültiger Wert vorhanden ist. Wenn ja, wird der Wert username im UDM-Feld principal.user.userid und der Wert method im UDM-Feld network.http.method gespeichert.

if [username] not in [ "-" ,"" ] {
  mutate {
    replace => {
      "event.idm.read_only_udm.principal.user.userid" => "%{username}"
    }
  }
}

if [method] != "" {
  mutate {
    replace => {
      "event.idm.read_only_udm.network.http.method" => "%{method}"
    }
  }
}

action im UDM-Feld security_result.action speichern

Im vorherigen Abschnitt wurde der Wert in der Zwischenvariable action ausgewertet und in einen der Standardwerte für das UDM-Feld security_result.action umgewandelt.

In den UDM-Feldern security_result und action wird ein Array von Elementen gespeichert. Daher müssen Sie beim Speichern dieses Werts etwas anders vorgehen.

Speichern Sie zuerst den transformierten Wert in einem Zwischenfeld security_result.action. Das Feld security_result ist ein übergeordnetes Feld des Felds action.

mutate {
   merge => {
     "security_result.action" => "action"
   }
}

Speichern Sie als Nächstes das Zwischenfeld security_result.action im UDM-Feld security_result. Im UDM-Feld security_result wird ein Array von Elementen gespeichert, sodass der Wert an dieses Feld angehängt wird.

 # save the security_result field
mutate {
  merge => {
    "event.idm.read_only_udm.security_result" => "security_result"
  }
}

Ziel-IP-Adresse und Quell-IP-Adresse mit der merge-Anweisung speichern

Speichern Sie die folgenden Werte im UDM-Ereignisdatensatz:

  • Wert in der Zwischenvariable srcip für das UDM-Feld principal.ip.
  • Wert in der Zwischenvariable tgtip für das UDM-Feld target.ip.

In den UDM-Feldern principal.ip und target.ip wird ein Array von Elementen gespeichert. Daher werden die Werte an jedes Feld angehängt.

In den folgenden Beispielen werden verschiedene Ansätze zum Speichern dieser Werte gezeigt. Während des Transformationsschritts wurde die Zwischenvariable tgtip mithilfe eines vordefinierten Grok-Musters einer IP-Adresse zugeordnet. In der folgenden Beispielanweisung wird geprüft, ob das Attribut not_valid_tgtip „true“ ist. Das bedeutet, dass der Wert tgtip nicht mit einem IP-Adressmuster übereinstimmt. Wenn der Wert „false“ ist, wird der Wert tgtip im UDM-Feld target.ip gespeichert.

if ![not_valid_tgtip] {
  mutate {
    merge => {
      "event.idm.read_only_udm.target.ip" => "tgtip"
    }
  }
 }

Die Zwischenvariable srcip wurde nicht transformiert. Mit der folgenden Anweisung wird geprüft, ob ein Wert aus dem ursprünglichen Log extrahiert wurde. Wenn ja, wird der Wert im UDM-Feld principal.ip gespeichert.

if [srcip] != "" {
  mutate {
    merge => {
      "event.idm.read_only_udm.principal.ip" => "srcip"
    }
  }
}

url, returnCode und size mit der rename-Anweisung speichern

Im folgenden Beispiel werden die Werte mit der rename-Anweisung gespeichert:

  • Die Variable url wurde im UDM-Feld target.url gespeichert.
  • Die Zwischenvariable returnCode, die im UDM-Feld network.http.response_code gespeichert ist.
  • Die Zwischenvariable size, die im UDM-Feld network.received_bytes gespeichert ist.
mutate {
  rename => {
     "url" => "event.idm.read_only_udm.target.url"
     "returnCode" => "event.idm.read_only_udm.network.http.response_code"
     "size" => "event.idm.read_only_udm.network.received_bytes"
  }
}

UDM-Eintrag an die Ausgabe binden

Die letzte Anweisung in der Datenzuordnungsanweisung gibt die verarbeiteten Daten in einen UDM-Ereignisdatensatz aus.

mutate {
    merge => {
      "@output" => "event"
    }
  }

Der vollständige Parsercode

Dies ist das vollständige Beispiel für den Parsercode. Die Reihenfolge der Anweisungen entspricht nicht der Reihenfolge in den vorherigen Abschnitten dieses Dokuments, führt aber zur selben Ausgabe.

filter {

# initialize variables
  mutate {
    replace => {
      "event.idm.read_only_udm.metadata.product_name" => "Webproxy"
      "event.idm.read_only_udm.metadata.vendor_name" => "Squid"
      "not_valid_log" => "false"
      "when" => ""
      "srcip" => ""
      "action" => ""
      "username" => ""
      "url" => ""
      "tgtip" => ""
      "method" => ""
    }
  }

  # Extract fields from the raw log.
    grok {
      match => {
        "message" => [
          "%{NUMBER:when}\\s+\\d+\\s%{SYSLOGHOST:srcip} %{WORD:action}\\/%{NUMBER:returnCode} %{NUMBER:size} %{WORD:method} (?P<url>\\S+) (?P<username>.*?) %{WORD}\\/(?P<tgtip>\\S+).*"
        ]
      }
      overwrite => ["when","srcip","action","returnCode","size","method","url","username","tgtip"]
      on_error => "not_valid_log"
    }

  # Parse event timestamp
  if [when] != "" {
    date {
      match => [
        "when", "UNIX"
      ]
     }
   }

   # Save the value in "when" to the event timestamp
   mutate {
     rename => {
       "when" => "timestamp"
     }
   }

   # Transform and save username
   if [username] not in [ "-" ,"" ] {
     mutate {
       lowercase => [ "username"]
        }
      }
     mutate {
       replace => {
         "event.idm.read_only_udm.principal.user.userid" => "%{username}"
       }
     }


if ([action] == "TCP_DENIED" or [action] == "TCP_MISS" or [action] == "Denied" or [action] == "denied" or [action] == "Dropped") {
      mutate {
        replace => {
          "action" => "BLOCK"
        }
      }
   } else if ([action] == "TCP_TUNNEL" or [action] == "Accessed" or [action] == "Built" or [action] == "Retrieved" or [action] == "Stored") {
     mutate {
        replace => {
          "action" => "ALLOW"
        }
     }
   } else {
      mutate {
        replace => {
          "action" => "UNKNOWN_ACTION" }
      }
   }

  # save transformed value to an intermediary field
   mutate {
      merge => {
        "security_result.action" => "action"
      }
   }

    # save the security_result field
    mutate {
      merge => {
        "event.idm.read_only_udm.security_result" => "security_result"
      }
    }

   # check for presence of target ip. Extract and store target IP address.
   if [tgtip] not in [ "","-" ] {
     grok {
       match => {
         "tgtip" => [ "%{IP:tgtip}" ]
       }
       overwrite => ["tgtip"]
       on_error => "not_valid_tgtip"
     }

     # store  target IP address
     if ![not_valid_tgtip] {
       mutate {
         merge => {
           "event.idm.read_only_udm.target.ip" => "tgtip"
         }
       }
     }
   }

   # convert  the returnCode and size  to integer data type
   mutate {
     convert => {
       "returnCode" => "integer"
       "size" => "uinteger"
     }
   }

   # save  url, returnCode, and size
   mutate {
     rename => {
        "url" => "event.idm.read_only_udm.target.url"
        "returnCode" => "event.idm.read_only_udm.network.http.response_code"
        "size" => "event.idm.read_only_udm.network.received_bytes"
     }

     # set the event type to NETWORK_HTTP
     replace => {
        "event.idm.read_only_udm.metadata.event_type" => "NETWORK_HTTP"
     }
   }

   # validate and set source IP address
   if [srcip] != "" {
     mutate {
       merge => {
         "event.idm.read_only_udm.principal.ip" => "srcip"
       }
     }
   }

  # save  event to @output
   mutate {
     merge => {
       "@output" => "event"
     }
   }

} #end of filter

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