Coletar registros de auditoria do Slack

Compatível com:

Este documento explica como ingerir registros de auditoria do Slack no Google Security Operations usando as funções do Google Cloud Run ou o Amazon S3 com o AWS Lambda.

Os registros de auditoria do Slack fornecem um registro detalhado de eventos relacionados à segurança em toda a organização do Slack Enterprise Grid. Com a API Audit Logs, é possível monitorar ações do usuário, como logins, downloads de arquivos, instalações de apps e mudanças administrativas para fins de compliance e monitoramento de segurança.

Antes de começar

Verifique se você atende os seguintes pré-requisitos:

  • Uma instância do Google SecOps
  • Um plano do Slack Enterprise Grid com acesso de proprietário da organização ou administrador

  • Acesso privilegiado a:

    • Google Cloud (para a opção 1: Cloud Run Functions e Cloud Scheduler) ou
    • AWS (para a opção 2: S3, IAM, Lambda, EventBridge)

Coletar credenciais do Slack

Criar o app Slack

A API Slack Audit Logs exige um token OAuth do usuário com o escopo auditlogs:read. Esse token precisa ser obtido instalando um app no nível da organização do Enterprise Grid, não no nível do espaço de trabalho.

  1. Faça login no Admin Console do Slack com uma conta de administrador ou proprietário da organização do Enterprise Grid.
  2. Acesse a página de apps da API Slack.
  3. Clique em Criar app.
  4. Selecione Do zero.
  5. Informe os seguintes detalhes de configuração:
    • Nome do app: insira um nome descritivo, por exemplo, Google SecOps Audit Integration.
    • Escolha um espaço de trabalho para desenvolver seu app: selecione o espaço de trabalho do Slack de desenvolvimento (qualquer espaço de trabalho na organização).
  6. Clique em Criar app.

Configurar escopos do OAuth

  1. Na página de configurações do app, selecione OAuth e permissões na navegação à esquerda.
  2. Role a tela para baixo até a seção Escopos.
  3. Em Escopos do token de usuário (NÃO escopos do token de bot), clique em Adicionar um escopo do OAuth.
  4. Adicione o seguinte escopo:
    • auditlogs:read: permite o acesso à API Audit Logs para a organização do Enterprise Grid.
  5. Em Escopos do token de bot, clique em Adicionar um escopo do OAuth.

  6. Adicione o seguinte escopo:

    • users:read: esse escopo é necessário para ativar a instalação de apps no nível da organização.

Configurar o URL de redirecionamento

  1. Na página de configurações do app, selecione OAuth e permissões na navegação à esquerda.
  2. Acesse a seção URLs de redirecionamento.
  3. Clique em Adicionar novo URL de redirecionamento.

  4. Digite o seguinte URL:

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

  5. Clique em Adicionar.

  6. Clique em Salvar URLs.

Ativar a distribuição pública

Para instalar um app no nível da organização Enterprise (não apenas um espaço de trabalho), ative a distribuição pública.

Por que a distribuição pública é necessária?

  • O Slack exige que os apps com permissões em toda a organização tenham a distribuição pública ativada.
  • Isso permite a instalação no nível da organização em vez de em espaços de trabalho individuais.
  • Sem ele, só é possível instalar o app em um único workspace na sua Enterprise Grid.
  • Ativar a distribuição pública remove as restrições internas no escopo da instalação.

Para ativar a distribuição pública, siga estas etapas:

  1. Na página de configurações do app, selecione Gerenciar distribuição na navegação à esquerda.
  2. Em Compartilhe seu app com outros espaços de trabalho, verifique se todas as quatro seções têm marcas de seleção verdes:
    • Remover informações codificadas
    • Ativar a distribuição pública
    • Definir um URL de redirecionamento
    • Adicionar um escopo do OAuth
  3. Se alguma seção mostrar um X vermelho, expanda e conclua a ação necessária.
  4. Marque a caixa de seleção ao lado de Revisei e removi todas as informações codificadas.
  5. Clique em Ativar distribuição pública.

Instalar app em uma organização empresarial

  1. Na página de configurações do app, selecione OAuth e permissões na navegação à esquerda.
  2. Em Compartilhar o app com seu espaço de trabalho, copie o URL compartilhável.
  3. Digite o URL no navegador.
  4. Importante: na tela de instalação, verifique o menu suspenso no canto superior direito.
  5. Verifique se você está instalando na organização Enterprise, e não em um espaço de trabalho individual.
  6. Se um nome de espaço de trabalho aparecer no menu suspenso, clique nele e selecione o nome da sua organização do Enterprise.
  7. Analise as permissões solicitadas e clique em Permitir.

