Collecter les journaux Delinea authentification unique (SSO) (anciennement Centrify)

Version de l'analyseur : 2.0

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, en les mappant 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 par rapport à 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 de créer et de 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 Client OAuth2, puis cliquez sur 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 Configuration de l'application, configurez les éléments suivants :
    • Onglet Paramètres :
      • ID d'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 cette valeur et conservez-la.
      • Code secret du client émis : copiez cette valeur et conservez-la.
    • Onglet Jetons :
      • Méthodes d'authentification : sélectionnez Identifiants du 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 : de l'étape 7.
    • Code secret du client : à partir de 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 : Événements d'audit : Afficher.

  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, vous devriez voir une réponse JSON contenant des événements d'audit. 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
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, delinea-centrify-logs-bucket).
    Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux fréquemment consultés)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions d'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 autorisé à é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 Storage.
    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 de l'espace de stockage : écrire des journaux dans un 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 le 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 dans lequel 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 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 sera déclenchée par les messages Pub/Sub de Cloud Scheduler pour récupérer 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 de modification directe 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).
    Durée d'exécution Sélectionnez Python 3.12 ou une 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. Vérifiez 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 application OAuth
    PAGE_SIZE 1000 Enregistrements par page
    MAX_PAGES 10 Nombre maximal de pages à récupérer

  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.
      • Processeur : 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éé (une à deux 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 :

    • 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)}')
    • 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 publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera 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, à l'heure pile)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé)
    Type de cible Pub/Sub
    Sujet 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 programmation

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 de faible volume
Tous les jours 0 0 * * * Collecte des 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 Forcer l'exécution 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 a bien été exécutée. Par exemple :

    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 nouveau fichier .json a été créé avec le code temporel actuel.

Si des erreurs s'affichent 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 : Événements d'audit : Afficher.
  • HTTP 429 : limitation du débit. La fonction effectue automatiquement une nouvelle tentative avec intervalle exponentiel entre les tentatives.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.

Configurer un flux dans Google SecOps pour ingérer les journaux d'authentification unique Delinea (Centrify)

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  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 Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique s'affiche, par exemple :

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

  8. Copiez cette adresse e-mail. Vous en aurez besoin lors de la tâche suivante.

  9. Cliquez sur Suivant.

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

    • URL du bucket de stockage : saisissez l'URI du bucket GCS avec le chemin d'accès du préfixe :
    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 (laissez ce champ vide pour la racine).

    Exemples :

    • Bucket racine : gs://company-logs/
    • Avec le préfixe : gs://company-logs/centrify-sso-logs/
    • Avec le 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 les fichiers 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 une fois le transfert réussi.
    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours. La valeur par défaut est de 180 jours.
    • Espace de noms de l'élément : espace de noms de l'élément.
    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  11. Cliquez sur Suivant.

  12. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps doit disposer 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.
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ du journal mappage UDM Logique
AccountID security_result.detection_fields.value La valeur de l'ID de compte 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 de 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 d'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 d'AzRoleId du journal brut est attribuée à un objet additional.fields avec la clé : AzRoleId.
AzRoleName target.user.attribute.roles.name La valeur d'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é : Directory Service Name.
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é : Directory Service Name Localized.
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é : UUID de service d'annuaire.
EventMessage security_result.summary La valeur d'EventMessage du journal brut est attribuée au champ security_result.summary.
EventType metadata.product_event_type La valeur d'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é : Proxy Id.
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 de "Tenant" 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 d'horodatage 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 n'est pas présent 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 du 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 "host" principal.hostname Extrait du champ d'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 "Level" et "FailReason" security_result.action Définissez sur "ALLOW" si le niveau est "Info", et sur "BLOCK" si FailReason est présent.
Déterminé par FailReason security_result.category Définie 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 cette option sur "INFORMATIONAL" si le niveau est "Info", sur "MEDIUM" si le niveau est "Warning" et sur "ERROR" si le niveau est "Error".
msg metadata.description Mappé à partir du journal des modifications
UserGuid principal.user.userid Mappé à partir du journal des modifications
ComputerName principal.asset.hostname Mappé à partir du journal des modifications
TokenType additional.fields Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications de cet analyseur

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