Collecter les journaux Okta Advanced Server Access

Compatible avec :

Ce document explique comment ingérer les journaux Okta Advanced Server Access dans Google Security Operations à l'aide de Google Cloud Storage V2.

Okta Advanced Server Access (anciennement ScaleFT) est une solution de gestion des accès privilégiés qui fournit un accès SSH et RDP aux serveurs avec des certificats éphémères et une journalisation d'audit complète. La plate-forme conserve les événements d'audit pendant 90 jours et fournit une API pour récupérer ces événements en vue d'un stockage et d'une analyse à long terme dans les plates-formes SIEM.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec les API Cloud Storage, Cloud Run, Pub/Sub et Cloud Scheduler activées
  • 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 accès administrateur à votre équipe Okta Advanced Server Access
  • Possibilité de créer des utilisateurs de service et des clés API dans Advanced Server Access

Configurer l'accès à l'API Okta Advanced Server Access

Pour permettre à Google SecOps de récupérer les événements d'audit, vous devez créer un utilisateur de service et générer une clé API. Les utilisateurs de service sont des comptes spéciaux conçus pour l'automatisation et les intégrations d'API.

Créer un utilisateur du service

  1. Connectez-vous au tableau de bord Advanced Server Access.
  2. Accédez à Utilisateurs.
  3. Sélectionnez l'onglet Utilisateurs du service.
  4. Cliquez sur Créer un utilisateur de service.

  5. Dans le champ Nom d'utilisateur, saisissez un nom descriptif pour l'utilisateur du service (par exemple, chronicle-integration).

  6. Cliquez sur Create Service User (Créer un utilisateur de service).

Générer une clé API

  1. Sur la page d'informations sur l'utilisateur du service, cliquez sur Créer une clé API.

  2. Copiez et enregistrez immédiatement les identifiants suivants :

    • ID de clé API : UUID qui identifie la clé API (par exemple, 6052868b-1b04-4a14-8288-e6496d7f2f4b)
    • Secret de clé API : chaîne secrète encodée en base64 utilisée pour authentifier les requêtes API

  3. Cliquez sur OK.

Attribuer l'utilisateur du service à un groupe disposant des autorisations appropriées

