Digital Guardian EDR-Logs erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Digital Guardian EDR-Logs mit Google Cloud Storage V2 über eine Cloud Run-Funktion in Google Security Operations aufnehmen.

Digital Guardian von Fortra (früher Digital Guardian) ist eine umfassende Plattform zur Verhinderung von Datenverlust und zur Endpunkterkennung und -reaktion, die Einblick in System-, Nutzer- und Datenereignisse an Endpunkten, in Netzwerken und in Cloud-Anwendungen bietet. Der Dienst Analytics & Reporting Cloud (ARC) bietet erweiterte Analyse-, Workflow- und Berichtsfunktionen für einen ganzheitlichen Datenschutz. Die Cloud Run-Funktion authentifiziert sich mit OAuth 2.0 bei der ARC Export API, ruft Exportdaten ab, bestätigt das Lesezeichen, um zum nächsten Chunk zu gelangen, schreibt die Ergebnisse als NDJSON in einen GCS-Bucket und Google SecOps nimmt sie über einen GCS V2-Feed auf.

Hinweise

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Eine Google SecOps-Instanz
  • Ein Google Cloud-Projekt mit den folgenden aktivierten APIs:
    • Cloud Storage
    • Cloud Run-Funktionen
    • Cloud Scheduler
    • Pub/Sub
    • Cloud Build
  • Berechtigungen zum Erstellen und Verwalten von Cloud Storage-Buckets, Cloud Run Functions-Funktionen, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Privilegierter Zugriff auf die Digital Guardian Management Console (DGMC)
  • Zugriff auf die Mandanteneinstellungen von Digital Guardian Analytics & Reporting Cloud (ARC)
  • Administratorberechtigungen zum Konfigurieren von Cloud-Diensten in DGMC
  • Ein in DGMC erstelltes Exportprofil mit einer gültigen GUID

