Coletar registros de auditoria do Slack

Compatível com:

Este guia 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.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

  • 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: Cloud Run Functions e Cloud Scheduler) ou
    • AWS (para a opção 2: S3, IAM, Lambda, EventBridge).

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

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.

Criar um app do Slack para registros de auditoria

  1. Faça login no Admin Console do Slack com uma conta de proprietário da organização do Enterprise Grid ou de administrador.
  2. Acesse https://api.slack.com/apps e clique em Criar novo app > Do zero.
  3. 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).
  4. Clique em Criar app.

Configurar escopos do OAuth

  1. Acesse OAuth e permissões na barra lateral 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 escopo: auditlogs:read.

Ativar a distribuição pública

  1. Navegue até Gerenciar distribuição na barra lateral à 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. Clique em Ativar distribuição pública.

Instalar app na organização do Enterprise Grid

  1. Acesse OAuth e permissões na barra lateral esquerda.
  2. Clique em Instalar na organização (NÃO "Instalar no Workspace").

CRÍTICO:verifique o menu suspenso no canto superior direito da tela de instalação para confirmar se você está instalando na organização empresarial, e não em um espaço de trabalho individual.

  1. Analise as permissões solicitadas e clique em Permitir.
  2. Depois que a autorização for concluída, você será redirecionado de volta à página "OAuth e permissões".

Recuperar credenciais

  1. Em Tokens OAuth para seu espaço de trabalho, localize o Token OAuth do usuário.
  2. Copie e salve com segurança o token que começa com xoxp- (por exemplo, xoxp-1234567890-0987654321-1234567890-abc123def456).

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

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

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.

Como configurar o diretório

  1. Crie um diretório na sua máquina local para a implantação da função do Cloud Run.
  2. Faça o download dos seguintes arquivos do repositório do GitHub de scripts de ingestão do Chronicle:
    • Na pasta slack, faça o download de:
      • .env.yml
      • main.py
      • requirements.txt
    • Na raiz do repositório, faça o download de todo o diretório common com todos os arquivos:
      • common/__init__.py
      • common/auth.py
      • common/env_constants.py
      • common/ingest.py
      • common/status.py
      • common/utils.py
  3. Coloque todos os arquivos baixados no diretório de implantação.

Sua estrutura de diretórios deve ser parecida com esta:

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

Criar secrets no Google Secret Manager

  1. No console do Google Cloud, acesse Segurança > Secret Manager.
  2. Clique em Criar secret.
  3. Forneça os seguintes detalhes de configuração para a conta de serviço do Chronicle:
    • Nome: insira chronicle-service-account.
    • Valor do secret: cole o conteúdo do arquivo JSON de autenticação de ingestão do Google SecOps.
  4. Clique em Criar secret.
  5. Copie o nome do recurso secreto no formato: projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
  6. Clique em Criar secret novamente para criar um segundo secret.
  7. Forneça os seguintes detalhes de configuração para o token do Slack:
    • Nome: insira slack-admin-token.
    • Valor da chave secreta: cole o token OAuth do usuário do Slack (começando com xoxp-).
  8. Clique em Criar secret.
  9. Copie o nome do recurso secreto no formato: projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Como definir as variáveis de ambiente de execução necessárias

  1. Abra o arquivo .env.yml no diretório de implantação.
  2. Configure as variáveis de ambiente com 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:

  • <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 a mesma do intervalo do job do Cloud Scheduler.
  1. Salve o arquivo .env.yml.

Como implantar a função do Cloud Run

  1. Abra um terminal ou o Cloud Shell no console do Google Cloud.
  2. Navegue até o diretório de implantação:
cd /path/to/deployment_directory
  1. Execute o comando a seguir para implantar 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 e-mail da conta de serviço que você quer que a função do Cloud Run use.

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

Configurar o Cloud Scheduler

  1. No console do Google Cloud, acesse Cloud Scheduler > Criar job.
  2. Informe os seguintes detalhes de configuração:
    • Nome: insira slack-audit-scheduler.
    • Região: selecione a mesma região em que você implantou a função do Cloud Run.
    • Frequência: insira */5 * * * * (executa a cada 5 minutos, correspondendo ao valor POLL_INTERVAL).
    • Fuso horário: selecione UTC.
    • 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.
    • 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.
  3. Clique em Criar.

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 S3. Em seguida, ela configura um feed do Google SecOps para ingerir os registros.