Pour accéder à l'API Audits, les utilisateurs de services doivent être membres d'un groupe disposant des rôles appropriés à l'échelle de l'équipe.

  1. Dans le tableau de bord Advanced Server Access, accédez à Groupes.
  2. Sélectionnez un groupe existant ou créez-en un pour l'accès à l'API.
  3. Cliquez sur le nom du groupe pour ouvrir ses détails.
  4. Cliquez sur l'onglet Utilisateurs.
  5. Cliquez sur Ajouter un utilisateur.
  6. Recherchez et sélectionnez l'utilisateur du service (par exemple, chronicle-integration).
  7. Cliquez sur Ajouter.
  8. Sélectionnez l'onglet Rôles.

  9. Assurez-vous que le groupe dispose de l'un des rôles suivants à l'échelle de l'équipe :

    • reporting_user : accès en lecture seule à tous les points de terminaison (recommandé pour l'ingestion de journaux)
    • access_admin : accès administrateur complet (accorde toutes les autorisations CRUD)

  10. Si le rôle requis n'est pas attribué, cliquez sur Ajouter un rôle, sélectionnez reporting_user ou access_admin, puis cliquez sur Enregistrer.

Vérifier les autorisations

Pour vérifier que l'utilisateur du service dispose des autorisations requises :

  1. Dans le tableau de bord Advanced Server Access, accédez à Groupes.
  2. Cliquez sur le groupe contenant l'utilisateur du service (par exemple, chronicle-integration).
  3. Sélectionnez l'onglet Rôles.
  4. Vérifiez que le rôle reporting_user ou access_admin est indiqué.
  5. Si vous ne voyez pas l'onglet "Rôles", contactez votre administrateur pour qu'il vous accorde l'accès approprié.

Tester l'accès à l'API

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

    # Replace with your actual credentials
TEAM_NAME="your-team-name"
KEY_ID="your-api-key-id"
KEY_SECRET="your-api-key-secret"

# Obtain bearer token
TOKEN=$(curl -s -X POST "https://app.scaleft.com/v1/teams/${TEAM_NAME}/service_token" \
    -H "Content-Type: application/json" \
    -d "{\"key_id\": \"${KEY_ID}\", \"key_secret\": \"${KEY_SECRET}\"}" \
    | python3 -c "import sys,json; print(json.load(sys.stdin)['bearer_token'])")

# Test audit events access
curl -s -H "Authorization: Bearer ${TOKEN}" \
    "https://app.scaleft.com/v1/teams/${TEAM_NAME}/auditsV2?count=5" \
    | python3 -m json.tool

Une réponse réussie renvoie un tableau JSON des événements d'audit récents.

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, okta-asa-audit-logs).
    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 fréquemment consultés)
    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 okta-asa-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Okta Advanced Server Access 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 (okta-asa-audit-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 l'adresse e-mail du compte de service (okta-asa-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 okta-asa-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 Okta Advanced Server Access Audits 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 okta-asa-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 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, sélectionnez okta-asa-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 okta-asa-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 okta-asa-audit-logs Nom du bucket GCS
    GCS_PREFIX okta-asa-audit Préfixe des fichiers journaux
    STATE_KEY okta-asa-audit/state.json Chemin d'accès au fichier d'état
    ASA_TEAM_NAME your-team-name Nom de l'équipe Advanced Server Access
    ASA_KEY_ID your-api-key-id ID de la clé API de l'utilisateur du service
    ASA_KEY_SECRET your-api-key-secret Secret de la clé API de l'utilisateur du service
    MAX_RECORDS 5000 Nombre maximal d'enregistrements par exécution
    PAGE_SIZE 1000 Enregistrements par page d'API (1 000 maximum)
    LOOKBACK_HOURS 24 Période d'analyse initiale

  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 time

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', 'okta-asa-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'okta-asa-audit/state.json')
ASA_TEAM_NAME = os.environ.get('ASA_TEAM_NAME')
ASA_KEY_ID = os.environ.get('ASA_KEY_ID')
ASA_KEY_SECRET = os.environ.get('ASA_KEY_SECRET')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

ASA_API_BASE = 'https://app.scaleft.com'

@functions_framework.cloud_event
def main(cloud_event):
  if not all([GCS_BUCKET, ASA_TEAM_NAME, ASA_KEY_ID, ASA_KEY_SECRET]):
    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_offset'):
      last_offset = state['last_offset']
    else:
      last_offset = None

    print(f"Starting audit log collection (last_offset={last_offset})")

    token = get_bearer_token()

    records, newest_offset = fetch_audit_events(
      token=token,
      last_offset=last_offset,
      page_size=PAGE_SIZE,
      max_records=MAX_RECORDS,
    )

    if not records:
      print("No new audit records found.")
      return

    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/okta_asa_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_offset:
      save_state(bucket, newest_offset)

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

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

def get_bearer_token():
  url = f"{ASA_API_BASE}/v1/teams/{ASA_TEAM_NAME}/service_token"
  body = json.dumps({
    'key_id': ASA_KEY_ID,
    'key_secret': ASA_KEY_SECRET
  }).encode('utf-8')

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

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

  data = json.loads(response.data.decode('utf-8'))
  token = data.get('bearer_token')
  if not token:
    raise Exception("No bearer_token in service token response")

  print("Successfully obtained ASA bearer token")
  return token

