Collecter les journaux d'activité SentinelOne

Compatible avec :

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

SentinelOne Singularity est une plate-forme autonome de protection des points de terminaison qui fournit des fonctionnalités de prévention, de détection et de réponse en temps réel sur les points de terminaison, les charges de travail cloud et les appareils IoT. Le journal d'activité capture les événements administratifs et opérationnels de votre environnement SentinelOne, y compris les connexions des utilisateurs, les modifications de règles, les actions de gestion des menaces, les installations d'agents et les modifications de configuration du système. Ces journaux d'activité peuvent être exportés via l'API REST SentinelOne et écrits dans un bucket GCS pour être ingérés par Google SecOps.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations de créer et de gérer des buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Une console de gestion SentinelOne Singularity avec accès à l'API
  • Un compte utilisateur de service SentinelOne avec le rôle Lecteur ou un rôle supérieur

Générer un jeton d'API SentinelOne

  1. Connectez-vous à votre console de gestion SentinelOne à l'adresse https://<your-management-url>.sentinelone.net.
  2. Accédez à Settings > Users > Service Users (Paramètres > Utilisateurs > Utilisateurs du service).
  3. Cliquez sur Actions > Create New Service User (Actions > Créer un utilisateur de service).
  4. Fournissez les informations de configuration suivantes :
    • Nom : saisissez un nom descriptif (par exemple, SIEM Activity Log Integration).
    • Date d'expiration : définissez une date d'expiration ou conservez la valeur par défaut.
    • Niveau d'accès : sélectionnez le niveau d'accès approprié (Compte ou Site).
    • Rôle : sélectionnez Lecteur (minimum requis pour lire les journaux d'activité).
  5. Cliquez sur Créer un utilisateur.
  6. Une boîte de dialogue affiche le jeton d'API.
  7. Copiez et enregistrez le jeton d'API de manière sécurisée.

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

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

    S1_BASE_URL="https://your-management-url.sentinelone.net"
S1_API_TOKEN="your-api-token"

curl -s -X GET "${S1_BASE_URL}/web/api/v2.1/activities?limit=2" \
    -H "Authorization: ApiToken ${S1_API_TOKEN}" \
    | python3 -m json.tool

  • Une réponse réussie renvoie un objet JSON avec un tableau data contenant des enregistrements d'activité et un objet pagination :

    {
    "data": [
        {
            "id": "123456789",
            "activityType": 27,
            "activityUuid": "a2c8037c-e6df-436d-b92b-bc09a418717e",
            "createdAt": "2026-03-29T10:30:00.000000Z",
            "primaryDescription": "User logged in",
            "accountId": "123456",
            "accountName": "My Account",
            "siteId": "789012",
            "data": {}
        }
    ],
    "pagination": {
        "nextCursor": "eyJpZCI6...",
        "totalItems": 1500
    }
}

Si vous rencontrez ce type d'erreur :

  • HTTP 401 (Non autorisé) : vérifiez que le jeton d'API est correct et qu'il n'a pas expiré.
  • HTTP 403 (Interdit) : vérifiez que l'utilisateur du service dispose du champ d'application et du rôle appropriés.

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, sentinelone-activity-logs).
    Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux fréquemment consultés)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions d'objets ou la règle de conservation.

  6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service autorisé à écrire dans le bucket GCS et à être appelée par Pub/Sub.

Créer un compte de service

  1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez s1-activity-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect SentinelOne Activity logs.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets Storage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. Cliquez sur OK.

Ces rôles sont requis pour :

  • Administrateur des objets de l'espace de stockage : écrire des journaux dans un bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction.
  • Demandeur Cloud Functions : autorise l'appel de fonctions.

Accorder des autorisations IAM sur le bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, s1-activity-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
  6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub dans lequel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Créer un sujet.
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez s1-activity-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 récupérer les journaux d'activité de l'API REST SentinelOne 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 s1-activity-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, choisissez le sujet s1-activity-trigger.
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Vérifiez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

  8. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service s1-activity-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 sentinelone-activity-logs Nom du bucket GCS
    GCS_PREFIX sentinelone-activities Préfixe des fichiers journaux
    STATE_KEY sentinelone-activities/state.json Chemin d'accès au fichier d'état
    S1_BASE_URL https://your-mgmt-url.sentinelone.net URL de la console de gestion SentinelOne
    S1_API_TOKEN your-api-token Jeton d'API SentinelOne
    PAGE_SIZE 1000 Enregistrements par page d'API (1 000 max.)
    MAX_RECORDS 50000 Nombre maximal d'enregistrements par exécution
    LOOKBACK_HOURS 2 Période d'analyse initiale

  10. Faites défiler la section Variables et secrets vers le bas jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 540 secondes (9 minutes).

  11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • Processeur : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (une à deux minutes).

  15. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

  1. Saisissez main dans 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=60.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', 'sentinelone-activities').strip('/')
STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
S1_BASE_URL = os.environ.get('S1_BASE_URL', '').rstrip('/')
S1_API_TOKEN = os.environ.get('S1_API_TOKEN')
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '50000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '2'))

ACTIVITIES_ENDPOINT = '/web/api/v2.1/activities'

def parse_datetime(value):
  """Parse ISO datetime string to datetime object."""
  if not value:
    return None
  if value.endswith("Z"):
    value = value[:-1] + "+00:00"
  try:
    return datetime.fromisoformat(value)
  except Exception:
    try:
      return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')
    except Exception:
      return None

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch
  SentinelOne Activity records and write to GCS.

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

  if not all([GCS_BUCKET, S1_BASE_URL, S1_API_TOKEN]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)

    # Load state
    state = load_state(bucket, STATE_KEY)

    # Determine time window
    now = datetime.now(timezone.utc)
    last_time = None

    if isinstance(state, dict) and state.get("last_event_time"):
      try:
        last_time = parse_datetime(state["last_event_time"])
        # Overlap by 2 minutes to catch delayed events
        if last_time:
          last_time = last_time - timedelta(minutes=2)
      except Exception as e:
        print(f"Warning: Could not parse last_event_time: {e}")

    if last_time is None:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

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

    # Fetch activity logs
    records, newest_event_time = fetch_activity_logs(
      start_time=last_time,
      end_time=now,
    )

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

    # Write to GCS as NDJSON
    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/logs_{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 "
      f"gs://{GCS_BUCKET}/{object_key}"
    )

    # Update state
    if newest_event_time:
      save_state(bucket, STATE_KEY, newest_event_time)
    else:
      save_state(bucket, STATE_KEY, now.isoformat())

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

  except Exception as e:
    print(f'Error processing activity 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, last_event_time_iso):
  """Save the last event timestamp to GCS state file."""
  try:
    state = {'last_event_time': last_event_time_iso}
    blob = bucket.blob(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_logs(start_time, end_time):
  """
  Fetch activity logs from SentinelOne REST API with
  cursor-based pagination.

  Args:
    start_time: Start time for log query
    end_time: End time for log query

  Returns:
    Tuple of (records list, newest_event_time ISO string)
  """
  url = f"{S1_BASE_URL}{ACTIVITIES_ENDPOINT}"
  headers = {
    'Authorization': f'ApiToken {S1_API_TOKEN}',
    'Content-Type': 'application/json',
  }

  # Format timestamps for SentinelOne API
  start_str = start_time.strftime('%Y-%m-%dT%H:%M:%S.000000Z')

  records = []
  newest_time = None
  cursor = None
  backoff = 1.0

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

    params = {
      'createdAt__gt': start_str,
      'limit': str(PAGE_SIZE),
      'sortBy': 'createdAt',
      'sortOrder': 'asc',
    }

    if cursor:
      params['cursor'] = cursor

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

      # Handle rate limiting with exponential backoff
      if response.status == 429:
        retry_after = int(
          response.headers.get(
            'Retry-After', str(int(backoff))
          )
        )
        print(
          f"Rate limited (429). "
          f"Retrying after {retry_after}s..."
        )
        time.sleep(retry_after)
        backoff = min(backoff * 2, 30.0)
        continue

      # Handle token expiry
      if response.status == 401:
        print(
          "API token is invalid or expired. "
          "Generate a new token in SentinelOne console."
        )
        return records, newest_time

      backoff = 1.0

      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, newest_time

      data = json.loads(response.data.decode('utf-8'))
      result = data.get('data', [])
      pagination = data.get('pagination', {})
      total_items = pagination.get('totalItems', 0)
      next_cursor = pagination.get('nextCursor')

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

      print(
        f"Retrieved {len(result)} events "
        f"(total: {total_items})"
      )
      records.extend(result)

      # Track newest event time
      for event in result:
        try:
          event_time = event.get('createdAt')
          if event_time:
            if newest_time is None:
              newest_time = event_time
            else:
              current_dt = parse_datetime(event_time)
              newest_dt = parse_datetime(newest_time)
              if (
                current_dt and newest_dt
                and current_dt > newest_dt
              ):
                newest_time = event_time
        except Exception as e:
          print(
            f"Warning: Could not parse "
            f"event time: {e}"
          )

      # Check pagination
      if not next_cursor:
        print("Reached last page")
        break

      cursor = next_cursor

    except Exception as e:
      print(f"Error fetching activity logs: {e}")
      return records, newest_time

  print(f"Retrieved {len(records)} total activity records")
  return records, newest_time

    • 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 publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera la fonction Cloud Run.

  1. Dans la console GCP, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom s1-activity-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électionnez le sujet s1-activity-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 10 minutes */10 * * * * Volume élevé, en temps quasi réel
Toutes les heures 0 * * * * Standard (recommandé)
Toutes les 2 heures 0 */2 * * * Baisser le volume

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Forcer l'exécution pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de la fonction s1-activity-collector.
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction a bien été exécutée. Par exemple :

    Fetching activity logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Retrieved X events (total: Y)
Wrote X records to gs://sentinelone-activity-logs/sentinelone-activities/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

  10. Accédez au dossier de préfixe sentinelone-activities/.

  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 400 : vérifiez que l'URL de la console de gestion SentinelOne ne se termine pas par une barre oblique. Vérifiez que les paramètres de requête sont corrects.
  • HTTP 401 : le jeton d'API n'est pas valide ou a expiré. Générez un nouveau jeton dans la console SentinelOne sous Settings > Users > Service Users (Paramètres > Utilisateurs > Utilisateurs du service).
  • HTTP 403 : l'utilisateur du service ne dispose pas des autorisations suffisantes. Vérifiez le rôle et le niveau du champ d'application.
  • HTTP 429 : limitation du débit. La fonction effectue 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.

Configurer un flux dans Google SecOps pour ingérer les journaux d'activité SentinelOne

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, SentinelOne Activity Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Sentinelone Activity comme Type de journal.

  7. Cliquez sur Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique s'affiche, par exemple :

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

  8. Copiez cette adresse e-mail 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 du préfixe :

      gs://sentinelone-activity-logs/sentinelone-activities/
      • Remplacez :
        • sentinelone-activity-logs : nom de votre bucket GCS.
        • sentinelone-activities : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laissez ce champ vide pour la racine).

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais les fichiers après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides une fois le transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • Espace de noms de l'élément : espace de noms de l'élément

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  11. Cliquez sur Suivant.

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

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps doit disposer du rôle Lecteur des objets Storage sur votre bucket GCS.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  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
deviceNtDomain about.administrative_domain Renommé/Mappé
deviceExternalId about.asset.asset_id Mappage direct
device_product about.asset.asset_id Mappage direct
device_vendor about.asset.asset_id Mappage direct
fileHash about.file.full_path Mappage direct
filePath about.file.full_path Renommé/Mappé
_hash about.file.sha256 Renommé/Mappé
fileHash about.file.sha256 Renommé/Mappé
fsize about.file.size Renommé/Mappé
dvchost about.hostname Renommé/Mappé
ips about.ip Fusionné
dvc_mac about.mac Mappé : slot → mac_address
dvcmac about.mac Fusionné
mac_address about.mac Fusionné
deviceTranslatedAddress about.nat_ip Fusionné
Emne about.process.command_line Mappage direct
Path about.process.command_line Mappage direct
Subject about.process.command_line Mappage direct
deviceProcessName about.process.command_line Renommé/Mappé
dvcpid about.process.pid Renommé/Mappé
permissions about.resource.attribute.permissions Fusionné
additional_cfp1 additional.fields Fusionné
additional_cfp2 additional.fields Fusionné
additional_cfp3 additional.fields Fusionné
additional_cfp4 additional.fields Fusionné
additional_cn1 additional.fields Fusionné
additional_cn2 additional.fields Fusionné
additional_cn3 additional.fields Fusionné
additional_cs1 additional.fields Fusionné
additional_cs2 additional.fields Fusionné
additional_cs3 additional.fields Fusionné
additional_cs4 additional.fields Fusionné
additional_cs5 additional.fields Fusionné
additional_cs6 additional.fields Fusionné
additional_cs7 additional.fields Fusionné
additional_devicePayloadId additional.fields Fusionné
additional_eventId additional.fields Fusionné
additional_flexString1 additional.fields Fusionné
additional_fname additional.fields Fusionné
cs2 additional.fields Mappé : arc_test → additional_cs2
cs5_label additional.fields Fusionné
source_type_label additional.fields Fusionné
has_user extensions.auth.type Mappé : true → AUTHTYPE_UNSPECIFIED
event_name metadata.description Mappage direct
msg metadata.description Renommé/Mappé
primaryDescription metadata.description Mappage direct
Generated metadata.event_timestamp Analysé en tant que yyyy-MM-ddTHH:mm:ss
Received metadata.event_timestamp Analysé en tant que yyyy-MM-ddTHH:mm:ss
createdAt metadata.event_timestamp Analysé en tant que ISO8601
rt metadata.event_timestamp Analysé en tant que (EEE,ddMMMyyyy,HH:mm:ss)
updatedAt metadata.event_timestamp Analysé en tant que ISO8601
event_name metadata.event_type Mappé : "LogSpyware","LogPredictiveMachineLearning" → SCAN_UNCATEGORIZED
has_principal metadata.event_type Mappé : true → NETWORK_CONNECTION, true → STATUS_UPDATE
has_user metadata.event_type Mappé : true → USER_LOGIN
activityType metadata.product_event_type Mappage direct
device_event_class_id metadata.product_event_type Mappage direct
event_name metadata.product_event_type Mappage direct
activityID metadata.product_log_id Mappage direct
activityUuid metadata.product_log_id Mappage direct
externalId metadata.product_log_id Mappage direct
device_product metadata.product_name Mappage direct
device_version metadata.product_version Mappage direct
device_vendor metadata.vendor_name Renommé/Mappé
app_protocol_output network.application_protocol Mappage direct
deviceDirection network.direction Mappé : 0 → INBOUND, 1 → OUTBOUND
requestMethod network.http.method Renommé/Mappé
requestClientApplication network.http.user_agent Renommé/Mappé
ip_protocol_out network.ip_protocol Mappage direct
in network.received_bytes Renommé/Mappé
out network.sent_bytes Renommé/Mappé
sntdom principal.administrative_domain Renommé/Mappé
sourceServiceName principal.application Renommé/Mappé
data.ipAddress principal.asset.ip Fusionné
Group_name principal.group.group_display_name Mappage direct
Gruppenavn principal.group.group_display_name Mappage direct
Device_name principal.hostname Mappage direct
Enhetsnavn principal.hostname Mappage direct
shost principal.hostname Renommé/Mappé
data.ipAddress principal.ip Fusionné
principal_ip principal.ip Fusionné
shost principal.ip Fusionné
mac principal.mac Fusionné
sourceTranslatedAddress principal.nat_ip Fusionné
sourceTranslatedPort principal.nat_port Renommé/Mappé
spt principal.port Renommé/Mappé
data.sourceprocesscommandline principal.process.command_line Mappage direct
sproc principal.process.command_line Renommé/Mappé
data.sourceprocessname principal.process.file.names Fusionné
spid principal.process.pid Renommé/Mappé
principal_role principal.user.attribute.roles Fusionné
suser principal.user.user_display_name Mappage direct
suid principal.user.userid Renommé/Mappé
sec_result security_result Fusionné
_action security_result.action Fusionné
act security_result.action Mappé : accept → _action, deny → _action
Action_Taken security_result.action_details Mappage direct
act security_result.action_details Mappage direct
cat security_result.category_details Fusionné
Scan_Type security_result.description Mappage direct
Type security_result.description Mappage direct
msg_data_2 security_result.description Mappage direct
infection_channel_label security_result.detection_fields Fusionné
operasjon_label security_result.detection_fields Fusionné
operation_label security_result.detection_fields Fusionné
permission_label security_result.detection_fields Fusionné
spyware_Grayware_Type_label security_result.detection_fields Fusionné
threat_probability_label security_result.detection_fields Fusionné
tillatelse_label security_result.detection_fields Fusionné
mwProfile security_result.rule_name Mappage direct
severity security_result.severity Mappé : "0", "1", "2", "3", "LOW" → LOW, `"4", "5", "6", "MEDIUM", "SUBSTANTIAL", "INFO"...
Result security_result.summary Mappage direct
appcategory security_result.summary Mappage direct
reason security_result.summary Renommé/Mappé
Spyware security_result.threat_name Mappage direct
Unknown_Threat security_result.threat_name Mappage direct
Virus_Malware_Name security_result.threat_name Mappage direct
oldFilePath src.file.full_path Renommé/Mappé
oldFileSize src.file.size Renommé/Mappé
old_permissions src.resource.attribute.permissions Fusionné
dntdom target.administrative_domain Renommé/Mappé
destinationServiceName target.application Renommé/Mappé
agentId target.asset.asset_id Mappage direct
data.computerName target.asset.hostname Mappage direct
data.newGroupName target.group.group_display_name Mappage direct
data.newGroupId target.group.product_object_id Mappage direct
data.computerName target.hostname Mappage direct
temp_dhost target.hostname Mappage direct
IPv6_Address target.ip Fusionné
dst_ip target.ip Fusionné
ipv6 target.ip Mappé : - → IPv6_Address
data.siteName target.location.name Mappage direct
siteName target.location.name Mappage direct
mac_address target.mac Fusionné
accountName target.namespace Mappage direct
destination_translated_address target.nat_ip Fusionné
destinationTranslatedPort target.nat_port Renommé/Mappé
dpt target.port Renommé/Mappé
dproc target.process.command_line Renommé/Mappé
File_name target.process.file.full_path Mappage direct
Infected_Resource target.process.file.full_path Mappage direct
Object target.process.file.full_path Mappage direct
Objekt target.process.file.full_path Mappage direct
dpid target.process.pid Renommé/Mappé
full_scope_details_label target.resource.attribute.labels Fusionné
notification_scope_label target.resource.attribute.labels Fusionné
resource_Type_label target.resource.attribute.labels Fusionné
scope_level_label target.resource.attribute.labels Fusionné
site_id_label target.resource.attribute.labels Fusionné
vendor_activity_id_label target.resource.attribute.labels Fusionné
request target.url Mappage direct
target_role target.user.attribute.roles Fusionné
CustomerName target.user.user_display_name Mappage direct
data.accountName target.user.user_display_name Mappage direct
temp_duser target.user.user_display_name Mappage direct
Bruker target.user.userid Mappage direct
User_value target.user.userid Mappage direct
accountId target.user.userid Mappage direct
temp_duid target.user.userid Mappage direct
N/A extensions.auth.type Constante : AUTHTYPE_UNSPECIFIED
N/A metadata.event_type Constante : PROCESS_UNCATEGORIZED
N/A metadata.vendor_name Constante : SentinelOne
N/A network.direction Constante : INBOUND
N/A security_result.severity Constante : LOW
createdAt event.idm.read_only_udm.metadata.event_timestamp Mappé à partir du journal des modifications
updatedAt event.idm.read_only_udm.security_result.last_updated_time Mappé à partir du journal des modifications
activityUuid event.idm.read_only_udm.metadata.product_log_id Mappé à partir du journal des modifications
activityID event.idm.read_only_udm.metadata.product_log_id Mappé à partir du journal des modifications
primaryDescription event.idm.read_only_udm.metadata.description Mappé à partir du journal des modifications
rt event.idm.read_only_udm.metadata.event_timestamp Mappé à partir du journal des modifications
activityType event.idm.read_only_udm.metadata.product_event_type Mappé à partir du journal des modifications
device_product event.idm.read_only_udm.metadata.product_name Mappé à partir du journal des modifications
data.ipAddress event.idm.read_only_udm.principal.ip Mappé à partir du journal des modifications
data.ipAddress event.idm.read_only_udm.principal.asset.ip Mappé à partir du journal des modifications
data.sourceprocesscommandline event.idm.read_only_udm.principal.process.command_line Mappé à partir du journal des modifications
data.sourceprocessname event.idm.read_only_udm.principal.process.file.names Mappé à partir du journal des modifications
agentId event.idm.read_only_udm.target.asset.asset_id Mappé à partir du journal des modifications
data.computerName event.idm.read_only_udm.target.hostname Mappé à partir du journal des modifications
data.computerName event.idm.read_only_udm.target.asset.hostname Mappé à partir du journal des modifications
accountName event.idm.read_only_udm.target.namespace Mappé à partir du journal des modifications
siteName, event.idm.read_only_udm.target.location.name Mappé à partir du journal des modifications
accountId event.idm.read_only_udm.target.user.userid Mappé à partir du journal des modifications
data.accountName event.idm.read_only_udm.target.user.user_display_name Mappé à partir du journal des modifications
data.newGroupId event.idm.read_only_udm.target.group.product_object_id Mappé à partir du journal des modifications
data.newGroupName event.idm.read_only_udm.target.group.group_display_name Mappé à partir du journal des modifications
data.sourceType event.idm.read_only_udm.additional.fields Mappé à partir du journal des modifications
data.alertid event.idm.read_only_udm.security_result.rule_id Mappé à partir du journal des modifications
data.ruledescription event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
data.oldGroupName event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
data.oldGroupId event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
data.newGroupId event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
data.newGroupName event.idm.read_only_udm.security_result.detection_fields Mappé à partir du journal des modifications
data.fullScopeDetails event.idm.read_only_udm.security_result.description Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications de cet analyseur

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