Collecter les journaux d'audit Slack

Compatible avec :

Google SecOps SIEM

Remarque : Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions spécifiques au service Google Security Operations. Les fonctionnalités pré-DG (avant disponibilité générale) sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les Instructions relatives aux services d'assistance technique Google SecOps et les Conditions spécifiques du service Google SecOps.

Ce document explique comment ingérer des journaux d'audit Slack dans Google Security Operations à l'aide de fonctions Google Cloud Run ou d'Amazon S3 avec AWS Lambda.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Forfait Slack Enterprise Grid avec accès propriétaire de l'organisation ou administrateur
• Un accès privilégié à l'un des éléments suivants :
  • Google Cloud (pour l'option 1 : Cloud Run Functions et Cloud Scheduler)
  • AWS (pour l'option 2 : S3, IAM, Lambda, EventBridge)

Remarque : L'API Slack Audit Logs n'est disponible que pour les organisations Enterprise Grid. Les espaces de travail Slack standards ne peuvent pas accéder à cette API.

Collecter les journaux d'audit Slack (ID d'application, jeton OAuth, ID d'organisation)

L'API Slack Audit Logs nécessite un jeton OAuth utilisateur avec le champ d'application auditlogs:read. Ce jeton doit être obtenu en installant une application au niveau de l'organisation Enterprise Grid, et non au niveau de l'espace de travail.

Créer une application Slack pour les journaux d'audit

1. Connectez-vous à la console d'administration Slack avec un compte propriétaire ou administrateur d'une organisation Enterprise Grid.
2. Accédez à https://api.slack.com/apps, puis cliquez sur Create New App > From scratch (Créer une application > À partir de zéro).
3. Fournissez les informations de configuration suivantes :
   • Nom de l'application : saisissez un nom descriptif (par exemple, Google SecOps Audit Integration).
   • Choisissez un espace de travail pour développer votre application : sélectionnez votre espace de travail Slack de développement (n'importe quel espace de travail de l'organisation).
4. Cliquez sur Créer une application.

Configurer les niveaux d'accès OAuth

1. Accédez à OAuth & Permissions (OAuth et autorisations) dans la barre latérale de gauche.
2. Accédez à la section Champs d'application.
3. Sous Champs d'application des jetons utilisateur (et NON "Champs d'application des jetons de bot"), cliquez sur Ajouter un champ d'application OAuth.
4. Ajoutez le champ d'application : auditlogs:read.

Remarque : Si vous rencontrez des problèmes d'installation lors des étapes ultérieures, vous devrez peut-être ajouter un champ d'application de bot de base (tel que users:read) pour activer l'installation au niveau de l'organisation.

Activer la distribution publique

1. Accédez à Gérer la distribution dans la barre latérale de gauche.
2. Sous Share Your App with Other Workspaces (Partager l'application avec d'autres espaces de travail), assurez-vous que les quatre sections sont cochées en vert :
   • Supprimer les informations codées en dur
   • Activer la distribution publique
   • Définir une URL de redirection
   • Ajouter une habilitation OAuth
3. Cliquez sur Activer la distribution publique.

Remarque : La distribution publique est requise pour les applications au niveau de l'organisation.

Installer une application dans une organisation Enterprise Grid

1. Accédez à OAuth & Permissions (OAuth et autorisations) dans la barre latérale de gauche.
2. Cliquez sur Installer dans l'organisation (et NON sur "Installer dans l'espace de travail").

CRITIQUE : Vérifiez le menu déroulant en haut à droite de l'écran d'installation pour vous assurer que vous installez l'application dans l'organisation Enterprise et non dans un espace de travail individuel.

1. Examinez les autorisations demandées, puis cliquez sur Autoriser.
2. Une fois l'autorisation terminée, vous serez redirigé vers la page OAuth et autorisations.

Récupérer les identifiants

1. Sous Jetons OAuth pour votre espace de travail, recherchez le jeton OAuth utilisateur.

2. Copiez et enregistrez de manière sécurisée le jeton qui commence par xoxp- (par exemple, xoxp-1234567890-0987654321-1234567890-abc123def456).

   Important : Il s'agit de votre SLACK_ADMIN_TOKEN pour la fonction Lambda ou Cloud Run. Conservez-le en lieu sûr.

3. Notez votre ID d'organisation :

   • Accédez à la console d'administration Slack.
   • Accédez à Paramètres et autorisations > Paramètres de l'organisation.
   • Copiez l'ID de l'organisation.

Option 1 : Configurer l'exportation des journaux d'audit Slack à l'aide des fonctions Google Cloud Run

Cette option utilise les fonctions Google Cloud Run et Cloud Scheduler pour collecter les journaux d'audit Slack et les ingérer directement dans Google SecOps.

Configurer le répertoire

1. Créez un répertoire sur votre ordinateur local pour le déploiement de la fonction Cloud Run.
2. Téléchargez les fichiers suivants à partir du dépôt GitHub des scripts d'ingestion Chronicle :
   • Dans le dossier slack, téléchargez les éléments suivants :
     • .env.yml
     • main.py
     • requirements.txt
   • À la racine du dépôt, téléchargez l'intégralité du répertoire common avec tous ses fichiers :
     • common/__init__.py
     • common/auth.py
     • common/env_constants.py
     • common/ingest.py
     • common/status.py
     • common/utils.py
3. Placez tous les fichiers téléchargés dans votre répertoire de déploiement.

• La structure de votre répertoire devrait se présenter comme suit :

  deployment_directory/
  ├─common/
  │ ├─__init__.py
  │ ├─auth.py
  │ ├─env_constants.py
  │ ├─ingest.py
  │ ├─status.py
  │ └─utils.py
  ├─.env.yml
  ├─main.py
  └─requirements.txt
  

Créer des secrets dans Google Secret Manager

1. Dans la console Google Cloud, accédez à Sécurité > Secret Manager.
2. Cliquez sur Créer un secret.
3. Fournissez les informations de configuration suivantes pour le compte de service Chronicle :
   • Nom : saisissez chronicle-service-account.
   • Valeur du secret : collez le contenu de votre fichier JSON d'authentification pour l'ingestion Google SecOps.
4. Cliquez sur Créer un secret.
5. Copiez le nom de la ressource secrète au format projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
6. Cliquez de nouveau sur Créer un secret pour créer un deuxième secret.
7. Fournissez les informations de configuration suivantes pour le jeton Slack :
   • Nom : saisissez slack-admin-token.
   • Valeur secrète : collez votre jeton OAuth utilisateur Slack (commençant par xoxp-).
8. Cliquez sur Créer un secret.
9. Copiez le nom de la ressource secrète au format projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Définir les variables d'environnement d'exécution requises

1. Ouvrez le fichier .env.yml dans votre répertoire de déploiement.

2. Configurez les variables d'environnement avec vos valeurs :

   CHRONICLE_CUSTOMER_ID: "<your-chronicle-customer-id>"
   CHRONICLE_REGION: us
   CHRONICLE_SERVICE_ACCOUNT: "projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest"
   CHRONICLE_NAMESPACE: ""
   POLL_INTERVAL: "5"
   SLACK_ADMIN_TOKEN: "projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest"
   

   • Remplacez l'élément suivant :
     • <your-chronicle-customer-id> : ID client Google SecOps.
     • <PROJECT_ID> : ID de votre projet Google Cloud .
     • CHRONICLE_REGION : définissez la région Google SecOps. Valeurs valides : us, asia-northeast1, asia-south1, asia-southeast1, australia-southeast1, europe, europe-west2, europe-west3, europe-west6, europe-west9, europe-west12, me-central1, me-central2, me-west1, northamerica-northeast2, southamerica-east1.
     • POLL_INTERVAL : intervalle de fréquence (en minutes) auquel la fonction s'exécute. Cette durée doit être identique à l'intervalle du job Cloud Scheduler.

3. Enregistrez le fichier .env.yml.

Déployer la fonction Cloud Run

1. Ouvrez un terminal ou Cloud Shell dans la console Google Cloud .

2. Accédez au répertoire de votre déploiement :

   cd /path/to/deployment_directory
   

3. Exécutez la commande suivante pour déployer la fonction Cloud Run :

   gcloud functions deploy slack-audit-to-chronicle \
     --entry-point main \
     --trigger-http \
     --runtime python39 \
     --env-vars-file .env.yml \
     --timeout 300s \
     --memory 512MB \
     --service-account <SERVICE_ACCOUNT_EMAIL>
   

   • Remplacez <SERVICE_ACCOUNT_EMAIL> par l'adresse e-mail du compte de service que vous souhaitez que votre fonction Cloud Run utilise.

     Remarque : Le compte de service exécutant votre fonction Cloud Run doit disposer des rôles Demandeur Cloud Functions (roles/cloudfunctions.invoker) et Accesseur de secrets Secret Manager (roles/secretmanager.secretAccessor).

4. Attendez la fin du déploiement.

5. Une fois la fonction déployée, notez son URL dans le résultat.

Configurer Cloud Scheduler

1. Dans la console Google Cloud, accédez à Cloud Scheduler > Créer un job.
2. Fournissez les informations de configuration suivantes :
   • Nom : saisissez slack-audit-scheduler.
   • Région : sélectionnez la même région que celle dans laquelle vous avez déployé la fonction Cloud Run.
   • Fréquence : saisissez */5 * * * * (l'exécution a lieu toutes les cinq minutes, ce qui correspond à la valeur POLL_INTERVAL).
   • Fuseau horaire : sélectionnez UTC.
   • Type de cible : sélectionnez HTTP.
   • URL : saisissez l'URL de la fonction Cloud Run à partir du résultat de déploiement.
   • Méthode HTTP : sélectionnez POST.
   • En-tête de l'authentification : sélectionnez Ajouter un jeton OIDC.
   • Compte de service : sélectionnez le même compte de service que celui utilisé pour la fonction Cloud Run.
3. Cliquez sur Créer.

Option 2 : Configurer l'exportation des journaux d'audit Slack à l'aide d'AWS S3

Cette option utilise AWS Lambda pour collecter les journaux d'audit Slack et les stocker dans S3, puis configure un flux Google SecOps pour ingérer les journaux.

Configurer un bucket AWS S3 et IAM pour Google SecOps

1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, slack-audit-logs).
3. Sélectionnez l'onglet Informations d'identification de sécurité.
4. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
5. Sélectionnez Service tiers comme Cas d'utilisation.
6. Cliquez sur Suivant.
7. Facultatif : Ajoutez un tag de description.
8. Cliquez sur Créer une clé d'accès.
9. Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour une utilisation ultérieure.
10. Cliquez sur OK.
11. Sélectionnez l'onglet Autorisations.
12. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations .
13. Sélectionnez Ajouter des autorisations.
14. Sélectionnez Joindre directement des règles.
15. Recherchez et sélectionnez la règle AmazonS3FullAccess.
16. Cliquez sur Suivant.
17. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

1. Dans la console AWS, accédez à IAM > Policies > Create policy > onglet JSON.

2. Copiez et collez le règlement suivant.

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::slack-audit-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::slack-audit-logs/slack/audit/state.json"
       }
     ]
   }
   

   • Remplacez slack-audit-logs si vous avez saisi un autre nom de bucket.

