Recolha registos de auditoria do Slack

Suportado em:

Google secops SIEM

Este guia explica como carregar registos de auditoria do Slack para o Google Security Operations através das funções do Google Cloud Run ou do Amazon S3 com o AWS Lambda.

Antes de começar

Certifique-se de que cumpre os seguintes pré-requisitos:

Instância do Google SecOps.
Plano Slack Enterprise Grid com acesso de proprietário da organização ou administrador.
Acesso privilegiado a:
- Google Cloud (para a opção 1: funções do Cloud Run e Cloud Scheduler) ou
- AWS (para a opção 2: S3, IAM, Lambda e EventBridge).

Recolha os pré-requisitos dos registos de auditoria do Slack (ID da app, token OAuth e ID da organização)

A API Slack Audit Logs requer um token OAuth de utilizador com o âmbito auditlogs:read. Este token tem de ser obtido através da instalação de uma app ao nível da organização do Enterprise Grid e não ao nível do espaço de trabalho.

Crie uma app Slack para registos de auditoria

Inicie sessão na consola de administração do Slack com uma conta de administrador ou de proprietário da organização do Enterprise Grid.
Aceda a https://api.slack.com/apps e clique em Create New App > From scratch.
Forneça os seguintes detalhes de configuração:
- Nome da app: introduza um nome descritivo (por exemplo, Google SecOps Audit Integration).
- Escolha um espaço de trabalho para desenvolver a sua app: selecione o seu Development Slack Workspace (qualquer espaço de trabalho na organização).
Clique em Criar app.

Configure âmbitos do OAuth

Navegue para OAuth e autorizações na barra lateral esquerda.
Desloque a página para baixo até à secção Âmbitos.
Em Âmbitos do token de utilizador (NÃO âmbitos do token do bot), clique em Adicionar um âmbito do OAuth.
Adicione o âmbito: auditlogs:read.

Ative a distribuição pública

Navegue para Gerir distribuição na barra lateral esquerda.
Em Partilhe a sua app com outros espaços de trabalho, certifique-se de que todas as quatro secções têm marcas de verificação verdes:
- Remova informações codificadas
- Ative a distribuição pública
- Defina um URL de redirecionamento
- Adicione um âmbito do OAuth
Clique em Ativar distribuição pública.

Instale a app na organização do Enterprise Grid

Navegue para OAuth e autorizações na barra lateral esquerda.
Clique em Instalar na organização (NÃO "Instalar no Workspace").

CRÍTICO: verifique o menu pendente na parte superior direita do ecrã de instalação para confirmar que está a instalar na organização empresarial e não num espaço de trabalho individual.

Reveja as autorizações pedidas e clique em Permitir.
Após a conclusão da autorização, é feito o redirecionamento novamente para a página OAuth e autorizações.

Recupere credenciais

Em Símbolos OAuth para o seu Workspace, localize o Símbolo OAuth do utilizador.
Copie e guarde em segurança a chave que começa por xoxp- (por exemplo, xoxp-1234567890-0987654321-1234567890-abc123def456).

Importante: este é o seu SLACK_ADMIN_TOKEN para a função Lambda ou a função Cloud Run. Armazene-o em segurança.

Tome nota do seu ID da organização:
- Aceda à consola de administração do Slack.
- Navegue para Definições e autorizações > Definições da organização.
- Copie o ID da organização.

Opção 1: configure a exportação dos registos de auditoria do Slack através das funções do Google Cloud Run

Esta opção usa as funções do Google Cloud Run e o Cloud Scheduler para recolher registos de auditoria do Slack e carregá-los diretamente no Google SecOps.

Configurar o diretório

Crie um novo diretório na sua máquina local para a implementação da função do Cloud Run.
Transfira os seguintes ficheiros do repositório GitHub chronicle-ingestion-scripts:
- Na pasta slack, transfira:
  - .env.yml
  - main.py
  - requirements.txt
- A partir da raiz do repositório, transfira todo o diretório common com todos os respetivos ficheiros:
  - common/__init__.py
  - common/auth.py
  - common/env_constants.py
  - common/ingest.py
  - common/status.py
  - common/utils.py
