Delinea SSO-Logs erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Delinea-SSO-Logs (Single Sign-On, ehemals Centrify) mit Amazon S3 in Google Security Operations aufnehmen. Der Parser extrahiert die Logs und verarbeitet sowohl JSON- als auch Syslog-Formate. Es werden Schlüssel/Wert-Paare, Zeitstempel und andere relevante Felder geparst und dem UDM-Modell zugeordnet. Dabei wird eine spezielle Logik für die Verarbeitung von Anmeldefehlern, User-Agents, Schweregraden, Authentifizierungsmechanismen und verschiedenen Ereignistypen verwendet. Bei Fehlerereignissen wird FailUserName gegenüber NormalizedUser für Ziel-E-Mail-Adressen priorisiert.

Hinweise

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

  • Eine Google SecOps-Instanz.
  • Privilegierter Zugriff auf den Delinea (Centrify) SSO-Mandanten.
  • Privilegierter Zugriff auf AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Voraussetzungen für Delinea (Centrify) SSO erfassen (IDs, API-Schlüssel, Organisations-IDs, Tokens)

  1. Melden Sie sich im Delinea Admin Portal an.
  2. Klicken Sie auf Apps > Apps hinzufügen.
  3. Suchen Sie nach OAuth2-Client und klicken Sie auf Hinzufügen.
  4. Klicken Sie im Dialogfeld Web-App hinzufügen auf Ja.
  5. Klicken Sie im Dialogfeld Web-Apps hinzufügen auf Schließen.
  6. Konfigurieren Sie auf der Seite Application Configuration (Anwendungskonfiguration) Folgendes:
    • Tab Allgemein:
      • Anwendungs-ID: Geben Sie eine eindeutige Kennzeichnung ein, z. B. secops-oauth-client.
      • Name der Anwendung: Geben Sie einen aussagekräftigen Namen ein, z. B. SecOps Data Export.
      • Anwendungsbeschreibung: Geben Sie eine Beschreibung ein (z. B. OAuth client for exporting audit events to SecOps).
    • Tab Vertrauen:
      • Application is Confidential (Anwendung ist vertraulich): Aktivieren Sie diese Option.
      • Client ID Type (Client-ID-Typ): Wählen Sie Confidential (Vertraulich) aus.
      • Ausgestellte Client-ID: Kopieren und speichern Sie diesen Wert.
      • Ausgestellter Clientschlüssel: Kopieren und speichern Sie diesen Wert.
    • Tab Tokens:
      • Auth methods (Authentifizierungsmethoden): Wählen Sie Client Creds (Client-Anmeldedaten) aus.
      • Token Type (Tokentyp): Wählen Sie Jwt RS256 aus.
    • Tab Scope (Bereich):
      • Fügen Sie den Bereich siem mit der Beschreibung SIEM Integration Access (Zugriff auf SIEM-Integration) hinzu.
      • Fügen Sie den Bereich redrock/query mit der Beschreibung Query API Access (Zugriff auf die Query API) hinzu.
  7. Klicken Sie auf Speichern, um den OAuth-Client zu erstellen.
  8. Klicken Sie auf Hauptdienste > Nutzer > Nutzer hinzufügen.
  9. Konfigurieren Sie den Dienstnutzer:
    • Anmeldename: Geben Sie die Client-ID aus Schritt 6 ein.
    • E-Mail-Adresse: Geben Sie eine gültige E-Mail-Adresse ein (erforderliches Feld).
    • Anzeigename: Geben Sie einen aussagekräftigen Namen ein, z. B. SecOps Service User.
    • Passwort und Passwort bestätigen: Geben Sie den Clientschlüssel aus Schritt 6 ein.
    • Status: Wählen Sie Vertraulicher OAuth-Client aus.
  10. Klicken Sie auf Create User (Nutzer erstellen).
  11. Rufen Sie ZugriffRollen auf und weisen Sie dem Dienstnutzer eine Rolle mit den entsprechenden Berechtigungen zum Abfragen von Audit-Ereignissen zu.
  12. Kopieren Sie die folgenden Details und speichern Sie sie an einem sicheren Ort:
    • Tenant-URL: Ihre Centrify-Tenant-URL, z. B. https://yourtenant.my.centrify.com
    • Client-ID: aus Schritt 6
    • Clientschlüssel: Aus Schritt 6
    • OAuth-Anwendungs-ID: Aus der Anwendungskonfiguration