Google Cloud Storage-Bucket erstellen

  1. Öffnen Sie die Google Cloud Console.
  2. Wählen Sie Ihr Projekt aus oder erstellen Sie ein neues.
  3. Rufen Sie im Navigationsmenü Cloud Storage > Buckets auf.
  4. Klicken Sie auf Bucket erstellen.

  5. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Bucket benennen Geben Sie einen global eindeutigen Namen ein, z. B. digitalguardian-edr-logs.
    Standorttyp Wählen Sie je nach Bedarf aus (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Standort aus, der Ihrer Google SecOps-Instanz am nächsten ist (z. B. us-central1).
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutzmaßnahmen Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Digital Guardian API-Anmeldedaten erfassen

  • Damit die Cloud Run-Funktion Exportdaten aus dem Digital Guardian ARC abrufen kann, müssen Sie API-Anmeldedaten abrufen und ein Exportprofil konfigurieren.

API-Anmeldedaten von DGMC abrufen

  1. Melden Sie sich in der Digital Guardian Management Console (DGMC) an.
  2. Gehen Sie zu System > Konfiguration > Cloud-Dienste.

  3. Suchen Sie im Abschnitt API-Zugriff nach den folgenden Werten und notieren Sie sie:

    • API-Zugriffs-ID: Dies ist Ihre Client-ID für die OAuth 2.0-Authentifizierung.
    • API-Zugriffsschlüssel: Dies ist Ihr Clientschlüssel für die OAuth 2.0-Authentifizierung.
    • Basis-URL des Access Gateways: Der API-Gateway-Endpunkt, z. B. https://accessgw-usw.msp.digitalguardian.com.
    • URL des Autorisierungsservers: Der OAuth 2.0-Token-Endpunkt (z. B. https://authsrv.msp.digitalguardian.com/as/token.oauth2).

Exportprofil erstellen und konfigurieren

  1. Rufen Sie in der Digital Guardian Management Console (DGMC) Admin > Berichte > Exportprofile auf.
  2. Klicken Sie auf Exportprofil erstellen oder wählen Sie ein vorhandenes Exportprofil aus.
  3. Konfigurieren Sie das Exportprofil mit den folgenden Einstellungen:
    • Profilname: Geben Sie einen aussagekräftigen Namen ein, z. B. Google SecOps SIEM Integration.
    • Datenquelle: Wählen Sie je nach den Daten, die Sie exportieren möchten, Ereignisse oder Benachrichtigungen aus.
    • Exportformat: Wählen Sie JSON Flattened Table (JSON-Tabelle in Kurzform) aus. Diese Option wird für SIEM-Integrationen empfohlen.
    • Felder: Wählen Sie die Felder aus, die Sie in den Export aufnehmen möchten.
    • Filter: Konfigurieren Sie optional Filter, um die exportierten Daten einzuschränken.
  4. Klicken Sie auf Speichern, um das Exportprofil zu erstellen.

  5. Suchen Sie nach dem Speichern das Exportprofil in der Liste und kopieren Sie die GUID aus der URL des Exportprofils oder von der Detailseite.

Zusammenfassung der erfassten Anmeldedaten

Speichern Sie die folgenden Informationen zum Konfigurieren der Umgebungsvariablen der Cloud Run-Funktion:

  • Client-ID (API-Zugriffs-ID): Von DGMC Cloud Services
  • Clientschlüssel (API-Zugriffsschlüssel): Von DGMC Cloud Services
  • Autorisierungsserver-URL: z. B. https://authsrv.msp.digitalguardian.com/as/token.oauth2
  • Access Gateway-Basis-URL: z. B. https://accessgw-usw.msp.digitalguardian.com
  • GUID des Exportprofils: Aus dem in DGMC erstellten Exportprofil

API-Zugriff testen

  1. Prüfen Sie mit den folgenden Befehlen, ob Ihre Anmeldedaten gültig sind:

    # Step 1: Obtain OAuth 2.0 access token
curl -s -X POST \
  -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=client" \
  "https://authsrv.msp.digitalguardian.com/as/token.oauth2"

    # Step 2: Test export endpoint with the access token
curl -s -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  "https://accessgw-usw.msp.digitalguardian.com/rest/1.0/export/YOUR_EXPORT_PROFILE_GUID"

  2. Bei einer erfolgreichen Antwort wird ein JSON-Dokument mit Exportdaten zurückgegeben. Wenn Sie einen Authentifizierungsfehler erhalten, überprüfen Sie die API-Zugriffs-ID und das Secret in DGMC Cloud Services.

Dienstkonto für die Cloud Run-Funktion erstellen

  1. Wechseln Sie in der Google Cloud Console zu IAM & Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie digitalguardian-ingestion (oder einen beschreibenden Namen) ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Digital Guardian EDR Cloud Run function to write logs to GCS ein.
  4. Klicken Sie auf Erstellen und fortfahren.
  5. Fügen Sie im Abschnitt Diesem Dienstkonto Zugriff auf das Projekt erteilen die folgenden Rollen hinzu:
    • Storage-Objekt-Administrator (zum Lesen/Schreiben von Objekten im Cloud Storage-Bucket)
    • Cloud Run Invoker (damit Cloud Scheduler die Funktion aufrufen kann)
  6. Klicken Sie auf Weiter.

  7. Klicken Sie auf Fertig.

Pub/Sub-Thema erstellen

Cloud Scheduler löst die Cloud Run-Funktion über ein Pub/Sub-Thema aus.

  1. Rufen Sie in der Google Cloud Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie im Feld Themen-ID den Wert digitalguardian-edr-trigger ein.
  4. Behalten Sie die Standardeinstellungen bei.

  5. Klicken Sie auf Erstellen.

Cloud Run-Funktion erstellen

Erstellen Sie eine Cloud Run-Funktion, die sich mit OAuth 2.0-Clientanmeldedaten bei Digital Guardian ARC authentifiziert, Exportdaten abruft, das Lesezeichen bestätigt, um zum nächsten Chunk zu gelangen, und Ergebnisse als NDJSON in GCS schreibt.

Funktionsquelldateien vorbereiten

Erstellen Sie die folgenden zwei Dateien für die Bereitstellung der Cloud Run-Funktion.

  • requirements.txt

    functions-framework==3.*
google-cloud-storage==2.*
urllib3==2.*

  • main.py

    """Cloud Run function to ingest Digital Guardian EDR logs into GCS."""

import json
import os
import time
import urllib.parse
from datetime import datetime, timezone

import functions_framework
import urllib3
from google.cloud import storage

GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "digitalguardian_edr")
STATE_KEY = os.environ.get("STATE_KEY", "digitalguardian_edr_state.json")
AUTH_SERVER_URL = os.environ["AUTH_SERVER_URL"]
ARC_SERVER_URL = os.environ["ARC_SERVER_URL"]
CLIENT_ID = os.environ["CLIENT_ID"]
CLIENT_SECRET = os.environ["CLIENT_SECRET"]
EXPORT_PROFILE_GUID = os.environ["EXPORT_PROFILE_GUID"]
MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))