Coloque todos os ficheiros transferidos no diretório de implementação.

A estrutura do diretório deve ter o seguinte aspeto:

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

Crie Secrets no Google Secret Manager

Na Google Cloud Console, aceda a Segurança > Secret Manager.
Clique em Criar segredo.
Forneça os seguintes detalhes de configuração para a conta de serviço do Chronicle:
- Nome: introduza chronicle-service-account.
- Valor secreto: cole o conteúdo do seu ficheiro JSON de autenticação de carregamento do Google SecOps.
Clique em Criar segredo.
Copie o nome do recurso secreto no formato: projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
Clique novamente em Criar segredo para criar um segundo segredo.
Forneça os seguintes detalhes de configuração para o token do Slack:
- Nome: introduza slack-admin-token.
- Valor secreto: cole o seu símbolo OAuth do utilizador do Slack (começando por xoxp-).
Clique em Criar segredo.
Copie o nome do recurso secreto no formato: projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Definir as variáveis de ambiente de tempo de execução necessárias

Abra o ficheiro .env.yml no diretório de implementação.
Configure as variáveis de ambiente com os seus valores:

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"

Substitua o seguinte:

<your-chronicle-customer-id>: o seu ID de cliente do Google SecOps.
<PROJECT_ID>: o ID do seu projeto do Google Cloud.
CHRONICLE_REGION: definido para a sua região do Google SecOps. Valores válidos: 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 e southamerica-east1.
POLL_INTERVAL: intervalo de frequência (em minutos) em que a função é executada. Esta duração tem de ser igual ao intervalo da tarefa do Cloud Scheduler.

Guarde o ficheiro .env.yml.

Implementar a função do Cloud Run

Abra um terminal ou o Cloud Shell na Google Cloud Console.
Navegue para o diretório de implementação:

cd /path/to/deployment_directory

Execute o seguinte comando para implementar a função do 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>

Substitua <SERVICE_ACCOUNT_EMAIL> pelo endereço de email da conta de serviço que quer que a sua função do Cloud Run use.

Aguarde a conclusão da implementação.
Após a implementação, tome nota do URL da função a partir da saída.

Configure o Cloud Scheduler

Na Google Cloud Console, aceda a Cloud Scheduler > Criar tarefa.
Forneça os seguintes detalhes de configuração:
- Nome: introduza slack-audit-scheduler.
- Região: selecione a mesma região onde implementou a função do Cloud Run.
- Frequência: introduza */5 * * * * (executa-se a cada 5 minutos, correspondendo ao valor POLL_INTERVAL).
- Fuso horário: selecione UTC.
- Tipo de destino: selecione HTTP.
- URL: introduza o URL da função do Cloud Run a partir da saída da implementação.
- Método HTTP: selecione POST.
- Cabeçalho de autorização: selecione Adicionar token OIDC.
- Conta de serviço: selecione a mesma conta de serviço usada para a função do Cloud Run.
Clique em Criar.

Opção 2: configure a exportação de registos de auditoria do Slack através do AWS S3

Esta opção usa o AWS Lambda para recolher registos de auditoria do Slack e armazená-los no S3. Em seguida, configura um feed do Google SecOps para carregar os registos.

Configure o contentor do AWS S3 e o IAM para o Google SecOps

Crie um contentor do Amazon S3 seguindo este manual do utilizador: Criar um contentor
Guarde o Nome e a Região do contentor para referência futura (por exemplo, slack-audit-logs).
Crie um utilizador seguindo este guia do utilizador: criar um utilizador do IAM.
Selecione o utilizador criado.
Selecione o separador Credenciais de segurança.
Clique em Criar chave de acesso na secção Chaves de acesso.
Selecione Serviço de terceiros como Exemplo de utilização.
Clicar em Seguinte.
Opcional: adicione a etiqueta de descrição.
Clique em Criar chave de acesso.
Clique em Transferir ficheiro .csv para guardar a chave de acesso e a chave de acesso secreta para referência futura.
Clique em Concluído.
Selecione o separador Autorizações.
Clique em Adicionar autorizações na secção Políticas de autorizações.
Selecione Adicionar autorizações.
Selecione Anexar políticas diretamente.
Pesquise a política AmazonS3FullAccess.
Selecione a política.
Clicar em Seguinte.
Clique em Adicionar autorizações.

