Collecter les journaux Delinea Single Sign-On (SSO)

Compatible avec :

Ce document explique comment ingérer les journaux d'authentification unique (SSO) Delinea (anciennement Centrify) dans Google Security Operations à l'aide de Google Cloud Storage. L'analyseur extrait les journaux, en gérant les formats JSON et syslog. Il analyse les paires clé-valeur, les codes temporels et d'autres champs pertinents, et les mappe au modèle UDM, avec une logique spécifique pour gérer les échecs de connexion, les user-agents, les niveaux de gravité, les mécanismes d'authentification et divers types d'événements. Il donne la priorité à FailUserName sur NormalizedUser pour les adresses e-mail cibles dans les événements d'échec.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations pour créer et gérer des buckets GCS
  • Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
  • Autorisations permettant de créer des fonctions Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Accès privilégié au locataire SSO Delinea (Centrify)

Collecter les identifiants SSO Delinea (Centrify)

Créer une application cliente OAuth2

  1. Connectez-vous au portail d'administration Delinea.
  2. Accédez à Applications > Ajouter des applications Web.
  3. Cliquez sur l'onglet Personnalisé.
  4. Recherchez OAuth2 Client, puis cliquez sur Add (Ajouter).
  5. Cliquez sur Oui dans la boîte de dialogue Ajouter une application Web.
  6. Cliquez sur Fermer dans la boîte de dialogue Ajouter des applications Web.
  7. Sur la page Application Configuration, configurez les éléments suivants :
    • Onglet Paramètres :
      • ID de l'application : saisissez un identifiant unique (par exemple, secops-oauth-client).
      • Nom de l'application : saisissez un nom descriptif (par exemple, SecOps Data Export).
      • Description de l'application : saisissez une description (par exemple, OAuth client for exporting audit events to SecOps).
    • Section Utilisation générale :
      • Type d'ID client : sélectionnez Confidentiel.
      • ID client émis : copiez et enregistrez cette valeur.
      • Code secret du client émis : copiez et enregistrez cette valeur.
    • Onglet Jetons :
      • Méthodes d'authentification : sélectionnez Identifiants client.
      • Type de jeton : sélectionnez JwtRS256.
    • Onglet Champ d'application :
      • Ajoutez le champ d'application redrock/query avec la description Query API Access.
  8. Cliquez sur Enregistrer pour créer le client OAuth.
  9. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
    • URL du locataire : URL de votre locataire Centrify (par exemple, https://yourtenant.my.centrify.com).
    • ID client : obtenu à l'étape 7.
    • Code secret du client : à l'étape 7.
    • ID d'application OAuth : à partir de la configuration de l'application.

Vérifier les autorisations

Pour vérifier que le client OAuth dispose des autorisations requises :

  1. Connectez-vous au portail d'administration Delinea.
  2. Accédez à Paramètres (⚙️) > Ressources > Rôles.
  3. Vérifiez que le rôle attribué au client OAuth inclut l'autorisation Rapport : Afficher les événements d'audit.

  4. Si l'autorisation est manquante, contactez votre administrateur Delinea pour qu'il vous l'accorde.

Tester l'accès à l'API

  • Testez vos identifiants avant de procéder à l'intégration :

    # Replace with your actual credentials
TENANT_URL="https://yourtenant.my.centrify.com"
CLIENT_ID="your-client-id"
CLIENT_SECRET="your-client-secret"
OAUTH_APP_ID="your-oauth-application-id"

# Get OAuth token
TOKEN=$(curl -s -X POST "${TENANT_URL}/oauth2/token/${OAUTH_APP_ID}" \
  -H "Authorization: Basic $(echo -n "${CLIENT_ID}:${CLIENT_SECRET}" | base64)" \
  -H "X-CENTRIFY-NATIVE-CLIENT: True" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=redrock/query" | jq -r '.access_token')

# Test query API access
curl -v -X POST "${TENANT_URL}/Redrock/query" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "X-CENTRIFY-NATIVE-CLIENT: True" \
  -H "Content-Type: application/json" \
  -d '{"Script":"Select * from Event where WhenOccurred > datefunc('"'"'now'"'"', '"'"'-1'"'"') ORDER BY WhenOccurred ASC","args":{"PageNumber":1,"PageSize":10,"Limit":10,"Caching":-1}}'

Si l'opération réussit, une réponse JSON contenant des événements d'audit s'affiche. Si vous recevez une erreur 401 ou 403, vérifiez vos identifiants et vos autorisations.

Créer un bucket Google Cloud Storage

  1. Accédez à la console Google Cloud.
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage> Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nommer votre bucket Saisissez un nom unique (par exemple, delinea-centrify-logs-bucket).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions des objets ou la règle de conservation

  6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service disposant des autorisations nécessaires pour écrire dans le bucket GCS et être appelée par Pub/Sub.

Créer un compte de service

  1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez delinea-sso-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Delinea SSO logs.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets de l'espace de stockage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. Cliquez sur OK.

Ces rôles sont requis pour :

  • Administrateur des objets Storage : écrire des journaux dans le bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction
  • Demandeur Cloud Functions : autorise l'appel de fonctions

Accorder des autorisations IAM sur un bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (par exemple, delinea-centrify-logs-bucket).
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, delinea-sso-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
  6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub auquel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Create topic (Créer un sujet).
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez delinea-sso-logs-trigger.
    • Conservez les valeurs par défaut des autres paramètres.
  4. Cliquez sur Créer.

Créer une fonction Cloud Run pour collecter les journaux

La fonction Cloud Run est déclenchée par les messages Pub/Sub de Cloud Scheduler pour extraire les journaux de l'API Delinea SSO et les écrire dans GCS.

  1. Dans la console GCP, accédez à Cloud Run.
  2. Cliquez sur Créer un service.
  3. Sélectionnez Fonction (utilisez un éditeur intégré pour créer une fonction).

  4. Dans la section Configurer, fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom du service delinea-sso-log-export
    Région Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
    Runtime (durée d'exécution) Sélectionnez Python 3.12 ou version ultérieure.

  5. Dans la section Déclencheur (facultatif) :

    1. Cliquez sur + Ajouter un déclencheur.
    2. Sélectionnez Cloud Pub/Sub.
    3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet Pub/Sub delinea-sso-logs-trigger.
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

  8. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service delinea-sso-collector-sa.

  9. Accédez à l'onglet Conteneurs :

    1. Cliquez sur Variables et secrets.
    2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
    Nom de la variable Exemple de valeur Description
    GCS_BUCKET delinea-centrify-logs-bucket Nom du bucket GCS
    GCS_PREFIX centrify-sso-logs Préfixe des fichiers journaux
    STATE_KEY centrify-sso-logs/state.json Chemin d'accès au fichier d'état
    TENANT_URL https://yourtenant.my.centrify.com URL du locataire Delinea
    CLIENT_ID your-client-id ID client OAuth
    CLIENT_SECRET your-client-secret Code secret du client OAuth
    OAUTH_APP_ID your-oauth-application-id ID de l'application OAuth
    PAGE_SIZE 1000 Enregistrements par page
    MAX_PAGES 10 Nombre maximal de pages à extraire

  10. Dans la section Variables et secrets, faites défiler la page jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 600 secondes (10 minutes).

  11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (1 à 2 minutes).

  15. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

  1. Saisissez main dans Point d'entrée de la fonction.

  2. Dans l'éditeur de code intégré, créez deux fichiers :

    • Premier fichier : main.py:
    import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time
import base64

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=30.0),
    retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch Delinea Centrify SSO audit events and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'centrify-sso-logs')
    state_key = os.environ.get('STATE_KEY', 'centrify-sso-logs/state.json')

    # Centrify API credentials
    tenant_url = os.environ.get('TENANT_URL')
    client_id = os.environ.get('CLIENT_ID')
    client_secret = os.environ.get('CLIENT_SECRET')
    oauth_app_id = os.environ.get('OAUTH_APP_ID')

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

    if not all([bucket_name, tenant_url, client_id, client_secret, oauth_app_id]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(bucket_name)

        # Load state (last processed timestamp)
        state = load_state(bucket, state_key)
        last_timestamp = state.get('last_timestamp')

        print(f'Processing logs since {last_timestamp if last_timestamp else "24 hours ago"}')

        # 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:
            # Write events to GCS
            current_timestamp = datetime.now(timezone.utc)
            blob_name = f"{prefix}/centrify-sso-events-{current_timestamp.strftime('%Y%m%d_%H%M%S')}.json"
            blob = bucket.blob(blob_name)

            # Convert to JSONL format (one JSON object per line)
            jsonl_content = '\n'.join([json.dumps(event, default=str) for event in events])
            blob.upload_from_string(jsonl_content, content_type='application/x-ndjson')

            print(f'Wrote {len(events)} events to {blob_name}')

            # Update state with latest timestamp
            latest_timestamp = get_latest_event_timestamp(events)
            save_state(bucket, state_key, {'last_timestamp': latest_timestamp, 'updated_at': current_timestamp.isoformat() + 'Z'})

            print(f'Successfully processed {len(events)} events')
        else:
            print('No new events found')

    except Exception as e:
        print(f'Error processing Centrify SSO logs: {str(e)}')
        raise

def get_oauth_token(tenant_url, client_id, client_secret, oauth_app_id):
    """Get OAuth access token using client credentials flow."""
    credentials = f"{client_id}:{client_secret}"
    basic_auth = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')

    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': 'redrock/query'
    }

    response = http.request('POST', token_url, headers=headers, fields=data)

    if response.status != 200:
        raise Exception(f"OAuth token request failed: {response.status} {response.data.decode('utf-8')}")

    token_data = json.loads(response.data.decode('utf-8'))
    return token_data['access_token']

def fetch_audit_events(tenant_url, access_token, last_timestamp, page_size, max_pages):
    """Fetch audit events from Centrify using the Redrock/query API with proper pagination."""
    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"

    all_events = []
    page_num = 1
    backoff = 1.0

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

        try:
            response = http.request('POST', query_url, headers=headers, body=json.dumps(payload))

            # Handle rate limiting with exponential backoff
            if response.status == 429:
                retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
                print(f"Rate limited (429). Retrying after {retry_after}s...")
                time.sleep(retry_after)
                backoff = min(backoff * 2, 30.0)
                continue

            backoff = 1.0

            if response.status != 200:
                raise Exception(f"API query failed: {response.status} {response.data.decode('utf-8')}")

            response_data = json.loads(response.data.decode('utf-8'))

            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', [])

            if not raw_results:
                print(f"No more results on page {page_num}")
                break

            print(f"Page {page_num}: Retrieved {len(raw_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.now(timezone.utc).isoformat() + 'Z'

                all_events.append(event)

            # Check if we've reached the end
            if len(raw_results) < page_size:
                print(f"Reached last page (page {page_num} returned {len(raw_results)} < {page_size})")
                break

            page_num += 1

        except Exception as e:
            print(f"Error fetching page {page_num}: {e}")
            raise

    print(f"Retrieved {len(all_events)} total events from {page_num} pages")
    return all_events

def get_latest_event_timestamp(events):
    """Get the latest timestamp from the events for state tracking."""
    if not events:
        return datetime.now(timezone.utc).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.now(timezone.utc).isoformat() + 'Z'

def load_state(bucket, key):
    """Load state from GCS."""
    try:
        blob = bucket.blob(key)
        if blob.exists():
            state_data = blob.download_as_text()
            return json.loads(state_data)
    except Exception as e:
        print(f'Warning: Could not load state: {str(e)}')
    return {}

def save_state(bucket, key, state):
    """Save state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state),
            content_type='application/json'
        )
    except Exception as e:
        print(f'Warning: Could not save state: {str(e)}')
    • Deuxième fichier : requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

  4. Attendez la fin du déploiement (deux à trois minutes).

Créer une tâche Cloud Scheduler

Cloud Scheduler publie des messages sur le sujet Pub/Sub à intervalles réguliers, ce qui déclenche la fonction Cloud Run.

  1. Dans la console GCP, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom delinea-sso-log-export-hourly
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Topic Sélectionnez le sujet Pub/Sub delinea-sso-logs-trigger.
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de planification

  • Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :

    Fréquence Expression Cron Cas d'utilisation
    Toutes les 5 minutes */5 * * * * Volume élevé, faible latence
    Toutes les 15 minutes */15 * * * * Volume moyen
    Toutes les heures 0 * * * * Standard (recommandé)
    Toutes les 6 heures 0 */6 * * * Traitement par lot à faible volume
    Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job (par exemple, delinea-sso-log-export-hourly).
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de la fonction delinea-sso-log-export.
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Recherchez les éléments suivants :

    Processing logs since YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Wrote X events to centrify-sso-logs/centrify-sso-events_YYYYMMDD_HHMMSS.json
Successfully processed X events

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket (par exemple, delinea-centrify-logs-bucket).

  10. Accédez au dossier de préfixe centrify-sso-logs/.

  11. Vérifiez qu'un fichier .json a été créé avec le code temporel actuel.

Si vous constatez des erreurs dans les journaux :

  • HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement (CLIENT_ID, CLIENT_SECRET, OAUTH_APP_ID).
  • HTTP 403 : vérifiez que le client OAuth dispose de l'autorisation Rapport : Afficher les événements d'audit.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un intervalle de temps.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Delinea Centrify SSO logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Centrify comme Type de journal.

  7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique pour le compte de service s'affiche, par exemple :

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

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin du rôle Lecteur des objets Storage sur votre bucket GCS.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (par exemple, delinea-centrify-logs-bucket).
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuez des rôles : sélectionnez Lecteur des objets de l'espace de stockage.

  6. Cliquez sur Enregistrer.

Configurer un flux dans Google SecOps pour ingérer les journaux SSO Delinea (Centrify)

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Delinea Centrify SSO logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Centrify comme Type de journal.
  7. Cliquez sur Suivant.

  8. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket Storage : saisissez l'URI du bucket GCS avec le préfixe du chemin d'accès :

      gs://delinea-centrify-logs-bucket/centrify-sso-logs/

      • Remplacez :

        • delinea-centrify-logs-bucket : nom de votre bucket GCS.
        • centrify-sso-logs : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).

      • Exemples :

        • Bucket racine : gs://company-logs/
        • Avec préfixe : gs://company-logs/centrify-sso-logs/
        • Avec un sous-dossier : gs://company-logs/delinea/sso/

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.

      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ du journal Mappage UDM Logique
AccountID security_result.detection_fields.value La valeur AccountID du journal brut est attribuée à un objet security_result.detection_fields avec la clé "ID de compte".
ApplicationName target.application La valeur de ApplicationName du journal brut est attribuée au champ target.application.
AuthorityFQDN target.asset.network_domain La valeur de AuthorityFQDN du journal brut est attribuée au champ target.asset.network_domain.
AuthorityID target.asset.asset_id La valeur AuthorityID du journal brut est attribuée au champ target.asset.asset_id, précédée de "AuthorityID:".
AzDeploymentId security_result.detection_fields.value La valeur de AzDeploymentId du journal brut est attribuée à un objet security_result.detection_fields avec la clé AzDeploymentId.
AzRoleId additional.fields.value.string_value La valeur de AzRoleId du journal brut est attribuée à un objet additional.fields avec la clé AzRoleId.
AzRoleName target.user.attribute.roles.name La valeur de AzRoleName du journal brut est attribuée au champ target.user.attribute.roles.name.
ComputerFQDN principal.asset.network_domain La valeur de ComputerFQDN du journal brut est attribuée au champ principal.asset.network_domain.
ComputerID principal.asset.asset_id La valeur de ComputerID du journal brut est attribuée au champ principal.asset.asset_id, précédée de "ComputerId:".
ComputerName about.hostname La valeur de ComputerName du journal brut est attribuée au champ about.hostname.
CredentialId security_result.detection_fields.value La valeur de CredentialId du journal brut est attribuée à un objet security_result.detection_fields avec la clé "ID d'identifiant".
DirectoryServiceName security_result.detection_fields.value La valeur de DirectoryServiceName du journal brut est attribuée à un objet security_result.detection_fields avec la clé "Nom du service d'annuaire".
DirectoryServiceNameLocalized security_result.detection_fields.value La valeur de DirectoryServiceNameLocalized du journal brut est attribuée à un objet security_result.detection_fields avec la clé "Nom localisé du service d'annuaire".
DirectoryServiceUuid security_result.detection_fields.value La valeur de DirectoryServiceUuid du journal brut est attribuée à un objet security_result.detection_fields avec la clé "Directory Service Uuid".
EventMessage security_result.summary La valeur EventMessage du journal brut est attribuée au champ security_result.summary.
EventType metadata.product_event_type La valeur de EventType du journal brut est attribuée au champ metadata.product_event_type. Il est également utilisé pour déterminer metadata.event_type.
FailReason security_result.summary La valeur de FailReason du journal brut est attribuée au champ security_result.summary lorsqu'elle est présente.
FailUserName target.user.email_addresses La valeur de FailUserName du journal brut est attribuée au champ target.user.email_addresses lorsqu'elle est présente.
FromIPAddress principal.ip La valeur de FromIPAddress du journal brut est attribuée au champ principal.ip.
ID security_result.detection_fields.value La valeur de l'ID du journal brut est attribuée à un objet security_result.detection_fields avec la clé "ID".
InternalTrackingID metadata.product_log_id La valeur de InternalTrackingID du journal brut est attribuée au champ metadata.product_log_id.
JumpType additional.fields.value.string_value La valeur de JumpType du journal brut est attribuée à un objet additional.fields avec la clé "Jump Type".
NormalizedUser target.user.email_addresses La valeur de NormalizedUser du journal brut est attribuée au champ target.user.email_addresses.
OperationMode additional.fields.value.string_value La valeur de OperationMode du journal brut est attribuée à un objet additional.fields avec la clé "Operation Mode".
ProxyId security_result.detection_fields.value La valeur de ProxyId du journal brut est attribuée à un objet security_result.detection_fields avec la clé "ID du proxy".
RequestUserAgent network.http.user_agent La valeur de RequestUserAgent du journal brut est attribuée au champ network.http.user_agent.
SessionGuid network.session_id La valeur de SessionGuid du journal brut est attribuée au champ network.session_id.
Locataire additional.fields.value.string_value La valeur du locataire du journal brut est attribuée à un objet additional.fields avec la clé "Tenant".
ThreadType additional.fields.value.string_value La valeur de ThreadType du journal brut est attribuée à un objet additional.fields avec la clé "Thread Type".
UserType principal.user.attribute.roles.name La valeur de UserType du journal brut est attribuée au champ principal.user.attribute.roles.name.
WhenOccurred metadata.event_timestamp La valeur de "WhenOccurred" du journal brut est analysée et attribuée au champ metadata.event_timestamp. Ce champ renseigne également le champ de code temporel de niveau supérieur.
Valeur codée en dur metadata.product_name "SSO".
Valeur codée en dur metadata.event_type Déterminé par le champ EventType. La valeur par défaut est STATUS_UPDATE si EventType est absent ou ne correspond à aucun critère spécifique. Il peut s'agir de "USER_LOGIN", "USER_CREATION", "USER_RESOURCE_ACCESS", "USER_LOGOUT" ou "USER_CHANGE_PASSWORD".
Valeur codée en dur metadata.vendor_name "CENTRIFY_SSO".
Valeur codée en dur metadata.product_version "SSO".
Valeur codée en dur metadata.log_type "Centrify".
Extrait du champ de message network.session_id Si le champ de message contient un ID de session, il est extrait et utilisé. Sinon, la valeur par défaut est "1".
Extrait du champ "Hôte" principal.hostname Extrait du champ "hôte" s'il est disponible, qui provient de l'en-tête syslog.
Extrait du champ "pid" principal.process.pid Extrait du champ "pid" s'il est disponible, qui provient de l'en-tête syslog.
UserGuid ou extrait du message target.user.userid Si UserGuid est présent, sa valeur est utilisée. Sinon, si le champ de message contient un ID utilisateur, il est extrait et utilisé.
Déterminé par le niveau et FailReason security_result.action Définissez la valeur sur "ALLOW" si le niveau est "Info", et sur "BLOCK" si FailReason est présent.
Déterminé par FailReason security_result.category Définissez sur "AUTH_VIOLATION" si FailReason est présent.
Déterminé par le champ "Niveau" security_result.severity Déterminé par le champ "Niveau". Définissez sur "INFORMATIONAL" si le niveau est "Info", sur "MEDIUM" si le niveau est "Warning" et sur "ERROR" si le niveau est "Error".

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.