http = urllib3.PoolManager()
gcs = storage.Client()

def _get_access_token() -> str:
    """Obtain an OAuth 2.0 access token using client credentials grant."""
    body = urllib.parse.urlencode({
        "grant_type": "client_credentials",
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "scope": "client",
    })
    resp = http.request(
        "POST",
        AUTH_SERVER_URL,
        body=body,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
    )
    if resp.status != 200:
        raise RuntimeError(
            f"OAuth token request failed: {resp.status} — "
            f"{resp.data.decode('utf-8')}"
        )
    token_data = json.loads(resp.data.decode("utf-8"))
    return token_data["access_token"]

def _arc_get(token: str, path: str, retries: int = 5) -> dict:
    """Execute a GET request against the ARC API with retry on 429."""
    url = f"{ARC_SERVER_URL}{path}"
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }
    backoff = 2
    for attempt in range(retries):
        resp = http.request("GET", url, headers=headers)
        if resp.status == 200:
            return json.loads(resp.data.decode("utf-8"))
        if resp.status == 429:
            wait = backoff * (2 ** attempt)
            print(
                f"Rate limited (429). Retrying in {wait}s "
                f"(attempt {attempt + 1}/{retries})."
            )
            time.sleep(wait)
            continue
        raise RuntimeError(
            f"ARC API error: {resp.status} — {resp.data.decode('utf-8')}"
        )
    raise RuntimeError(
        "ARC API rate limit exceeded after maximum retries."
    )

def _arc_acknowledge(token: str) -> None:
    """POST to the acknowledge endpoint to advance the export bookmark."""
    url = (
        f"{ARC_SERVER_URL}/rest/1.0/export/"
        f"{EXPORT_PROFILE_GUID}/acknowledge"
    )
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }
    resp = http.request("POST", url, headers=headers)
    if resp.status not in (200, 204):
        raise RuntimeError(
            f"ARC acknowledge failed: {resp.status} — "
            f"{resp.data.decode('utf-8')}"
        )
    print("Export bookmark acknowledged successfully.")

def _load_state() -> dict:
    """Load the last run state from GCS."""
    bucket = gcs.bugcs.bucketUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    if blob.exists():
        return json.loads(blob.downlodownload_as_text  return {}

def _save_state(state: dict) -> None:
    """Persist run state to GCS."""
    bucket = gcs.bugcs.bucketUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    blob.uploadupload_from_string    json.dumps(state), content_type="application/json"
    )

def _fetch_export(token: str) -> list:
    """Fetch export data from the ARC Export API."""
    path = f"/rest/1.0/export/{EXPORT_PROFILE_GUID}"
    data = _arc_get(token, path)
    records = data if isinstance(data, list) else data.get("data", [])
    return records[:MAX_RECORDS]

def _write_ndjson(records: list, run_ts: str) -> str:
    """Write records as NDJSON to GCS and return the blob path."""
    bucket = gcs.bugcs.bucketUCKET)
    blob_path = (
        f"{GCS_PREFIX}/year={run_ts[:4]}/month={run_ts[5:7]}/"
        f"day={run_ts[8:10]}/{run_ts}_export.ndjson"
    )
    blob = bucket.blob(blob_path)
    ndjson = "\n".join(
        json.dumps(r, separators=(",", ":")) for r in records
    )
    blob.uploadupload_from_stringn, content_type="application/x-ndjson")
    return blob_path

@functions_framework.cloud_event
def main(cloud_event):
    """Entry point triggered by Pub/Sub via Cloud Scheduler."""
    state = _load_state()
    now = datetime.now(timezone.utc)

    print("Authenticating to Digital Guardian ARC.")
    token = _get_access_token()

    print(
        f"Fetching export data for profile {EXPORT_PROFILE_GUID}."
    )
    records = _fetch_export(token)

    if not records:
        print("No new export data found.")
        return "OK"

    run_ts = now.strftime("%Y-%m-%dT%H%M%SZ")
    blob_path = _write_ndjson(records, run_ts)
    print(
        f"Wrote {len(records)} records to "
        f"gs://{GCS_BUCKET}/{blob_path}."
    )

    _arc_acknowledge(token)

    state["last_run"] = now.isoformat()
    state["records_written"] = len(records)
    _save_state(state)
    print(f"State updated. last_run={now.isoformat()}.")
    return "OK"