Configure a política e a função de IAM para carregamentos do S3

Na consola da AWS, aceda a IAM > Políticas > Criar política > separador JSON.
Copie e cole a política abaixo.
JSON da política (substitua slack-audit-logs se tiver introduzido um nome de contentor diferente):

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

Clicar em Seguinte.
Introduza o nome da política SlackAuditS3Policy.
Clique em Criar política.
Aceda a IAM > Funções > Criar função > Serviço AWS > Lambda.
Anexe a política criada recentemente SlackAuditS3Policy.
Dê o nome SlackAuditToS3Role à função e clique em Criar função.

Crie a função Lambda

Na consola da AWS, aceda a Lambda > Functions > Create function.
Clique em Criar do zero.
Faculte os seguintes detalhes de configuração:

Definição	Valor
Nome	`slack_audit_to_s3`
Runtime	Python 3.13
Arquitetura	x86_64
Função de execução	`SlackAuditToS3Role`

Clique em Criar função.
Depois de criar a função, abra o separador Código, elimine o fragmento de código e cole o código abaixo (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())

Aceda a Configuração > Variáveis de ambiente > Editar > Adicionar variável de ambiente.
Introduza as variáveis de ambiente indicadas abaixo, substituindo-as pelos seus valores.

Variáveis de ambiente

Chave	Valor de exemplo
`S3_BUCKET`	`slack-audit-logs`
`S3_PREFIX`	`slack/audit/`
`STATE_KEY`	`slack/audit/state.json`
`SLACK_AUDIT_TOKEN`	`xoxp-***` (token de utilizador ao nível da organização com `auditlogs:read`)
`LIMIT`	`200`
`MAX_PAGES`	`20`
`LOOKBACK_SECONDS`	`3600`
`HTTP_TIMEOUT`	`60`
`HTTP_RETRIES`	`3`
`RETRY_AFTER_DEFAULT`	`2`
`ACTIONS`	(opcional, CSV) `user_login,app_installed`

Clique em Guardar.
Selecione o separador Configuração.
No painel Configuração geral, clique em Editar.
Altere Tempo limite para 5 minutos (300 segundos) e clique em Guardar.

Crie um horário do EventBridge

Aceda a Amazon EventBridge > Scheduler > Create schedule.
Forneça os seguintes detalhes de configuração:
- Nome: introduza slack-audit-1h.
- Programação recorrente: selecione Programação baseada em tarifas.
- Expressão de tarifa: introduza 1 horas.
- Intervalo de tempo flexível: selecione Desativar.
Clicar em Seguinte.
Selecione Segmentar:
- API de destino: selecione AWS Lambda Invoke.
- Função Lambda: selecione slack_audit_to_s3.
Clicar em Seguinte.
Clique em Seguinte (ignore as definições opcionais).
Reveja e clique em Criar horário.

(Opcional) Crie um utilizador e chaves da IAM só de leitura para o Google SecOps

Aceda a AWS Console > IAM > Users > Create user.
Forneça os seguintes detalhes de configuração:
- Nome de utilizador: introduza secops-reader.
- Tipo de acesso: selecione Acesso programático.
Clicar em Seguinte.
Selecione Anexar políticas diretamente.
Clique em Criar política.
No separador JSON, cole:

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

Clicar em Seguinte.
Introduza o nome da política secops-reader-policy.
Clique em Criar política.
Regresse à página de criação de utilizadores, atualize a lista de políticas e selecione secops-reader-policy.
Clicar em Seguinte.
Clique em Criar utilizador.
Selecione o utilizador criado secops-reader.
Aceda a Credenciais de segurança > Chaves de acesso > Criar chave de acesso.
Selecione Serviço de terceiros.
Clicar em Seguinte.
Clique em Criar chave de acesso.
Clique em Transferir ficheiro .csv para guardar as credenciais.

