Collecter les journaux d'audit Lucid

Compatible avec :

Ce document explique comment ingérer les journaux d'audit Lucid dans Google Security Operations à l'aide de Google Cloud Storage V2.

Lucid Software propose une suite de collaboration visuelle incluant Lucidchart, Lucidspark et Lucidscale. L'API Audit Logs, disponible exclusivement pour les clients Enterprise Shield, capture les événements liés à la sécurité et à la conformité dans l'ensemble de l'organisation, y compris l'accès aux comptes, l'activité des documents, la gestion des utilisateurs, les actions d'administration et les opérations d'équipe.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations permettant 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 services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Un compte Lucid Enterprise Shield avec des droits d'administrateur ou de propriétaire de compte
  • Accès au portail des développeurs Lucid avec les outils pour les développeurs activés

Activer les outils pour les développeurs dans Lucid

Avant de créer des identifiants d'API, vous devez avoir accès au portail des développeurs Lucid. Il existe deux façons d'activer les outils pour les développeurs :

Option 1 : Activer la fonctionnalité dans les paramètres utilisateur

  1. Connectez-vous à lucid.app.
  2. Cliquez sur l'icône de votre profil en haut à droite.
  3. Sélectionnez Paramètres du compte.

  4. Cochez la case Activer les outils pour les développeurs.

Option 2 : Activer la fonctionnalité en attribuant un rôle d'administrateur

  1. Connectez-vous à lucid.app en tant que propriétaire du compte ou administrateur de l'équipe.
  2. Accédez au panneau d'administration.
  3. Accédez à la section Utilisateurs.
  4. Sélectionnez l'utilisateur cible.

  5. Modifiez les rôles de l'utilisateur et attribuez-lui le rôle Développeur.

Configurer l'accès à l'API Lucid

Pour permettre à Google SecOps de récupérer les journaux d'audit, vous devez créer un client OAuth 2.0 et générer un jeton d'accès au niveau du compte avec le champ d'application account.audit.logs.

Créer une application et un client OAuth 2.0

  1. Accédez au portail des développeurs Lucid.
  2. Cliquez sur Créer une application.
  3. Saisissez un nom pour votre application (par exemple, Chronicle SIEM Integration).
  4. Cliquez sur l'application que vous venez de créer pour accéder à ses paramètres.
  5. Accédez à l'onglet OAuth 2.0.

  6. Saisissez un nom pour votre client OAuth 2.0 (par exemple, Chronicle Audit Log Collector).

  7. Cliquez sur Créer un client OAuth 2.0.

Enregistrer les identifiants client

Une fois le client OAuth 2.0 créé, le portail affiche vos identifiants :

  • ID client : votre identifiant client unique.
  • Code secret du client : code secret de votre API.

Important : Copiez et enregistrez immédiatement le code secret du client. Si le code secret du client est compromis, cliquez sur le bouton Réinitialiser le code secret du client sur la page des paramètres OAuth 2.0. La réinitialisation du secret révoque immédiatement l'accès jusqu'à ce que le nouveau secret soit mis à jour dans votre intégration.

Enregistrer un URI de redirection

  1. Sur la page des paramètres OAuth 2.0, cliquez sur Ajouter un URI de redirection.

  2. Saisissez l'URI de redirection pour votre intégration. Si vous utilisez la redirection de test fournie par Lucid, saisissez :

    https://lucid.app/oauth2/clients/<CLIENT_ID>/redirect

    Remplacez <CLIENT_ID> par votre ID client.

Obtenir un jeton d'accès au niveau du compte

