SLACK_AUDIT

Supportato in:

Questa guida 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.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Istanza Google SecOps.
  • 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) oppure
    • AWS (per l'opzione 2: S3, IAM, Lambda, EventBridge).

Prerequisiti per la raccolta dei log di controllo di Slack (ID app, token OAuth, ID organizzazione)

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.

Creare l'app Slack per i log di controllo

  1. Accedi alla console di amministrazione di Slack con un account proprietario dell'organizzazione Enterprise Grid o amministratore.
  2. Vai su https://api.slack.com/apps e fai clic su Crea nuova app > Da zero.
  3. 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).
  4. Fai clic su Crea app.

Configura gli ambiti OAuth

  1. Vai a OAuth e autorizzazioni nella barra laterale 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 l'ambito: auditlogs:read.

Attivare la distribuzione pubblica

  1. Vai a Gestisci distribuzione nella barra laterale sinistra.
  2. In Condividi la tua app con altri spazi di lavoro, assicurati che tutte e quattro le sezioni siano contrassegnate da un segno di spunta verde:
    • Rimuovere informazioni codificate
    • Attiva la distribuzione pubblica
    • Impostare un URL di reindirizzamento
    • Aggiungere un ambito OAuth
  3. Fai clic su Attiva distribuzione pubblica.

Installare l'app nell'organizzazione Enterprise Grid

  1. Vai a OAuth e autorizzazioni nella barra laterale sinistra.
  2. Fai clic su Installa nell'organizzazione (NON "Installa in Workspace").

CRITICO: controlla il menu a discesa in alto a destra della schermata di installazione per verificare di eseguire l'installazione nell'organizzazione Enterprise, non in un singolo spazio di lavoro.

  1. Controlla le autorizzazioni richieste e fai clic su Consenti.
  2. Al termine dell'autorizzazione, tornerai alla pagina OAuth e autorizzazioni.

Recuperare le credenziali

  1. In Token OAuth per il tuo spazio di lavoro, individua il token OAuth utente.
  2. Copia e salva in modo sicuro il token che inizia con xoxp- (ad esempio, xoxp-1234567890-0987654321-1234567890-abc123def456).

Importante:questo è il tuo SLACK_ADMIN_TOKEN per la funzione Lambda o Cloud Run. Conservalo in modo sicuro.

  1. Prendi nota dell'ID organizzazione:
    • Vai alla Console di amministrazione di Slack.
    • Vai a Impostazioni e autorizzazioni > Impostazioni dell'organizzazione.
    • Copia l'ID organizzazione.

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 gli audit log di Slack e inserirli direttamente in Google SecOps.

Configurare la directory

  1. Crea una nuova directory sulla macchina locale per il deployment della funzione Cloud Run.
  2. Scarica i seguenti file dal repository GitHub di Chronicle ingestion-scripts:
    • Dalla cartella slack, scarica:
      • .env.yml
      • main.py
      • requirements.txt
    • Dalla radice del repository, scarica l'intera directory common con tutti i relativi file:
      • common/__init__.py
      • common/auth.py
      • common/env_constants.py
      • common/ingest.py
      • common/status.py
      • common/utils.py
  3. Inserisci tutti i file scaricati nella directory di deployment.

La struttura di directory dovrebbe essere simile alla seguente:

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

Crea secret in Google Secret Manager

  1. Nella console Google Cloud, vai a Sicurezza > Secret Manager.
  2. Fai clic su Crea secret.
  3. Fornisci i seguenti dettagli di configurazione per il service account Chronicle:
    • Nome: inserisci chronicle-service-account.
    • Valore segreto: incolla i contenuti del file JSON di autenticazione dell'importazione di Google SecOps.
  4. Fai clic su Crea secret.
  5. Copia il nome della risorsa secret nel formato: projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
  6. Fai di nuovo clic su Crea secret per creare un secondo secret.
  7. Fornisci i seguenti dettagli di configurazione per il token Slack:
    • Nome: inserisci slack-admin-token.
    • Valore del segreto: incolla il token OAuth utente di Slack (che inizia con xoxp-).
  8. Fai clic su Crea secret.
  9. Copia il nome della risorsa secret nel formato: projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Impostazione delle variabili di ambiente runtime richieste

  1. Apri il file .env.yml nella directory di deployment.
  2. Configura le variabili di ambiente con i tuoi valori:
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: impostalo sulla tua 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.
  1. Salva il file .env.yml.

Deployment della funzione Cloud Run

  1. Apri un terminale o Cloud Shell nella Google Cloud Console.
  2. Vai alla directory di deployment:
