Duo-Authentifizierungs-Logs erfassen

Parserversion:7.0

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Duo-Authentifizierungsprotokolle in Google Security Operations aufnehmen. Der Parser extrahiert die Logs aus JSON-formatierten Nachrichten. Die Rohprotokolldaten werden in das Unified Data Model (UDM) umgewandelt. Dabei werden Felder wie Nutzer, Gerät, Anwendung, Standort und Authentifizierungsdetails zugeordnet. Außerdem werden verschiedene Authentifizierungsfaktoren und ‑ergebnisse verarbeitet, um Sicherheitsereignisse zu kategorisieren. Der Parser führt auch Datenbereinigung, Typkonvertierung und Fehlerbehandlung durch, um Datenqualität und -konsistenz zu gewährleisten.

Sie haben zwei Erhebungsmethoden zur Auswahl:

  • Option 1: Direkte Aufnahme über die Drittanbieter-API
  • Option 2: Logs mit einer Cloud Run-Funktion und Google Cloud Storage erfassen

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Privilegierter Zugriff auf das Duo-Admin-Panel (zum Erstellen von Admin API-Anwendungen ist die Rolle „Inhaber“ erforderlich)
  • Privilegierter Zugriff auf GCP bei Verwendung von Option 2

Option 1: Duo-Authentifizierungslogs über die Drittanbieter-API aufnehmen

Duo-Voraussetzungen (API-Anmeldedaten) erfassen

  1. Melden Sie sich im Duo-Admin-Steuerfeld als Administrator mit der Rolle Inhaber, Administrator oder Application Manager an.
  2. Rufen Sie Anwendungen > Anwendungskatalog auf.
  3. Suchen Sie im Katalog nach dem Eintrag für die Admin API.
  4. Klicken Sie auf + Hinzufügen, um die Anwendung zu erstellen.
  5. Kopieren Sie die folgenden Details und speichern Sie sie an einem sicheren Ort:
    • Integrationsschlüssel
    • Geheimer Schlüssel
    • API-Hostname (z. B. api-XXXXXXXX.duosecurity.com)
  6. Rufen Sie den Bereich Berechtigungen auf.
  7. Deaktivieren Sie alle Berechtigungsoptionen mit Ausnahme von Leseprotokoll gewähren.
  8. Klicken Sie auf Änderungen speichern.

Feed in Google SecOps konfigurieren, um Duo-Authentifizierungslogs aufzunehmen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf + Neuen Feed hinzufügen.
  3. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Duo Authentication Logs.
  4. Wählen Sie Drittanbieter-API als Quelltyp aus.
  5. Wählen Sie Duo Auth als Log type (Protokolltyp) aus.
  6. Klicken Sie auf Weiter.
  7. Geben Sie Werte für die folgenden Eingabeparameter an:
    • Nutzername: Geben Sie den Integrationsschlüssel von Duo ein.
    • Secret: Geben Sie den geheimen Schlüssel von Duo ein.
    • API-Hostname: Geben Sie Ihren API-Hostname ein (z. B. api-XXXXXXXX.duosecurity.com).
    • Asset-Namespace: Optional. Der Asset-Namespace.
    • Labels für Datenaufnahme: Optional. Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.
  8. Klicken Sie auf Weiter.
  9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Option 2: Duo-Authentifizierungslogs mit Google Cloud Storage aufnehmen

Duo Admin API-Anmeldedaten erfassen

  1. Melden Sie sich im Duo Admin-Steuerfeld an.
  2. Rufen Sie Anwendungen > Anwendungskatalog auf.
  3. Suchen Sie im Anwendungskatalog nach der Admin API.
  4. Klicken Sie auf + Hinzufügen, um die Admin API-Anwendung hinzuzufügen.
  5. Kopieren und speichern Sie die folgenden Werte:
    • Integrationsschlüssel (ikey)
    • Geheimer Schlüssel (skey)
    • API-Hostname (z. B. api-XXXXXXXX.duosecurity.com)
  6. Aktivieren Sie unter Berechtigungen die Option Leseprotokoll gewähren.
  7. Klicken Sie auf Änderungen speichern.

