Collecter les journaux 1Password

Compatible avec :

Ce document explique comment ingérer des journaux 1Password dans Google Security Operations à l'aide de Google Cloud Storage V2.

1Password est une plate-forme de gestion des mots de passe qui aide les équipes à stocker, partager et gérer de manière sécurisée les identifiants, les secrets et les informations sensibles. L'API 1Password Events permet d'accéder aux données sur les tentatives de connexion et l'utilisation des éléments de votre compte 1Password Business.

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 services Cloud Run, des sujets Pub/Sub et des tâches Cloud Scheduler
  • Un compte 1Password Business
  • Un rôle de propriétaire ou d'administrateur dans votre compte 1Password

Créer un bucket Google Cloud Storage

  1. Accédez à Google Cloud Console.
  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, onepassword-secops-logs).
    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.

Collecter les identifiants 1Password

Configurer l'intégration des rapports sur les événements

  1. Connectez-vous à votre compte sur 1Password.com.
  2. Sélectionnez Intégrations dans la barre latérale.
  3. Si vous avez déjà configuré d'autres intégrations, sélectionnez Annuaire sur la page Intégrations.
  4. Dans la section Reporting sur les événements, sélectionnez Autre.
  5. Dans le champ Nom, saisissez un nom pour l'intégration (par exemple, Google SecOps Integration).
  6. Cliquez sur Add Integration (Ajouter une intégration).

Créer un jeton de support

  1. Sur la page d'informations sur l'intégration, cliquez sur Ajouter un jeton du porteur.
  2. Fournissez les informations de configuration suivantes :
    • Nom du jeton : saisissez un nom descriptif (par exemple, SecOps GCS Collector - SignIn and ItemUsage).
    • Expire après : sélectionnez la période d'expiration de votre choix. Sélectionnez Jamais pour un jeton sans date d'expiration, ou choisissez 30 jours, 90 jours ou 180 jours.
    • Événements à signaler : cochez les cases suivantes :
      • Tentatives de connexion
      • Événements d'utilisation des éléments
  3. Cliquez sur Émettre un jeton.

  4. Sur la page Enregistrer votre jeton, cliquez sur Enregistrer dans 1Password ou copiez le jeton et enregistrez-le dans un emplacement sécurisé.

  5. Cliquez sur Afficher les détails de l'intégration pour vérifier que l'intégration est active.

Déterminer l'URL de base de l'API Events

L'URL de base dépend du serveur qui héberge votre compte 1Password :

Si votre compte est hébergé sur L'URL de base de votre API Events est
1password.com https://events.1password.com
ent.1password.com https://events.ent.1password.com
1password.ca https://events.1password.ca
1password.eu https://events.1password.eu

Tester l'accès à l'API

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

    # Replace with your actual bearer token and base URL
BEARER_TOKEN="<your-bearer-token>"
API_BASE="https://events.1password.com"

# Test API access using the introspect endpoint
curl -v \
    -H "Authorization: Bearer $BEARER_TOKEN" \
    "$API_BASE/api/v2/auth/introspect"

Une réponse réussie renvoie un objet JSON avec le champ features listant les types d'événements auxquels votre jeton peut accéder (par exemple, ["signinattempts", "itemusages"]).

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 onepassword-logs-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect 1Password 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 votre bucket (onepassword-secops-logs).
  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 onepassword-logs-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 onepassword-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 extraire les journaux de tentatives de connexion et d'utilisation des éléments de l'API 1Password Events, 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 onepassword-logs-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, choisissez onepassword-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 onepassword-logs-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 onepassword-secops-logs Nom du bucket GCS
      GCS_PREFIX onepassword Préfixe des fichiers journaux
      STATE_KEY onepassword/state.json Chemin d'accès au fichier d'état
      OP_API_BASE https://events.1password.com URL de base de l'API 1Password Events
      OP_BEARER_TOKEN <your-bearer-token> Jeton de support de l'API 1Password Events
      MAX_RECORDS 10000 Nombre maximal d'enregistrements par point de terminaison et par exécution
      PAGE_SIZE 1000 Enregistrements par page (1 000 maximum)
      LOOKBACK_HOURS 24 Période d'analyse initiale en heures

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

  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

# 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()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'onepassword')
STATE_KEY = os.environ.get('STATE_KEY', 'onepassword/state.json')
API_BASE = os.environ.get('OP_API_BASE')
BEARER_TOKEN = os.environ.get('OP_BEARER_TOKEN')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

# 1Password Events API v2 endpoints for sign-in and item usage
ENDPOINTS = {
  'signinattempts': '/api/v2/signinattempts',
  'itemusages': '/api/v2/itemusages',
}

