Raccogliere gli audit log di Slack

Supportato in:

Questo documento spiega come importare i log di controllo di Slack in Google Security Operations utilizzando le funzioni Google Cloud Run o Amazon S3 con AWS Lambda.

I log di controllo di Slack forniscono un registro dettagliato degli eventi correlati alla sicurezza nell'organizzazione Slack Enterprise Grid. L'API Audit Logs ti consente di monitorare le azioni degli utenti, come accessi, download di file, installazioni di app e modifiche amministrative a fini di conformità e monitoraggio della sicurezza.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps.

  • Un piano Slack Enterprise Grid con accesso di proprietario dell'organizzazione.

  • Accesso privilegiato a:

    • Google Cloud (per l'opzione 1: Cloud Run Functions e Cloud Scheduler) o
    • AWS (per l'opzione 2: S3, IAM, Lambda, EventBridge).

Raccogliere le credenziali di Slack

Crea l'app Slack

L'API Slack Audit Logs richiede un token OAuth utente con l'ambito auditlogs:read. Questo token deve essere ottenuto installando un'app a livello di organizzazione Enterprise Grid, non a livello di spazio di lavoro.

  1. Accedi a Slack come proprietario della tua organizzazione Enterprise Grid.
  2. Vai alla pagina delle app API Slack.
  3. Fai clic su Crea nuova app.
  4. Seleziona Da zero.
  5. Fornisci i seguenti dettagli di configurazione:
    • Nome app: inserisci un nome descrittivo (ad esempio, Google SecOps Audit Integration).
    • Scegli un workspace in cui sviluppare l'app: seleziona il tuo workspace di sviluppo di Slack (qualsiasi workspace dell'organizzazione).
  6. Fai clic su Crea app.

Configurare gli ambiti OAuth

  1. Nella pagina delle impostazioni dell'app, seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.
  2. Vai alla sezione Ambiti.
  3. Nella sezione Ambiti token utente (NON Ambiti token bot), fai clic su Aggiungi un ambito OAuth.
  4. Aggiungi il seguente ambito:
    • auditlogs:read: questo ambito consente l'accesso all'API Audit Logs per l'organizzazione Enterprise Grid.
  5. Nella sezione Ambiti del token bot, fai clic su Aggiungi un ambito OAuth.
  6. Aggiungi il seguente ambito:
    • users:read: presente in modo che l'app possa essere installata a livello di organizzazione.

Installare l'app nell'organizzazione Enterprise

L'API Audit Logs legge gli eventi per l'intera organizzazione Enterprise, quindi l'app deve essere installata a livello di organizzazione anziché in un singolo spazio di lavoro. Slack documenta due modi per farlo. Entrambi producono lo stesso token OAuth utente a livello di organizzazione. Utilizzane uno.

Opzione A: installa dalle impostazioni dell'app (app a livello di organizzazione)

Questo è il percorso dalla pagina Developing apps for Enterprise orgs di Slack. Non richiede URL di reindirizzamento, distribuzione pubblica o servizio web.

  1. Nella pagina delle impostazioni dell'app, seleziona App a livello di organizzazione nel menu di navigazione a sinistra.
  2. Fai clic su Attiva.

  3. Nel prompt di conferma, fai clic su Sì, attiva.

  4. Accedi come proprietario dell'organizzazione Enterprise.

  5. Seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.

  6. Fai clic su Installa nell'organizzazione.

  7. Esamina le autorizzazioni richieste nella schermata di conferma e fai clic su Consenti.

Opzione B: distribuzione pubblica e URL condivisibile

Questo è il percorso dalla pagina API Audit Logs di Slack. L'attivazione della distribuzione pubblica non elenca l'app nel Marketplace di Slack, ma consente solo l'installazione al di fuori dello spazio di lavoro di sviluppo.

  1. Nella pagina delle impostazioni dell'app, seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.

  2. Nella sezione URL di reindirizzamento, fai clic su Aggiungi nuovo URL di reindirizzamento, inserisci un URL, fai clic su Aggiungi e poi su Salva URL.

  3. Seleziona Gestisci distribuzione nel menu di navigazione a sinistra.

  4. In Condividi la tua app con altri spazi di lavoro, verifica che tutte e quattro le sezioni dell'elenco di controllo mostrino un segno di spunta verde. Se una sezione mostra una X rossa, espandila e completa l'azione richiesta.

  5. Seleziona la casella di controllo Ho esaminato e rimosso tutte le informazioni codificate.

  6. Fai clic su Attiva distribuzione pubblica.

  7. Accedi come proprietario dell'organizzazione aziendale.

  8. Nella sezione Condividi la tua app con il tuo spazio di lavoro, copia l'URL condivisibile e aprilo nel browser.

  9. Nella schermata di installazione, apri il menu a discesa nell'angolo in alto a destra e seleziona l'organizzazione Enterprise, non uno spazio di lavoro individuale.

  10. Rivedi le autorizzazioni richieste e fai clic su Consenti.

Recuperare le credenziali

  1. Al termine dell'installazione, tornerai alla pagina OAuth e autorizzazioni.
  2. Nella sezione Token OAuth, individua il token OAuth utente.
  3. Il token inizia con xoxp-.

  4. Fai clic su Copia e salva questo token in modo sicuro.

    Importante: questo è il tuo SLACK_ADMIN_TOKEN per la funzione Cloud Run o la funzione Lambda. Conservala in modo sicuro. Fornisce l'accesso in lettura a tutti i log di controllo della tua organizzazione Enterprise Grid.

  5. Prendi nota dell'ID organizzazione:

    1. Apri Slack in un browser web utilizzando l'URL della tua organizzazione (ad esempio, acmeinc.enterprise.slack.com).
    2. Dopo il caricamento della pagina, leggi l'URL. Ha il formato https://app.slack.com/client/EXXXXXXX/CXXXXXXX.
    3. Copia la stringa che inizia con E. Questo è l'ID organizzazione.

Verifica le autorizzazioni

Per verificare che la tua app disponga delle autorizzazioni richieste:

  1. Vai alla pagina delle app API Slack.
  2. Selezionare l'app.
  3. Seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.
  4. In Token OAuth, verifica che venga visualizzato un token OAuth utente (inizia con xoxp-).
  5. In Ambiti, verifica che auditlogs:read venga visualizzato in Ambiti token utente.

Testare l'accesso API

  • Testa il token prima di procedere con l'integrazione:

    SLACK_TOKEN="xoxp-your-token-here"

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

Una risposta corretta contiene un array entries con eventi del log di controllo. Se ricevi un errore invalid_auth o missing_scope, verifica il token e gli ambiti.

Opzione 1: configura l'esportazione degli audit log di Slack utilizzando le funzioni Google Cloud Run

Questa opzione utilizza le funzioni Google Cloud Run e Cloud Scheduler per raccogliere gli audit log di Slack e inserirli direttamente in Google SecOps utilizzando gli script di importazione di Google SecOps.

Prima di iniziare (opzione 1)

Assicurati di soddisfare i seguenti prerequisiti aggiuntivi:

  • Un progetto Google Cloud con le seguenti API abilitate:
    • API Cloud Run Admin
    • API Eventarc
    • API Pub/Sub
    • API Cloud Scheduler
    • API Secret Manager
  • Autorizzazioni per creare funzioni Cloud Run, argomenti Pub/Sub, trigger Eventarc, job Cloud Scheduler e secret in Secret Manager.
  • Un file JSON dell'account di servizio Google SecOps.

Recuperare il account di servizio Google SecOps

  1. Accedi alla console Google SecOps.
  2. Vai a Impostazioni SIEM > Agente di raccolta.
  3. Fai clic su Scarica per scaricare il file di autenticazione dell'importazione.
  4. Salva il file JSON in modo sicuro. Caricherai questo file come secret in Google Secret Manager.

Prepara il codice della funzione

Scarica i file di deployment dal repository GitHub google-secops-ingestion-scripts:

  1. Dalla cartella slack, scarica:
    • .env.yml
    • main.py
    • requirements.txt

  2. Dalla radice del repository, scarica l'intera directory common con tutti i relativi file.

    La directory di deployment deve avere la seguente struttura:

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

Configura i secret in Google Secret Manager

Archivia le credenziali sensibili in Secret Manager per un accesso sicuro da parte della funzione Cloud Run.

Crea un secret per il account di servizio Google SecOps

  1. Nella consoleGoogle Cloud , vai a Sicurezza > Secret Manager.
  2. Fai clic su Crea secret.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci chronicle-service-account.
    • Valore del secret: incolla l'intero contenuto del file JSON del account di servizio Google SecOps.
  4. Fai clic su Crea secret.

  5. Copia il nome della risorsa del secret. Il formato è:

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

Crea un secret per il token Slack

  1. Nella pagina Secret Manager, fai clic su Crea secret.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci slack-admin-token.
    • Valore del secret: incolla il token OAuth utente di Slack (inizia con xoxp-).
  3. Fai clic su Crea secret.

  4. Copia il nome della risorsa del secret. Il formato è:

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

Configura le variabili di ambiente

  1. Apri il file .env.yml nella directory di deployment e configura le variabili di ambiente:

    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"

    • Sostituisci quanto segue:

      • <your-chronicle-customer-id>: il tuo ID cliente Google SecOps.
      • <PROJECT_ID>: l'ID progetto Google Cloud .
      • CHRONICLE_REGION: impostalo sulla regione Google SecOps. Valori validi: 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: Intervallo di frequenza (in minuti) con cui viene eseguita la funzione. Questa durata deve corrispondere all'intervallo del job Cloud Scheduler.

  2. Salva il file .env.yml.

Crea un argomento Pub/Sub

Cloud Scheduler attiva la funzione Cloud Run tramite un argomento Pub/Sub.

  1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Nel campo ID argomento, inserisci slack-audit-trigger.
  4. Fai clic su Crea.

Esegui il deployment della funzione Cloud Run

  1. Apri un terminale o Cloud Shell nella console Google Cloud . Vai alla directory di deployment ed esegui questo comando:

    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
    • Sostituisci <REGION> con la regione (ad esempio us-central1) e <SERVICE_ACCOUNT_EMAIL> con l'indirizzo email del account di servizio che vuoi che la tua funzione Cloud Run utilizzi.

  2. Crea il trigger Pub/Sub per la funzione nel seguente modo:

    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>
    • Sostituisci <PROJECT_ID> con l'ID progetto Google Cloud .

  3. Attendi il completamento del deployment.

Configura Cloud Scheduler

  1. Nella console GCP, vai a Cloud Scheduler > Crea job.

  2. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome slack-audit-scheduler
    Regione Seleziona la stessa regione in cui hai eseguito il deployment della funzione Cloud Run
    Frequenza */5 * * * * (ogni 5 minuti, in base al valore di POLL_INTERVAL)
    Fuso orario Seleziona il fuso orario (UTC consigliato)

  3. Fai clic su Continua.

  4. Nella sezione Configura l'esecuzione:

    • Tipo di target: seleziona Pub/Sub.
    • Argomento: seleziona slack-audit-trigger.
    • Corpo del messaggio: inserisci run.

  5. Fai clic su Crea.

Opzioni di frequenza di pianificazione

Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

Frequenza Espressione cron Caso d'uso
Ogni 5 minuti */5 * * * * Standard (consigliato)
Ogni 15 minuti */15 * * * * Volume medio
Ogni ora 0 * * * * Volume basso

Testare l'integrazione (opzione 1)

  1. Nella console Cloud Scheduler, trova il tuo job (slack-audit-scheduler).
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi alcuni secondi.
  4. Vai a Cloud Run.
  5. Fai clic sul nome del servizio (slack-audit-to-chronicle).
  6. Fai clic sulla scheda Log.

  7. Verifica che la funzione sia stata eseguita correttamente. Cerca:

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

Opzione 2: configura l'esportazione dei log di controllo di Slack utilizzando AWS S3

Questa opzione utilizza AWS Lambda per raccogliere i log di controllo di Slack e archiviarli in Amazon S3, quindi configura un feed Google SecOps per importare i log.

Prima di iniziare (opzione 2)

Assicurati di soddisfare i seguenti prerequisiti aggiuntivi:

  • Un account AWS con autorizzazioni per creare bucket S3, utenti/ruoli/policy IAM, funzioni Lambda e regole EventBridge.

Crea un bucket Amazon S3

  1. Crea un bucket Amazon S3 seguendo la guida dell'utente Creazione di un bucket.
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, slack-audit-logs).

