Collecter les journaux d'audit Slack

Compatible avec :

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

Les journaux d'audit Slack fournissent un enregistrement détaillé des événements liés à la sécurité dans votre organisation Slack Enterprise Grid. L'API Audit Logs vous permet de surveiller les actions des utilisateurs, telles que les connexions, les téléchargements de fichiers, les installations d'applications et les modifications administratives, à des fins de surveillance de la conformité et de la sécurité.

Avant de commencer

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

  • Une instance Google SecOps
  • Un forfait Slack Enterprise Grid avec un accès propriétaire ou administrateur de l'organisation

  • 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)

Collecter les identifiants Slack

Créer l'application Slack

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.

  1. Connectez-vous à la console d'administration Slack avec un compte administrateur ou propriétaire d'une organisation Enterprise Grid.
  2. Accédez à la page Applications de l'API Slack.
  3. Cliquez sur Créer une application.
  4. Sélectionnez À partir de zéro.
  5. 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).
  6. Cliquez sur Créer une application.

Configurer les habilitations OAuth

  1. Sur la page des paramètres de votre application, sélectionnez OAuth et autorisations dans le menu de navigation de gauche.
  2. Faites défiler la page jusqu'à 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 suivant :
    • auditlogs:read : ce champ d'application permet d'accéder à l'API Audit Logs pour l'organisation Enterprise Grid.
  5. Sous Champs d'application des jetons de bot, cliquez sur Ajouter un champ d'application OAuth.

  6. Ajoutez le champ d'application suivant :

    • users:read : ce champ d'application est requis pour activer l'installation d'applications au niveau de l'organisation.

Configurer une URL de redirection

  1. Sur la page des paramètres de votre application, sélectionnez OAuth et autorisations dans le menu de navigation de gauche.
  2. Accédez à la section URL de redirection.
  3. Cliquez sur Ajouter une URL de redirection.

  4. Saisissez l'URL suivante :

    https://slack.com/oauth/v2/authorize

  5. Cliquez sur Ajouter.

  6. Cliquez sur Enregistrer les URL.

Activer la distribution publique

Pour installer une application au niveau de l'organisation Enterprise (et pas seulement dans un espace de travail), vous devez activer la distribution publique.

Pourquoi la distribution publique est-elle requise ?

  • Slack exige que la distribution publique soit activée pour les applications disposant d'autorisations à l'échelle de l'organisation.
  • Vous pouvez ainsi installer l'application au niveau de l'organisation plutôt que dans des espaces de travail individuels.
  • Sans cela, vous ne pouvez installer l'application que dans un seul espace de travail de votre Enterprise Grid.
  • L'activation de la distribution publique supprime simplement les restrictions internes concernant le champ d'installation.