def parse_datetime(value: str) -> datetime:
  """Parse RFC 3339 datetime string to datetime object."""
  if value.endswith('Z'):
    value = value[:-1] + '+00:00'
  return datetime.fromisoformat(value)

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch 1Password
  sign-in attempt and item usage logs and write them to GCS
  as NDJSON.
  """
  if not all([GCS_BUCKET, API_BASE, BEARER_TOKEN]):
    print('Error: Missing required environment variables '
        '(GCS_BUCKET, OP_API_BASE, OP_BEARER_TOKEN)')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)

    # Load state (stores cursors per endpoint)
    state = load_state(bucket, STATE_KEY)

    now = datetime.now(timezone.utc)
    total_records = 0

    for event_type, path in ENDPOINTS.items():
      print(f'--- Processing endpoint: {event_type} ---')

      saved_cursor = state.get(f'cursor_{event_type}')

      records, last_cursor = fetch_endpoint(
        api_base=API_BASE,
        path=path,
        bearer_token=BEARER_TOKEN,
        saved_cursor=saved_cursor,
        lookback_hours=LOOKBACK_HOURS,
        page_size=PAGE_SIZE,
        max_records=MAX_RECORDS,
      )

      if records:
        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = (f'{GCS_PREFIX}/'
                f'{event_type}_{timestamp}.ndjson')
        blob = bucket.blob(object_key)

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

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

      # Save cursor even if no records (for next poll)
      if last_cursor:
        state[f'cursor_{event_type}'] = last_cursor

      total_records += len(records)

    # Save state with all cursors
    state['last_run'] = now.isoformat()
    save_state(bucket, STATE_KEY, state)

    print(f'Successfully processed {total_records} total records')

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

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: {e}')
  return {}

def save_state(bucket, key, state: dict):
  """Save state to GCS."""
  try:
    blob = bucket.blob(key)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json',
    )
    print(f'Saved state: {json.dumps(state)}')
  except Exception as e:
    print(f'Warning: Could not save state: {e}')

def fetch_endpoint(api_base, path, bearer_token, saved_cursor,
          lookback_hours, page_size, max_records):
  """
  Fetch events from a single 1Password Events API v2 endpoint.

  The 1Password Events API uses cursor-based pagination with POST
  requests. The first request sends a ResetCursor object with
  optional start_time and limit. Subsequent requests send the
  cursor returned from the previous response.

  Args:
    api_base: Events API base URL
    path: Endpoint path
    bearer_token: JWT bearer token
    saved_cursor: Cursor from previous run (or None)
    lookback_hours: Hours to look back on first run
    page_size: Max events per page (1-1000)
    max_records: Max total events per run

  Returns:
    Tuple of (records list, last_cursor string)
  """
  url = f'{api_base.rstrip("/")}{path}'

  headers = {
    'Authorization': f'Bearer {bearer_token}',
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'User-Agent': 'GoogleSecOps-1PasswordCollector/1.0',
  }

  records = []
  cursor = saved_cursor
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

    if len(records) >= max_records:
      print(f'Reached max_records limit ({max_records})')
      break

    # Build request body
    if cursor:
      # Continuing cursor: resume from last position
      body = json.dumps({'cursor': cursor})
    else:
      # ResetCursor: first request or no saved state
      start_time = (
        datetime.now(timezone.utc)
        - timedelta(hours=lookback_hours)
      )
      body = json.dumps({
        'limit': page_size,
        'start_time': start_time.strftime(
          '%Y-%m-%dT%H:%M:%SZ'
        ),
      })

    try:
      response = http.request(
        'POST', url, body=body, headers=headers,
      )

      # Handle rate limiting (600 req/min, 30000 req/hour)
      if response.status == 429:
        retry_after = int(
          response.headers.get(
            'Retry-After', str(int(backoff))
          )
        )
        print(f'Rate limited (429). Retrying after '
            f'{retry_after}s...')
        time.sleep(retry_after)
        backoff = min(backoff * 2, 60.0)
        continue

      backoff = 1.0

      if response.status != 200:
        response_text = response.data.decode('utf-8')
        print(f'HTTP Error {response.status}: '
            f'{response_text}')
        break

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

      page_items = data.get('items', [])
      cursor = data.get('cursor')
      has_more = data.get('has_more', False)

      if page_items:
        print(f'Page {page_num}: Retrieved '
            f'{len(page_items)} events')
        records.extend(page_items)

      if not has_more:
        print(f'No more pages (has_more=false)')
        break

      if not cursor:
        print(f'No cursor returned, stopping')
        break

    except urllib3.exceptions.HTTPError as e:
      print(f'HTTP error: {str(e)}')
      break
    except Exception as e:
      print(f'Error fetching events: {str(e)}')
      break

  print(f'Retrieved {len(records)} total records '
      f'from {page_num} pages')
  return records, cursor

    • 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 onepassword-logs-collector-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
    Sujet Sélectionner onepassword-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 onepassword-logs-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 onepassword-logs-collector.
  6. Cliquez sur l'onglet Journaux.

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

    --- Processing endpoint: signinattempts ---
Page 1: Retrieved X events
Wrote X signinattempts records to gs://onepassword-secops-logs/onepassword/signinattempts_YYYYMMDD_HHMMSS.ndjson
--- Processing endpoint: itemusages ---
Page 1: Retrieved X events
Wrote X itemusages records to gs://onepassword-secops-logs/onepassword/itemusages_YYYYMMDD_HHMMSS.ndjson
Successfully processed X total records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur onepassword-secops-logs.

  10. Accédez au dossier onepassword/.

  11. Vérifiez que de nouveaux fichiers .ndjson ont été créés avec le code temporel actuel.

Si vous constatez des erreurs dans les journaux :

  • HTTP 401 : vérifiez le jeton du porteur dans la variable d'environnement OP_BEARER_TOKEN. Le jeton a peut-être expiré.
  • HTTP 429 : limitation du débit. La fonction effectue automatiquement des nouvelles tentatives avec un délai d'intervalle. L'API 1Password Events autorise 600 requêtes par minute et 30 000 requêtes par heure.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.
  • Aucun enregistrement renvoyé : vérifiez que votre jeton du porteur a accès aux types d'événements demandés à l'aide du point de terminaison d'introspection.

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, 1Password Sign-In and Item Usage Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez 1Password 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.

  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://onepassword-secops-logs/onepassword/

    • 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 (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 onepassword-secops-logs.
  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 des objets de l'espace de stockage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
category security_result.category_details La valeur est extraite du champ category du journal brut.
client.app_name principal.application La valeur est extraite du champ client.app_name du journal brut.
client.app_version metadata.product_version La valeur est extraite du champ client.app_version du journal brut.
client.ip_address principal.ip La valeur est extraite du champ client.ip_address du journal brut.
client.os_name principal.platform La valeur est extraite du champ client.os_name du journal brut et mappée à la valeur de plate-forme UDM correspondante (LINUX, WINDOWS, MAC).
client.os_version principal.platform_version La valeur est extraite du champ client.os_version du journal brut.
client.platform_name principal.resource.attribute.labels La valeur est extraite du champ client.platform_name du journal brut.
client.platform_version principal.asset.platform_software.platform_version La valeur est extraite du champ client.platform_version du journal brut.
pays principal.location.country_or_region La valeur est extraite du champ country du journal brut si location.country n'est pas présent.
item_uuid security_result.about.resource.attribute.labels La valeur est extraite du champ item_uuid du journal brut.
location.city principal.location.city La valeur est extraite du champ location.city du journal brut.
location.country principal.location.country_or_region La valeur est extraite du champ location.country du journal brut.
location.latitude principal.location.region_latitude La valeur est extraite du champ location.latitude du journal brut.
location.longitude principal.location.region_longitude La valeur est extraite du champ location.longitude du journal brut.
location.region principal.location.name La valeur est extraite du champ location.region du journal brut.
session.ip principal.ip La valeur est extraite du champ session.ip du journal brut.
session_uuid network.session_id La valeur est extraite du champ session_uuid du journal brut.
target_user.email target.user.email_addresses La valeur est extraite du champ target_user.email du journal brut.
target_user.uuid target.user.userid La valeur est extraite du champ target_user.uuid du journal brut.
timestamp metadata.event_timestamp La valeur est extraite du champ timestamp du journal brut, puis convertie en secondes et en nanosecondes.
type additional.fields La valeur est extraite du champ type du journal brut.
user.email principal.user.email_addresses La valeur est extraite du champ user.email du journal brut.
nom.utilisateur principal.user.user_display_name La valeur est extraite du champ user.name du journal brut.
used_version additional.fields La valeur est extraite du champ used_version du journal brut.
uuid principal.resource.attribute.labels La valeur est extraite du champ uuid du journal brut.
vault_uuid security_result.about.resource.attribute.labels La valeur est extraite du champ vault_uuid du journal brut.
N/A extensions.auth Un objet vide est créé pour ce champ.
N/A metadata.event_type Défini sur USER_LOGIN si la catégorie est success ou firewall_reported_success, sur STATUS_UPDATE si aucune information sur l'utilisateur n'est présente et sur USER_UNCATEGORIZED dans le cas contraire.
N/A metadata.log_type Variable définie sur ONEPASSWORD.
N/A metadata.product_name Variable définie sur ONEPASSWORD.
N/A metadata.vendor_name Variable définie sur ONEPASSWORD.
N/A security_result.action Définie sur ALLOW si la catégorie est success ou firewall_reported_success, sur BLOCK si la catégorie est credentials_failed, mfa_failed, modern_version_failed ou firewall_failed, et laissée vide dans le cas contraire.

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