3. Cliquez sur Suivant.

4. Saisissez le nom de la règle : SlackAuditS3Policy.

5. Cliquez sur Créer une règle.

6. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

7. Associez la règle que vous venez de créer SlackAuditS3Policy.

8. Nommez le rôle SlackAuditToS3Role, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
2. Cliquez sur Créer à partir de zéro.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	slack_audit_to_s3
   Durée d'exécution	Python 3.13
   Architecture	x86_64
   Rôle d'exécution	SlackAuditToS3Role

4. Cliquez sur Créer une fonction.

5. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant (slack_audit_to_s3.py) :

   #!/usr/bin/env python3
   # Lambda: Pull Slack Audit Logs (Enterprise Grid) to S3 (no transform)
   
   import os, json, time, urllib.parse
   from urllib.request import Request, urlopen
   from urllib.error import HTTPError, URLError
   import boto3
   
   BASE_URL = "https://api.slack.com/audit/v1/logs"
   
   TOKEN        = os.environ["SLACK_AUDIT_TOKEN"]  # org-level user token with auditlogs:read
   BUCKET       = os.environ["S3_BUCKET"]
   PREFIX       = os.environ.get("S3_PREFIX", "slack/audit/")
   STATE_KEY    = os.environ.get("STATE_KEY", "slack/audit/state.json")
   LIMIT        = int(os.environ.get("LIMIT", "200"))             # Slack recommends <= 200
   MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
   LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600")) # First-run window
   HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
   HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
   RETRY_AFTER_DEFAULT = int(os.environ.get("RETRY_AFTER_DEFAULT", "2"))
   # Optional server-side filters (comma-separated "action" values), empty means no filter
   ACTIONS      = os.environ.get("ACTIONS", "").strip()
   
   s3 = boto3.client("s3")
   
   def _get_state() -> dict:
       try:
           obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
           st = json.loads(obj["Body"].read() or b"{}")
           return {"cursor": st.get("cursor")}
       except Exception:
           return {"cursor": None}
   
   def _put_state(state: dict) -> None:
       body = json.dumps(state, separators=(",", ":")).encode("utf-8")
       s3.put_object(Bucket=BUCKET, Key=STATE_KEY, Body=body, ContentType="application/json")
   
   def _http_get(params: dict) -> dict:
       qs  = urllib.parse.urlencode(params, doseq=True)
       url = f"{BASE_URL}?{qs}" if qs else BASE_URL
       req = Request(url, method="GET")
       req.add_header("Authorization", f"Bearer {TOKEN}")
       req.add_header("Accept", "application/json")
   
       attempt = 0
       while True:
           try:
               with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                   return json.loads(r.read().decode("utf-8"))
           except HTTPError as e:
               # Respect Retry-After on 429/5xx
               if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                   retry_after = 0
                   try:
                       retry_after = int(e.headers.get("Retry-After", RETRY_AFTER_DEFAULT))
                   except Exception:
                       retry_after = RETRY_AFTER_DEFAULT
                   time.sleep(max(1, retry_after))
                   attempt += 1
                   continue
               # Re-raise other HTTP errors
               raise
           except URLError:
               if attempt < HTTP_RETRIES:
                   time.sleep(RETRY_AFTER_DEFAULT)
                   attempt += 1
                   continue
               raise
   
   def _write_page(payload: dict, page_idx: int) -> str:
       ts  = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
       key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
       body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
       s3.put_object(Bucket=BUCKET, Key=key, Body=body, ContentType="application/json")
       return key
   
   def lambda_handler(event=None, context=None):
       state  = _get_state()
       cursor = state.get("cursor")
   
       params = {"limit": LIMIT}
       if ACTIONS:
           params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
       if cursor:
           params["cursor"] = cursor
       else:
           # First run (or reset): fetch a recent window by time
           params["oldest"] = int(time.time()) - LOOKBACK_SEC
   
       pages = 0
       total = 0
       last_cursor = None
   
       while pages < MAX_PAGES:
           data = _http_get(params)
           _write_page(data, pages)
   
           entries = data.get("entries") or []
           total += len(entries)
   
           # Cursor for next page
           meta = data.get("response_metadata") or {}
           next_cursor = meta.get("next_cursor") or data.get("next_cursor")
           if next_cursor:
               params = {"limit": LIMIT, "cursor": next_cursor}
               if ACTIONS:
                   params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
               last_cursor = next_cursor
               pages += 1
               continue
           break
   
       if last_cursor:
           _put_state({"cursor": last_cursor})
   
       return {"ok": True, "pages": pages + (1 if total or last_cursor else 0), "entries": total, "cursor": last_cursor}
   
   if __name__ == "__main__":
       print(lambda_handler())
   

