Collecter les journaux Netwrix Auditor

Compatible avec :

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

Netwrix Auditor est une plate-forme de visibilité pour l'analyse du comportement des utilisateurs et la réduction des risques. Elle permet de contrôler les modifications, les configurations et les accès dans les environnements informatiques hybrides. La plate-forme fournit des analyses de sécurité pour détecter les anomalies dans le comportement des utilisateurs et examiner les schémas de menace avant qu'une violation de données ne se produise. Grâce à une API d'intégration RESTful, la plate-forme offre une visibilité et un contrôle unifiés sur tous vos systèmes informatiques sur site ou dans le cloud.

Avant de commencer

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

  • Une instance Google SecOps
  • Un projet GCP avec les API Cloud Storage, Cloud Run, Pub/Sub et Cloud Scheduler activées
  • 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
  • Accès administrateur au serveur Netwrix Auditor
  • Un compte de domaine Windows disposant des autorisations appropriées pour l'accès à l'API
  • Serveur Netwrix Auditor avec l'API d'intégration activée (activée par défaut)
  • Base de données d'audit configurée dans Netwrix Auditor
  • Connectivité réseau entre la fonction Cloud Run et le serveur Netwrix Auditor sur le port 9699 (par défaut)

Configurer l'accès à l'API Netwrix Auditor

Pour permettre à la fonction Cloud Run de récupérer les enregistrements d'activité, vous devez vérifier que l'API Integration est activée et créer un compte de domaine Windows avec le rôle approprié dans Netwrix Auditor.

Vérifier que l'API Integration est activée

  1. Sur l'ordinateur sur lequel Netwrix Auditor Server est installé, lancez Netwrix Auditor.
  2. Accédez à Paramètres > Intégrations.
  3. Vérifiez que l'option Exploiter l'API d'intégration est activée.
  4. Notez le numéro de port (9699 par défaut).

  5. Si vous devez modifier le port :

    1. Cliquez sur Modifier dans la section Paramètres de l'API.
    2. Spécifiez un nouveau numéro de port.
    3. Cliquez sur OK.