AWS S3-Bucket und IAM für Google SecOps konfigurieren

  1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
  2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. delinea-centrify-logs-bucket).
  3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
  4. Wählen Sie den erstellten Nutzer aus.
  5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
  6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
  7. Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
  8. Klicken Sie auf Weiter.
  9. Optional: Fügen Sie ein Beschreibungstag hinzu.
  10. Klicken Sie auf Zugriffsschlüssel erstellen.
  11. Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
  12. Klicken Sie auf Fertig.
  13. Wählen Sie den Tab Berechtigungen aus.
  14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
  15. Wählen Sie Berechtigungen hinzufügen aus.
  16. Wählen Sie Richtlinien direkt anhängen aus.
  17. Suchen Sie nach der Richtlinie AmazonS3FullAccess.
  18. Wählen Sie die Richtlinie aus.
  19. Klicken Sie auf Weiter.
  20. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und ‑Rolle für S3-Uploads konfigurieren

  1. Rufen Sie in der AWS-Konsole IAM > Richtlinien auf.
  2. Klicken Sie auf Richtlinie erstellen> Tab „JSON“.
  3. Kopieren Sie die folgende Richtlinie und fügen Sie sie ein.

  4. Policy JSON (ersetzen Sie delinea-centrify-logs-bucket, wenn Sie einen anderen Bucket-Namen eingegeben haben):

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::delinea-centrify-logs-bucket/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::delinea-centrify-logs-bucket/centrify-sso-logs/state.json"
    }
  ]
}

  5. Klicken Sie auf Weiter > Richtlinie erstellen.

  6. Rufen Sie IAM > Rollen auf.

  7. Klicken Sie auf Rolle erstellen > AWS-Service > Lambda.

  8. Hängen Sie die neu erstellte Richtlinie und die verwaltete Richtlinie AWSLambdaBasicExecutionRole (für CloudWatch-Logging) an.

  9. Geben Sie der Rolle den Namen CentrifySSOLogExportRole und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

  1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
  2. Klicken Sie auf Von Grund auf erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name CentrifySSOLogExport
    Laufzeit Python 3.13
    Architektur x86_64
    Ausführungsrolle CentrifySSOLogExportRole

  4. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und fügen Sie den folgenden Code (CentrifySSOLogExport.py) ein.

    import json
import boto3
import requests
import base64
from datetime import datetime, timedelta
import os
from typing import Dict, List, Optional

def lambda_handler(event, context):
    """
    Lambda function to fetch Delinea Centrify SSO audit events and store them in S3
    """

    # Environment variables
    S3_BUCKET = os.environ['S3_BUCKET']
    S3_PREFIX = os.environ['S3_PREFIX']
    STATE_KEY = os.environ['STATE_KEY']

    # Centrify API credentials
    TENANT_URL = os.environ['TENANT_URL']
    CLIENT_ID = os.environ['CLIENT_ID']
    CLIENT_SECRET = os.environ['CLIENT_SECRET']
    OAUTH_APP_ID = os.environ['OAUTH_APP_ID']

    # Optional parameters
    PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
    MAX_PAGES = int(os.environ.get('MAX_PAGES', '10'))

    s3_client = boto3.client('s3')

    try:
        # Get last execution state
        last_timestamp = get_last_state(s3_client, S3_BUCKET, STATE_KEY)

        # Get OAuth access token
        access_token = get_oauth_token(TENANT_URL, CLIENT_ID, CLIENT_SECRET, OAUTH_APP_ID)

        # Fetch audit events
        events = fetch_audit_events(TENANT_URL, access_token, last_timestamp, PAGE_SIZE, MAX_PAGES)

        if events:
            # Store events in S3
            current_timestamp = datetime.utcnow()
            filename = f"{S3_PREFIX}centrify-sso-events-{current_timestamp.strftime('%Y%m%d_%H%M%S')}.json"

            store_events_to_s3(s3_client, S3_BUCKET, filename, events)

            # Update state with latest timestamp
            latest_timestamp = get_latest_event_timestamp(events)
            update_state(s3_client, S3_BUCKET, STATE_KEY, latest_timestamp)

            print(f"Successfully processed {len(events)} events and stored to {filename}")
        else:
            print("No new events found")

        return {
            'statusCode': 200,
            'body': json.dumps(f'Successfully processed {len(events) if events else 0} events')
        }

    except Exception as e:
        print(f"Error processing Centrify SSO logs: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps(f'Error: {str(e)}')
        }

