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 fonctions Google Cloud Run 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 conformité et de surveillance de la sécurité.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps.

  • Un forfait Slack Enterprise Grid avec accès en tant que propriétaire 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), ou
    • 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 à Slack en tant que propriétaire de votre 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 niveaux d'accès OAuth

  1. Sur la page des paramètres de votre application, sélectionnez OAuth & Permissions (OAuth et autorisations) dans le panneau de navigation de gauche.
  2. Accédez à la section Champs d'application.
  3. Sous Niveaux d'accès des jetons utilisateur (et NON "Niveaux d'accès des jetons de bot"), cliquez sur Ajouter un niveau d'accès 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 Niveaux d'accès du jeton du bot, cliquez sur Ajouter un niveau d'accès OAuth.
  6. Ajoutez le champ d'application suivant :
    • users:read : présent pour que l'application puisse être installée au niveau de l'organisation.

Installer l'application dans l'organisation Enterprise

L'API Audit Logs lit les événements pour l'ensemble de l'organisation Enterprise. L'application doit donc être installée au niveau de l'organisation plutôt que dans un seul espace de travail. Slack propose deux méthodes pour ce faire. Les deux méthodes génèrent le même jeton OAuth utilisateur au niveau de l'organisation. Utilisez-en un.

Option A : Installer depuis les paramètres de l'application (application au niveau de l'organisation)

Il s'agit du chemin d'accès à la page Developing apps for Enterprise orgs (Développer des applications pour les organisations Enterprise) de Slack. Il ne nécessite pas d'URL de redirection, de distribution publique ni de service Web.

  1. Sur la page des paramètres de votre application, sélectionnez Applications au niveau de l'organisation dans le panneau de navigation de gauche.
  2. Cliquez sur Activer.

  3. Dans l'invite de confirmation, cliquez sur Oui, activer.

  4. Connectez-vous en tant que propriétaire de l'organisation Enterprise.

  5. Sélectionnez OAuth et autorisations dans le menu de navigation de gauche.

  6. Cliquez sur Installer dans l'organisation.

  7. Examinez les autorisations demandées sur l'écran de confirmation, puis cliquez sur Autoriser.

Option B : Distribution publique et URL partageable

Il s'agit du chemin d'accès à la page de l'API Slack Audit Logs. L'activation de la distribution publique ne liste pas l'application sur le Slack Marketplace. Elle permet uniquement l'installation en dehors de l'espace de travail de développement.

  1. Sur la page des paramètres de votre application, sélectionnez OAuth & Permissions (OAuth et autorisations) dans le panneau de navigation de gauche.

  2. Dans la section URL de redirection, cliquez sur Ajouter une URL de redirection, saisissez une URL, cliquez sur Ajouter, puis sur Enregistrer les URL.

  3. Sélectionnez Gérer la distribution dans le menu de navigation de gauche.

  4. Sous Partager votre application avec d'autres espaces de travail, vérifiez que les quatre sections de la checklist sont cochées en vert. Si une section affiche une croix rouge, développez-la et effectuez l'action requise.

  5. Cochez la case J'ai vérifié et supprimé toutes les informations codées en dur.

  6. Cliquez sur Activer la distribution publique.

  7. Connectez-vous en tant que propriétaire de l'organisation Enterprise.

  8. Sous Partager votre application avec votre espace de travail, copiez l'URL partageable et ouvrez-la dans votre navigateur.

  9. Sur l'écran d'installation, ouvrez le menu déroulant en haut à droite et sélectionnez l'organisation Enterprise, et non un espace de travail individuel.

  10. Consultez les autorisations demandées, puis cliquez sur Autoriser.