def fetch_audit_events(token, last_offset, page_size, max_records):
  endpoint = f"{ASA_API_BASE}/v1/teams/{ASA_TEAM_NAME}/auditsV2"

  headers = {
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
  }

  records = []
  page_num = 0
  backoff = 1.0
  current_offset = last_offset

  while True:
    page_num += 1

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

    params = [f"count={page_size}"]
    if current_offset:
      params.append(f"offset={current_offset}")

    url = f"{endpoint}?{'&'.join(params)}"

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

      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 == 401:
        print("Token expired (401). Refreshing bearer token...")
        token = get_bearer_token()
        headers['Authorization'] = f'Bearer {token}'
        continue

      if response.status != 200:
        print(f"HTTP Error: {response.status}")
        response_text = response.data.decode('utf-8')
        print(f"Response body: {response_text}")
        return records, current_offset

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

      page_results = data.get('list', [])

      if not page_results:
        print(f"No more results (empty page)")
        break

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

      # Extract next offset from Link header for pagination
      link_header = response.headers.get('Link', '')
      next_offset = extract_next_offset(link_header)

      if next_offset:
        current_offset = next_offset
      else:
        print("No more pages (no next link)")
        break

    except Exception as e:
      print(f"Error fetching audit events: {e}")
      return records, current_offset

  print(f"Retrieved {len(records)} total records from {page_num} pages")
  return records, current_offset

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

  parts = link_header.split(',')
  for part in parts:
    if 'rel="next"' in part:
      url_part = part.split(';')[0].strip().strip('<>')
      if 'offset=' in url_part:
        for param in url_part.split('?')[-1].split('&'):
          if param.startswith('offset='):
            return param.split('=', 1)[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_offset):
  try:
    state = {
      'last_offset': last_offset,
      '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_offset={last_offset}")
  except Exception as e:
    print(f"Warning: Could not save state: {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

  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 okta-asa-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 okta-asa-audit-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 de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job (okta-asa-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 okta-asa-collector.
  6. Cliquez sur l'onglet Journaux.

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

    Starting audit log collection (last_offset=None)
Successfully obtained ASA bearer token
Page 1: Retrieved X events
Wrote X records to gs://okta-asa-audit-logs/okta-asa-audit/okta_asa_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur okta-asa-audit-logs.

  10. Accédez au dossier okta-asa-audit/.

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

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez que les variables d'environnement ASA_KEY_ID et ASA_KEY_SECRET sont correctes.
  • HTTP 403 : vérifiez que l'utilisateur du service dispose du rôle reporting_user ou access_admin.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un 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.

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, Okta ASA Audit Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Okta Advanced Server Access comme Type de journal.
  7. Cliquez sur Obtenir un compte de service.

  8. Une adresse e-mail de compte de service unique s'affiche. Exemple :

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

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

  10. Cliquez sur Suivant.

  11. 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://okta-asa-audit-logs/okta-asa-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

  12. Cliquez sur Suivant.

  13. 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

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur okta-asa-audit-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 d'objets Storage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ du journal Mappage UDM Logique
details.actor.details.email principal.user.email_addresses Valeur copiée directement
details.actor.details.first_name principal.user.first_name Valeur copiée directement
details.actor.details.full_name principal.user.user_display_name Valeur copiée directement
details.actor.details.last_name principal.user.last_name Valeur copiée directement
details.actor.details.user_type principal.user.attribute.roles Valeur copiée directement
details.actor.id principal.user.employee_id Valeur copiée directement
details.actor.name principal.user.userid Valeur de details.actor.name si elle n'est pas vide, sinon details.unix_user_name
details.unix_user_name principal.user.userid
details.actor.status principal.user.attribute.labels Fusionné en tant que libellé avec la clé "actor_status"
details.actor.team_name principal.user.department Valeur copiée directement
details.actor.user_type principal.user.attribute.labels Fusionné en tant que libellé avec la clé "actor_user_type"
details.client.description principal.application Valeur copiée directement
details.client.encrypted principal.asset.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "details_client_encrypted"
details.client.hostname principal.hostname, principal.asset.hostname Valeur copiée directement
details.client.id principal.user.product_object_id Valeur copiée directement
details.client.os principal.platform Définissez sur WINDOWS si la valeur correspond à (?i)Win|win, sur LINUX si elle correspond à (?i)Lin|lin, sur MAC si elle correspond à (?i)Mac|ios|mac et sur ANDROID si elle correspond à (?i)Android|android.
details.client.os principal.platform_version Extraction de major.minor.patch à partir de la chaîne OS à l'aide de grok
details.client.state principal.resource.attribute.labels Fusionné en tant que libellé avec la clé "client_state"
details.client.user_name target.user.userid Valeur copiée directement
details.client_ip principal.ip, principal.asset.ip Adresse IP extraite à l'aide du modèle grok
details.from_address principal.ip, principal.asset.ip IP extraite à l'aide du modèle grok
details.project.create_server_users target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "project_create_server_users"
details.project.force_shared_ssh_users target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "project_force_shared_ssh_users"
details.project.forward_traffic target.resource.attribute.labels Converti en chaîne, fusionné en tant qu'étiquette avec la clé "project_forward_traffic"
details.project.id target.resource.id Valeur copiée directement
details.project.name target.resource.name Valeur copiée directement
details.project.next_unix_gid target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "next_unix_gid"
details.project.next_unix_uid target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "next_unix_uid"
details.project.rdp_session_recording target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "project_rdp_session_recording"
details.project.require_preauth_for_creds target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "project_require_preauth_for_creds"
details.project.ssh_certificate_type target.resource.attribute.labels Fusionné en tant qu'étiquette avec la clé "project_ssh_certificate_type"
details.project.ssh_session_recording target.resource.attribute.labels Converti en chaîne, fusionné en tant que libellé avec la clé "project_ssh_session_recording"
details.project.team target.resource.attribute.labels Fusionné en tant qu'étiquette avec la clé "project_team"
details.server.alt_names target.hostname, target.asset.hostname, target.resource.attribute.labels Premier alt_name défini sur target.hostname et target.asset.hostname, les autres sont fusionnés en tant qu'étiquettes avec la clé "alt_name"
details.server.hostname intermediary_value.hostname Valeur copiée directement
details.server.id intermediary_value.resource.attribute.labels Fusionné en tant qu'étiquette avec la clé "details_server_id"
details.server.os intermediary_value.platform_version Valeur copiée directement
details.server.os intermediary_value.resource.attribute.labels Fusionné en tant que libellé avec la clé "details_server_os"
details.server.os_type intermediary_value.platform Définissez la valeur sur LINUX si elle correspond à (?i)linux, WINDOWS si elle correspond à (?i)windows ou MAC si elle correspond à (?i)mac.
details.server.services intermediary_value.resource.attribute.labels Fusionnés en tant qu'étiquettes avec la clé "server_services {index}"
details.server.source intermediary_value.resource.attribute.labels Fusionné en tant que libellé avec la clé "server_source"
details.server.source_details.cloud_account intermediary_value.resource.attribute.labels Fusionné en tant qu'étiquette avec la clé "server_source_details_cloud_account"
details.server.source_details.cloud_provider intermediary_value.resource.attribute.labels Fusionné en tant que libellé avec la clé "server_source_details_cloud_provider"
details.server.source_details.instance_id intermediary_value.resource.attribute.labels Fusionné en tant que libellé avec la clé "server_source_details_instance_id"
details.server.state target.asset.attribute.labels Converti en chaîne, fusionné en tant qu'étiquette avec la clé "server_state"
details.server.team_name intermediary_value.user.department Valeur copiée directement
details.server_hostnames target.hostname, target.resource.attribute.labels Le premier nom d'hôte est défini sur target.hostname, les autres sont fusionnés en tant qu'étiquettes avec la clé "server_hostname {index}"
details.server_id target.resource.attribute.labels Fusionné en tant que libellé avec la clé "details_server_id"
details.server_os target.platform_version Valeur copiée directement
details.server_os_type target.platform Définissez sur LINUX si la valeur correspond à (?i)linux, sur WINDOWS si elle correspond à (?i)windows et sur MAC si elle correspond à (?i)mac.
details.server_state target.resource.attribute.labels Fusionné en tant que libellé avec la clé "details_server_state"
details.session_type extensions.auth.auth_details Valeur copiée directement
details.session_type security_result.detection_fields Fusionné en tant que libellé avec la clé "session_type"
details.servers intermédiaire Traités et fusionnés en tant qu'objet intermédiaire
details.ssh_algorithm network.tls.cipher Valeur copiée directement
details.ssh_key_fingerprint target.asset.attribute.labels Fusionné en tant que libellé avec la clé "ssh_key_fingerprint"
details.ssh_public_key security_result.detection_fields Fusionné en tant qu'étiquette avec la clé "ssh_public_key"
details.target_server target.application Valeur copiée directement
details.team_id principal.resource.id Valeur copiée directement
details.team_id target.resource.id Valeur copiée directement
details.team_name additional.fields Fusionné en tant qu'étiquette avec la clé "team_name"
details.trace_id network.session_id Valeur copiée directement
details.type metadata.product_event_type Valeur copiée directement
details.username target.user.user_display_name Valeur copiée directement
details.via network.session_id Valeur copiée directement
details_server intermediary_value Traitées et fusionnées en tant qu'objet intermediary_value
id additional.fields Fusionné en tant que libellé avec la clé "id"
code temporel metadata.event_timestamp Converti au format ISO8601
extensions.auth.type extensions.auth.type Définissez cette option sur "SSO" si metadata.event_type est défini sur USER_LOGIN.
intermediary_value intermédiaire Fusionné à partir de intermediary_value s'il n'est pas vide
has_principal_user metadata.event_type Défini sur USER_LOGIN si has_principal_user et has_target_user ou has_principal_user et has_target et details_type correspondent à la connexion ; sinon, USER_UNCATEGORIZED si has_principal_user ; sinon, STATUS_UPDATE si has_principal
has_target_user metadata.event_type
metadata.product_name metadata.product_name Défini sur "OKTA_SCALEFT"
metadata.vendor_name metadata.vendor_name Défini sur "OKTA_SCALEFT"
desc event.idm.read_only_udm.metadata.description Mappé à partir du journal des modifications
asset_id event.idm.read_only_udm.target.asset.asset_id Mappé à partir du journal des modifications
details.hostname event.idm.read_only_udm.principal.hostname et event.idm.read_only_udm.principal.asset.hostname Mappé à partir du journal des modifications
details.actor event.idm.read_only_udm.principal.user.userid Mappé à partir du journal des modifications
details.client event.idm.read_only_udm.principal.hostname et event.idm.read_only_udm.principal.asset.hostname Mappé à partir du journal des modifications
details.username event.idm.read_only_udm.target.user.user_display_name Mappé à partir du journal des modifications
details.server.server_accounts.username event.idm.read_only_udm.target.user.user_display_name Mappé à partir du journal des modifications
details.project event.idm.read_only_udm.target.resource.attribute.cloud.project.name Mappé à partir du journal des modifications
details.server.server_accounts event.idm.read_only_udm.target.asset.attribute.labels Mappé à partir du journal des modifications
"id" event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
"details.from_address" event.idm.read_only_udm.principal.ip Mappé à partir du journal des modifications
"details.client_ip" event.idm.read_only_udm.principal.ip Mappé à partir du journal des modifications
"details.from_address" event.idm.read_only_udm.principal.asset.ip Mappé à partir du journal des modifications
"details.client_ip" event.idm.read_only_udm.principal.asset.ip Mappé à partir du journal des modifications
"details.type" event.idm.read_only_udm.metadata.product_event_type Mappé à partir du journal des modifications
"details.actor.status" event.idm.read_only_udm.principal.user.attribute.labels Mappé à partir du journal des modifications
"details.actor.user_type" event.idm.read_only_udm.principal.user.attribute.labels Mappé à partir du journal des modifications
"details.session_type" event.idm.read_only_udm.extensions.auth.auth_details Mappé à partir du journal des modifications
"details.actor.name" event.idm.read_only_udm.principal.user.userid Mappé à partir du journal des modifications
"details.unix_user_name" event.idm.read_only_udm.principal.user.userid Mappé à partir du journal des modifications
"details.actor.details.full_name" event.idm.read_only_udm.principal.user.user_display_name Mappé à partir du journal des modifications
"details.actor.details.first_name" event.idm.read_only_udm.principal.user.first_name Mappé à partir du journal des modifications
"details.actor.details.last_name" event.idm.read_only_udm.principal.user.last_name Mappé à partir du journal des modifications
"details.actor.id" event.idm.read_only_udm.principal.user.employee_id Mappé à partir du journal des modifications
"details.actor.team_name" event.idm.read_only_udm.principal.user.department Mappé à partir du journal des modifications
"details.client.hostname" event.idm.read_only_udm.principal.hostname Mappé à partir du journal des modifications
"details.client.hostname" event.idm.read_only_udm.principal.asset.hostname Mappé à partir du journal des modifications
"details.client.id" event.idm.read_only_udm.principal.user.product_object_id Mappé à partir du journal des modifications
"details.client.description" event.idm.read_only_udm.principal.application Mappé à partir du journal des modifications
"details.client.os" event.idm.read_only_udm.principal.platform Mappé à partir du journal des modifications
"details_client_os" event.idm.read_only_udm.principal.platform_version Mappé à partir du journal des modifications
"details.actor.details.email" event.idm.read_only_udm.principal.user.email_addresses Mappé à partir du journal des modifications
"details.team_id" event.idm.read_only_udm.target.resource.id Mappé à partir du journal des modifications
"details.project.id" event.idm.read_only_udm.target.resource.id Mappé à partir du journal des modifications
"details.team_name" event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
"details.client.state" event.idm.read_only_udm.principal.resource.attribute.labels Mappé à partir du journal des modifications
"details.target_server" event.idm.read_only_udm.target.application Mappé à partir du journal des modifications
"details.via" event.idm.read_only_udm.network.session_id Mappé à partir du journal des modifications
"details.trace_id" event.idm.read_only_udm.network.session_id Mappé à partir du journal des modifications
"details_session_type" event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
"details.ssh_public_key" event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
"details.actor.details.user_type" event.idm.read_only_udm.principal.user.attribute.roles Mappé à partir du journal des modifications
"details.project.name" event.idm.read_only_udm.target.resource.name Mappé à partir du journal des modifications
"details.server.id" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.server.state" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.team" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.create_server_users" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.force_shared_ssh_users" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.forward_traffic" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.next_unix_gid" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.next_unix_uid" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.rdp_session_recording" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.require_preauth_for_creds" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.ssh_certificate_type" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.project.ssh_session_recording" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"serverhostname" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"alt_name" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.ssh_key_fingerprint" event.idm.read_only_udm.target.resource.attribute.labels Mappé à partir du journal des modifications
"details.server.os" event.idm.read_only_udm.target.platform_version Mappé à partir du journal des modifications
"detailsserver.os" event.idm.read_only_udm.target.platform_version Mappé à partir du journal des modifications
"details.server.os_type" event.idm.read_only_udm.target.platform Mappé à partir du journal des modifications
"detailsserver.os_type" event.idm.read_only_udm.target.platform Mappé à partir du journal des modifications
"details_team_id" event.idm.read_only_udm.principal.resource.id Mappé à partir du journal des modifications
"details.client.encrypted" event.idm.read_only_udm.principal.asset.attribute.labels Mappé à partir du journal des modifications
"details.client.user_name" event.idm.read_only_udm.target.user.userid Mappé à partir du journal des modifications
"timestamp" event.idm.read_only_udm.metadata.event_timestamp Mappé à partir du journal des modifications
"serverhostname" event.idm.read_only_udm.target.hostname Mappé à partir du journal des modifications
"alt_name" event.idm.read_only_udm.target.hostname Mappé à partir du journal des modifications
"alt_name" event.idm.read_only_udm.target.asset.hostname Mappé à partir du journal des modifications
"intermediary" event.idm.read_only_udm.intermediary Mappé à partir du journal des modifications
"intermediary_value" event.idm.read_only_udm.intermediary Mappé à partir du journal des modifications
"detailsserver.sftd_version" event.idm.read_only_udm.metadata.product_version Mappé à partir du journal des modifications
"details.server.sftd_version" event.idm.read_only_udm.metadata.product_version Mappé à partir du journal des modifications
"detailsserver.state" event.idm.read_only_udm.target.asset.attribute.labels Mappé à partir du journal des modifications
"detailsserver.managed" event.idm.read_only_udm.target.asset.attribute.labels Mappé à partir du journal des modifications
"detailsserver.ssh_key_fingerprint" event.idm.read_only_udm.target.asset.attribute.labels Mappé à partir du journal des modifications
"details.username" event.idm.read_only_udm.target.user.user_display_name Mappé à partir du journal des modifications
"details.ssh_algorithm" event.idm.read_only_udm.network.tls.cipher Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications de ce parseur

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