def get_oauth_token(tenant_url: str, client_id: str, client_secret: str, oauth_app_id: str) -> str:
    """
    Get OAuth access token using client credentials flow
    """

    # Create basic auth token
    credentials = f"{client_id}:{client_secret}"
    basic_auth = base64.b64encode(credentials.encode()).decode()

    token_url = f"{tenant_url}/oauth2/token/{oauth_app_id}"

    headers = {
        'Authorization': f'Basic {basic_auth}',
        'X-CENTRIFY-NATIVE-CLIENT': 'True',
        'Content-Type': 'application/x-www-form-urlencoded'
    }

    data = {
        'grant_type': 'client_credentials',
        'scope': 'siem redrock/query'
    }

    response = requests.post(token_url, headers=headers, data=data)
    response.raise_for_status()

    token_data = response.json()
    return token_data['access_token']

def fetch_audit_events(tenant_url: str, access_token: str, last_timestamp: str, page_size: int, max_pages: int) -> List[Dict]:
    """
    Fetch audit events from Centrify using the Redrock/query API
    """

    query_url = f"{tenant_url}/Redrock/query"

    headers = {
        'Authorization': f'Bearer {access_token}',
        'X-CENTRIFY-NATIVE-CLIENT': 'True',
        'Content-Type': 'application/json'
    }

    # Build SQL query with timestamp filter
    if last_timestamp:
        sql_query = f"Select * from Event where WhenOccurred > '{last_timestamp}' ORDER BY WhenOccurred ASC"
    else:
        # First run - get events from last 24 hours
        sql_query = "Select * from Event where WhenOccurred > datefunc('now', '-1') ORDER BY WhenOccurred ASC"

    payload = {
        "Script": sql_query,
        "args": {
            "PageSize": page_size,
            "Limit": page_size * max_pages,
            "Caching": -1
        }
    }

    response = requests.post(query_url, headers=headers, json=payload)
    response.raise_for_status()

    response_data = response.json()

    if not response_data.get('success', False):
        raise Exception(f"API query failed: {response_data.get('Message', 'Unknown error')}")

    # Parse the response
    result = response_data.get('Result', {})
    columns = {col['Name']: i for i, col in enumerate(result.get('Columns', []))}
    raw_results = result.get('Results', [])

    events = []
    for raw_event in raw_results:
        event = {}
        row_data = raw_event.get('Row', {})

        # Map column names to values
        for col_name, col_index in columns.items():
            if col_name in row_data and row_data[col_name] is not None:
                event[col_name] = row_data[col_name]

        # Add metadata
        event['_source'] = 'centrify_sso'
        event['_collected_at'] = datetime.utcnow().isoformat() + 'Z'

        events.append(event)

    return events