Récupérer les identifiants

  1. Une fois l'installation terminée, vous êtes redirigé vers la page OAuth et autorisations.
  2. Dans la section Jetons OAuth, recherchez le jeton OAuth utilisateur.
  3. Le jeton commence par xoxp-.

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

    Important : Il s'agit de votre SLACK_ADMIN_TOKEN pour la fonction Cloud Run ou Lambda. Stockez-le de manière sécurisée. Il fournit un accès en lecture à tous les journaux d'audit de votre organisation Enterprise Grid.

  5. Notez votre ID d'organisation :

    1. Ouvrez Slack dans un navigateur Web en utilisant l'URL de votre organisation (par exemple, acmeinc.enterprise.slack.com).
    2. Une fois la page chargée, lisez l'URL. Il est au format https://app.slack.com/client/EXXXXXXX/CXXXXXXX.
    3. Copiez la chaîne commençant par E. Il s'agit de l'ID de votre 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, 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 réussie 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 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 à l'aide des scripts d'ingestion Google SecOps.

Avant de commencer (option 1)

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

  • Un projet Google Cloud avec les API suivantes activées :
    • API Cloud Run Admin
    • API Eventarc
    • API Pub/Sub
    • API Cloud Scheduler
    • API Secret Manager
  • Autorisations pour créer des fonctions Cloud Run, des sujets Pub/Sub, des déclencheurs Eventarc, 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 SIEM > Agent de collecte.
  3. Cliquez sur Télécharger pour télécharger le fichier d'authentification pour l'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 Google SecOps ingestion-scripts :

  1. Dans le dossier slack, téléchargez les éléments suivants :
    • .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 consoleGoogle Cloud , 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 : collez 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 : collez 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.

Créer un sujet Pub/Sub

Cloud Scheduler déclenche la fonction Cloud Run via un sujet Pub/Sub.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Créer un sujet.
  3. Dans le champ ID du sujet, saisissez slack-audit-trigger.
  4. Cliquez sur Créer.

Déployer la fonction Cloud Run

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

    gcloud run deploy slack-audit-to-chronicle \
  --source . \
  --function main \
  --base-image google-22/python312 \
  --region <REGION> \
  --service-account <SERVICE_ACCOUNT_EMAIL> \
  --env-vars-file .env.yml \
  --memory 512Mi \
  --timeout 540 \
  --max-instances 1 \
  --no-allow-unauthenticated
    • Remplacez <REGION> par la région (par exemple, us-central1) et <SERVICE_ACCOUNT_EMAIL> par l'adresse e-mail du compte de service que vous souhaitez que votre fonction Cloud Run utilise.

  2. Créez le déclencheur Pub/Sub pour la fonction comme suit :

    gcloud eventarc triggers create slack-audit-trigger \
  --location <REGION> \
  --destination-run-service slack-audit-to-chronicle \
  --destination-run-region <REGION> \
  --event-filters "type=google.cloud.pubsub.topic.v1.messagePublished" \
  --transport-topic projects/<PROJECT_ID>/topics/slack-audit-trigger \
  --service-account <SERVICE_ACCOUNT_EMAIL>
    • Remplacez <PROJECT_ID> par l'ID du projet Google Cloud .

  3. Attendez la fin du déploiement.

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 Pub/Sub.
    • Thème : sélectionnez slack-audit-trigger.
    • Corps du message : saisissez run.

  5. 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 Run.
  5. Cliquez sur le nom du service (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 les rôles et la stratégie IAM pour les importations S3

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

  2. Copiez et collez le règlement suivant. 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 SlackAuditS3Policy que vous venez de créer.

  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 collez 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 d'inactivité sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

Créer une programmation EventBridge

  1. Accédez à Amazon EventBridge> Scheduler> 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.
    • Période flexible : sélectionnez Désactivée.
  3. Cliquez sur Suivant.
  4. Sélectionnez la cible :
    • API cible : sélectionnez Invocation AWS Lambda.
    • 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 la programmation.

(Facultatif) Créez 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 Associer directement les règles.

  5. Cliquez sur Créer une règle. Dans l'onglet JSON, collez le code suivant :

    {
  "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 Create User (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 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.

  8. 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/
```

Replace `slack-audit-logs` with your actual S3 bucket name.

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

    • Âge maximal du fichier : 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 secops-reader Identity and Access Management (IAM)).

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

  9. Cliquez sur Suivant.

  10. 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 epoch converti en objet 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

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.