6. Accédez à Configuration> Variables d'environnement> Modifier> Ajouter une variable d'environnement.

7. Saisissez les variables d'environnement suivantes en remplaçant par vos valeurs.

   Clé	Exemple de valeur
   S3_BUCKET	slack-audit-logs
   S3_PREFIX	slack/audit/
   STATE_KEY	slack/audit/state.json
   SLACK_AUDIT_TOKEN	xoxp-*** (jeton utilisateur au niveau de l'organisation avec auditlogs:read)
   LIMIT	200
   MAX_PAGES	20
   LOOKBACK_SECONDS	3600
   HTTP_TIMEOUT	60
   HTTP_RETRIES	3
   RETRY_AFTER_DEFAULT	2
   ACTIONS	(facultatif, CSV) user_login,app_installed

8. Cliquez sur Enregistrer.

9. Accédez à l'onglet Configuration.

10. Dans le panneau Configuration générale, cliquez sur Modifier.

11. Définissez Délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

    Remarque : Le délai d'expiration est une limite supérieure stricte. Cela signifie que si la fonction est toujours en cours d'exécution lorsque le minuteur atteint cinq minutes, AWS Lambda l'arrête. Toute exécution plus courte se termine normalement. Vous n'êtes facturé que pour la durée d'exécution réelle.

Créer une programmation EventBridge

1. Accédez à Amazon EventBridge> Scheduler> Create schedule.
2. Fournissez les informations de configuration suivantes :
   • Nom : saisissez slack-audit-1h.
   • Programmation récurrente : sélectionnez Programmation basée sur le taux.
   • Expression du taux : saisissez 1 heures.
   • Plage horaire flexible : sélectionnez Désactivé.
3. Cliquez sur Suivant.
4. Sélectionnez Cible :
   • API cible : sélectionnez AWS Lambda Invoke.
   • Fonction Lambda : sélectionnez slack_audit_to_s3.
5. Cliquez sur Suivant.
6. Cliquez sur Suivant (ignorez les paramètres facultatifs).
7. Vérifiez, puis cliquez sur Créer une programmation.

Facultatif : Créez un utilisateur et des clés IAM en lecture seule pour Google SecOps

1. Accédez à la console AWS> IAM> Utilisateurs> Ajouter des utilisateurs.
2. Cliquez sur Add users (Ajouter des utilisateurs).
3. Fournissez les informations de configuration suivantes :
   • Utilisateur : saisissez secops-reader.
   • Type d'accès : sélectionnez Clé d'accès – Accès programmatique.
4. Cliquez sur Créer un utilisateur.
5. Associez une stratégie de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des stratégies directement > Créer une stratégie.

6. Dans l'éditeur JSON, saisissez la stratégie suivante :

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["s3:GetObject"],
         "Resource": "arn:aws:s3:::slack-audit-logs/*"
       },
       {
         "Effect": "Allow",
         "Action": ["s3:ListBucket"],
         "Resource": "arn:aws:s3:::slack-audit-logs"
       }
     ]
   }
   