def get_last_state(s3_client, bucket: str, state_key: str) -> Optional[str]:
    """
    Get the last processed timestamp from S3 state file
    """
    try:
        response = s3_client.get_object(Bucket=bucket, Key=state_key)
        state_data = json.loads(response['Body'].read().decode('utf-8'))
        return state_data.get('last_timestamp')
    except s3_client.exceptions.NoSuchKey:
        print("No previous state found, starting from 24 hours ago")
        return None
    except Exception as e:
        print(f"Error reading state: {e}")
        return None

def update_state(s3_client, bucket: str, state_key: str, timestamp: str):
    """
    Update the state file with the latest processed timestamp
    """
    state_data = {
        'last_timestamp': timestamp,
        'updated_at': datetime.utcnow().isoformat() + 'Z'
    }

    s3_client.put_object(
        Bucket=bucket,
        Key=state_key,
        Body=json.dumps(state_data),
        ContentType='application/json'
    )

def store_events_to_s3(s3_client, bucket: str, key: str, events: List[Dict]):
    """
    Store events as JSONL (one JSON object per line) in S3
    """
    # Convert to JSONL format (one JSON object per line)
    jsonl_content = 'n'.join(json.dumps(event, default=str) for event in events)

    s3_client.put_object(
        Bucket=bucket,
        Key=key,
        Body=jsonl_content,
        ContentType='application/x-ndjson'
    )

def get_latest_event_timestamp(events: List[Dict]) -> str:
    """
    Get the latest timestamp from the events for state tracking
    """
    if not events:
        return datetime.utcnow().isoformat() + 'Z'

    latest = None
    for event in events:
        when_occurred = event.get('WhenOccurred')
        if when_occurred:
            if latest is None or when_occurred > latest:
                latest = when_occurred

    return latest or datetime.utcnow().isoformat() + 'Z'

  5. Rufen Sie Konfiguration > Umgebungsvariablen auf.

  6. Klicken Sie auf Bearbeiten> Neue Umgebungsvariable hinzufügen.

  7. Geben Sie die in der folgenden Tabelle aufgeführten Umgebungsvariablen ein und ersetzen Sie die Beispielwerte durch Ihre Werte.

    Umgebungsvariablen

    Schlüssel Beispielwert
    S3_BUCKET delinea-centrify-logs-bucket
    S3_PREFIX centrify-sso-logs/
    STATE_KEY centrify-sso-logs/state.json
    TENANT_URL https://yourtenant.my.centrify.com
    CLIENT_ID your-client-id
    CLIENT_SECRET your-client-secret
    OAUTH_APP_ID your-oauth-application-id
    OAUTH_SCOPE siem
    PAGE_SIZE 1000
    MAX_PAGES 10

  8. Bleiben Sie nach dem Erstellen der Funktion auf der zugehörigen Seite oder öffnen Sie Lambda > Funktionen > Ihre Funktion.

  9. Wählen Sie den Tab Konfiguration aus.

  10. Klicken Sie im Bereich Allgemeine Konfiguration auf Bearbeiten.

  11. Ändern Sie Zeitlimit in 5 Minuten (300 Sekunden) und klicken Sie auf Speichern.

EventBridge-Zeitplan erstellen

  1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).
  2. Geben Sie die folgenden Konfigurationsdetails an:
    • Wiederkehrender Zeitplan: Preis (1 hour).
    • Ziel: Ihre Lambda-Funktion CentrifySSOLogExport.
    • Name: CentrifySSOLogExport-1h.
  3. Klicken Sie auf Zeitplan erstellen.