Cloud Run-Funktion bereitstellen

  1. Speichern Sie beide Dateien (main.py und requirements.txt) in einem lokalen Verzeichnis (z. B. digitalguardian-function/).
  2. Öffnen Sie die Cloud Shell oder ein Terminal mit installiertem gcloud CLI.

  3. Führen Sie den folgenden Befehl aus, um die Funktion bereitzustellen:

    gcloud functions deploy digitalguardian-edr-to-gcs \
  --gen2 \
  --region=us-central1 \
  --runtime=python312 \
  --trigger-topic=digitalguardian-edr-trigger \
  --entry-point=main \
  --memory=512MB \
  --timeout=540s \
  --service-account=digitalguardian-ingestion@PROJECT_ID.iam.gserviceaccount.com \
  --set-env-vars=\
  "GCS_BUCKET=digitalguardian-edr-logs",\
  "GCS_PREFIX=digitalguardian_edr",\
  "STATE_KEY=digitalguardian_edr_state.json",\
  "AUTH_SERVER_URL=https://authsrv.msp.digitalguardian.com/as/token.oauth2",\
  "ARC_SERVER_URL=https://accessgw-usw.msp.digitalguardian.com",\
  "CLIENT_ID=YOUR_CLIENT_ID",\
  "CLIENT_SECRET=YOUR_CLIENT_SECRET",\
  "EXPORT_PROFILE_GUID=YOUR_EXPORT_PROFILE_GUID",\
  "MAX_RECORDS=10000"

  4. Ersetzen Sie die folgenden Platzhalterwerte:

    • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
    • digitalguardian-edr-logs: Der Name Ihres GCS-Buckets.
    • YOUR_CLIENT_ID: Ihre Digital Guardian API-Zugriffs-ID.
    • YOUR_CLIENT_SECRET: Ihr Digital Guardian API Access Secret.
    • YOUR_EXPORT_PROFILE_GUID: Die GUID Ihres Exportprofils aus DGMC.

  5. Überprüfen Sie die Bereitstellung, indem Sie den Funktionsstatus prüfen:

    gcloud functions describe digitalguardian-edr-to-gcs --region=us-central1 --gen2

Referenz zu Umgebungsvariablen

Variable Erforderlich Standard Beschreibung
GCS_BUCKET Ja GCS-Bucket-Name zum Speichern der NDJSON-Ausgabe
GCS_PREFIX Nein digitalguardian_edr Objektpräfix (Ordnerpfad) im Bucket
STATE_KEY Nein digitalguardian_edr_state.json Blob-Name für die Statusdatei innerhalb des Präfix
AUTH_SERVER_URL Ja OAuth 2.0-Autorisierungsserver-URL
ARC_SERVER_URL Ja ARC Access Gateway-Basis-URL
CLIENT_ID Ja API-Zugriffs-ID von DGMC
CLIENT_SECRET Ja API-Zugriffs-Secret aus DGMC
EXPORT_PROFILE_GUID Ja Profil-GUID aus DGMC exportieren
MAX_RECORDS Nein 10000 Maximale Anzahl der Einträge, die pro Ausführung geschrieben werden sollen

Cloud Scheduler-Job erstellen

Cloud Scheduler löst die Cloud Run-Funktion in regelmäßigen Abständen über das Pub/Sub-Thema aus.

  1. Rufen Sie in der Google Cloud Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    • Name: Geben Sie digitalguardian-edr-ingestion-schedule ein.
    • Region: Wählen Sie dieselbe Region wie für Ihre Cloud Run-Funktion aus (z. B. us-central1).

    • Häufigkeit: Geben Sie */5 * * * * (alle 5 Minuten) ein.

    • Zeitzone: Wählen Sie Ihre bevorzugte Zeitzone aus (z. B. UTC).

  4. Klicken Sie auf Weiter.

  5. Im Abschnitt Ausführung konfigurieren:

    • Zieltyp: Wählen Sie Pub/Sub aus.
    • Thema: Wählen Sie digitalguardian-edr-trigger aus.
    • Nachrichtentext: Geben Sie {"run": true} ein.

  6. Klicken Sie auf Weiter.

  7. Im Abschnitt Optionale Einstellungen konfigurieren:

    • Maximale Wiederholungsversuche: Geben Sie 3 ein.
    • Minimale Backoff-Dauer: Geben Sie 5s ein.
    • Maximale Backoff-Dauer: Geben Sie 60s ein.

  8. Klicken Sie auf Erstellen.

  9. Wenn Sie einen sofortigen Test ausführen möchten, klicken Sie neben dem Jobnamen auf das Dreipunkt-Menü (...) und wählen Sie Ausführung erzwingen aus.