7. Cliquez sur Suivant.

8. Saisissez le nom de la règle : secops-reader-policy.

9. Cliquez sur Créer une règle.

10. Revenez à la page de création d'utilisateur, actualisez la liste des règles, puis sélectionnez secops-reader-policy.

11. Cliquez sur Suivant.

12. Cliquez sur Créer un utilisateur.

13. Sélectionnez l'utilisateur créé secops-reader.

14. Accédez à Identifiants de sécurité> Clés d'accès> Créer une clé d'accès.

15. Sélectionnez Service tiers.

16. Cliquez sur Suivant.

17. Cliquez sur Créer une clé d'accès.

18. Cliquez sur Télécharger le fichier .csv pour enregistrer les identifiants.

Configurer un flux dans Google SecOps pour ingérer les journaux d'audit Slack

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Ajouter.
3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Slack Audit Logs).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez Audit Slack comme Type de journal.
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : s3://slack-audit-logs/slack/audit/
   • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
   • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3 (à partir de secops-reader).
   • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3 (à partir de secops-reader).
   • Espace de noms de l'élément : espace de noms de l'élément.
   • Libellés d'ingestion : libellé appliqué aux événements de ce flux.
8. Cliquez sur Suivant.
9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
action	metadata.product_event_type	Directement mappé à partir du champ action dans le journal brut.
actor.type	principal.labels.value	Directement mappé à partir du champ actor.type, avec la clé actor.type ajoutée.
actor.user.email	principal.user.email_addresses	Mappé directement à partir du champ actor.user.email.
actor.user.id	principal.user.product_object_id	Mappé directement à partir du champ actor.user.id.
actor.user.id	principal.user.userid	Mappé directement à partir du champ actor.user.id.
actor.user.name	principal.user.user_display_name	Mappé directement à partir du champ actor.user.name.
actor.user.team	principal.user.group_identifiers	Mappé directement à partir du champ actor.user.team.
context.ip_address	principal.ip	Mappé directement à partir du champ context.ip_address.
context.location.domain	about.resource.attribute.labels.value	Directement mappé à partir du champ context.location.domain, avec la clé context.location.domain ajoutée.
context.location.id	about.resource.id	Mappé directement à partir du champ context.location.id.
context.location.name	about.resource.name	Mappé directement à partir du champ context.location.name.
context.location.name	about.resource.attribute.labels.value	Directement mappé à partir du champ context.location.name, avec la clé context.location.name ajoutée.
context.location.type	about.resource.resource_subtype	Mappé directement à partir du champ context.location.type.
context.session_id	network.session_id	Mappé directement à partir du champ context.session_id.
context.ua	network.http.user_agent	Mappé directement à partir du champ context.ua.
context.ua	network.http.parsed_user_agent	Informations analysées sur l'agent utilisateur, dérivées du champ context.ua à l'aide du filtre parseduseragent.
country	principal.location.country_or_region	Mappé directement à partir du champ country.
date_create	metadata.event_timestamp.seconds	L'horodatage epoch du champ date_create est converti en objet d'horodatage.
details.inviter.email	target.user.email_addresses	Mappé directement à partir du champ details.inviter.email.
details.inviter.id	target.user.product_object_id	Mappé directement à partir du champ details.inviter.id.
details.inviter.name	target.user.user_display_name	Mappé directement à partir du champ details.inviter.name.
details.inviter.team	target.user.group_identifiers	Mappé directement à partir du champ details.inviter.team.
details.reason	security_result.description	Directement mappé à partir du champ details.reason ou, s'il s'agit d'un tableau, concaténé avec des virgules.
details.type	about.resource.attribute.labels.value	Directement mappé à partir du champ details.type, avec la clé details.type ajoutée.
details.type	security_result.summary	Mappé directement à partir du champ details.type.
entity.app.id	target.resource.id	Mappé directement à partir du champ entity.app.id.
entity.app.name	target.resource.name	Mappé directement à partir du champ entity.app.name.
entity.channel.id	target.resource.id	Mappé directement à partir du champ entity.channel.id.
entity.channel.name	target.resource.name	Mappé directement à partir du champ entity.channel.name.
entity.channel.privacy	target.resource.attribute.labels.value	Directement mappé à partir du champ entity.channel.privacy, avec la clé entity.channel.privacy ajoutée.
entity.file.filetype	target.resource.attribute.labels.value	Directement mappé à partir du champ entity.file.filetype, avec la clé entity.file.filetype ajoutée.
entity.file.id	target.resource.id	Mappé directement à partir du champ entity.file.id.
entity.file.name	target.resource.name	Mappé directement à partir du champ entity.file.name.
entity.file.title	target.resource.attribute.labels.value	Directement mappé à partir du champ entity.file.title, avec la clé entity.file.title ajoutée.
entity.huddle.date_end	about.resource.attribute.labels.value	Directement mappé à partir du champ entity.huddle.date_end, avec la clé entity.huddle.date_end ajoutée.
entity.huddle.date_start	about.resource.attribute.labels.value	Directement mappé à partir du champ entity.huddle.date_start, avec la clé entity.huddle.date_start ajoutée.
entity.huddle.id	about.resource.attribute.labels.value	Directement mappé à partir du champ entity.huddle.id, avec la clé entity.huddle.id ajoutée.
entity.huddle.participants.0	about.resource.attribute.labels.value	Directement mappé à partir du champ entity.huddle.participants.0, avec la clé entity.huddle.participants.0 ajoutée.
entity.huddle.participants.1	about.resource.attribute.labels.value	Directement mappé à partir du champ entity.huddle.participants.1, avec la clé entity.huddle.participants.1 ajoutée.
entity.type	target.resource.resource_subtype	Mappé directement à partir du champ entity.type.
entity.user.email	target.user.email_addresses	Mappé directement à partir du champ entity.user.email.
entity.user.id	target.user.product_object_id	Mappé directement à partir du champ entity.user.id.
entity.user.name	target.user.user_display_name	Mappé directement à partir du champ entity.user.name.
entity.user.team	target.user.group_identifiers	Mappé directement à partir du champ entity.user.team.
entity.workflow.id	target.resource.id	Mappé directement à partir du champ entity.workflow.id.
entity.workflow.name	target.resource.name	Mappé directement à partir du champ entity.workflow.name.
id	metadata.product_log_id	Mappé directement à partir du champ id.
ip	principal.ip	Mappé directement à partir du champ ip. Déterminé par une logique basée sur le champ action. La valeur par défaut est USER_COMMUNICATION, mais elle peut être remplacée par d'autres valeurs telles que USER_CREATION, USER_LOGIN, USER_LOGOUT, USER_RESOURCE_ACCESS, USER_RESOURCE_UPDATE_PERMISSIONS ou USER_CHANGE_PERMISSIONS en fonction de la valeur de action. Codé en dur sur "SLACK_AUDIT". Défini sur "Enterprise Grid" si date_create existe, sinon défini sur "Journaux d'audit" si user_id existe. Codé en dur sur "Slack". Codé en dur sur "REMOTE". Définissez sur "SSO" si action contient "user_login" ou "user_logout". Sinon, définissez-le sur "MACHINE". Non mappé dans les exemples fournis. La valeur par défaut est "ALLOW", mais elle est définie sur "BLOCK" si action est "user_login_failed". Définissez la valeur sur "Slack" si date_create existe, sinon définissez-la sur "SLACK" si user_id existe.
user_agent	network.http.user_agent	Mappé directement à partir du champ user_agent.
user_id	principal.user.product_object_id	Mappé directement à partir du champ user_id.
username	principal.user.product_object_id	Mappé directement à partir du champ username.

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