Configurar o bucket do AWS S3 e o IAM para o Google SecOps

  1. Crie um bucket do Amazon S3 seguindo este 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).
  3. Crie um usuário seguindo este guia: Como criar um usuário do IAM.
  4. Selecione o usuário criado.
  5. Selecione a guia Credenciais de segurança.
  6. Clique em Criar chave de acesso na seção Chaves de acesso.
  7. Selecione Serviço de terceiros como Caso de uso.
  8. Clique em Próxima.
  9. Opcional: adicione uma tag de descrição.
  10. Clique em Criar chave de acesso.
  11. Clique em Baixar arquivo .csv para salvar a chave de acesso e a chave de acesso secreta para referência futura.
  12. Clique em Concluído.
  13. Selecione a guia Permissões.
  14. Clique em Adicionar permissões na seção Políticas de permissões.
  15. Selecione Adicionar permissões.
  16. Selecione Anexar políticas diretamente.
  17. Pesquise a política AmazonS3FullAccess.
  18. Selecione a política.
  19. Clique em Próxima.
  20. Clique em Adicionar permissões

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

  1. No console da AWS, acesse IAM > Políticas > Criar política > guia JSON.
  2. Copie e cole a política abaixo.
  3. JSON da política (substitua slack-audit-logs se você inseriu 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"
    }
  ]
}
  1. Clique em Próxima.
  2. Insira o nome da política SlackAuditS3Policy.
  3. Clique em Criar política.
  4. Acesse IAM > Funções > Criar função > Serviço da AWS > Lambda.
  5. Anexe a política recém-criada SlackAuditS3Policy.
  6. 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
  1. Clique em Criar função.
  2. Depois que a função for criada, abra a guia Código, exclua o stub 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())

  1. Acesse Configuração > Variáveis de ambiente > Editar > Adicionar variável de ambiente.
  2. Insira as variáveis de ambiente fornecidas abaixo, substituindo 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 usuário no 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
  1. Clique em Salvar.
  2. Selecione a guia Configuração.
  3. No painel Configuração geral, clique em Editar.
  4. Mude Tempo limite para 5 minutos (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 horas.
    • Período flexível: selecione Desativado.
  3. Clique em Próxima.
  4. Selecione Destino:
    • API de destino: selecione AWS Lambda Invoke.
    • 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 e chaves do IAM 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.
  6. Na guia 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"
    }
  ]
}
  1. Clique em Próxima.
  2. Insira o nome da política secops-reader-policy.
  3. Clique em Criar política.
  4. Volte à página de criação de usuários, atualize a lista de políticas e selecione secops-reader-policy.
  5. Clique em Próxima.
  6. Clique em Criar usuário.
  7. Selecione o usuário criado secops-reader.
  8. Acesse Credenciais de segurança > Chaves de acesso > Criar chave de acesso.
  9. Selecione Serviço de terceiros.
  10. Clique em Próxima.
  11. Clique em Criar chave de acesso.
  12. 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.
  3. No campo Nome do feed, insira um nome para o feed (por exemplo, Slack Audit Logs).
  4. Selecione Amazon S3 V2 como o Tipo de origem.
  5. Selecione Auditoria do Slack como o Tipo de registro.
  6. Clique em Próxima.
  7. Especifique valores para os seguintes parâmetros de entrada:
    • URI do S3: s3://slack-audit-logs/slack/audit/
    • Opções 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 no último número de dias. O padrão é de 180 dias.
    • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3 (de secops-reader).
    • Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3 (de secops-reader).
    • Namespace do recurso: o namespace do recurso.
    • Rótulos de ingestão: o rótulo 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 no registro bruto.