cd /path/to/deployment_directory
  1. Esegui questo comando per eseguire il deployment della funzione Cloud Run:
gcloud functions deploy slack-audit-to-chronicle \
  --entry-point main \
  --trigger-http \
  --runtime python39 \
  --env-vars-file .env.yml \
  --timeout 300s \
  --memory 512MB \
  --service-account <SERVICE_ACCOUNT_EMAIL>

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

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

Configura Cloud Scheduler

  1. Nella console Google Cloud, vai a Cloud Scheduler > Crea job.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci slack-audit-scheduler.
    • Regione: seleziona la stessa regione in cui hai eseguito il deployment della funzione Cloud Run.
    • Frequenza: inserisci */5 * * * * (l'esecuzione avviene ogni 5 minuti, in corrispondenza del valore POLL_INTERVAL).
    • Fuso orario: seleziona UTC.
    • Tipo di destinazione: seleziona HTTP.
    • URL: inserisci l'URL della funzione Cloud Run dall'output del deployment.
    • Metodo HTTP: seleziona POST.
    • Intestazione di autenticazione: seleziona Aggiungi token OIDC.
    • Service account: seleziona lo stesso account di servizio utilizzato per la funzione Cloud Run.
  3. Fai clic su Crea.

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 S3, quindi configura un feed Google SecOps per importare i log.

Configura il bucket AWS S3 e IAM per Google SecOps

  1. Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, slack-audit-logs).
  3. Crea un utente seguendo questa guida utente: Creazione di un utente IAM.
  4. Seleziona l'utente creato.
  5. Seleziona la scheda Credenziali di sicurezza.
  6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
  7. Seleziona Servizio di terze parti come Caso d'uso.
  8. Fai clic su Avanti.
  9. (Facoltativo) Aggiungi il tag della descrizione.
  10. Fai clic su Crea chiave di accesso.
  11. Fai clic su Scarica file .csv per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
  12. Fai clic su Fine.
  13. Seleziona la scheda Autorizzazioni.
  14. Fai clic su Aggiungi autorizzazioni nella sezione Criteri per le autorizzazioni.
  15. Seleziona Aggiungi autorizzazioni.
  16. Seleziona Collega direttamente i criteri.
  17. Cerca i criteri AmazonS3FullAccess.
  18. Seleziona la policy.
  19. Fai clic su Avanti.
  20. Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

  1. Nella console AWS, vai a IAM > Policy > Crea policy > scheda JSON.
  2. Copia e incolla il criterio riportato di seguito.
  3. JSON delle policy (sostituisci slack-audit-logs se hai inserito 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"
    }
  ]
}
  1. Fai clic su Avanti.
  2. Inserisci il nome della policy SlackAuditS3Policy.
  3. Fai clic su Crea policy.
  4. Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.
  5. Allega il criterio appena creato SlackAuditS3Policy.
  6. 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
  1. Fai clic su Crea funzione.
  2. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e incolla il codice riportato di seguito (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"]  # org-level user token with auditlogs:read
BUCKET       = os.environ["S3_BUCKET"]
PREFIX       = os.environ.get("S3_PREFIX", "slack/audit/")
STATE_KEY    = os.environ.get("STATE_KEY", "slack/audit/state.json")
LIMIT        = int(os.environ.get("LIMIT", "200"))             # Slack recommends <= 200
MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600")) # First-run window
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
RETRY_AFTER_DEFAULT = int(os.environ.get("RETRY_AFTER_DEFAULT", "2"))
# Optional server-side filters (comma-separated 'action' values), empty means no filter
ACTIONS      = os.environ.get("ACTIONS", "").strip()

s3 = boto3.client("s3")


def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
        st = json.loads(obj["Body"].read() or b"{}")
        return {"cursor": st.get("cursor")}
    except Exception:
        return {"cursor": None}


def _put_state(state: dict) -> None:
    body = json.dumps(state, separators=(",", ":")).encode("utf-8")
    s3.put_object(Bucket=BUCKET, Key=STATE_KEY, Body=body, ContentType="application/json")


def _http_get(params: dict) -> dict:
    qs  = urllib.parse.urlencode(params, doseq=True)
    url = f"{BASE_URL}?{qs}" if qs else BASE_URL
    req = Request(url, method="GET")
    req.add_header("Authorization", f"Bearer {TOKEN}")
    req.add_header("Accept", "application/json")

    attempt = 0
    while True:
        try:
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            # Respect Retry-After on 429/5xx
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                retry_after = 0
                try:
                    retry_after = int(e.headers.get("Retry-After", RETRY_AFTER_DEFAULT))
                except Exception:
                    retry_after = RETRY_AFTER_DEFAULT
                time.sleep(max(1, retry_after))
                attempt += 1
                continue
            # Re-raise other HTTP errors
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(RETRY_AFTER_DEFAULT)
                attempt += 1
                continue
            raise


def _write_page(data: dict, page_idx: int) -> str:
    """
    Extract entries from Slack API response and write as JSONL (one event per line).
    Chronicle requires newline-delimited JSON, not a JSON array.
    """
    entries = data.get("entries") or []
    
    if not entries:
        # No entries to write, skip file creation
        return None
    
    # Convert each entry to a single-line JSON string
    lines = [json.dumps(entry, separators=(",", ":")) for entry in entries]
    
    # Join with newlines to create JSONL format
    body = "\n".join(lines).encode("utf-8")
    
    # Write to S3
    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 entries in JSONL format
        written_key = _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())
  1. Vai a Configurazione > Variabili di ambiente > Modifica > Aggiungi variabile di ambiente.
  2. Inserisci le variabili di ambiente fornite di seguito, sostituendole con i tuoi valori.