Pour activer la distribution publique, procédez comme suit :

  1. Sur la page des paramètres de votre application, sélectionnez Gérer la distribution dans le panneau de navigation de gauche.
  2. Sous Share Your App with Other Workspaces (Partager votre application avec d'autres espaces de travail), vérifiez que les quatre sections sont accompagnées d'une coche verte :
    • Supprimer les informations codées en dur
    • Activer la distribution publique
    • Définir une URL de redirection
    • Ajouter une habilitation OAuth
  3. Si une croix rouge s'affiche dans une section, développez-la et effectuez l'action requise.
  4. Cochez la case J'ai vérifié et supprimé toutes les informations codées en dur.
  5. Cliquez sur Activer la distribution publique.

Installer une application dans une organisation Enterprise

  1. Sur la page des paramètres de votre application, sélectionnez OAuth et autorisations dans le menu de navigation de gauche.
  2. Sous Share Your App with Your Workspace (Partager l'application avec votre espace de travail), copiez l'URL partageable.
  3. Saisissez l'URL dans votre navigateur.
  4. Critique : dans l'écran d'installation, vérifiez le menu déroulant en haut à droite.
  5. Assurez-vous d'installer l'application dans l'organisation Enterprise et NON dans un espace de travail individuel.
  6. Si le nom d'un espace de travail s'affiche dans le menu déroulant, cliquez dessus et sélectionnez plutôt le nom de votre organisation Enterprise.
  7. Examinez les autorisations demandées, puis cliquez sur Autoriser.

Récupérer les identifiants

Une fois l'autorisation terminée, vous serez redirigé vers la page OAuth et autorisations.

  1. Sous Jetons OAuth pour votre espace de travail, recherchez le jeton OAuth utilisateur.
  2. Le jeton commence par xoxp-.

  3. Cliquez sur Copier et enregistrez ce jeton de manière sécurisée.

  4. Notez votre ID d'organisation :

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

Vérifier les autorisations

Pour vérifier que votre application dispose des autorisations requises :

  1. Accédez à la page Applications de l'API Slack.
  2. Sélectionnez votre application.
  3. Sélectionnez OAuth et autorisations dans le menu de navigation de gauche.
  4. Sous Jetons OAuth pour votre espace de travail, vérifiez qu'un jeton OAuth utilisateur s'affiche (il commence par xoxp-).
  5. Sous Scopes, vérifiez que auditlogs:read s'affiche sous User Token Scopes.

Tester l'accès à l'API

  • Testez votre jeton avant de procéder à l'intégration :

    SLACK_TOKEN="xoxp-your-token-here"

curl -H "Authorization: Bearer $SLACK_TOKEN" \
  "https://api.slack.com/audit/v1/logs?limit=1"

    Une réponse positive contient un tableau entries avec des événements de journaux d'audit. Si vous recevez une erreur invalid_auth ou missing_scope, vérifiez votre jeton et vos autorisations.

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

Cette option utilise Google Cloud Run Functions et Cloud Scheduler pour collecter les journaux d'audit Slack et les ingérer directement dans Google SecOps à l'aide des scripts d'ingestion Chronicle.

Avant de commencer (option 1)

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

  • Un projet GCP avec les API suivantes activées :
    • API Cloud Functions
    • API Cloud Scheduler
    • API Secret Manager
  • Autorisations permettant de créer des Cloud Functions, des jobs Cloud Scheduler et des secrets dans Secret Manager
  • Fichier JSON d'un compte de service Google SecOps

Obtenir le compte de service Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres du SIEM > Agents de collecte.
  3. Téléchargez le fichier d'authentification d'ingestion.

  4. Enregistrez le fichier JSON de manière sécurisée. Vous l'importerez en tant que secret dans Google Secret Manager.

Préparer le code de la fonction

Téléchargez les fichiers de déploiement à partir du dépôt GitHub chronicle-ingestion-scripts :

  1. Dans le dossier slack, téléchargez :
    • .env.yml
    • main.py
    • requirements.txt

  2. À partir de la racine du dépôt, téléchargez l'intégralité du répertoire common avec tous ses fichiers.

    La structure de votre répertoire de déploiement doit 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

Configurer les secrets dans Google Secret Manager

Stockez les identifiants sensibles dans Secret Manager pour que la fonction Cloud Run puisse y accéder de manière sécurisée.

Créer un secret pour le compte de service Google SecOps

  1. Dans la console GCP, accédez à Sécurité > Secret Manager.
  2. Cliquez sur Créer un secret.
  3. Fournissez les informations de configuration suivantes :
    • Nom : saisissez chronicle-service-account.
    • Valeur du secret : saisissez l'intégralité du contenu du fichier JSON du compte de service Google SecOps.
  4. Cliquez sur Créer un secret.

  5. Copiez le nom de ressource du secret. Il a le format suivant :

    projects/PROJECT_ID/secrets/chronicle-service-account/versions/latest

Créer un secret pour le jeton Slack

  1. Sur la page Secret Manager, cliquez sur Créer un secret.
  2. Fournissez les informations de configuration suivantes :
    • Nom : saisissez slack-admin-token.
    • Valeur du secret : saisissez le jeton OAuth de l'utilisateur Slack (commence par xoxp-).
  3. Cliquez sur Créer un secret.

  4. Copiez le nom de ressource du secret. Il a le format suivant :

    projects/PROJECT_ID/secrets/slack-admin-token/versions/latest

Configurer les variables d'environnement

  1. Ouvrez le fichier .env.yml dans votre répertoire de déploiement et configurez les variables d'environnement :

    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 les éléments suivants :

    • <your-chronicle-customer-id> : ID client Google SecOps.
    • <PROJECT_ID> : ID de votre projet Google Cloud.
    • CHRONICLE_REGION : définie sur votre 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.

  2. Enregistrez le fichier .env.yml.

Déployer la fonction Cloud Run

  1. Ouvrez un terminal ou Cloud Shell dans la console Google Cloud. Accédez au répertoire de déploiement et exécutez la commande suivante :

    gcloud functions deploy slack-audit-to-chronicle \
  --entry-point main \
  --trigger-http \
  --runtime python312 \
  --env-vars-file .env.yml \
  --timeout 540s \
  --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.

  2. Attendez la fin du déploiement. Une fois la fonction déployée, notez son URL dans le résultat.

Configurer Cloud Scheduler

  1. Dans la console GCP, accédez à Cloud Scheduler > Créer un job.

  2. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom 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 */5 * * * * (toutes les cinq minutes, ce qui correspond à la valeur POLL_INTERVAL)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).

  3. Cliquez sur Continuer.

  4. Dans la section Configurer l'exécution :

    • Type de cible : sélectionnez HTTP.
    • URL : saisissez l'URL de la fonction Cloud Run à partir du résultat du déploiement.
    • Méthode HTTP : sélectionnez POST.

  5. Dans la section En-tête d'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.

  6. 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 * * * * Standard (recommandé)
Toutes les 15 minutes */15 * * * * Volume moyen
Toutes les heures 0 * * * * Volume faible

Tester l'intégration (option 1)

  1. Dans la console Cloud Scheduler, recherchez votre job (slack-audit-scheduler).
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez quelques secondes.
  4. Accédez à Cloud Functions.
  5. Cliquez sur le nom de la fonction (slack-audit-to-chronicle).
  6. Cliquez sur l'onglet Journaux.

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

    Retrieving the Slack Audit logs since: YYYY-MM-DDTHH:MM:SSZ
Processing logs...
Retrieved X audit logs from the API call
Logs processed successfully.

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 Amazon S3, puis configure un flux Google SecOps pour ingérer les journaux.

Avant de commencer (option 2)

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

  • Un compte AWS disposant des autorisations nécessaires pour créer des buckets S3, des utilisateurs/rôles/stratégies IAM, des fonctions Lambda et des règles EventBridge.

Créer un bucket Amazon S3

  1. Créez un bucket Amazon S3 en suivant le 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).

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

  1. Dans la console AWS, accédez à IAM> Stratégies> Créer une stratégie> onglet JSON.

  2. Saisissez la règle suivante. Remplacez slack-audit-logs si vous avez utilisé un autre nom de bucket :

    {
  "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"
    }
  ]
}

  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 nouvellement créée 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 (JSONL format)
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"]
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"))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600"))
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)
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
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(RETRY_AFTER_DEFAULT)
                attempt += 1
                continue
            raise