(Optional) IAM-Nutzer mit Lesezugriff und Schlüssel für Google SecOps erstellen

  1. Wechseln Sie in der AWS-Konsole zu IAM > Nutzer.
  2. Klicken Sie auf Add users (Nutzer hinzufügen).
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Nutzer: Geben Sie secops-reader ein.
    • Zugriffstyp: Wählen Sie Zugriffsschlüssel – programmatischer Zugriff aus.
  4. Klicken Sie auf Nutzer erstellen.
  5. Minimale Leserichtlinie anhängen (benutzerdefiniert): Nutzer > secops-reader > Berechtigungen.
  6. Klicken Sie auf Berechtigungen hinzufügen > Richtlinien direkt anhängen.
  7. Wählen Sie Richtlinie erstellen aus.

  8. JSON:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::delinea-centrify-logs-bucket/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::delinea-centrify-logs-bucket"
    }
  ]
}

  9. Name = secops-reader-policy.

  10. Klicken Sie auf Richtlinie erstellen> suchen/auswählen > Weiter.

  11. Klicken Sie auf Berechtigungen hinzufügen.

  12. Erstellen Sie einen Zugriffsschlüssel für secops-reader: Sicherheitsanmeldedaten > Zugriffsschlüssel.

  13. Klicken Sie auf Zugriffsschlüssel erstellen.

  14. Laden Sie die Datei .CSV herunter. Sie fügen diese Werte in den Feed ein.

Feed in Google SecOps konfigurieren, um Delinea-SSO-Logs (Centrify) 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. Delinea Centrify SSO logs.
  4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
  5. Wählen Sie Centrify als Logtyp aus.
  6. Klicken Sie auf Weiter.
  7. Geben Sie Werte für die folgenden Eingabeparameter an:
    • S3-URI: s3://delinea-centrify-logs-bucket/centrify-sso-logs/
    • Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus.
    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
    • Zugriffsschlüssel-ID: Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
    • Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
    • Asset-Namespace: der Asset-Namespace.
    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.
  8. Klicken Sie auf Weiter.
  9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