Créer un compte de service pour accéder à l'API

  1. Sur votre contrôleur de domaine Windows, ouvrez Utilisateurs et ordinateurs Active Directory.
  2. Accédez à l'unité organisationnelle dans laquelle vous souhaitez créer le compte de service.
  3. Effectuez un clic droit sur l'unité organisationnelle > Nouveau > Utilisateur.
  4. Dans le champ Prénom, saisissez Chronicle Integration.
  5. Dans le champ Nom d'ouverture de session de l'utilisateur, saisissez chronicle-api (ou le nom d'utilisateur de votre choix).
  6. Cliquez sur Suivant.
  7. Saisissez un mot de passe sécurisé et configurez les paramètres de mot de passe conformément aux règles de votre organisation.
  8. Décochez la case L'utilisateur doit changer le mot de passe à la prochaine ouverture de session.
  9. Sélectionnez Le mot de passe n'expire jamais (recommandé pour les comptes de service).
  10. Cliquez sur Suivant > Terminer.

Attribuer le rôle d'examinateur global

  1. Dans la fenêtre principale de Netwrix Auditor, accédez à Monitoring Plans (Plans de surveillance).
  2. Dans l'arborescence des plans de surveillance, sélectionnez Tous les plans de surveillance (dossier racine).
  3. Cliquez sur Déléguer.
  4. Dans la boîte de dialogue Délégation, cliquez sur Ajouter un utilisateur.
  5. Dans la boîte de dialogue Sélectionner un utilisateur ou un groupe :
    1. Cliquez sur Parcourir.
    2. Dans le champ Entrez le nom de l'objet à sélectionner, saisissez le nom d'utilisateur chronicle-api.
    3. Cliquez sur Vérifier les noms pour valider le compte.
    4. Cliquez sur OK.
  6. Dans le menu déroulant Rôle, sélectionnez Réviseur mondial.
  7. Cliquez sur OK.

  8. Cliquez sur Enregistrer.

Enregistrer les identifiants de l'API

Notez les informations suivantes pour configurer les variables d'environnement de la fonction Cloud Run :

  • Nom d'utilisateur : compte de domaine au format DOMAIN\username (par exemple, ENTERPRISE\chronicle-api)
  • Mot de passe : mot de passe du compte de service
  • Nom d'hôte : nom de domaine complet (FQDN) ou adresse IP du serveur Netwrix Auditor (par exemple, auditor.enterprise.local ou 172.28.6.15)

  • Port : port de l'API Integration (9699 par défaut)

Vérifier les autorisations

Pour vérifier que le compte dispose des autorisations requises :

  1. Dans Netwrix Auditor, accédez à Monitoring Plans (Plans de surveillance).
  2. Sélectionnez Tous les forfaits de surveillance.
  3. Cliquez sur Déléguer.
  4. Vérifiez que le compte chronicle-api apparaît avec le rôle Examinateur général.
  5. Si le compte n'apparaît pas, suivez la procédure Attribuer le rôle d'examinateur global ci-dessus.

Tester l'accès à l'API

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

    # Replace with your actual values
NETWRIX_HOST="auditor.enterprise.local"
NETWRIX_PORT="9699"
NETWRIX_USER="ENTERPRISE\\chronicle-api"
NETWRIX_PASS="your-password"

# Test API access (retrieve first batch of activity records)
curl -k --ntlm -u "${NETWRIX_USER}:${NETWRIX_PASS}" \
    "https://${NETWRIX_HOST}:${NETWRIX_PORT}/netwrix/api/v1/activity_records/enum" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

Une réponse réussie renvoie un objet JSON contenant un tableau d'enregistrements d'activité et un ContinuationMark pour la pagination.

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, netwrix-auditor-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.

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

Accorder des autorisations IAM sur un bucket GCS

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (netwrix-auditor-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 (netwrix-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 sujet : saisissez netwrix-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 les messages Pub/Sub de Cloud Scheduler pour extraire les enregistrements d'activité de l'API d'intégration Netwrix Auditor 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 netwrix-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 netwrix-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 netwrix-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 netwrix-auditor-logs Nom du bucket GCS
    GCS_PREFIX netwrix-audit Préfixe des fichiers journaux
    STATE_KEY netwrix-audit/state.json Chemin d'accès au fichier d'état
    NETWRIX_HOST auditor.enterprise.local Nom de domaine complet ou adresse IP du serveur Netwrix Auditor
    NETWRIX_PORT 9699 Port de l'API d'intégration
    NETWRIX_USER ENTERPRISE\chronicle-api Compte de domaine au format DOMAINE\nom d'utilisateur
    NETWRIX_PASS your-password Mot de passe du compte de service
    MAX_RECORDS 10000 Nombre maximal d'enregistrements par exécution
    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éé (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 :

    • main.py:
    import functions_framework
from google.cloud import storage
import json
import os
import requests
from requests_ntlm import HttpNtlmAuth
from datetime import datetime, timezone, timedelta
import time
import urllib3

# Suppress insecure HTTPS warnings for self-signed certificates
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'netwrix-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'netwrix-audit/state.json')
NETWRIX_HOST = os.environ.get('NETWRIX_HOST')
NETWRIX_PORT = os.environ.get('NETWRIX_PORT', '9699')
NETWRIX_USER = os.environ.get('NETWRIX_USER')
NETWRIX_PASS = os.environ.get('NETWRIX_PASS')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

def parse_datetime(value):
  """Parse ISO 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 Netwrix Auditor
  activity records and write to GCS.

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

  if not all([GCS_BUCKET, NETWRIX_HOST, NETWRIX_USER, NETWRIX_PASS]):
    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_time = parse_datetime(state['last_event_time'])
        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 activity records from {last_time.isoformat()} "
        f"to {now.isoformat()}")

    records, newest_event_time = fetch_activity_records(
      last_time, now
    )

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

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

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

    print(f"Wrote {len(records)} records to "
        f"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)} records")

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

def load_state(bucket):
  """Load state from GCS."""
  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):
  """Save the last event timestamp to GCS state file."""
  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 fetch_activity_records(start_time, end_time):
  """
  Fetch activity records from Netwrix Auditor Integration API
  using the enum endpoint with continuation mark pagination.

  The API returns up to 1000 records per request. Subsequent
  requests include the ContinuationMark from the previous
  response to retrieve the next batch.

  Args:
    start_time: Start time for filtering records
    end_time: End time for filtering records

  Returns:
    Tuple of (records list, newest_event_time ISO string)
  """
  base_url = (
    f"https://{NETWRIX_HOST}:{NETWRIX_PORT}"
    f"/netwrix/api/v1/activity_records/enum"
  )
  auth = HttpNtlmAuth(NETWRIX_USER, NETWRIX_PASS)
  session = requests.Session()
  session.auth = auth
  session.verify = False
  session.headers.update({
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'User-Agent': 'GoogleSecOps-NetwrixCollector/1.0'
  })

  all_records = []
  newest_time = None
  continuation_mark = None
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

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

    try:
      if continuation_mark:
        response = session.post(
          base_url,
          json={"ContinuationMark": continuation_mark},
          timeout=(10, 60)
        )
      else:
        response = session.get(
          base_url,
          timeout=(10, 60)
        )

      if response.status_code == 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, 30.0)
        continue

      backoff = 1.0

      if response.status_code != 200:
        print(f"HTTP Error: {response.status_code}")
        print(f"Response body: {response.text}")
        return all_records, newest_time

      data = response.json()

      page_results = data.get('ActivityRecordList', [])
      continuation_mark = data.get('ContinuationMark')

      if not page_results:
        print("No more activity records (empty page)")
        break

      # Filter records by time window
      filtered = []
      for record in page_results:
        when = record.get('When')
        if when:
          try:
            record_time = parse_datetime(when)
            if start_time <= record_time <= end_time:
              filtered.append(record)
            if (newest_time is None or
                record_time >
                parse_datetime(newest_time)):
              newest_time = when
          except Exception as e:
            print(f"Warning: Could not parse "
                f"record time: {e}")
            filtered.append(record)
        else:
          filtered.append(record)

      print(f"Page {page_num}: Retrieved "
          f"{len(page_results)} records, "
          f"{len(filtered)} within time window")
      all_records.extend(filtered)

      if not continuation_mark:
        print("No more pages (no ContinuationMark)")
        break

    except requests.exceptions.Timeout:
      print(f"Request timeout on page {page_num}")
      return all_records, newest_time
    except Exception as e:
      print(f"Error fetching activity records: {e}")
      return all_records, newest_time

  print(f"Retrieved {len(all_records)} total records "
      f"from {page_num} pages")
  return all_records, newest_time
    • requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
requests>=2.31.0
requests-ntlm>=1.2.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 netwrix-audit-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 netwrix-audit-trigger
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de planification

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

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

Tester l'intégration

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

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

    Fetching activity records from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X records, X within time window
Wrote X records to gs://netwrix-auditor-logs/netwrix-audit/netwrix_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur netwrix-auditor-logs.

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

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

Si vous constatez des erreurs dans les journaux :

  • HTTP 401 : vérifiez que les variables d'environnement NETWRIX_USER et NETWRIX_PASS sont correctes et utilisent le format DOMAIN\username.
  • HTTP 403 : vérifiez que le compte de service dispose du rôle Examinateur global dans Netwrix Auditor.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un intervalle exponentiel entre les tentatives.
  • Délai de connexion dépassé : vérifiez la connectivité réseau entre Cloud Run et le serveur Netwrix Auditor sur le port 9691. Assurez-vous qu'un connecteur VPC ou Cloud VPN est configuré si le serveur est sur site.
  • 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 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, Netwrix Auditor Activity Records).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Netwrix comme type de journal.
  7. Cliquez sur Obtenir un compte de service.

  8. Une adresse e-mail unique pour le compte de service 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://netwrix-auditor-logs/netwrix-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 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

  12. Cliquez sur Suivant.

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

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur netwrix-auditor-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
Opcode about.labels Libellés associés aux informations "À propos"
Légende about.resource.attribute.labels Libellés d'attributs pour la ressource dans la section "À propos"
Tâche additional.fields Champs supplémentaires contenant des informations supplémentaires sur l'événement
Quoi additional.fields
Notification additional.fields
Description additional.fields
Ajouté additional.fields
Supprimé additional.fields
service_type additional.fields
Détails additional.fields
extensions.auth.type extensions.auth.type Type d'authentification utilisé
EventReceivedTime metadata.collected_timestamp Code temporel indiquant quand l'événement a été collecté par le système
Message metadata.description Description de l'événement
event_type metadata.event_type Type d'événement
EventType metadata.product_event_type Type d'événement spécifique au produit
EventID metadata.product_log_id Identifiant de journal spécifique au produit
SourceModuleType observer.application Application ayant observé l'événement
Nom d'hôte principal.asset.hostname Nom d'hôte de l'élément associé au principal
Où principal.asset.hostname
Station de travail principal.asset.hostname
device_name principal.asset.hostname
Station de travail principal.hostname Nom d'hôte du compte principal
device_name principal.hostname
ProcessID principal.process.pid ID du processus du principal
Nom principal.resource.name Nom de la ressource associée au compte principal
Qui principal.user.user_display_name Nom à afficher de l'utilisateur
SourceName security_result.about.resource.attribute.labels Libellés des attributs de ressources pour la section "À propos" des résultats de sécurité
action security_result.action Action effectuée dans le résultat de sécurité
action_details security_result.action_details Détails de l'action dans le résultat de sécurité
backup_name security_result.description Description du résultat de sécurité
service_failed security_result.description
Mots clés security_result.detection_fields Champs utilisés pour la détection dans le résultat de sécurité
RecordNumber security_result.detection_fields
session_ID security_result.detection_fields
allow_connection_with_desktop security_result.detection_fields
service_account security_result.detection_fields
Gravité security_result.severity Niveau de gravité du résultat de sécurité
SeverityValue security_result.severity
résumé security_result.summary Résumé du résultat de sécurité
application_name target.application Application sur la cible
Nom d'hôte target.asset.hostname Nom d'hôte de l'élément associé à la cible
Où target.asset.hostname
file_path target.file.full_path Chemin d'accès complet au fichier cible
Taille target.file.size Taille du fichier cible
Nom d'hôte target.hostname Nom d'hôte de la cible
Où target.hostname
Type target.resource.attribute.labels Libellés d'attributs pour la ressource cible
SourceModuleName target.resource.name Nom de la ressource cible
DataSource metadata.product_name Nom du produit qui a généré l'événement
metadata.vendor_name metadata.vendor_name Nom du fournisseur

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