Recuperar credenciais

Depois que a autorização for concluída, você será redirecionado para a página OAuth e permissões.

  1. Em Tokens OAuth para seu espaço de trabalho, localize o Token OAuth do usuário.
  2. O token começa com xoxp-.

  3. Clique em Copiar e salve esse token com segurança.

  4. Anote o ID da organização:

    1. Acesse o Admin Console do Slack.
    2. Acesse Configurações e permissões > Configurações da organização.
    3. Copie o ID da organização.

Verifique as permissões

Para verificar se o app tem as permissões necessárias:

  1. Acesse a página de apps da API Slack.
  2. Selecione seu app.
  3. Selecione OAuth e permissões na navegação à esquerda.
  4. Em Tokens OAuth para seu espaço de trabalho, verifique se um Token OAuth do usuário aparece (começa com xoxp-).
  5. Em Escopos, verifique se auditlogs:read aparece em Escopos de token de usuário.

Testar o acesso à API

  • Teste seu token antes de continuar com a integração:

    SLACK_TOKEN="xoxp-your-token-here"

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

    Uma resposta bem-sucedida contém uma matriz entries com eventos de registro de auditoria. Se você receber um erro invalid_auth ou missing_scope, verifique seu token e escopos.

Opção 1: configurar a exportação de registros de auditoria do Slack usando as funções do Google Cloud Run

Essa opção usa o Google Cloud Run Functions e o Cloud Scheduler para coletar registros de auditoria do Slack e ingerir diretamente no Google SecOps usando os scripts de ingestão do Chronicle.

Antes de começar (opção 1)

Verifique se você atende aos seguintes pré-requisitos adicionais:

  • Um projeto do GCP com as seguintes APIs ativadas:
    • API Cloud Functions
    • API Cloud Scheduler
    • API Secret Manager
  • Permissões para criar funções do Cloud Functions, jobs do Cloud Scheduler e secrets no Secret Manager
  • Um arquivo JSON da conta de serviço do Google SecOps

Acessar a conta de serviço do Google SecOps

  1. Faça login no console do Google SecOps.
  2. Acesse Configurações do SIEM > Agentes de coleta.
  3. Baixe o arquivo de autenticação de ingestão.

  4. Salve o arquivo JSON com segurança. Você vai fazer upload disso como um secret no Google Secret Manager.

Preparar o código da função

Faça o download dos arquivos de implantação no repositório do GitHub de scripts de ingestão do Chronicle:

  1. Na pasta slack, faça o download de:
    • .env.yml
    • main.py
    • requirements.txt

  2. Na raiz do repositório, faça o download de todo o diretório common com todos os arquivos.

    Seu diretório de implantação precisa ter a seguinte estrutura:

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

Configurar secrets no Google Secret Manager

Armazene credenciais sensíveis no Secret Manager para acesso seguro pela função do Cloud Run.

Criar um secret para a conta de serviço do Google SecOps

  1. No Console do GCP, acesse Segurança > Secret Manager.
  2. Clique em Criar secret.
  3. Informe os seguintes detalhes de configuração:
    • Nome: insira chronicle-service-account.
    • Valor do secret: insira todo o conteúdo do arquivo JSON da conta de serviço do Google SecOps.
  4. Clique em Criar secret.

  5. Copie o nome do recurso do secret. O formato é:

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

Criar secret para o token do Slack

  1. Na página Secret Manager, clique em Criar secret.
  2. Informe os seguintes detalhes de configuração:
    • Nome: insira slack-admin-token.
    • Valor secreto: insira o token OAuth do usuário do Slack (começa com xoxp-).
  3. Clique em Criar secret.

  4. Copie o nome do recurso do secret. O formato é:

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

Configure as variáveis de ambiente

  1. Abra o arquivo .env.yml no diretório de implantação e configure as variáveis de 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"

    Substitua:

    • <your-chronicle-customer-id>: seu ID de cliente do Google SecOps.
    • <PROJECT_ID> pelo ID do projeto no Google Cloud.
    • CHRONICLE_REGION: defina como 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, southamerica-east1.
    • POLL_INTERVAL: intervalo de frequência (em minutos) em que a função é executada. Essa duração precisa ser igual ao intervalo do job do Cloud Scheduler.

  2. Salve o arquivo .env.yml.