L'API Audit Logs nécessite un jeton de compte (et non un jeton utilisateur). Un administrateur de compte doit autoriser le client OAuth 2.0 à créer un jeton au nom du compte.

  1. Demandez à un administrateur de compte d'accéder à l'URL d'autorisation suivante dans un navigateur :

    https://lucid.app/oauth2/authorizeAccount?client_id=<CLIENT_ID>&redirect_uri=<REDIRECT_URI>&scope=account.audit.logs

    Remplacez <CLIENT_ID> et <REDIRECT_URI> par vos valeurs réelles.

  2. L'administrateur examine les autorisations demandées sur l'écran de consentement, puis clique sur Autoriser.

  3. Lucid redirige vers l'URI de redirection avec un paramètre de requête code d'autorisation.

  4. Échangez le code d'autorisation contre un jeton d'accès en envoyant une requête POST au point de terminaison du jeton :

    curl --request POST \
  --url https://api.lucid.co/oauth2/token \
  --header 'Content-Type: application/json' \
  --data '{
    "grant_type": "authorization_code",
    "client_id": "<CLIENT_ID>",
    "client_secret": "<CLIENT_SECRET>",
    "code": "<AUTHORIZATION_CODE>",
    "redirect_uri": "<REDIRECT_URI>"
  }'

  5. La réponse inclut un access_token et un refresh_token. Consignez les deux valeurs de manière sécurisée.

Vérifier l'accès à l'API

  • Vérifiez que le jeton d'accès fonctionne en effectuant une requête de test :

    curl --request GET \
  --url 'https://api.lucid.co/auditLogs?pageSize=1' \
  --header 'Authorization: Bearer <ACCESS_TOKEN>' \
  --header 'Lucid-Api-Version: 1' \
  --header 'Accept: application/json'

Une réponse réussie renvoie un tableau JSON d'événements du journal d'audit.

Autorisations d'API requises

  • Le client OAuth 2.0 nécessite le champ d'application suivant :

    Champ d'application Type de jeton Objectif
    account.audit.logs Compte Récupérer les événements du journal d'audit pour le compte

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, lucid-audit-logs-gcs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion, 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 : Activez 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

  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 lucid-audit-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Lucid audit 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.

Accorder des autorisations IAM sur le bucket GCS

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (lucid-audit-logs-gcs).
  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 (lucid-audit-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

  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 thème : saisissez lucid-audit-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 des messages Pub/Sub provenant de Cloud Scheduler pour extraire les journaux de l'API Lucid Audit Logs 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 lucid-audit-collector
    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 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, sélectionnez lucid-audit-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 lucid-audit-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 lucid-audit-logs-gcs Nom du bucket GCS
    GCS_PREFIX lucid-audit Préfixe des fichiers journaux
    STATE_KEY lucid-audit/state.json Chemin d'accès au fichier d'état
    LUCID_CLIENT_ID your-oauth-client-id ID client Lucid OAuth 2.0
    LUCID_CLIENT_SECRET your-oauth-client-secret Code secret du client Lucid OAuth 2.0
    LUCID_REFRESH_TOKEN your-refresh-token Jeton d'actualisation Lucid OAuth 2.0
    LOOKBACK_HOURS 24 Période d'analyse initiale
    PAGE_SIZE 200 Enregistrements par page d'API (200 max.)
    MAX_PAGES 50 Nombre maximal de pages par exécution

  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.

  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 le champ Point d'entrée.
  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 re

http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=10.0, read=60.0),
    retries=False,
)

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'lucid-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'lucid-audit/state.json')
LUCID_CLIENT_ID = os.environ.get('LUCID_CLIENT_ID')
LUCID_CLIENT_SECRET = os.environ.get('LUCID_CLIENT_SECRET')
LUCID_REFRESH_TOKEN = os.environ.get('LUCID_REFRESH_TOKEN')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
MAX_PAGES = int(os.environ.get('MAX_PAGES', '50'))

API_BASE = 'https://api.lucid.co'