AccountID security_result.detection_fields.value Der Wert von AccountID aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Account ID zugewiesen.
ApplicationName target.application Der Wert von ApplicationName aus dem Rohlog wird dem Feld target.application zugewiesen.
AuthorityFQDN target.asset.network_domain Der Wert von AuthorityFQDN aus dem Rohlog wird dem Feld target.asset.network_domain zugewiesen.
AuthorityID target.asset.asset_id Der Wert von AuthorityID aus dem Rohlog wird dem Feld target.asset.asset_id zugewiesen und mit „AuthorityID:“ versehen.
AzDeploymentId security_result.detection_fields.value Der Wert von AzDeploymentId aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:AzDeploymentId zugewiesen.
AzRoleId additional.fields.value.string_value Der Wert von AzRoleId aus dem Rohlog wird einem additional.fields-Objekt mit key:AzRole Id zugewiesen.
AzRoleName target.user.attribute.roles.name Der Wert von AzRoleName aus dem Rohlog wird dem Feld target.user.attribute.roles.name zugewiesen.
ComputerFQDN principal.asset.network_domain Der Wert von ComputerFQDN aus dem Rohlog wird dem Feld principal.asset.network_domain zugewiesen.
ComputerID principal.asset.asset_id Der Wert von ComputerID aus dem Rohlog wird dem Feld principal.asset.asset_id zugewiesen und mit „ComputerId:“ vorangestellt.
ComputerName about.hostname Der Wert von ComputerName aus dem Rohlog wird dem Feld about.hostname zugewiesen.
CredentialId security_result.detection_fields.value Der Wert von CredentialId aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Credential Id zugewiesen.
DirectoryServiceName security_result.detection_fields.value Der Wert von DirectoryServiceName aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Directory Service Name zugewiesen.
DirectoryServiceNameLocalized security_result.detection_fields.value Der Wert von DirectoryServiceNameLocalized aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Directory Service Name Localized zugewiesen.
DirectoryServiceUuid security_result.detection_fields.value Der Wert von DirectoryServiceUuid aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Directory Service Uuid zugewiesen.
EventMessage security_result.summary Der Wert von EventMessage aus dem Rohlog wird dem Feld security_result.summary zugewiesen.
EventType metadata.product_event_type Der Wert von EventType aus dem Rohlog wird dem Feld metadata.product_event_type zugewiesen. Außerdem wird damit die metadata.event_type bestimmt.
FailReason security_result.summary Der Wert von FailReason aus dem Rohlog wird dem Feld security_result.summary zugewiesen, sofern vorhanden.
FailUserName target.user.email_addresses Der Wert von FailUserName aus dem Rohlog wird dem Feld target.user.email_addresses zugewiesen, sofern vorhanden.
FromIPAddress principal.ip Der Wert von FromIPAddress aus dem Rohlog wird dem Feld principal.ip zugewiesen.
ID security_result.detection_fields.value Der Wert von ID aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:ID zugewiesen.
InternalTrackingID metadata.product_log_id Der Wert von InternalTrackingID aus dem Rohlog wird dem Feld metadata.product_log_id zugewiesen.
JumpType additional.fields.value.string_value Der Wert von JumpType aus dem Rohlog wird einem additional.fields-Objekt mit key:Jump Type zugewiesen.
NormalizedUser target.user.email_addresses Der Wert von NormalizedUser aus dem Rohlog wird dem Feld target.user.email_addresses zugewiesen.
OperationMode additional.fields.value.string_value Der Wert von OperationMode aus dem Rohlog wird einem additional.fields-Objekt mit key:Operation Mode zugewiesen.
ProxyId security_result.detection_fields.value Der Wert von ProxyId aus dem Rohlog wird einem security_result.detection_fields-Objekt mit key:Proxy Id zugewiesen.
RequestUserAgent network.http.user_agent Der Wert von RequestUserAgent aus dem Rohlog wird dem Feld network.http.user_agent zugewiesen.
SessionGuid network.session_id Der Wert von SessionGuid aus dem Rohlog wird dem Feld network.session_id zugewiesen.
Tenant additional.fields.value.string_value Der Wert von Tenant aus dem Rohlog wird einem additional.fields-Objekt mit key:Tenant zugewiesen.
ThreadType additional.fields.value.string_value Der Wert von ThreadType aus dem Rohlog wird einem additional.fields-Objekt mit key:Thread Type zugewiesen.
UserType principal.user.attribute.roles.name Der Wert von UserType aus dem Rohlog wird dem Feld principal.user.attribute.roles.name zugewiesen.
WhenOccurred metadata.event_timestamp Der Wert von WhenOccurred aus dem Rohlog wird geparst und dem Feld metadata.event_timestamp zugewiesen. Dieses Feld wird auch für das übergeordnete Feld timestamp verwendet. Der Wert „SSO“ ist fest codiert. Wird durch das Feld EventType bestimmt. Standardmäßig wird STATUS_UPDATE verwendet, wenn EventType nicht vorhanden ist oder keine bestimmten Kriterien erfüllt. Kann USER_LOGIN, USER_CREATION, USER_RESOURCE_ACCESS, USER_LOGOUT oder USER_CHANGE_PASSWORD sein. Der Wert „CENTRIFY_SSO“ ist fest codiert. Der Wert „SSO“ ist fest codiert. Hartcodierter Wert „Centrify“. Wenn das Feld message eine Sitzungs-ID enthält, wird diese extrahiert und verwendet. Andernfalls wird standardmäßig „1“ verwendet. Wird aus dem Feld host extrahiert, sofern verfügbar. Dieses Feld stammt aus dem Syslog-Header. Wird aus dem Feld pid extrahiert, sofern verfügbar. Dieses Feld stammt aus dem Syslog-Header. Wenn UserGuid vorhanden ist, wird sein Wert verwendet. Andernfalls wird die Nutzer-ID aus dem Feld message extrahiert und verwendet, sofern es eine enthält. Legen Sie den Wert auf „ALLOW“ fest, wenn Level „Info“ ist, und auf „BLOCK“, wenn FailReason vorhanden ist. Wird auf „AUTH_VIOLATION“ festgelegt, wenn FailReason vorhanden ist. Wird durch das Feld Level bestimmt. Wird auf „INFORMATIONAL“ festgelegt, wenn Level „Info“ ist, auf „MEDIUM“, wenn Level „Warning“ ist, und auf „ERROR“, wenn Level „Error“ ist.

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