def _write_page(data: dict, page_idx: int) -> str:
    """Extract entries from Slack API response and write as JSONL."""
    entries = data.get("entries") or []
    if not entries:
        return None
    lines = [json.dumps(entry, separators=(",", ":")) for entry in entries]
    body = "\n".join(lines).encode("utf-8")
    ts = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
    key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
    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())

Configurer les variables d'environnement Lambda

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

  2. Saisissez les variables d'environnement suivantes en remplaçant les valeurs par les vôtres :

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

  3. Cliquez sur Enregistrer.

  4. Accédez à l'onglet Configuration. Dans le panneau Configuration générale, cliquez sur Modifier.

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

Créer une programmation EventBridge

  1. Accédez à Amazon EventBridge> Scheduler> Create schedule (Créer une programmation).
  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 hours.
    • Plage horaire flexible : sélectionnez Désactivé.
  3. Cliquez sur Suivant.
  4. Sélectionnez la 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éer un utilisateur IAM en lecture seule pour Google SecOps

  1. Accédez à la console AWS> IAM > Utilisateurs > Créer un utilisateur.
  2. Fournissez les informations de configuration suivantes :
    • Nom d'utilisateur : saisissez secops-reader.
    • Type d'accès : sélectionnez Accès programmatique.
  3. Cliquez sur Suivant.
  4. Sélectionnez Joindre directement des règles.

  5. Cliquez sur Créer une règle. Dans l'onglet JSON, saisissez ce qui suit :

    {
  "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"
    }
  ]
}

  6. Cliquez sur Suivant.

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

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

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

  10. Cliquez sur Suivant.

  11. Cliquez sur Créer un utilisateur.

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

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

  14. Sélectionnez Service tiers.

  15. Cliquez sur Suivant.

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

  17. 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 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, Slack Audit Logs).
  5. Sélectionnez Amazon S3 V2 comme type de source.
  6. Sélectionnez Audit Slack comme Type de journal.

  7. Cliquez sur Suivant.

    Spécifiez les valeurs des paramètres d'entrée suivants :

    • URI S3 : saisissez l'URI du bucket S3 avec le chemin du préfixe :

      s3://slack-audit-logs/slack/audit/

      Remplacez slack-audit-logs par le nom réel de votre bucket S3.

    • Option 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 avec accès au bucket S3 (à partir de l'utilisateur IAM secops-reader).

    • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3 (à partir de l'utilisateur IAM secops-reader).

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

  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 Mappé directement à partir du champ action
actor.type principal.labels Mappé directement avec la clé actor.type
actor.user.email principal.user.email_addresses Mappé directement
actor.user.id principal.user.product_object_id Mappé directement
actor.user.id principal.user.userid Mappé directement
actor.user.name principal.user.user_display_name Mappé directement
actor.user.team principal.user.group_identifiers Mappé directement
context.ip_address principal.ip Mappé directement
context.location.domain about.resource.attribute.labels Mappé directement avec la clé context.location.domain
context.location.id about.resource.id Mappé directement
context.location.name about.resource.name Mappé directement
context.location.name about.resource.attribute.labels Mappé directement avec la clé context.location.name
context.location.type about.resource.resource_subtype Mappé directement
context.session_id network.session_id Mappé directement
context.ua network.http.user_agent Mappé directement
context.ua network.http.parsed_user_agent User-agent analysé dérivé du champ context.ua
country principal.location.country_or_region Mappé directement
date_create metadata.event_timestamp.seconds Code temporel de l'epoch converti en objet de code temporel
details.inviter.email target.user.email_addresses Mappé directement
details.inviter.id target.user.product_object_id Mappé directement
details.inviter.name target.user.user_display_name Mappé directement
details.inviter.team target.user.group_identifiers Mappé directement
details.reason security_result.description Mappé directement ; si le tableau est concaténé avec des virgules
details.type about.resource.attribute.labels Mappé directement avec la clé details.type
details.type security_result.summary Mappé directement
entity.app.id target.resource.id Mappé directement
entity.app.name target.resource.name Mappé directement
entity.channel.id target.resource.id Mappé directement
entity.channel.name target.resource.name Mappé directement
entity.channel.privacy target.resource.attribute.labels Mappé directement avec la clé entity.channel.privacy
entity.file.filetype target.resource.attribute.labels Mappé directement avec la clé entity.file.filetype
entity.file.id target.resource.id Mappé directement
entity.file.name target.resource.name Mappé directement
entity.file.title target.resource.attribute.labels Mappé directement avec la clé entity.file.title
entity.huddle.date_end about.resource.attribute.labels Mappé directement avec la clé entity.huddle.date_end
entity.huddle.date_start about.resource.attribute.labels Mappé directement avec la clé entity.huddle.date_start
entity.huddle.id about.resource.attribute.labels Mappé directement avec la clé entity.huddle.id
entity.huddle.participants.0 about.resource.attribute.labels Mappé directement avec la clé entity.huddle.participants.0
entity.huddle.participants.1 about.resource.attribute.labels Mappé directement avec la clé entity.huddle.participants.1
entity.type target.resource.resource_subtype Mappé directement
entity.user.email target.user.email_addresses Mappé directement
entity.user.id target.user.product_object_id Mappé directement
entity.user.name target.user.user_display_name Mappé directement
entity.user.team target.user.group_identifiers Mappé directement
entity.workflow.id target.resource.id Mappé directement
entity.workflow.name target.resource.name Mappé directement
id metadata.product_log_id Mappé directement
ip principal.ip Mappé directement
user_agent network.http.user_agent Mappé directement
user_id principal.user.product_object_id Mappé directement
username principal.user.product_object_id Mappé directement
metadata.event_type La valeur par défaut est USER_COMMUNICATION. Définissez-la sur USER_CREATION si l'action est user_created, sur USER_LOGIN si l'action est user_login ou user_login_failed, sur USER_LOGOUT si l'action est user_logout, sur USER_RESOURCE_ACCESS si l'action correspond à file_, sur USER_RESOURCE_UPDATE_PERMISSIONS si l'action correspond à app_, private_, public_ ou auth_policy_, sur USER_CHANGE_PERMISSIONS si l'action correspond à pref, legal_hold_, workflow_, channel_, user_deactivated, user_reactivated, role_change_ ou user_channel_.
metadata.log_type Codé en dur sur SLACK_AUDIT
metadata.product_name Définie sur Enterprise Grid si date_create existe, sinon sur Audit Logs si user_id existe
metadata.vendor_name Codé en dur sur Slack
extensions.auth.mechanism Codé en dur sur REMOTE
extensions.auth.type Définissez sur SSO si l'action contient user_login ou user_logout, sinon MACHINE
security_result.action La valeur par défaut est ALLOW. Définissez-la sur BLOCK si l'action est user_login_failed.
target.application Définie sur Slack si date_create existe, sinon sur SLACK si user_id existe
details.url_private target.url Mappé à partir du journal des modifications
details.previous_ip_address principal.labels Mappé à partir du journal des modifications
details.previous_ua principal.labels Mappé à partir du journal des modifications

Journal des modifications

Afficher le journal des modifications pour ce parseur

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