Recolha registos de auditoria do Slack

Suportado em:

Google secops SIEM

Nota: esta funcionalidade está abrangida pelos Termos das Ofertas de Pré-DG dos Termos Específicos do serviço Google Security Operations. As funcionalidades de pré-DG podem ter suporte limitado e as alterações às funcionalidades de pré-DG podem não ser compatíveis com outras versões de pré-DG. Para mais informações, consulte as diretrizes dos serviços de apoio técnico do Google SecOps e os Termos Específicos dos Serviços do Google SecOps.

Este documento explica como carregar registos de auditoria do Slack para o Google Security Operations através de 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:

• Uma 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)
  • AWS (para a opção 2: S3, IAM, Lambda e EventBridge)

Nota: a API Slack Audit Logs só está disponível para organizações do Enterprise Grid. Os espaços de trabalho do Slack padrão não podem aceder a esta API.

Pré-requisitos para recolher 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

1. 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.
2. Aceda a https://api.slack.com/apps e clique em Create New App > From scratch.
3. 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).
4. Clique em Criar app.

Configure âmbitos do OAuth

1. Navegue para OAuth e autorizações na barra lateral esquerda.
2. Aceda à secção Âmbitos.
3. Em Âmbitos do token de utilizador (NÃO âmbitos do token do bot), clique em Adicionar um âmbito do OAuth.
4. Adicione o âmbito: auditlogs:read.

Nota: se tiver problemas de instalação nos passos posteriores, pode ter de adicionar um âmbito de bot básico (como users:read) para ativar a instalação ao nível da organização.

Ative a distribuição pública

1. Navegue para Gerir distribuição na barra lateral esquerda.
2. 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
3. Clique em Ativar distribuição pública.

Nota: a distribuição pública é necessária para apps ao nível da organização.

Instale a app na organização do Enterprise Grid

1. Navegue para OAuth e autorizações na barra lateral esquerda.
2. 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.

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

Recupere credenciais

1. Em Símbolos OAuth para o seu Workspace, localize o símbolo OAuth do utilizador.

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

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

1. Crie um novo diretório na sua máquina local para a implementação da função do Cloud Run.
2. Transfira os seguintes ficheiros do repositório do 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
3. 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

1. Na Google Cloud Console, aceda a Segurança > Secret Manager.
2. Clique em Criar segredo.
3. 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.
4. Clique em Criar segredo.
5. Copie o nome do recurso secreto no formato: projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
6. Clique novamente em Criar segredo para criar um segundo segredo.
7. 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 de utilizador do Slack (começando por xoxp-).
8. Clique em Criar segredo.
9. 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

1. Abra o ficheiro .env.yml no diretório de implementação.

2. 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 Google Cloud projeto.
     • 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.

3. Guarde o ficheiro .env.yml.

Implementar a função do Cloud Run

1. Abra um terminal ou o Cloud Shell na Google Cloud consola.

2. Navegue para o diretório de implementação:

   cd /path/to/deployment_directory
   

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

     Nota: a conta de serviço que executa a sua função do Cloud Run tem de ter as funções Cloud Functions Invoker (roles/cloudfunctions.invoker) e Secret Manager Secret Accessor (roles/secretmanager.secretAccessor).

4. Aguarde a conclusão da implementação.

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

Configure o Cloud Scheduler

1. Na Google Cloud Console, aceda a Cloud Scheduler > Criar tarefa.
2. 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.
3. 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