@functions_framework.cloud_event
def main(cloud_event):
    if not all([GCS_BUCKET, LUCID_CLIENT_ID, LUCID_CLIENT_SECRET, LUCID_REFRESH_TOKEN]):
        print('Error: Missing required environment variables')
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)
        state = load_state(bucket)
        now = datetime.now(timezone.utc)

        if isinstance(state, dict) and state.get('last_event_time'):
            try:
                last_val = state['last_event_time']
                if last_val.endswith('Z'):
                    last_val = last_val[:-1] + '+00:00'
                last_time = datetime.fromisoformat(last_val)
                last_time = last_time - timedelta(minutes=2)
            except Exception as e:
                print(f"Warning: Could not parse last_event_time: {e}")
                last_time = now - timedelta(hours=LOOKBACK_HOURS)
        else:
            last_time = now - timedelta(hours=LOOKBACK_HOURS)

        print(f"Fetching audit logs from {last_time.isoformat()} to {now.isoformat()}")

        access_token, new_refresh_token = refresh_access_token()

        if new_refresh_token:
            save_refresh_token(bucket, new_refresh_token)

        records, newest_event_time = fetch_audit_logs(access_token, last_time, now)

        if not records:
            print("No new audit log records found.")
            save_state(bucket, now.isoformat())
            return

        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = f"{GCS_PREFIX}/lucid_audit_{timestamp}.ndjson"
        blob = bucket.blob(object_key)

        ndjson = '\n'.join(
            [json.dumps(record, ensure_ascii=False) for record in records]
        ) + '\n'
        blob.upload_from_string(ndjson, content_type='application/x-ndjson')

        print(f"Wrote {len(records)} records to gs://{GCS_BUCKET}/{object_key}")

        if newest_event_time:
            save_state(bucket, newest_event_time)
        else:
            save_state(bucket, now.isoformat())

        print(f"Successfully processed {len(records)} audit log records")

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

def refresh_access_token():
    url = f"{API_BASE}/oauth2/token"
    body = json.dumps({
        'grant_type': 'refresh_token',
        'refresh_token': LUCID_REFRESH_TOKEN,
        'client_id': LUCID_CLIENT_ID,
        'client_secret': LUCID_CLIENT_SECRET
    }).encode('utf-8')

    response = http.request(
        'POST', url,
        body=body,
        headers={'Content-Type': 'application/json'}
    )

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

    data = json.loads(response.data.decode('utf-8'))
    access_token = data.get('access_token')
    new_refresh_token = data.get('refresh_token')

    if not access_token:
        raise Exception("No access_token in token refresh response")

    print("Successfully refreshed Lucid API access token")
    return access_token, new_refresh_token

def fetch_audit_logs(access_token, start_time, end_time):
    records = []
    newest_time = None
    page_num = 0
    next_page_url = None

    since_str = start_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
    until_str = end_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')

    while page_num < MAX_PAGES:
        page_num += 1

        if next_page_url:
            url = next_page_url
        else:
            url = (
                f"{API_BASE}/auditLogs"
                f"?pageSize={PAGE_SIZE}"
                f"&since={since_str}"
                f"&until={until_str}"
            )

        headers = {
            'Authorization': f'Bearer {access_token}',
            'Lucid-Api-Version': '1',
            'Accept': 'application/json'
        }

        response = http.request('GET', url, headers=headers)

        if response.status == 429:
            print(f"Rate limited on page {page_num}. Stopping pagination.")
            break

        if response.status != 200:
            print(
                f"API error on page {page_num}: {response.status} - "
                f"{response.data.decode('utf-8')}"
            )
            break

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

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

        records.extend(page_results)
        print(f"Page {page_num}: Retrieved {len(page_results)} events "
              f"(total: {len(records)})")

        for event in page_results:
            try:
                event_time = event.get('eventTimestamp')
                if event_time:
                    if newest_time is None or event_time > newest_time:
                        newest_time = event_time
            except Exception as e:
                print(f"Warning: Could not parse event time: {e}")

        link_header = response.headers.get('Link', '')
        next_page_url = parse_link_header(link_header)

        if not next_page_url:
            print(f"No next page link found. Pagination complete.")
            break

        if len(page_results) < PAGE_SIZE:
            break

    print(f"Total audit log records fetched: {len(records)} from {page_num} pages")
    return records, newest_time

def parse_link_header(link_header):
    if not link_header:
        return None

    match = re.search(r'<([^>]+)>;\s*rel="next"', link_header)
    if match:
        return match.group(1)
    return None

def load_state(bucket):
    try:
        blob = bucket.blob(STATE_KEY)
        if blob.exists():
            return json.loads(blob.download_as_text())
    except Exception as e:
        print(f"Warning: Could not load state: {e}")
    return {}