Variabili di ambiente

Chiave Valore di esempio
S3_BUCKET slack-audit-logs
S3_PREFIX slack/audit/
STATE_KEY slack/audit/state.json
SLACK_AUDIT_TOKEN xoxp-*** (token utente a livello di organizzazione con auditlogs:read)
LIMIT 200
MAX_PAGES 20
LOOKBACK_SECONDS 3600
HTTP_TIMEOUT 60
HTTP_RETRIES 3
RETRY_AFTER_DEFAULT 2
ACTIONS (facoltativo, CSV) user_login,app_installed
  1. Fai clic su Salva.
  2. Seleziona la scheda Configurazione.
  3. Nel riquadro Configurazione generale, fai clic su Modifica.
  4. Modifica Timeout impostando 5 minuti (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 della tariffa: inserisci 1 ore.
    • 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 chiavi e utenti IAM 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 Collega direttamente i criteri.
  5. Fai clic su Crea policy.
  6. 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"
    }
  ]
}
  1. Fai clic su Avanti.
  2. Inserisci il nome della policy secops-reader-policy.
  3. Fai clic su Crea policy.
  4. Torna alla pagina di creazione dell'utente, aggiorna l'elenco delle policy e seleziona secops-reader-policy.
  5. Fai clic su Avanti.
  6. Fai clic su Crea utente.
  7. Seleziona l'utente creato secops-reader.
  8. Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.
  9. Seleziona Servizio di terze parti.
  10. Fai clic su Avanti.
  11. Fai clic su Crea chiave di accesso.
  12. 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.
  3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Slack Audit Logs).
  4. Seleziona Amazon S3 V2 come Tipo di origine.
  5. Seleziona Audit di Slack come Tipo di log.
  6. Fai clic su Avanti.
  7. Specifica i valori per i seguenti parametri di input:
    • URI S3: s3://slack-audit-logs/slack/audit/
    • Opzioni 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 (da secops-reader).
    • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3 (da secops-reader).
    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
    • Etichette di importazione: l'etichetta applicata 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 Logic