implantar a função do Cloud Run

  1. Abra um terminal ou o Cloud Shell no console do Google Cloud. Navegue até o diretório de implantação e execute o seguinte 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>

    Substitua <SERVICE_ACCOUNT_EMAIL> pelo endereço de e-mail da conta de serviço que você quer que a função do Cloud Run use.

  2. Aguarde até que a implantação seja concluída. Depois da implantação, observe o URL da função na saída.

Configurar o Cloud Scheduler

  1. No Console do GCP, acesse Cloud Scheduler > Criar job.

  2. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nome slack-audit-scheduler
    Região Selecione a mesma região em que você implantou a função do Cloud Run.
    Frequência */5 * * * * (a cada 5 minutos, correspondendo ao valor POLL_INTERVAL)
    Fuso horário Selecione o fuso horário (UTC recomendado)

  3. Clique em Continuar.

  4. Na seção Configurar a execução:

    • Tipo de destino: selecione HTTP.
    • URL: insira o URL da função do Cloud Run na saída da implantação.
    • Método HTTP: selecione POST.

  5. Na seção Cabeçalho de autenticação:

    • Selecione Adicionar token OIDC.
    • Conta de serviço: selecione a mesma conta de serviço usada para a função do Cloud Run.

  6. Clique em Criar.

Opções de frequência de programação

Escolha a frequência com base no volume de registros e nos requisitos de latência:

Frequência Expressão Cron Caso de uso
A cada 5 minutos */5 * * * * Padrão (recomendado)
A cada 15 minutos */15 * * * * Volume médio
A cada hora 0 * * * * Volume baixo

Testar a integração (opção 1)

  1. No console do Cloud Scheduler, encontre seu job (slack-audit-scheduler).
  2. Clique em Forçar execução para acionar o job manualmente.
  3. Aguarde alguns segundos.
  4. Acesse Cloud Functions.
  5. Clique no nome da função (slack-audit-to-chronicle).
  6. Clique na guia Registros.

  7. Verifique se a função foi executada com sucesso. Procure:

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

Opção 2: configurar a exportação de registros de auditoria do Slack usando o AWS S3

Essa opção usa o AWS Lambda para coletar registros de auditoria do Slack e armazená-los no Amazon S3. Em seguida, ela configura um feed do Google SecOps para ingerir os registros.

Antes de começar (opção 2)

Verifique se você atende a este pré-requisito adicional:

  • Uma conta da AWS com permissões para criar buckets do S3, usuários/papéis/políticas do IAM, funções do Lambda e regras do EventBridge.

Criar um bucket do Amazon S3

  1. Crie um bucket do Amazon S3 seguindo o guia do usuário Como criar um bucket.
  2. Salve o Nome e a Região do bucket para referência futura (por exemplo, slack-audit-logs).

Configurar a política e o papel do IAM para uploads do S3

  1. No console da AWS, acesse a guia IAM > Políticas > Criar política > JSON.

  2. Insira a política a seguir. Substitua slack-audit-logs se você usou um nome de bucket 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"
    }
  ]
}

  3. Clique em Próxima.

  4. Insira o nome da política SlackAuditS3Policy.

  5. Clique em Criar política.

  6. Acesse IAM > Funções > Criar função > Serviço da AWS > Lambda.

  7. Anexe a política recém-criada SlackAuditS3Policy.

  8. Nomeie a função como SlackAuditToS3Role e clique em Criar função.

Criar a função Lambda

  1. No console da AWS, acesse Lambda > Functions > Create function.
  2. Clique em Criar do zero.

  3. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nome slack_audit_to_s3
    Ambiente de execução Python 3.13
    Arquitetura x86_64
    Função de execução SlackAuditToS3Role

  4. Clique em Criar função.

  5. Depois que a função for criada, abra a guia Código, exclua o stub e insira o seguinte código (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())