Configura policy e ruoli IAM per i caricamenti S3

  1. Nella console AWS, vai alla scheda IAM > Policy > Crea policy > JSON.

  2. Copia e incolla la seguente policy. Sostituisci slack-audit-logs se hai utilizzato un nome del bucket diverso:

    {
  "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. Fai clic su Avanti.

  4. Inserisci il nome della norma SlackAuditS3Policy.

  5. Fai clic su Crea policy.

  6. Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.

  7. Allega la policy appena creata SlackAuditS3Policy.

  8. Assegna al ruolo il nome SlackAuditToS3Role e fai clic su Crea ruolo.

Crea la funzione Lambda

  1. Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
  2. Fai clic su Crea autore da zero.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome slack_audit_to_s3
    Tempo di esecuzione Python 3.13
    Architettura x86_64
    Ruolo di esecuzione SlackAuditToS3Role

  4. Fai clic su Crea funzione.

  5. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e incolla il seguente codice (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())

Configura le variabili di ambiente Lambda

  1. Vai a Configurazione > Variabili di ambiente > Modifica > Aggiungi variabile di ambiente.

  2. Inserisci le seguenti variabili di ambiente, sostituendo i valori con i tuoi:

    Chiave Valore di esempio
    SLACK_AUDIT_TOKEN xoxp-... (token utente a livello di organizzazione con 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 (facoltativo, filtro per le azioni separato da virgole)

  3. Fai clic su Salva.

  4. Seleziona la scheda Configurazione. Nel riquadro Configurazione generale, fai clic su Modifica.

  5. Modifica Timeout impostandolo su 5 minutes (300 secondi) e fai clic su Salva.

Creare una pianificazione EventBridge

  1. Vai a Amazon EventBridge > Scheduler > Crea pianificazione.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci slack-audit-1h.
    • Programmazione ricorrente: seleziona Programmazione basata sulla tariffa.
    • Espressione del tasso: inserisci 1 hours.
    • Finestra temporale flessibile: seleziona Off.
  3. Fai clic su Avanti.
  4. Seleziona target:
    • API di destinazione: seleziona AWS Lambda Invoke.
    • Funzione Lambda: seleziona slack_audit_to_s3.
  5. Fai clic su Avanti.
  6. Fai clic su Avanti (salta le impostazioni facoltative).
  7. Rivedi e fai clic su Crea pianificazione.

(Facoltativo) Crea un utente IAM di sola lettura per Google SecOps

  1. Vai alla console AWS > IAM > Utenti > Crea utente.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome utente: inserisci secops-reader.
    • Tipo di accesso: seleziona Accesso programmatico.
  3. Fai clic su Avanti.
  4. Seleziona Allega direttamente le norme.

  5. Fai clic su Crea policy. Nella scheda JSON, incolla:

    {
  "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. Fai clic su Avanti.

  7. Inserisci il nome della norma secops-reader-policy.

  8. Fai clic su Crea policy.

  9. Torna alla pagina di creazione dell'utente, aggiorna l'elenco delle policy e seleziona secops-reader-policy.

  10. Fai clic su Avanti.

  11. Fai clic su Crea utente.

  12. Seleziona l'utente creato secops-reader.

  13. Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.

  14. Seleziona Servizio di terze parti.

  15. Fai clic su Avanti.

  16. Fai clic su Crea chiave di accesso.

  17. Fai clic su Scarica file .csv per salvare le credenziali.

Configura un feed in Google SecOps per importare i log di controllo di Slack

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Slack Audit Logs).
  5. Seleziona Amazon S3 V2 come Tipo di origine.
  6. Seleziona Audit di Slack come Tipo di log.
  7. Fai clic su Avanti.

  8. Specifica i valori per i seguenti parametri di input:

    • URI S3: inserisci l'URI del bucket S3 con il percorso del prefisso:

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

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

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.

    • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3 (dall'utente secops-reader Identity and Access Management (IAM)).

    • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3 (dell'utente IAM secops-reader).

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

  9. Fai clic su Avanti.

  10. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
action metadata.product_event_type Mappato direttamente dal campo action
actor.type principal.labels Mappato direttamente con la chiave actor.type
actor.user.email principal.user.email_addresses Mappato direttamente
actor.user.id principal.user.product_object_id Mappato direttamente
actor.user.id principal.user.userid Mappato direttamente
actor.user.name principal.user.user_display_name Mappato direttamente
actor.user.team principal.user.group_identifiers Mappato direttamente
context.ip_address principal.ip Mappato direttamente
context.location.domain about.resource.attribute.labels Mappato direttamente con la chiave context.location.domain
context.location.id about.resource.id Mappato direttamente
context.location.name about.resource.name Mappato direttamente
context.location.name about.resource.attribute.labels Mappato direttamente con la chiave context.location.name
context.location.type about.resource.resource_subtype Mappato direttamente
context.session_id network.session_id Mappato direttamente
context.ua network.http.user_agent Mappato direttamente
context.ua network.http.parsed_user_agent User agent analizzato derivato dal campo context.ua
country principal.location.country_or_region Mappato direttamente
date_create metadata.event_timestamp.seconds Timestamp Unix epoch convertito in oggetto timestamp
details.inviter.email target.user.email_addresses Mappato direttamente
details.inviter.id target.user.product_object_id Mappato direttamente
details.inviter.name target.user.user_display_name Mappato direttamente
details.inviter.team target.user.group_identifiers Mappato direttamente
details.reason security_result.description Mappato direttamente; se array, concatenato con virgole
details.type about.resource.attribute.labels Mappato direttamente con la chiave details.type
details.type security_result.summary Mappato direttamente
entity.app.id target.resource.id Mappato direttamente
entity.app.name target.resource.name Mappato direttamente
entity.channel.id target.resource.id Mappato direttamente
entity.channel.name target.resource.name Mappato direttamente
entity.channel.privacy target.resource.attribute.labels Mappato direttamente con la chiave entity.channel.privacy
entity.file.filetype target.resource.attribute.labels Mappato direttamente con la chiave entity.file.filetype
entity.file.id target.resource.id Mappato direttamente
entity.file.name target.resource.name Mappato direttamente
entity.file.title target.resource.attribute.labels Mappato direttamente con la chiave entity.file.title
entity.huddle.date_end about.resource.attribute.labels Mappato direttamente con la chiave entity.huddle.date_end
entity.huddle.date_start about.resource.attribute.labels Mappato direttamente con la chiave entity.huddle.date_start
entity.huddle.id about.resource.attribute.labels Mappato direttamente con la chiave entity.huddle.id
entity.huddle.participants.0 about.resource.attribute.labels Mappato direttamente con la chiave entity.huddle.participants.0
entity.huddle.participants.1 about.resource.attribute.labels Mappato direttamente con la chiave entity.huddle.participants.1
entity.type target.resource.resource_subtype Mappato direttamente
entity.user.email target.user.email_addresses Mappato direttamente
entity.user.id target.user.product_object_id Mappato direttamente
entity.user.name target.user.user_display_name Mappato direttamente
entity.user.team target.user.group_identifiers Mappato direttamente
entity.workflow.id target.resource.id Mappato direttamente
entity.workflow.name target.resource.name Mappato direttamente
id metadata.product_log_id Mappato direttamente
ip principal.ip Mappato direttamente
user_agent network.http.user_agent Mappato direttamente
user_id principal.user.product_object_id Mappato direttamente
username principal.user.product_object_id Mappato direttamente
metadata.event_type Il valore predefinito è USER_COMMUNICATION; impostalo su USER_CREATION se l'azione è user_created, USER_LOGIN se l'azione è user_login o user_login_failed, USER_LOGOUT se l'azione è user_logout, USER_RESOURCE_ACCESS se l'azione corrisponde a file_, USER_RESOURCE_UPDATE_PERMISSIONS se l'azione corrisponde a app_, private_, public_ o auth_policy_, USER_CHANGE_PERMISSIONS se l'azione corrisponde a pref, legal_hold_, workflow_, channel_, user_deactivated, user_reactivated, role_change_ o user_channel_
metadata.log_type Codificato in modo permanente su SLACK_AUDIT
metadata.product_name Imposta su Enterprise Grid se esiste date_create, altrimenti su Audit Logs se esiste user_id
metadata.vendor_name Codificato in modo permanente su Slack
extensions.auth.mechanism Codificato in modo permanente su REMOTE
extensions.auth.type Imposta su SSO se l'azione contiene user_login o user_logout, altrimenti MACHINE
security_result.action Il valore predefinito è ALLOW; impostato su BLOCK se l'azione è user_login_failed
target.application Imposta su Slack se esiste date_create, altrimenti su SLACK se esiste user_id

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.