def save_state(bucket, last_event_time_iso):
    try:
        state = {
            'last_event_time': last_event_time_iso,
            'last_run': datetime.now(timezone.utc).isoformat()
        }
        blob = bucket.blob(STATE_KEY)
        blob.upload_from_string(
            json.dumps(state, indent=2),
            content_type='application/json'
        )
        print(f"Saved state: last_event_time={last_event_time_iso}")
    except Exception as e:
        print(f"Warning: Could not save state: {e}")

def save_refresh_token(bucket, new_refresh_token):
    try:
        token_key = f"{GCS_PREFIX}/refresh_token.json"
        blob = bucket.blob(token_key)
        blob.upload_from_string(
            json.dumps({'refresh_token': new_refresh_token}, indent=2),
            content_type='application/json'
        )
        print("Saved new refresh token to GCS")
    except Exception as e:
        print(f"Warning: Could not save refresh token: {e}")

  • requirements.txt:

      functions-framework==3.*
  google-cloud-storage==2.*
  urllib3>=2.0.0
  ```
  1. Cliquez sur Déployer pour enregistrer et déployer la fonction.

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

Créer une tâche Cloud Scheduler

  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 lucid-audit-collector-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électionner lucid-audit-trigger
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job (lucid-audit-collector-hourly).
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur lucid-audit-collector.
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Par exemple :

    Fetching audit logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Successfully refreshed Lucid API access token
Page 1: Retrieved X events (total: X)
Wrote X records to gs://lucid-audit-logs-gcs/lucid-audit/lucid_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X audit log records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur lucid-audit-logs-gcs.

  10. Accédez au dossier lucid-audit/.

  11. Vérifiez qu'un nouveau fichier .ndjson a été créé avec l'horodatage actuel.

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez que les variables d'environnement LUCID_CLIENT_ID, LUCID_CLIENT_SECRET et LUCID_REFRESH_TOKEN sont correctes.
  • HTTP 403 : vérifiez que le client OAuth 2.0 dispose du champ d'application account.audit.logs et que le jeton est un jeton de compte.
  • HTTP 429 : limitation du débit. La fonction arrête la pagination et la reprend lors de la prochaine exécution planifiée.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.

Catégories d'événements du journal d'audit

Les journaux d'audit Lucid sont organisés dans les catégories d'événements suivantes :

Catégorie Description
Connexions Événements associés aux connexions des utilisateurs
Contenu Événements associés à l'accès aux documents et aux dossiers, et à leur modification
Administration Événements associés à l'activité d'administration et aux modifications apportées au compte
Utilisateur Événements associés aux actions de l'utilisateur sur les paramètres personnels
Équipe Événements associés aux opérations d'équipe

Pour obtenir la liste complète des types d'événements et de leurs schémas, consultez la documentation Événements du journal d'audit Lucid.

Environnement FedRAMP

Les utilisateurs de l'environnement Lucid FedRAMP utilisent des points de terminaison d'autorisation et d'API différents. Consultez la documentation sur l'environnement Lucid FedRAMP pour connaître les URL des points de terminaison appropriés.

Récupérer le compte de service Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur 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, Lucid Audit Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Lucid comme Type de journal.

  7. Cliquez sur 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 pour l'utiliser à l'étape 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 au préfixe :

      gs://lucid-audit-logs-gcs/lucid-audit/

    • 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 une fois le 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 des derniers jours (180 jours par défaut).

    • 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

  11. Cliquez sur Suivant.

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

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 lucid-audit-logs-gcs.
  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 de journal Mappage UDM Logique
document_opened additional.fields Fusionné avec les libellés créés à partir de chaque champ source s'il n'est pas vide
share_link_enable additional.fields
restricted_account_enable additional.fields
event1.documentIds additional.fields
team_folder additional.fields
method_type additional.fields
extensions.auth.type extensions.auth.type Définissez la valeur sur "AUTHTYPE_UNSPECIFIED" pour les événements de connexion/déconnexion.
eventTimestamp metadata.event_timestamp Converti à l'aide de la date correspondant à la norme ISO8601 ou au format AAAA-MM-JJTHH:mm:ss.SSSSSSZ
has_user_login metadata.event_type Défini en fonction des indicateurs has_*: USER_LOGIN si has_user_login et has_target_user, USER_LOGOUT si has_user_logout et has_target_user, USER_RESOURCE_UPDATE_CONTENT si has_user_resource_updated et has_target_resource et has_principal_user, USER_CREATION si has_principal_user et has_target_application et has_target_user, USER_RESOURCE_CREATION si has_target_resource et has_principal_user, FILE_CREATION si has_target_file et has_principal et has_target, USER_RESOURCE_ACCESS si has_target_resource, USER_COMMUNICATION si has_principal_user, STATUS_UPDATE si has_principal et has_target sont définis sur "false", sinon GENERIC_EVENT
has_user_logout metadata.event_type
has_user_resource_updated metadata.event_type
has_principal_user metadata.event_type
has_target_resource metadata.event_type
has_target_file metadata.event_type
has_principal metadata.event_type
has_target_user metadata.event_type
has_target_application metadata.event_type
has_target metadata.event_type
event1.event1Type metadata.product_event_type Valeur copiée directement
actor.actorIp principal.asset.ip Valeur copiée directement si elle n'est pas vide
actor.actorIp principal.ip Valeur copiée directement si elle n'est pas vide
actor.actorAccountId principal.resource.id Valeur copiée directement si elle n'est pas vide
actor.actorClient principal.resource.name Valeur copiée directement si elle n'est pas vide
flowId principal.resource.product_object_id Valeur copiée directement si elle n'est pas vide
actor.actorType principal.user.attribute.roles Fusionné à partir de actor_type si eventType n'est pas login/logout et que actor_type n'est pas vide
actor.actorEmail principal.user.email_addresses Fusionné si actor_email n'est pas vide et que l'adresse e-mail est valide, et si eventType n'est pas login/logout
actor.actorUserId principal.user.userid Valeur copiée directement si elle n'est pas vide et que eventType n'est pas login/logout
event1.registrationMethod security_result.description Valeur copiée directement si elle n'est pas vide
event1.source target.application Valeur copiée directement si elle n'est pas vide
event1.publishedLink.link target.file.full_path Valeur copiée directement si elle n'est pas vide
event1.filename target.file.names Fusionné s'il n'est pas vide
targetData._targetType target.resource.attribute.labels Fusionné avec les libellés créés à partir de chaque champ source s'il n'est pas vide
targetData._targetId target.resource.attribute.labels
event1.format target.resource.attribute.labels
event1.method target.resource.attribute.labels
event1.publishedLink.format target.resource.attribute.labels
accountId target.resource.id Valeur copiée directement si elle n'est pas vide
event1.destinationFolderName target.resource.name Définissez sur destinationFolderName si la valeur n'est pas vide, sinon sur folderName si la valeur n'est pas vide, sinon sur publishedLink.name si la valeur n'est pas vide.
event1.folderName target.resource.name
event1.publishedLink.name target.resource.name
event1.documentId target.resource.product_object_id Valeur copiée directement si elle n'est pas vide
actor.actorType target.user.attribute.roles Fusionné à partir de actor_type si eventType est login/logout, et à partir de event_role si non vide
event1.role target.user.attribute.roles
actor.actorEmail target.user.email_addresses Fusionné à partir de actor_email si la connexion/déconnexion est valide, et à partir de userEmail dans _target
targetData.userEmail target.user.email_addresses
event1.destinationFolderId target.user.product_object_id Définissez sur destinationFolderId si la valeur n'est pas vide, sinon sur folderId si la valeur n'est pas vide.
event1.folderId target.user.product_object_id
targetData.displayName target.user.user_display_name Valeur copiée directement si elle n'est pas vide
actor.actorUserId target.user.userid Valeur copiée directement si elle n'est pas vide et que eventType est "login" ou "logout"
event1.product metadata.product_name Valeur du produit si elle n'est pas vide, sinon "LUCID"
metadata.vendor_name metadata.vendor_name Définie sur "LUCID"

Journal des modifications

Afficher le journal des modifications pour ce parseur

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