Configurar variáveis de ambiente do Lambda

  1. Acesse Configuração > Variáveis de ambiente > Editar > Adicionar variável de ambiente.

  2. Insira as seguintes variáveis de ambiente, substituindo pelos seus valores:

    Chave Valor de exemplo
    SLACK_AUDIT_TOKEN xoxp-... (token de usuário no nível da organização com 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 (opcional, filtro de ação separado por vírgulas)

  3. Clique em Salvar.

  4. Selecione a guia Configuração. No painel Configuração geral, clique em Editar.

  5. Mude Tempo limite para 5 minutes (300 segundos) e clique em Salvar.

Criar uma programação do EventBridge

  1. Acesse Amazon EventBridge > Scheduler > Criar programação.
  2. Informe os seguintes detalhes de configuração:
    • Nome: insira slack-audit-1h.
    • Programação recorrente: selecione Programação com base em taxa.
    • Expressão de taxa: insira 1 hours.
    • Janela de tempo flexível: selecione Desativado.
  3. Clique em Próxima.
  4. Selecione "Destino":
    • API de destino: selecione Invocar AWS Lambda.
    • Função Lambda: selecione slack_audit_to_s3.
  5. Clique em Próxima.
  6. Clique em Próxima (pule as configurações opcionais).
  7. Revise e clique em Criar programação.

Opcional: criar um usuário do IAM com acesso somente leitura para o Google SecOps

  1. Acesse Console da AWS > IAM > Usuários > Criar usuário.
  2. Informe os seguintes detalhes de configuração:
    • Nome de usuário: insira secops-reader.
    • Tipo de acesso: selecione Acesso programático.
  3. Clique em Próxima.
  4. Selecione Anexar políticas diretamente.

  5. Clique em Criar política. Na guia JSON, insira:

    {
  "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. Clique em Próxima.

  7. Insira o nome da política secops-reader-policy.

  8. Clique em Criar política.

  9. Volte à página de criação de usuários, atualize a lista de políticas e selecione secops-reader-policy.

  10. Clique em Próxima.

  11. Clique em Criar usuário.

  12. Selecione o usuário criado secops-reader.

  13. Acesse Credenciais de segurança > Chaves de acesso > Criar chave de acesso.

  14. Selecione Serviço de terceiros.

  15. Clique em Próxima.

  16. Clique em Criar chave de acesso.

  17. Clique em Fazer o download do arquivo .csv para salvar as credenciais.

Configurar um feed no Google SecOps para ingerir registros de auditoria do Slack

  1. Acesse Configurações do SIEM > Feeds.
  2. Clique em Adicionar novo feed.
  3. Clique em Configurar um único feed.
  4. No campo Nome do feed, insira um nome para o feed (por exemplo, Slack Audit Logs).
  5. Selecione Amazon S3 V2 como o Tipo de origem.
  6. Selecione Auditoria do Slack como o Tipo de registro.

  7. Clique em Próxima.

    Especifique valores para os seguintes parâmetros de entrada:

    • URI do S3: insira o URI do bucket do S3 com o caminho do prefixo:

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

      Substitua slack-audit-logs pelo nome real do bucket do S3.

    • Opção de exclusão da fonte: selecione a opção de exclusão de acordo com sua preferência.

    • Idade máxima do arquivo: inclui arquivos modificados nos últimos dias. O padrão é de 180 dias.

    • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3 (do usuário do IAM secops-reader).

    • Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3 (do usuário do IAM secops-reader).

    • Namespace do recurso: o namespace do recurso.

    • Rótulos de ingestão: o rótulo a ser aplicado aos eventos deste feed.

  8. Clique em Próxima.

  9. Revise a nova configuração do feed na tela Finalizar e clique em Enviar.

Tabela de mapeamento do UDM

Campo de registro Mapeamento do UDM Lógica
action metadata.product_event_type Mapeado diretamente do campo action
actor.type principal.labels Mapeado diretamente com a chave actor.type
actor.user.email principal.user.email_addresses Mapeado diretamente
actor.user.id principal.user.product_object_id Mapeado diretamente
actor.user.id principal.user.userid Mapeado diretamente
actor.user.name principal.user.user_display_name Mapeado diretamente
actor.user.team principal.user.group_identifiers Mapeado diretamente
context.ip_address principal.ip Mapeado diretamente
context.location.domain about.resource.attribute.labels Mapeado diretamente com a chave context.location.domain
context.location.id about.resource.id Mapeado diretamente
context.location.name about.resource.name Mapeado diretamente
context.location.name about.resource.attribute.labels Mapeado diretamente com a chave context.location.name
context.location.type about.resource.resource_subtype Mapeado diretamente
context.session_id network.session_id Mapeado diretamente
context.ua network.http.user_agent Mapeado diretamente
context.ua network.http.parsed_user_agent User agent analisado derivado do campo context.ua.
country principal.location.country_or_region Mapeado diretamente
date_create metadata.event_timestamp.seconds Carimbo de data/hora da época convertido em objeto de carimbo de data/hora
details.inviter.email target.user.email_addresses Mapeado diretamente
details.inviter.id target.user.product_object_id Mapeado diretamente
details.inviter.name target.user.user_display_name Mapeado diretamente
details.inviter.team target.user.group_identifiers Mapeado diretamente
details.reason security_result.description Mapeado diretamente. Se for uma matriz, será concatenado com vírgulas.
details.type about.resource.attribute.labels Mapeado diretamente com a chave details.type
details.type security_result.summary Mapeado diretamente
entity.app.id target.resource.id Mapeado diretamente
entity.app.name target.resource.name Mapeado diretamente
entity.channel.id target.resource.id Mapeado diretamente
entity.channel.name target.resource.name Mapeado diretamente
entity.channel.privacy target.resource.attribute.labels Mapeado diretamente com a chave entity.channel.privacy
entity.file.filetype target.resource.attribute.labels Mapeado diretamente com a chave entity.file.filetype
entity.file.id target.resource.id Mapeado diretamente
entity.file.name target.resource.name Mapeado diretamente
entity.file.title target.resource.attribute.labels Mapeado diretamente com a chave entity.file.title
entity.huddle.date_end about.resource.attribute.labels Mapeado diretamente com a chave entity.huddle.date_end
entity.huddle.date_start about.resource.attribute.labels Mapeado diretamente com a chave entity.huddle.date_start
entity.huddle.id about.resource.attribute.labels Mapeado diretamente com a chave entity.huddle.id
entity.huddle.participants.0 about.resource.attribute.labels Mapeado diretamente com a chave entity.huddle.participants.0
entity.huddle.participants.1 about.resource.attribute.labels Mapeado diretamente com a chave entity.huddle.participants.1
entity.type target.resource.resource_subtype Mapeado diretamente
entity.user.email target.user.email_addresses Mapeado diretamente
entity.user.id target.user.product_object_id Mapeado diretamente
entity.user.name target.user.user_display_name Mapeado diretamente
entity.user.team target.user.group_identifiers Mapeado diretamente
entity.workflow.id target.resource.id Mapeado diretamente
entity.workflow.name target.resource.name Mapeado diretamente
id metadata.product_log_id Mapeado diretamente
ip principal.ip Mapeado diretamente
user_agent network.http.user_agent Mapeado diretamente
user_id principal.user.product_object_id Mapeado diretamente
username principal.user.product_object_id Mapeado diretamente
metadata.event_type O padrão é USER_COMMUNICATION. Defina como USER_CREATION se a ação for user_created, USER_LOGIN se a ação for user_login ou user_login_failed, USER_LOGOUT se a ação for user_logout, USER_RESOURCE_ACCESS se a ação corresponder a file_, USER_RESOURCE_UPDATE_PERMISSIONS se a ação corresponder a app_, private_, public_ ou auth_policy_, USER_CHANGE_PERMISSIONS se a ação corresponder a pref, legal_hold_, workflow_, channel_, user_deactivated, user_reactivated, role_change_ ou user_channel_.
metadata.log_type Fixado no código como SLACK_AUDIT
metadata.product_name Definido como Enterprise Grid se date_create existir. Caso contrário, Audit Logs se user_id existir.
metadata.vendor_name Fixado no código como Slack
extensions.auth.mechanism Fixado no código como REMOTE
extensions.auth.type Defina como SSO se a ação contiver user_login ou user_logout. Caso contrário, MACHINE.
security_result.action O padrão é ALLOW. Defina como BLOCK se a ação for user_login_failed.
target.application Definido como Slack se date_create existir. Caso contrário, SLACK se user_id existir.
details.url_private target.url Mapeado do registro de mudanças
details.previous_ip_address principal.labels Mapeado do registro de mudanças
details.previous_ua principal.labels Mapeado do registro de mudanças

Registro de alterações

Ver o registro de alterações deste analisador

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