Configure um feed no Google SecOps para carregar registos de auditoria do Slack

Aceda a Definições do SIEM > Feeds.
Clique em Adicionar novo.
No campo Nome do feed, introduza um nome para o feed (por exemplo, Slack Audit Logs).
Selecione Amazon S3 V2 como o Tipo de origem.
Selecione Auditoria do Slack como o Tipo de registo.
Clicar em Seguinte.
Especifique valores para os seguintes parâmetros de entrada:
- URI do S3: s3://slack-audit-logs/slack/audit/
- Opções de eliminação de origens: selecione a opção de eliminação de acordo com a sua preferência.
- Idade máxima do ficheiro: inclua ficheiros modificados no último número de dias. A predefinição é 180 dias.
- ID da chave de acesso: chave de acesso do utilizador com acesso ao contentor do S3 (de secops-reader).
- Chave de acesso secreta: chave secreta do utilizador com acesso ao contentor do S3 (de secops-reader).
- Espaço de nomes do recurso: o espaço de nomes do recurso.
- Etiquetas de carregamento: a etiqueta aplicada aos eventos deste feed.
Clicar em Seguinte.
Reveja a nova configuração do feed no ecrã Finalizar e, de seguida, clique em Enviar.

Tabela de mapeamento da UDM

Campo de registo	Mapeamento da UDM	Lógica
`action`	`metadata.product_event_type`	Mapeado diretamente a partir do campo `action` no registo não processado.
`actor.type`	`principal.labels.value`	Mapeado diretamente a partir do campo `actor.type`, com a chave `actor.type` adicionada.
`actor.user.email`	`principal.user.email_addresses`	Mapeado diretamente a partir do campo `actor.user.email`.
`actor.user.id`	`principal.user.product_object_id`	Mapeado diretamente a partir do campo `actor.user.id`.
`actor.user.id`	`principal.user.userid`	Mapeado diretamente a partir do campo `actor.user.id`.
`actor.user.name`	`principal.user.user_display_name`	Mapeado diretamente a partir do campo `actor.user.name`.
`actor.user.team`	`principal.user.group_identifiers`	Mapeado diretamente a partir do campo `actor.user.team`.
`context.ip_address`	`principal.ip`	Mapeado diretamente a partir do campo `context.ip_address`.
`context.location.domain`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `context.location.domain`, com a chave `context.location.domain` adicionada.
`context.location.id`	`about.resource.id`	Mapeado diretamente a partir do campo `context.location.id`.
`context.location.name`	`about.resource.name`	Mapeado diretamente a partir do campo `context.location.name`.
`context.location.name`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `context.location.name`, com a chave `context.location.name` adicionada.
`context.location.type`	`about.resource.resource_subtype`	Mapeado diretamente a partir do campo `context.location.type`.
`context.session_id`	`network.session_id`	Mapeado diretamente a partir do campo `context.session_id`.
`context.ua`	`network.http.user_agent`	Mapeado diretamente a partir do campo `context.ua`.
`context.ua`	`network.http.parsed_user_agent`	Informações do agente do utilizador analisadas derivadas do campo `context.ua` através do filtro `parseduseragent`.
`country`	`principal.location.country_or_region`	Mapeado diretamente a partir do campo `country`.
`date_create`	`metadata.event_timestamp.seconds`	A indicação de tempo de época do campo `date_create` é convertida num objeto de indicação de tempo.
`details.inviter.email`	`target.user.email_addresses`	Mapeado diretamente a partir do campo `details.inviter.email`.
`details.inviter.id`	`target.user.product_object_id`	Mapeado diretamente a partir do campo `details.inviter.id`.
`details.inviter.name`	`target.user.user_display_name`	Mapeado diretamente a partir do campo `details.inviter.name`.
`details.inviter.team`	`target.user.group_identifiers`	Mapeado diretamente a partir do campo `details.inviter.team`.
`details.reason`	`security_result.description`	Mapeado diretamente a partir do campo `details.reason` ou, se for uma matriz, concatenado com vírgulas.
`details.type`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `details.type`, com a chave `details.type` adicionada.
`details.type`	`security_result.summary`	Mapeado diretamente a partir do campo `details.type`.
`entity.app.id`	`target.resource.id`	Mapeado diretamente a partir do campo `entity.app.id`.
`entity.app.name`	`target.resource.name`	Mapeado diretamente a partir do campo `entity.app.name`.
`entity.channel.id`	`target.resource.id`	Mapeado diretamente a partir do campo `entity.channel.id`.
`entity.channel.name`	`target.resource.name`	Mapeado diretamente a partir do campo `entity.channel.name`.
`entity.channel.privacy`	`target.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.channel.privacy`, com a chave `entity.channel.privacy` adicionada.
`entity.file.filetype`	`target.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.file.filetype`, com a chave `entity.file.filetype` adicionada.
`entity.file.id`	`target.resource.id`	Mapeado diretamente a partir do campo `entity.file.id`.
`entity.file.name`	`target.resource.name`	Mapeado diretamente a partir do campo `entity.file.name`.
`entity.file.title`	`target.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.file.title`, com a chave `entity.file.title` adicionada.
`entity.huddle.date_end`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.huddle.date_end`, com a chave `entity.huddle.date_end` adicionada.
`entity.huddle.date_start`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.huddle.date_start`, com a chave `entity.huddle.date_start` adicionada.
`entity.huddle.id`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.huddle.id`, com a chave `entity.huddle.id` adicionada.
`entity.huddle.participants.0`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.huddle.participants.0`, com a chave `entity.huddle.participants.0` adicionada.
`entity.huddle.participants.1`	`about.resource.attribute.labels.value`	Mapeado diretamente a partir do campo `entity.huddle.participants.1`, com a chave `entity.huddle.participants.1` adicionada.
`entity.type`	`target.resource.resource_subtype`	Mapeado diretamente a partir do campo `entity.type`.
`entity.user.email`	`target.user.email_addresses`	Mapeado diretamente a partir do campo `entity.user.email`.
`entity.user.id`	`target.user.product_object_id`	Mapeado diretamente a partir do campo `entity.user.id`.
`entity.user.name`	`target.user.user_display_name`	Mapeado diretamente a partir do campo `entity.user.name`.
`entity.user.team`	`target.user.group_identifiers`	Mapeado diretamente a partir do campo `entity.user.team`.
`entity.workflow.id`	`target.resource.id`	Mapeado diretamente a partir do campo `entity.workflow.id`.
`entity.workflow.name`	`target.resource.name`	Mapeado diretamente a partir do campo `entity.workflow.name`.
`id`	`metadata.product_log_id`	Mapeado diretamente a partir do campo `id`.
`ip`	`principal.ip`	Mapeado diretamente a partir do campo `ip`. Determinado pela lógica com base no campo `action`. A predefinição é `USER_COMMUNICATION`, mas muda para outros valores, como `USER_CREATION`, `USER_LOGIN`, `USER_LOGOUT`, `USER_RESOURCE_ACCESS`, `USER_RESOURCE_UPDATE_PERMISSIONS` ou `USER_CHANGE_PERMISSIONS`, com base no valor de `action`. Codificado de forma rígida para "SLACK_AUDIT". Definido como "Enterprise Grid" se `date_create` existir. Caso contrário, é definido como "Registos de auditoria" se `user_id` existir. Codificado de forma rígida para "Slack". Codificado de forma rígida como "REMOTE". Definido como "SSO" se `action` contiver "user_login" ou "user_logout". Caso contrário, defina como "MACHINE". Não mapeado nos exemplos fornecidos. A predefinição é "ALLOW", mas é definida como "BLOCK" se `action` for "user_login_failed". Definido como "Slack" se `date_create` existir. Caso contrário, definido como "SLACK" se `user_id` existir.
`user_agent`	`network.http.user_agent`	Mapeado diretamente a partir do campo `user_agent`.
`user_id`	`principal.user.product_object_id`	Mapeado diretamente a partir do campo `user_id`.
`username`	`principal.user.product_object_id`	Mapeado diretamente a partir do campo `username`.

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais da Google SecOps.