Google Cloud Storage-Bucket erstellen

  1. Gehen Sie zur 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. duo-auth-logs.
    Standorttyp Wählen Sie die Option aus, die am besten zu Ihren Anforderungen passt (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Speicherort aus, z. B. us-central1.
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutztools Optional: Objektversionierung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Dienstkonto für Cloud Run-Funktion erstellen

Für die Cloud Run-Funktion ist ein Dienstkonto mit Berechtigungen zum Schreiben in den GCS-Bucket erforderlich.

Dienstkonto erstellen

  1. Wechseln Sie in der GCP Console zu IAM und Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie duo-auth-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect Duo authentication logs 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:
    1. Klicken Sie auf Rolle auswählen.
    2. Suchen Sie nach Storage Object Admin und wählen Sie die Rolle aus.
    3. Klicken Sie auf + Weitere Rolle hinzufügen.
    4. Suchen Sie nach Cloud Run Invoker und wählen Sie die Rolle aus.
    5. Klicken Sie auf + Weitere Rolle hinzufügen.
    6. Suchen Sie nach Cloud Functions Invoker und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

Diese Rollen sind für Folgendes erforderlich:

  • Storage-Objekt-Administrator: Protokolle in GCS-Bucket schreiben und Statusdateien verwalten
  • Cloud Run Invoker: Pub/Sub darf die Funktion aufrufen.
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

IAM-Berechtigungen für GCS-Bucket erteilen

Gewähren Sie dem Dienstkonto Schreibberechtigungen für den GCS-Bucket:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Geben Sie die E-Mail-Adresse des Dienstkontos ein (z. B. duo-auth-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage Object Admin aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, in dem Cloud Scheduler veröffentlicht und das von der Cloud Run-Funktion abonniert wird.

  1. Rufen Sie in der GCP Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie duo-auth-trigger ein.
    • Übernehmen Sie die anderen Einstellungen.
  4. Klicken Sie auf Erstellen.

Cloud Run-Funktion zum Erfassen von Logs erstellen

Die Cloud Run-Funktion wird durch Pub/Sub-Nachrichten von Cloud Scheduler ausgelöst, um Logs von der Duo Admin API abzurufen und in GCS zu schreiben.

  1. Rufen Sie in der GCP Console Cloud Run auf.
  2. Klicken Sie auf Dienst erstellen.
  3. Wählen Sie Funktion aus, um eine Funktion mit einem Inline-Editor zu erstellen.

  4. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname duo-auth-collector
    Region Wählen Sie die Region aus, die Ihrem GCS-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.

  5. Im Abschnitt Trigger (optional):

    1. Klicken Sie auf + Trigger hinzufügen.
    2. Wählen Sie Cloud Pub/Sub aus.
    3. Wählen Sie unter Cloud Pub/Sub-Thema auswählen das Thema duo-auth-trigger aus.
    4. Klicken Sie auf Speichern.

  6. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Weitere Informationen finden Sie unter Identity and Access Management (IAM).

  7. Scrollen Sie nach unten und maximieren Sie Container, Netzwerk, Sicherheit.

  8. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie das Dienstkonto duo-auth-collector-sa aus.

  9. Rufen Sie den Tab Container auf:

    1. Klicken Sie auf Variablen und Secrets.
    2. Klicken Sie für jede Umgebungsvariable auf + Variable hinzufügen:
    Variablenname Beispielwert
    GCS_BUCKET duo-auth-logs
    GCS_PREFIX duo/auth/
    STATE_KEY duo/auth/state.json
    DUO_IKEY DIXYZ...
    DUO_SKEY ****************
    DUO_API_HOSTNAME api-XXXXXXXX.duosecurity.com
    LIMIT 500

  10. Scrollen Sie auf dem Tab Variablen und Secrets nach unten zu Anfragen:

    • Zeitüberschreitung bei Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.

  11. Rufen Sie den Tab Einstellungen unter Container auf:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 512 MiB oder höher aus.
      • CPU: Wählen Sie 1 aus.
    • Klicken Sie auf Fertig.

  12. Scrollen Sie zu Ausführungsumgebung:

    • Wählen Sie Standard (empfohlen) aus.

  13. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 100 ein (oder passen Sie den Wert an die erwartete Last an).

  14. Klicken Sie auf Erstellen.

  15. Warten Sie, bis der Dienst erstellt wurde (1–2 Minuten).

  16. Nachdem der Dienst erstellt wurde, wird automatisch der Inline-Code-Editor geöffnet.

Funktionscode hinzufügen

  1. Geben Sie main unter Funktionseinstiegspunkt ein.

  2. Erstellen Sie im Inline-Code-Editor zwei Dateien:

    • Erste Datei: main.py::
    #!/usr/bin/env python3
# Cloud Run Function: Pull Duo Admin API v2 Authentication Logs to GCS (raw JSON pages)
# Notes:
# - Duo v2 requires mintime/maxtime in *milliseconds* (13-digit epoch).
# - Pagination via metadata.next_offset ("<millis>,<txid>").
# - We save state (mintime_ms) in ms to resume next run without gaps.

import functions_framework
from google.cloud import storage
import os
import json
import time
import hmac
import hashlib
import base64
import email.utils
import urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

DUO_IKEY = os.environ["DUO_IKEY"]
DUO_SKEY = os.environ["DUO_SKEY"]
DUO_API_HOSTNAME = os.environ["DUO_API_HOSTNAME"].strip()
GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "duo/auth/").strip("/")
STATE_KEY = os.environ.get("STATE_KEY", "duo/auth/state.json")
LIMIT = min(int(os.environ.get("LIMIT", "500")), 1000)  # default 500, max 1000

storage_client = storage.Client()

def _canon_params(params: dict) -> str:
    parts = []
    for k in sorted(params.keys()):
        v = params[k]
        if v is None:
            continue
        parts.append(f"{urllib.parse.quote(str(k), '~')}={urllib.parse.quote(str(v), '~')}")
    return "&".join(parts)

def _sign(method: str, host: str, path: str, params: dict) -> dict:
    now = email.utils.formatdate()
    canon = "\n".join([
        now,
        method.upper(),
        host.lower(),
        path,
        _canon_params(params)
    ])
    sig = hmac.new(
        DUO_SKEY.encode("utf-8"),
        canon.encode("utf-8"),
        hashlib.sha1
    ).hexdigest()
    auth = base64.b64encode(f"{DUO_IKEY}:{sig}".encode()).decode()
    return {
        "Date": now,
        "Authorization": f"Basic {auth}"
    }

def _http(method: str, path: str, params: dict, timeout: int = 60, max_retries: int = 5) -> dict:
    host = DUO_API_HOSTNAME
    assert host.startswith("api-") and host.endswith(".duosecurity.com"), \
        "DUO_API_HOSTNAME must be like api-XXXXXXXX.duosecurity.com"

    qs = _canon_params(params)
    url = f"https://{host}{path}" + (f"?{qs}" if qs else "")

    attempt, backoff = 0, 1.0
    while True:
        req = Request(url, method=method.upper())
        req.add_header("Accept", "application/json")
        for k, v in _sign(method, host, path, params).items():
            req.add_header(k, v)

        try:
            with urlopen(req, timeout=timeout) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            if (e.code == 429 or 500 <= e.code <= 599) and attempt < max_retries:
                time.sleep(backoff)
                attempt += 1
                backoff *= 2
                continue
            raise
        except URLError:
            if attempt < max_retries:
                time.sleep(backoff)
                attempt += 1
                backoff *= 2
                continue
            raise

def _read_state_ms() -> int | None:
    try:
        bucket = storage_client.bucket(GCS_BUCKET)
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            state_data = blob.download_as_text()
            val = json.loads(state_data).get("mintime")
            if val is None:
                return None
            # Backward safety: if seconds were stored, convert to ms
            return int(val) * 1000 if len(str(int(val))) <= 10 else int(val)
    except Exception:
        return None

def _write_state_ms(mintime_ms: int):
    bucket = storage_client.bucket(GCS_BUCKET)
    blob = bucket.blob(STATE_KEY)
    body = json.dumps({"mintime": int(mintime_ms)}).encode("utf-8")
    blob.upload_from_string(body, content_type="application/json")

def _write_page(payload: dict, when_epoch_s: int, page: int) -> str:
    bucket = storage_client.bucket(GCS_BUCKET)
    key = f"{GCS_PREFIX}/{time.strftime('%Y/%m/%d', time.gmtime(when_epoch_s))}/duo-auth-{page:05d}.json"
    blob = bucket.blob(key)
    blob.upload_from_string(
        json.dumps(payload, separators=(",", ":")).encode("utf-8"),
        content_type="application/json"
    )
    return key

def fetch_and_store():
    now_s = int(time.time())
    # Duo recommends a ~2-minute delay buffer; use maxtime = now - 120 seconds (in ms)
    maxtime_ms = (now_s - 120) * 1000
    mintime_ms = _read_state_ms() or (maxtime_ms - 3600 * 1000)  # 1 hour on first run

    page = 0
    total = 0
    next_offset = None

    while True:
        params = {
            "mintime": mintime_ms,
            "maxtime": maxtime_ms,
            "limit": LIMIT
        }
        if next_offset:
            params["next_offset"] = next_offset

        data = _http("GET", "/admin/v2/logs/authentication", params)
        _write_page(data, maxtime_ms // 1000, page)
        page += 1

        resp = data.get("response")
        items = resp if isinstance(resp, list) else []
        total += len(items)

        meta = data.get("metadata") or {}
        next_offset = meta.get("next_offset")
        if not next_offset:
            break

    # Advance window to maxtime_ms for next run
    _write_state_ms(maxtime_ms)

    return {
        "ok": True,
        "pages": page,
        "events": total,
        "next_mintime_ms": maxtime_ms
    }

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch Duo authentication logs and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """
    try:
        result = fetch_and_store()
        print(f"Successfully processed {result['events']} events in {result['pages']} pages")
        print(f"Next mintime_ms: {result['next_mintime_ms']}")
    except Exception as e:
        print(f"Error processing logs: {str(e)}")
        raise
    • Zweite Datei: requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*

  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema und löst so die Cloud Run-Funktion aus.

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

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name duo-auth-collector-hourly
    Region Dieselbe Region wie die Cloud Run-Funktion auswählen
    Frequenz 0 * * * * (stündlich zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema Wählen Sie das Thema duo-auth-trigger aus.
    Inhalt der Nachricht {} (leeres JSON-Objekt)

  4. Klicken Sie auf Erstellen.

Optionen für die Häufigkeit des Zeitplans

  • Wählen Sie die Häufigkeit basierend auf dem Logvolumen und den Latenzanforderungen aus:

    Häufigkeit Cron-Ausdruck Anwendungsfall
    Alle 5 Minuten */5 * * * * Hohes Volumen, niedrige Latenz
    Alle 15 Minuten */15 * * * * Mittleres Suchvolumen
    Stündlich 0 * * * * Standard (empfohlen)
    Alle 6 Stunden 0 */6 * * * Geringes Volumen, Batchverarbeitung
    Täglich 0 0 * * * Erhebung von Verlaufsdaten

Scheduler-Job testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job.
  2. Klicken Sie auf Force run (Ausführung erzwingen), um den Trigger manuell auszulösen.
  3. Warten Sie einige Sekunden und rufen Sie Cloud Run > Dienste > duo-auth-collector > Logs auf.
  4. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde.
  5. Prüfen Sie den GCS-Bucket, um zu bestätigen, dass Logs geschrieben wurden.

Google SecOps-Dienstkonto abrufen

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. Duo Authentication Logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Duo Auth als Log type (Protokolltyp) 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.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt die Rolle Storage Object Viewer für Ihren GCS-Bucket.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  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.
    • Rollen zuweisen: Wählen Sie Storage Object Viewer aus.

  6. Klicken Sie auf Speichern.

Feed in Google SecOps konfigurieren, um Duo-Authentifizierungslogs aufzunehmen

  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. Duo Authentication Logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Duo Auth als Log type (Protokolltyp) aus.
  7. Klicken Sie auf Weiter.

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

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI mit dem Präfixpfad ein:

      gs://duo-auth-logs/duo/auth/

      • Ersetzen Sie:

        • duo-auth-logs: Der Name Ihres GCS-Buckets.
        • duo/auth/: Optionales Präfix/Ordnerpfad, in dem Logs gespeichert werden (für den Stamm leer lassen).

      • Beispiele:

        • Root-Bucket: gs://company-logs/
        • Mit Präfix: gs://company-logs/duo-logs/
        • Mit Unterordner: gs://company-logs/duo/auth/

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

      • Nie: Löscht nach Übertragungen nie Dateien (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.

    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.

    • Asset-Namespace: Der Asset-Namespace.

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

  9. Klicken Sie auf Weiter.

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

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
access_device.browser target.resource.attribute.labels.value Wenn „access_device.browser“ vorhanden ist, wird der Wert dem UDM zugeordnet.
access_device.hostname principal.hostname Wenn „access_device.hostname“ vorhanden und nicht leer ist, wird der Wert dem UDM zugeordnet. Wenn das Feld leer ist und der event_type USER_CREATION lautet, wird der event_type in USER_UNCATEGORIZED geändert. Wenn „access_device.hostname“ leer ist und das Feld „hostname“ vorhanden ist, wird der Wert von „hostname“ verwendet.
access_device.ip principal.ip Wenn access_device.ip vorhanden und eine gültige IPv4-Adresse ist, wird der Wert dem UDM zugeordnet. Wenn es sich nicht um eine gültige IPv4-Adresse handelt, wird sie als Stringwert zu „additional.fields“ mit dem Schlüssel „access_device.ip“ hinzugefügt.
access_device.location.city principal.location.city Falls vorhanden, wird der Wert der UDM zugeordnet.
access_device.location.country principal.location.country_or_region Falls vorhanden, wird der Wert der UDM zugeordnet.
access_device.location.state principal.location.state Falls vorhanden, wird der Wert der UDM zugeordnet.
access_device.os principal.platform Falls vorhanden, wird der Wert in den entsprechenden UDM-Wert (MAC, WINDOWS, LINUX) übersetzt.
access_device.os_version principal.platform_version Falls vorhanden, wird der Wert der UDM zugeordnet.
application.key target.resource.id Falls vorhanden, wird der Wert der UDM zugeordnet.
application.name target.application Falls vorhanden, wird der Wert der UDM zugeordnet.
auth_device.ip target.ip Wenn der Wert vorhanden und nicht „None“ ist, wird er dem UDM zugeordnet.
auth_device.location.city target.location.city Falls vorhanden, wird der Wert der UDM zugeordnet.
auth_device.location.country target.location.country_or_region Falls vorhanden, wird der Wert der UDM zugeordnet.
auth_device.location.state target.location.state Falls vorhanden, wird der Wert der UDM zugeordnet.
auth_device.name target.hostname ODER target.user.phone_numbers Wenn auth_device.name vorhanden und nach der Normalisierung eine Telefonnummer ist, wird sie zu target.user.phone_numbers hinzugefügt. Andernfalls wird sie target.hostname zugeordnet.
client_ip target.ip Wenn der Wert vorhanden und nicht „None“ ist, wird er dem UDM zugeordnet.
client_section target.resource.attribute.labels.value Wenn „client_section“ vorhanden ist, wird der Wert mit dem Schlüssel „client_section“ der UDM zugeordnet.
dn target.user.userid Wenn „dn“ vorhanden ist und „user.name“ und „username“ nicht, wird die Nutzer-ID mit „grok“ aus dem Feld „dn“ extrahiert und der UDM zugeordnet. Der event_type ist auf USER_LOGIN festgelegt.
event_type metadata.product_event_type UND metadata.event_type Der Wert wird metadata.product_event_type zugeordnet. Außerdem wird damit der metadata.event_type bestimmt: „authentication“ wird zu USER_LOGIN, „enrollment“ zu USER_CREATION und wenn der Wert leer oder keiner der beiden ist, wird er zu GENERIC_EVENT.
Faktor extensions.auth.mechanism UND extensions.auth.auth_details Der Wert wird in den entsprechenden UDM-Wert für „auth.mechanism“ (HARDWARE_KEY, REMOTE_INTERACTIVE, LOCAL, OTP) übersetzt. Der ursprüngliche Wert wird auch extensions.auth.auth_details zugeordnet.
Hostname principal.hostname Wenn der Wert vorhanden ist und access_device.hostname leer ist, wird er dem UDM zugeordnet.
log_format target.resource.attribute.labels.value Wenn „log_format“ vorhanden ist, wird sein Wert mit dem Schlüssel „log_format“ dem UDM zugeordnet.
loglevel._classuuid_ target.resource.attribute.labels.value Wenn loglevel._classuuid_ vorhanden ist, wird sein Wert mit dem Schlüssel class_uuid dem UDM zugeordnet.
log_level.name target.resource.attribute.labels.value UND security_result.severity Wenn „log_level.name“ vorhanden ist, wird sein Wert mit dem Schlüsselnamen dem UDM zugeordnet. Wenn der Wert „info“ ist, wird security_result.severity auf INFORMATIONAL gesetzt.
log_logger.unpersistable target.resource.attribute.labels.value Wenn log_logger.unpersistable vorhanden ist, wird sein Wert mit dem Schlüssel „unpersistable“ dem UDM zugeordnet.
log_namespace target.resource.attribute.labels.value Wenn „log_namespace“ vorhanden ist, wird sein Wert mit dem Schlüssel „log_namespace“ dem UDM zugeordnet.
log_source target.resource.attribute.labels.value Wenn „log_source“ vorhanden ist, wird der Wert mit dem Schlüssel „log_source“ dem UDM zugeordnet.
msg security_result.summary Wenn vorhanden und der Grund leer ist, wird der Wert dem UDM zugeordnet.
reason security_result.summary Falls vorhanden, wird der Wert der UDM zugeordnet.
Ergebnis security_result.action_details UND security_result.action Falls vorhanden, wird der Wert security_result.action_details zugeordnet. „success“ oder „SUCCESS“ wird in security_result.action ALLOW übersetzt, andernfalls in BLOCK.
server_section target.resource.attribute.labels.value Wenn „server_section“ vorhanden ist, wird der Wert mit dem Schlüssel „server_section“ dem UDM zugeordnet.
server_section_ikey target.resource.attribute.labels.value Wenn „server_section_ikey“ vorhanden ist, wird der Wert mit dem Schlüssel „server_section_ikey“ dem UDM zugeordnet.
Status security_result.action_details UND security_result.action Falls vorhanden, wird der Wert security_result.action_details zugeordnet. „Zulassen“ entspricht security_result.action ALLOW, „Ablehnen“ entspricht BLOCK.
timestamp metadata.event_timestamp UND event.timestamp Der Wert wird in einen Zeitstempel umgewandelt und sowohl metadata.event_timestamp als auch event.timestamp zugeordnet.
txid metadata.product_log_id UND network.session_id Der Wert wird sowohl metadata.product_log_id als auch network.session_id zugeordnet.
user.groups target.user.group_identifiers Alle Werte im Array werden zu „target.user.group_identifiers“ hinzugefügt.
user.key target.user.product_object_id Falls vorhanden, wird der Wert der UDM zugeordnet.
nutzer.name target.user.userid Falls vorhanden, wird der Wert der UDM zugeordnet.
Nutzername target.user.userid Wenn der Wert vorhanden ist und „user.name“ nicht, wird er dem UDM zugeordnet. Der event_type ist auf USER_LOGIN festgelegt.
(Parserlogik) metadata.vendor_name Immer auf „DUO_SECURITY“ festgelegt.
(Parserlogik) metadata.product_name Immer auf „MULTI-FACTOR_AUTHENTICATION“ festgelegt.
(Parserlogik) metadata.log_type Aus dem Feld „log_type“ der obersten Ebene des Rohlogs.
(Parserlogik) extensions.auth.type Immer auf „SSO“ festgelegt.
access_device.key event.idm.read_only_udm.target.resource.product_object_id Aus dem Änderungsprotokoll zugeordnet
access_device.browser_version event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.device_info_source event.idm.read_only_udm.principal.asset.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.epkey event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.flash_version event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.is_encryption_enabled event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.is_firewall_enabled event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
trusted_endpoint_status event.idm.read_only_udm.principal.asset.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.is_password_set event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
access_device.java_version event.idm.read_only_udm.principal.resource.attribute.labels Aus dem Änderungsprotokoll zugeordnet
host event.idm.read_only_udm.target.hostname Aus dem Änderungsprotokoll zugeordnet
host event.idm.read_only_udm.target.asset.hostname Aus dem Änderungsprotokoll zugeordnet
application.name event.idm.read_only_udm.target.application Aus dem Änderungsprotokoll zugeordnet
is_supported event.idm.read_only_udm.security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
trusted_session_uuid event.idm.read_only_udm.security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
passport_assessment_reason event.idm.read_only_udm.security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
remembered_factor event.idm.read_only_udm.security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
passport_assessment.is_potential event.idm.read_only_udm.security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
access_device.os event.idm.read_only_udm.principal.platform Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.detected_attack_detectors additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.features_version security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.model_version security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.policy_enabled additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.preview_mode_enabled additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.reason additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.more_secure_auth.trust_level security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.features_version security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.model_version security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.policy_enabled additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.preview_mode_enabled additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.reason additional.fields Aus dem Änderungsprotokoll zugeordnet
adaptive_trust_assessments.remember_me.trust_level security_result.detection_fields Aus dem Änderungsprotokoll zugeordnet
application.destination_name target.application Aus dem Änderungsprotokoll zugeordnet
auth_stage metadata.product_event_type Aus dem Änderungsprotokoll zugeordnet

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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