Duo-Authentifizierungs-Logs erfassen

Unterstützt in:

Google SecOps SIEM

In diesem Dokument wird beschrieben, wie Sie Duo-Authentifizierungslogs 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

Prüfen Sie, ob die folgenden Voraussetzungen erfüllt sind:

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

Option 1: Duo-Authentifizierungslogs mit der Drittanbieter-API aufnehmen

Duo-Voraussetzungen (API-Anmeldedaten) erfassen

Melden Sie sich als Administrator mit der Rolle Inhaber, Administrator oder Application Manager in der Duo Admin-Konsole an.
Rufen Sie Anwendungen > App-Katalog auf.
Suchen Sie im Katalog nach dem Eintrag für die Admin API.
Klicken Sie auf + Hinzufügen, um die Anwendung zu erstellen.
Kopieren und speichern Sie die folgenden Details an einem sicheren Ort:
- Integrationsschlüssel
- Geheimer Schlüssel
- API-Hostname (z. B. api-XXXXXXXX.duosecurity.com)
Rufen Sie den Bereich Berechtigungen auf.
Deaktivieren Sie alle Berechtigungsoptionen außer Leseprotokoll gewähren.
Klicken Sie auf Änderungen speichern.

Feed in Google SecOps konfigurieren, um Duo-Authentifizierungslogs aufzunehmen

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf + Neuen Feed hinzufügen.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Duo Authentication Logs.
Wählen Sie Drittanbieter-API als Quelltyp aus.
Wählen Sie Duo Auth als Logtyp aus.
Klicken Sie auf Weiter.
Geben Sie Werte für die folgenden Eingabeparameter an:
- Nutzername: Geben Sie den Integrationsschlüssel von Duo ein.
- Secret (Secret): Geben Sie den Secret-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 die Datenaufnahme: Optional. Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.
Klicken Sie auf Weiter.
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

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

Google Cloud Storage-Bucket erstellen

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

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 je nach Bedarf aus (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)
Zugriffssteuerung	Einheitlich (empfohlen)
Schutzmaßnahmen	Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren

Klicken Sie auf Erstellen.

Dienstkonto für Cloud Run-Funktion erstellen

Die Cloud Run-Funktion benötigt ein Dienstkonto mit Berechtigungen zum Schreiben in den GCS-Bucket.

Dienstkonto erstellen

Wechseln Sie in der GCP Console zu IAM & Verwaltung > Dienstkonten.
Klicken Sie auf Dienstkonto erstellen.
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.
Klicken Sie auf Erstellen und fortfahren.
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-Objekt-Administrator 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.
Klicken Sie auf Weiter.
Klicken Sie auf Fertig.

Diese Rollen sind erforderlich für:

Storage-Objekt-Administrator: Protokolle in GCS-Bucket schreiben und Statusdateien verwalten
Cloud Run-Aufrufer: 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:

Rufen Sie Cloud Storage > Buckets auf.
Klicken Sie auf den Namen Ihres Buckets.
Wechseln Sie zum Tab Berechtigungen.
Klicken Sie auf Zugriff erlauben.
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-Objekt-Administrator aus.
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.

Rufen Sie in der GCP Console Pub/Sub > Themen auf.
Klicken Sie auf Thema erstellen.
Geben Sie die folgenden Konfigurationsdetails an:
- Themen-ID: Geben Sie duo-auth-trigger ein.
- Übernehmen Sie die anderen Einstellungen.
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.

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

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.

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.
Im Abschnitt Authentifizierung:
1. Wählen Sie Authentifizierung erforderlich aus.
2. Identitäts- und Zugriffsverwaltung
Hinweis: Pub/Sub übernimmt die Authentifizierung beim Aufrufen der Funktion automatisch.
Scrollen Sie nach unten und maximieren Sie Container, Netzwerk, Sicherheit.
Rufen Sie den Tab Sicherheit auf:
- Dienstkonto: Wählen Sie das Dienstkonto duo-auth-collector-sa aus.

Rufen Sie den Tab Container auf:

Klicken Sie auf Variablen und Secrets.
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`

Scrollen Sie auf dem Tab Variablen und Secrets nach unten zu Anfragen:
- Zeitlimit für Anfragen: Geben Sie 600 Sekunden (10 Minuten) ein.
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.
Scrollen Sie zu Ausführungsumgebung:
- Wählen Sie Standard aus (empfohlen).
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).
Klicken Sie auf Erstellen.
Warten Sie ein bis zwei Minuten, bis der Dienst erstellt wurde.
Nachdem der Dienst erstellt wurde, wird automatisch der Inline-Code-Editor geöffnet.

Funktionscode hinzufügen

Geben Sie main unter Funktionseinstiegspunkt ein.

Erstellen Sie im Inline-Codeeditor 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.*

Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.
Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Hinweis :Bei der Konfiguration des Pub/Sub-Triggers werden automatisch die erforderlichen Abos und Berechtigungen erstellt.

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema, wodurch die Cloud Run-Funktion ausgelöst wird.

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

Geben Sie die folgenden Konfigurationsdetails an:

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

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

Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job.
Klicken Sie auf Force run (Ausführung erzwingen), um die Ausführung manuell auszulösen.
Warten Sie einige Sekunden und rufen Sie dann Cloud Run > Dienste > duo-auth-collector > Logs auf.
Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde.
Prüfen Sie im GCS-Bucket, ob 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

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf Neuen Feed hinzufügen.
Klicken Sie auf Einzelnen Feed konfigurieren.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Duo Authentication Logs.
Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
Wählen Sie Duo Auth als Logtyp aus.
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
```
Kopieren Sie diese E‑Mail-Adresse für den nächsten Schritt.

Hinweis :Jede Google SecOps-Instanz hat ein eindeutiges Dienstkonto. Verwenden Sie keine Dienstkonten aus anderer Dokumentation oder anderen Beispielen.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

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

Rufen Sie Cloud Storage > Buckets auf.
Klicken Sie auf den Namen Ihres Buckets.
Wechseln Sie zum Tab Berechtigungen.
Klicken Sie auf Zugriff erlauben.
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-Objekt-Betrachter aus.
Klicken Sie auf Speichern.

Hinweis: Wenn Sie die Löschoption „Übertragene Dateien löschen“ oder „Übertragene Dateien und leere Verzeichnisse löschen“ verwenden möchten, weisen Sie die Rolle Storage-Objekt-Administrator anstelle von „Storage-Objekt-Betrachter“ zu.

Feed in Google SecOps konfigurieren, um Duo-Authentifizierungslogs aufzunehmen

Rufen Sie die SIEM-Einstellungen > Feeds auf.
Klicken Sie auf Neuen Feed hinzufügen.
Klicken Sie auf Einzelnen Feed konfigurieren.
Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Duo Authentication Logs.
Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
Wählen Sie Duo Auth als Logtyp aus.
Klicken Sie auf Weiter.
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/
  Hinweis :Fügen Sie immer den Schrägstrich (/) am Ende des URI ein.
- Option zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption aus:
  - Nie: Es werden nach Übertragungen nie Dateien 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.
    
    Hinweis :Wenn Sie eine Löschoption auswählen, muss das Dienstkonto die Rolle Storage-Objekt-Administrator anstelle von „Storage-Objekt-Betrachter“ haben. Aktualisieren Sie die IAM-Berechtigungen entsprechend.
- 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.
Klicken Sie auf Weiter.
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 sein 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 dem UDM zugeordnet.
access_device.location.country	principal.location.country_or_region	Falls vorhanden, wird der Wert dem UDM zugeordnet.
access_device.location.state	principal.location.state	Falls vorhanden, wird der Wert dem UDM zugeordnet.
access_device.os	principal.platform	Wenn 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 dem UDM zugeordnet.
application.key	target.resource.id	Falls vorhanden, wird der Wert dem UDM zugeordnet.
application.name	target.application	Falls vorhanden, wird der Wert dem 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 dem UDM zugeordnet.
auth_device.location.country	target.location.country_or_region	Falls vorhanden, wird der Wert dem UDM zugeordnet.
auth_device.location.state	target.location.state	Falls vorhanden, wird der Wert dem 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 „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 „userid“ 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 er leer ist oder keines der beiden, 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 der 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 der Wert mit dem Schlüsselnamen der 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 der 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“ der 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 dem 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 sein 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“ wird in security_result.action ALLOW und „Ablehnen“ in BLOCK übersetzt.
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 dem UDM zugeordnet.
user.name	target.user.userid	Falls vorhanden, wird der Wert dem UDM zugeordnet.
Nutzername	target.user.userid	Wenn der Wert vorhanden ist und user.name nicht, wird er der 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	Wird aus dem Feld „log_type“ der obersten Ebene des Rohlogs übernommen.
(Parserlogik)	extensions.auth.type	Immer auf „SSO“ festgelegt.

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