Raccogliere i log di controllo 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 monitoraggio della conformità e della sicurezza.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un piano Slack Enterprise Grid con accesso come Proprietario dell'organizzazione o Amministratore

  • 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 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 alla console di amministrazione di Slack con un account di amministratore o proprietario dell'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.

Configura gli ambiti OAuth

  1. Nella pagina delle impostazioni dell'app, seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.
  2. Scorri verso il basso fino 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 token bot, fai clic su Aggiungi un ambito OAuth.

  6. Aggiungi il seguente ambito:

    • users:read: questo ambito è necessario per attivare l'installazione di app a livello di organizzazione.

Configura l'URL di reindirizzamento

  1. Nella pagina delle impostazioni dell'app, seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.
  2. Vai alla sezione URL di reindirizzamento.
  3. Fai clic su Aggiungi nuovo URL di reindirizzamento.

  4. Inserisci il seguente URL:

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

  5. Fai clic su Aggiungi.

  6. Fai clic su Salva URL.

Attivare la distribuzione pubblica

Per installare un'app a livello di organizzazione Enterprise (non solo di spazio di lavoro), devi attivare la distribuzione pubblica.

Perché è richiesta la distribuzione pubblica?

  • Slack richiede che le app con autorizzazioni a livello di organizzazione abbiano la distribuzione pubblica abilitata.
  • In questo modo è possibile installare a livello di organizzazione anziché in singoli spazi di lavoro.
  • Senza, puoi installare l'app solo in un singolo spazio di lavoro all'interno di Enterprise Grid.
  • L'attivazione della distribuzione pubblica rimuove semplicemente le limitazioni interne all'ambito di installazione.

Per attivare la distribuzione pubblica:

  1. Nella pagina delle impostazioni dell'app, seleziona Gestisci distribuzione nel menu di navigazione a sinistra.
  2. In Condividi la tua app con altri spazi di lavoro, verifica che tutte e quattro le sezioni siano contrassegnate da un segno di spunta verde:
    • Rimuovere le informazioni codificate
    • Attiva la distribuzione pubblica
    • Impostare un URL di reindirizzamento
    • Aggiungere un ambito OAuth
  3. Se una sezione mostra una X rossa, espandila e completa l'azione richiesta.
  4. Seleziona la casella di controllo accanto a Ho esaminato e rimosso tutte le informazioni codificate.
  5. Fai clic su Attiva distribuzione pubblica.

Installare l'app nell'organizzazione Enterprise

  1. Nella pagina delle impostazioni dell'app, seleziona OAuth e autorizzazioni nel menu di navigazione a sinistra.
  2. In Condividi la tua app con il tuo spazio di lavoro, copia l'URL condivisibile.
  3. Inserisci l'URL nel browser.
  4. Importante: nella schermata di installazione, controlla il menu a discesa nell'angolo in alto a destra.
  5. Assicurati di eseguire l'installazione nell'organizzazione Enterprise, NON in un singolo spazio di lavoro.
  6. Se vedi un nome dello spazio di lavoro nel menu a discesa, fai clic e seleziona invece il nome della tua organizzazione Enterprise.
  7. Controlla le autorizzazioni richieste e fai clic su Consenti.

Recuperare le credenziali

Una volta completata l'autorizzazione, verrà eseguito il reindirizzamento alla pagina OAuth e autorizzazioni.

  1. In Token OAuth per il tuo spazio di lavoro, individua il token OAuth utente.
  2. Il token inizia con xoxp-.

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

  4. Prendi nota dell'ID organizzazione:

    1. Vai alla Console di amministrazione di Slack.
    2. Vai a Impostazioni e autorizzazioni > Impostazioni dell'organizzazione.
    3. Copia 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 per il tuo spazio di lavoro, 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 dei log di controllo di Slack utilizzando Google Cloud Run Functions

Questa opzione utilizza Google Cloud Run Functions e Cloud Scheduler per raccogliere i log di controllo di Slack e importarli direttamente in Google SecOps utilizzando gli script di importazione di Chronicle.

Prima di iniziare (opzione 1)

Assicurati di soddisfare i seguenti prerequisiti aggiuntivi:

  • Un progetto Google Cloud con le seguenti API abilitate:
    • API Cloud Functions
    • API Cloud Scheduler
    • API Secret Manager
  • Autorizzazioni per creare Cloud Functions, 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 > Agenti di raccolta.
  3. Scarica il file di autenticazione dell'acquisizione.

  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 chronicle-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 l'accesso sicuro da parte della funzione Cloud Run.

Crea un secret per il account di servizio Google SecOps

  1. Nella console Google 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 secret: inserisci l'intero contenuto del file JSON dell'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 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 segreto: inserisci 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 del tuo progetto Google Cloud.
    • CHRONICLE_REGION: impostato 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.

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

    Sostituisci <SERVICE_ACCOUNT_EMAIL> con l'indirizzo email del account di servizio che vuoi che utilizzi la tua funzione Cloud Run.

  2. Attendi il completamento del deployment. Una volta eseguito il deployment, prendi nota dell'URL della funzione dall'output.

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 destinazione: seleziona HTTP.
    • URL: inserisci l'URL della funzione Cloud Run dall'output del deployment.
    • Metodo HTTP: seleziona POST.

  5. Nella sezione Intestazione di autenticazione:

    • Seleziona Aggiungi token OIDC.
    • Service account: seleziona lo stesso account di servizio utilizzato per la funzione Cloud Run.

  6. 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 qualche secondo.
  4. Vai a Cloud Functions.
  5. Fai clic sul nome della funzione (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 degli audit log 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.

(Opzione 2) Prima di iniziare

Assicurati di soddisfare il seguente prerequisito aggiuntivo:

  • 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 utente Creazione di un bucket.
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, slack-audit-logs).

Configura il ruolo e il criterio IAM per i caricamenti S3

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

  2. Inserisci le seguenti norme. 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 policy 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 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 inserisci 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, sostituendole con i tuoi valori:

    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 con autorizzazione di sola lettura per Google SecOps

  1. Vai a AWS Console > IAM > Users > Create user.
  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 i criteri.

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

    {
  "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 policy 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 gli audit log 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.

    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/

      Sostituisci slack-audit-logs con il nome effettivo del bucket S3.

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

    • Età massima del 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 IAM secops-reader).

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

  8. Fai clic su Avanti.

  9. 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 il tasto 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 il tasto 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 il tasto 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 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 il tasto 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 il tasto entity.channel.privacy
entity.file.filetype target.resource.attribute.labels Mappato direttamente con il tasto 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 il tasto entity.file.title
entity.huddle.date_end about.resource.attribute.labels Mappato direttamente con il tasto entity.huddle.date_end
entity.huddle.date_start about.resource.attribute.labels Mappato direttamente con il tasto entity.huddle.date_start
entity.huddle.id about.resource.attribute.labels Mappato direttamente con il tasto entity.huddle.id
entity.huddle.participants.0 about.resource.attribute.labels Mappato direttamente con il tasto entity.huddle.participants.0
entity.huddle.participants.1 about.resource.attribute.labels Mappato direttamente con il tasto 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; impostato 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 date_create esiste, altrimenti Audit Logs se user_id esiste
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 date_create esiste, altrimenti SLACK se user_id esiste
details.url_private target.url Mappato dal log delle modifiche
details.previous_ip_address principal.labels Mappato dal log delle modifiche
details.previous_ua principal.labels Mappato dal log delle modifiche

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.