actor.type principal.labels.value Mapeado diretamente do campo actor.type, com a chave actor.type adicionada.
actor.user.email principal.user.email_addresses Mapeado diretamente do campo actor.user.email.
actor.user.id principal.user.product_object_id Mapeado diretamente do campo actor.user.id.
actor.user.id principal.user.userid Mapeado diretamente do campo actor.user.id.
actor.user.name principal.user.user_display_name Mapeado diretamente do campo actor.user.name.
actor.user.team principal.user.group_identifiers Mapeado diretamente do campo actor.user.team.
context.ip_address principal.ip Mapeado diretamente do campo context.ip_address.
context.location.domain about.resource.attribute.labels.value Mapeado diretamente do campo context.location.domain, com a chave context.location.domain adicionada.
context.location.id about.resource.id Mapeado diretamente do campo context.location.id.
context.location.name about.resource.name Mapeado diretamente do campo context.location.name.
context.location.name about.resource.attribute.labels.value Mapeado diretamente do campo context.location.name, com a chave context.location.name adicionada.
context.location.type about.resource.resource_subtype Mapeado diretamente do campo context.location.type.
context.session_id network.session_id Mapeado diretamente do campo context.session_id.
context.ua network.http.user_agent Mapeado diretamente do campo context.ua.
context.ua network.http.parsed_user_agent Informações analisadas do user agent derivadas do campo context.ua usando o filtro parseduseragent.
country principal.location.country_or_region Mapeado diretamente do campo country.
date_create metadata.event_timestamp.seconds O carimbo de data/hora da época do campo date_create é convertido em um objeto de carimbo de data/hora.
details.inviter.email target.user.email_addresses Mapeado diretamente do campo details.inviter.email.
details.inviter.id target.user.product_object_id Mapeado diretamente do campo details.inviter.id.
details.inviter.name target.user.user_display_name Mapeado diretamente do campo details.inviter.name.
details.inviter.team target.user.group_identifiers Mapeado diretamente do campo details.inviter.team.
details.reason security_result.description Mapeado diretamente do campo details.reason ou, se for uma matriz, concatenado com vírgulas.
details.type about.resource.attribute.labels.value Mapeado diretamente do campo details.type, com a chave details.type adicionada.
details.type security_result.summary Mapeado diretamente do campo details.type.
entity.app.id target.resource.id Mapeado diretamente do campo entity.app.id.
entity.app.name target.resource.name Mapeado diretamente do campo entity.app.name.
entity.channel.id target.resource.id Mapeado diretamente do campo entity.channel.id.
entity.channel.name target.resource.name Mapeado diretamente do campo entity.channel.name.
entity.channel.privacy target.resource.attribute.labels.value Mapeado diretamente do campo entity.channel.privacy, com a chave entity.channel.privacy adicionada.
entity.file.filetype target.resource.attribute.labels.value Mapeado diretamente do campo entity.file.filetype, com a chave entity.file.filetype adicionada.
entity.file.id target.resource.id Mapeado diretamente do campo entity.file.id.
entity.file.name target.resource.name Mapeado diretamente do campo entity.file.name.
entity.file.title target.resource.attribute.labels.value Mapeado diretamente do campo entity.file.title, com a chave entity.file.title adicionada.
entity.huddle.date_end about.resource.attribute.labels.value Mapeado diretamente 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 do campo entity.huddle.date_start, com a chave entity.huddle.date_start adicionada.
entity.huddle.id about.resource.attribute.labels.value Mapeado diretamente do campo entity.huddle.id, com a chave entity.huddle.id adicionada.
entity.huddle.participants.0 about.resource.attribute.labels.value Mapeado diretamente 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 do campo entity.huddle.participants.1, com a chave entity.huddle.participants.1 adicionada.
entity.type target.resource.resource_subtype Mapeado diretamente do campo entity.type.
entity.user.email target.user.email_addresses Mapeado diretamente do campo entity.user.email.
entity.user.id target.user.product_object_id Mapeado diretamente do campo entity.user.id.
entity.user.name target.user.user_display_name Mapeado diretamente do campo entity.user.name.
entity.user.team target.user.group_identifiers Mapeado diretamente do campo entity.user.team.
entity.workflow.id target.resource.id Mapeado diretamente do campo entity.workflow.id.
entity.workflow.name target.resource.name Mapeado diretamente do campo entity.workflow.name.
id metadata.product_log_id Mapeado diretamente do campo id.
ip principal.ip Mapeado diretamente do campo ip. Determinado por uma lógica baseada no campo action. O padrã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. Fixado no código como "SLACK_AUDIT". Definido como "Enterprise Grid" se date_create existir. Caso contrário, definido como "Registros de auditoria" se user_id existir. Fixado no código como "Slack". Fixado no código como "REMOTE". Defina como "SSO" se action contiver "user_login" ou "user_logout". Caso contrário, defina como "MACHINE". Não mapeado nos exemplos fornecidos. O padrão é "ALLOW", mas é definido como "BLOCK" se action for "user_login_failed". Defina como "Slack" se date_create existir. Caso contrário, defina como "SLACK" se user_id existir.
user_agent network.http.user_agent Mapeado diretamente do campo user_agent.
user_id principal.user.product_object_id Mapeado diretamente do campo user_id.
username principal.user.product_object_id Mapeado diretamente do campo username.

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