Google SecOps-Dienstkonto abrufen und Feed konfigurieren

Google SecOps verwendet ein eindeutiges Dienstkonto, um Daten aus Ihrem GCS-Bucket zu lesen. Sie müssen diesem Dienstkonto Zugriff auf Ihren Bucket gewähren.

E-Mail-Adresse des Dienstkontos abrufen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Digital Guardian EDR Logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Digital Guardian EDR als Logtyp aus.

  7. Klicken Sie auf Dienstkonto abrufen. Es wird eine eindeutige E-Mail-Adresse für das Dienstkonto angezeigt, z. B.:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Kopieren Sie diese E‑Mail-Adresse für den nächsten Schritt.

  9. Klicken Sie auf Weiter.

  10. Geben Sie Werte für die folgenden Eingabeparameter an:

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI ein:

      gs://digitalguardian-edr-logs/digitalguardian_edr/
      • Ersetzen Sie digitalguardian-edr-logs durch den Namen Ihres GCS-Buckets.
      • Ersetzen Sie digitalguardian_edr durch den konfigurierten Wert GCS_PREFIX.

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption aus:

      • Nie: Es werden niemals Dateien nach Übertragungen gelöscht (empfohlen für Tests).
      • Übertragene Dateien löschen: Dateien werden nach der erfolgreichen Übertragung gelöscht.

      • Übertragene Dateien und leere Verzeichnisse löschen: Löscht Dateien und leere Verzeichnisse nach der erfolgreichen Übertragung.

    • Höchstalter von Dateien: Dateien einschließen, die in den letzten Tagen geändert wurden (Standardwert: 180 Tage).

    • Asset-Namespace: Der Asset-Namespace.

    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.

  11. Klicken Sie auf Weiter.

  12. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt die Rolle Storage-Objekt-Betrachter für Ihren Cloud Storage-Bucket.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets, z. B. digitalguardian-edr-logs.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Fügen Sie die E-Mail-Adresse des Google SecOps-Dienstkontos ein (z. B. chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage-Objekt-Betrachter aus.

  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
Anwendung target.application Wert direkt kopiert
Anwendung target.process.command_line Auf %{Application} festgelegt, wenn die Regel mit Printer übereinstimmt.
Bytes_Written network.sent_bytes Wert direkt kopiert und in „uinteger“ konvertiert
Category, Computer_Name, Detail metadata.description Auf %{Detail} setzen, wenn Category == "Policies" und Computer_Name leer ist; andernfalls auf %{message} bei grok_parse_failure setzen
Command_Line, Command_Line1 principal.process.command_line Wert aus „Command_Line“ nach dem Entfernen nachgestellter Anführungszeichen, falls nicht leer, andernfalls aus „Command_Line1“ nach dem Entfernen nachgestellter Anführungszeichen
Computer_Name, source principal.hostname Wert aus „computerName“, falls nicht leer, andernfalls auf %{source} festgelegt
Destination_Device_Serial_Number, Destination_Device_Serial_Number1 Extrahieren mit Grok-Muster für die Verarbeitung von Anführungszeichen
Destination_Directory, Destination_File target.file.full_path Verkettung von „Destination_Directory“ und „Destination_File“, wenn beide nicht leer sind
Destination_Drive_Type security_result.detection_fields Mit „destination_drive_type_label“ zusammengeführt (Schlüssel: Destination_Drive_Type, Wert: %{Destination_Drive_Type})
Destination_File target.file.names Zusammengeführt aus Destination_File
Destination_File_Extension target.file.mime_type Wert direkt kopiert
Dll_SHA1_Hash target.process.file.sha1 Wert direkt nach der Umwandlung in Kleinbuchstaben kopiert
Email_Address principal.user.email_addresses Zusammengeführt aus Email_Address
Email_Sender, Email_Subject network.email.from Wird auf %{Email_Sender} gesetzt, wenn nicht leer.
Email_Sender, Email_Subject network.email.subject Zusammengeführt aus Betreff (%{Email_Subject}), wenn Email_Sender nicht leer ist
File_Extension principal.process.file.mime_type Wert direkt kopiert
IP_Address, source_ip principal.ip Wird aus „source_ip“ zusammengeführt, falls nicht leer, andernfalls aus „IP_Address“
Local_Port, source_port principal.port Wert aus „source_port“, sofern nicht leer und in eine Ganzzahl konvertiert, andernfalls aus „Local_Port“ und in eine Ganzzahl konvertiert
MD5_Checksum target.process.file.md5 Wert direkt nach der Umwandlung in Kleinbuchstaben kopiert
Network_Direction network.direction Auf INBOUND gesetzt, wenn „True“, andernfalls auf OUTBOUND gesetzt, wenn „False“
Process_PID principal.process.pid Wert direkt kopiert
Process_SHA256_Hash target.process.file.sha256 Wert direkt nach der Umwandlung in Kleinbuchstaben kopiert
Product_Version metadata.product_version Wert direkt kopiert
Protokoll network.ip_protocol Auf ICMP setzen, wenn == „1“
Remote_Port target.port Wert direkt kopiert und in eine Ganzzahl konvertiert
Regel security_result.rule_name Wert direkt kopiert
Regel metadata.event_type Auf PROCESS_UNCATEGORIZED setzen, wenn Übereinstimmungen mit .Printer. vorliegen, andernfalls auf FILE_MOVE, wenn Übereinstimmungen mit DLP.* vorliegen.
Schweregrad security_result.severity LOW, wenn <=3, MEDIUM, wenn <=6, HIGH, wenn <=8, CRITICAL, wenn <=10 nach der Konvertierung in eine Ganzzahl
Schweregrad security_result.severity_details Wert direkt kopiert
Source_Directory, Source_File src.file.full_path Wird aus Source_Directory und Source_File verkettet, wenn beide nicht leer sind
Source_Drive_Type security_result.detection_fields Zusammengeführt mit source_drive_type_label (Schlüssel: Source_Drive_Type, Wert: %{Source_Drive_Type})
Source_File src.file.names Zusammengeführt aus Source_File
Source_File_Extension src.file.mime_type Wert direkt kopiert
URL_Path, http_url target.url Wert aus „http_url“, falls nicht leer, andernfalls aus „URL_Path“
User_Name principal.user.userid Wert aus „userName“ nach der Grok-Extraktion
User_Name principal.administrative_domain Wert aus „domainName“ nach der Grok-Extraktion
Was_Removable security_result.detection_fields Mit „was_removable_label“ zusammengeführt (Schlüssel: Was_Removable, Wert: %{Was_Removable})
Was_Source_Removable security_result.detection_fields Mit „was_source_removable_label“ zusammengeführt (Schlüssel: Was_Source_Removable, Wert: %{Was_Source_Removable})
computerName, destination_ip, protocol, source_ip, IP_Address, destination, userName, Process_PID, Category, Computer_Name metadata.event_type Anfangs auf GENERIC_EVENT festgelegt; NETWORK_HTTP, wenn protocol == HTTPS und (destination_ip oder computerName); NETWORK_CONNECTION, wenn (source_ip oder IP_Address) und destination_ip; USER_UNCATEGORIZED, wenn userName nicht leer; SCAN_PROCESS, wenn Process_PID nicht leer
destination_ip target.ip Zusammengeführt aus „destination_ip“
incidents_url, matched_policies_by_severity security_result Zusammengeführt mit _sr (rule_name: %{matched_policies_by_severity}, url_back_to_product: %{incidents_url})
Protokoll network.application_protocol Auf HTTPS festlegen, wenn protocol == HTTP oder HTTPS
security_action security_result.action Zusammengeführt aus „security_action“
metadata.product_name Auf „Enterprise DLP Platform“ festlegen
metadata.vendor_name Auf „DigitalGuardian“ festgelegt

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