1. Crie um contentor do Amazon S3 seguindo este manual do utilizador: Criar um contentor
2. Guarde o nome e a região do contentor para referência futura (por exemplo, slack-audit-logs).
3. Selecione o separador Credenciais de segurança.
4. Clique em Criar chave de acesso na secção Chaves de acesso.
5. Selecione Serviço de terceiros como o Exemplo de utilização.
6. Clicar em Seguinte.
7. Opcional: adicione uma etiqueta de descrição.
8. Clique em Criar chave de acesso.
9. Clique em Transferir ficheiro CSV para guardar a chave de acesso e a chave de acesso secreta para utilização posterior.
10. Clique em Concluído.
11. Selecione o separador Autorizações.
12. Clique em Adicionar autorizações na secção Políticas de autorizações .
13. Selecione Adicionar autorizações.
14. Selecione Anexar políticas diretamente.
15. Pesquise e selecione a política AmazonS3FullAccess.
16. Clicar em Seguinte.
17. Clique em Adicionar autorizações.

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

1. Na consola da AWS, aceda a IAM > Políticas > Criar política > separador JSON.

2. Copie e cole a seguinte política.

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

   • Substitua slack-audit-logs se tiver introduzido um nome de contentor diferente.

3. Clicar em Seguinte.

4. Introduza o nome da política SlackAuditS3Policy.

5. Clique em Criar política.

6. Aceda a IAM > Funções > Criar função > Serviço AWS > Lambda.

7. Anexe a política criada recentemente SlackAuditS3Policy.

8. Dê o nome SlackAuditToS3Role à função e clique em Criar função.

Crie a função Lambda

1. Na consola da AWS, aceda a Lambda > Functions > Create function.
2. Clique em Criar do zero.

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

4. Clique em Criar função.

5. Depois de criar a função, abra o separador Código, elimine o fragmento de código e introduza o seguinte código (slack_audit_to_s3.py):

   #!/usr/bin/env python3
   # Lambda: Pull Slack Audit Logs (Enterprise Grid) to S3 (no transform)
   
   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(payload: dict, page_idx: int) -> str:
       ts  = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
       key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
       body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
       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())
   

6. Aceda a Configuração > Variáveis de ambiente > Editar > Adicionar variável de ambiente.

7. Introduza as seguintes variáveis de ambiente, substituindo-as pelos seus valores.

   Chave	Exemplo de valor
   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

8. Clique em Guardar.

9. Selecione o separador Configuração.

10. No painel Configuração geral, clique em Editar.

11. Altere Tempo limite para 5 minutos (300 segundos) e clique em Guardar.

    Nota: o tempo limite é um limite superior rígido, o que significa que, se a função ainda estiver em execução quando o temporizador atingir os 5 minutos, o AWS Lambda termina-a. Qualquer execução mais curta termina normalmente. Só lhe é cobrado o tempo de execução real.

Crie um horário do EventBridge

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

Opcional: crie um utilizador e chaves da IAM só de leitura para o Google SecOps

1. Aceda a AWS Console > IAM > Users > Add users.
2. Clique em Adicionar utilizadores.
3. Forneça os seguintes detalhes de configuração:
   • Utilizador: introduza secops-reader.
   • Tipo de acesso: selecione Chave de acesso – Acesso programático.
4. Clique em Criar utilizador.
5. Anexe a política de leitura mínima (personalizada): Users > secops-reader > Permissions > Add permissions > Attach policies directly > Create policy.

6. No editor JSON, introduza a seguinte política:

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

7. Clicar em Seguinte.

8. Introduza o nome da política secops-reader-policy.

9. Clique em Criar política.

10. Regresse à página de criação de utilizadores, atualize a lista de políticas e selecione secops-reader-policy.

11. Clicar em Seguinte.

12. Clique em Criar utilizador.

13. Selecione o utilizador criado secops-reader.

14. Aceda a Credenciais de segurança > Chaves de acesso > Criar chave de acesso.

15. Selecione Serviço de terceiros.

16. Clicar em Seguinte.

17. Clique em Criar chave de acesso.

18. Clique em Transferir ficheiro .csv para guardar as credenciais.

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

1. Aceda a Definições do SIEM > Feeds.
2. Clique em Adicionar novo.
3. No campo Nome do feed, introduza 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 registo.
6. Clicar em Seguinte.
7. 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 (a partir 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.
8. Clicar em Seguinte.
9. 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, é definido 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.