action metadata.product_event_type Mappato direttamente dal campo action nel log non elaborato.
actor.type principal.labels.value Mappato direttamente dal campo actor.type, con l'aggiunta della chiave actor.type.
actor.user.email principal.user.email_addresses Mappato direttamente dal campo actor.user.email.
actor.user.id principal.user.product_object_id Mappato direttamente dal campo actor.user.id.
actor.user.id principal.user.userid Mappato direttamente dal campo actor.user.id.
actor.user.name principal.user.user_display_name Mappato direttamente dal campo actor.user.name.
actor.user.team principal.user.group_identifiers Mappato direttamente dal campo actor.user.team.
context.ip_address principal.ip Mappato direttamente dal campo context.ip_address.
context.location.domain about.resource.attribute.labels.value Mappato direttamente dal campo context.location.domain, con l'aggiunta della chiave context.location.domain.
context.location.id about.resource.id Mappato direttamente dal campo context.location.id.
context.location.name about.resource.name Mappato direttamente dal campo context.location.name.
context.location.name about.resource.attribute.labels.value Mappato direttamente dal campo context.location.name, con l'aggiunta della chiave context.location.name.
context.location.type about.resource.resource_subtype Mappato direttamente dal campo context.location.type.
context.session_id network.session_id Mappato direttamente dal campo context.session_id.
context.ua network.http.user_agent Mappato direttamente dal campo context.ua.
context.ua network.http.parsed_user_agent Informazioni sull'user agent analizzate derivate dal campo context.ua utilizzando il filtro parseduseragent.
country principal.location.country_or_region Mappato direttamente dal campo country.
date_create metadata.event_timestamp.seconds Il timestamp Unix del campo date_create viene convertito in un oggetto timestamp.
details.inviter.email target.user.email_addresses Mappato direttamente dal campo details.inviter.email.
details.inviter.id target.user.product_object_id Mappato direttamente dal campo details.inviter.id.
details.inviter.name target.user.user_display_name Mappato direttamente dal campo details.inviter.name.
details.inviter.team target.user.group_identifiers Mappato direttamente dal campo details.inviter.team.
details.reason security_result.description Mappato direttamente dal campo details.reason o, se si tratta di un array, concatenato con virgole.
details.type about.resource.attribute.labels.value Mappato direttamente dal campo details.type, con l'aggiunta della chiave details.type.
details.type security_result.summary Mappato direttamente dal campo details.type.
entity.app.id target.resource.id Mappato direttamente dal campo entity.app.id.
entity.app.name target.resource.name Mappato direttamente dal campo entity.app.name.
entity.channel.id target.resource.id Mappato direttamente dal campo entity.channel.id.
entity.channel.name target.resource.name Mappato direttamente dal campo entity.channel.name.
entity.channel.privacy target.resource.attribute.labels.value Mappato direttamente dal campo entity.channel.privacy, con l'aggiunta della chiave entity.channel.privacy.
entity.file.filetype target.resource.attribute.labels.value Mappato direttamente dal campo entity.file.filetype, con l'aggiunta della chiave entity.file.filetype.
entity.file.id target.resource.id Mappato direttamente dal campo entity.file.id.
entity.file.name target.resource.name Mappato direttamente dal campo entity.file.name.
entity.file.title target.resource.attribute.labels.value Mappato direttamente dal campo entity.file.title, con l'aggiunta della chiave entity.file.title.
entity.huddle.date_end about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.date_end, con l'aggiunta della chiave entity.huddle.date_end.
entity.huddle.date_start about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.date_start, con l'aggiunta della chiave entity.huddle.date_start.
entity.huddle.id about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.id, con l'aggiunta della chiave entity.huddle.id.
entity.huddle.participants.0 about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.participants.0, con l'aggiunta della chiave entity.huddle.participants.0.
entity.huddle.participants.1 about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.participants.1, con l'aggiunta della chiave entity.huddle.participants.1.
entity.type target.resource.resource_subtype Mappato direttamente dal campo entity.type.
entity.user.email target.user.email_addresses Mappato direttamente dal campo entity.user.email.
entity.user.id target.user.product_object_id Mappato direttamente dal campo entity.user.id.
entity.user.name target.user.user_display_name Mappato direttamente dal campo entity.user.name.
entity.user.team target.user.group_identifiers Mappato direttamente dal campo entity.user.team.
entity.workflow.id target.resource.id Mappato direttamente dal campo entity.workflow.id.
entity.workflow.name target.resource.name Mappato direttamente dal campo entity.workflow.name.
id metadata.product_log_id Mappato direttamente dal campo id.
ip principal.ip Mappato direttamente dal campo ip. Determinato dalla logica in base al campo action. Il valore predefinito è USER_COMMUNICATION, ma cambia in altri valori come USER_CREATION, USER_LOGIN, USER_LOGOUT, USER_RESOURCE_ACCESS, USER_RESOURCE_UPDATE_PERMISSIONS o USER_CHANGE_PERMISSIONS in base al valore di action. Codificato in modo permanente su "SLACK_AUDIT". Imposta "Enterprise Grid" se esiste date_create, altrimenti imposta "Log di controllo" se esiste user_id. Codificato in modo permanente su "Slack". Codificato come "REMOTE". Imposta "SSO" se action contiene "user_login" o "user_logout". In caso contrario, imposta "MACHINE". Non mappato negli esempi forniti. Il valore predefinito è "ALLOW", ma è impostato su "BLOCK" se action è "user_login_failed". Imposta "Slack" se esiste date_create, altrimenti imposta "SLACK" se esiste user_id.
user_agent network.http.user_agent Mappato direttamente dal campo user_agent.
user_id principal.user.product_object_id Mappato direttamente dal campo user_id.
username principal.user.product_object_id Mappato direttamente dal campo username.

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