Coletar registros de auditoria do Slack

Compatível com:

Neste documento, explicamos 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ê tem os pré-requisitos a seguir:

  • Uma instância do Google SecOps.

  • Um plano Enterprise Grid do Slack com acesso de proprietário da organização.

  • 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 do Slack

A API Slack Audit Logs requer um token OAuth de usuário com o escopo auditlogs:read. Esse token precisa ser obtido com a instalação de 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 Slack como proprietário da sua organização do Enterprise Grid.
  2. Acesse a página de apps da API Slack.
  3. Clique em Criar novo 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 de desenvolvimento do Slack (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 & Permissions na navegação à esquerda.
  2. Navegue até a seção Escopos.
  3. Em Escopos de token de usuário (NÃO em "Escopos de token de bot"), clique em Adicionar um escopo do OAuth.
  4. Adicione o seguinte escopo:
    • auditlogs:read: esse escopo permite o acesso à API Audit Logs para a organização do Enterprise Grid.
  5. Em Escopos de token de bot, clique em Adicionar um escopo do OAuth.
  6. Adicione o seguinte escopo:
    • users:read: presente para que o app possa ser instalado no nível da organização.

Instalar o app na organização Enterprise

A API Audit Logs lê eventos de toda a organização Enterprise. Por isso, o app precisa ser instalado no nível da organização, e não em um único espaço de trabalho. O Slack documenta duas maneiras de fazer isso. Ambos produzem o mesmo token OAuth de usuário no nível da organização. Use um deles.

Opção A: instalar nas configurações do app (app no nível da organização)

Esse é o caminho da página Developing apps for Enterprise orgs do Slack. Ele não precisa de um URL de redirecionamento, distribuição pública ou serviço da Web.

  1. Na página de configurações do app, selecione Apps no nível da organização na navegação à esquerda.
  2. Clique em Ativar.

  3. No prompt de confirmação, clique em Sim, aceitar.

  4. Faça login como proprietário da organização Enterprise.

  5. Selecione OAuth e permissões no menu de navegação à esquerda.

  6. Clique em Install to Organization.

  7. Revise as permissões solicitadas na tela de confirmação e clique em Permitir.

Opção B: distribuição pública e URL compartilhável

Este é o caminho da página da API Audit Logs do Slack. A ativação da distribuição pública não lista o app no Slack Marketplace, apenas permite a instalação fora do espaço de trabalho de desenvolvimento.

  1. Na página de configurações do app, selecione OAuth & Permissions na navegação à esquerda.

  2. Na seção URLs de redirecionamento, clique em Adicionar novo URL de redirecionamento, insira um URL, clique em Adicionar e em Salvar URLs.

  3. Selecione Gerenciar distribuição no menu de navegação à esquerda.

  4. Em Compartilhar seu app com outros espaços de trabalho, confirme se as quatro seções da lista de verificação mostram uma marca de seleção verde. Se uma seção mostrar um X vermelho, abra-a e conclua a ação necessária.

  5. Marque a caixa de seleção Analisei e removi todas as informações codificadas.

  6. Clique em Ativar distribuição pública.

  7. Faça login como proprietário da organização Enterprise.

  8. Em Compartilhar o app com seu Workspace, copie o URL compartilhável e abra-o no navegador.

  9. Na tela de instalação, abra o menu suspenso no canto superior direito e selecione a organização empresarial, não um espaço de trabalho individual.

  10. Revise as permissões solicitadas e clique em Permitir.

Recuperar credenciais

  1. Após a conclusão da instalação, você vai voltar para a página OAuth e permissões.
  2. Na seção Tokens OAuth, localize o Token OAuth do usuário.
  3. O token começa com xoxp-.

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

    Importante: esse é o SLACK_ADMIN_TOKEN da função do Cloud Run ou do Lambda. Armazene-a com segurança. Ele fornece acesso de leitura a todos os registros de auditoria na sua organização do Enterprise Grid.

  5. Anote o ID da organização:

    1. Abra o Slack em um navegador da Web usando o URL da sua organização (por exemplo, acmeinc.enterprise.slack.com).
    2. Depois que a página carregar, leia o URL. O formato é https://app.slack.com/client/EXXXXXXX/CXXXXXXX.
    3. Copie a string que começa com E. Esse é o ID da sua 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 no menu de navegação à esquerda.
  4. Em Tokens OAuth, verifique se um Token OAuth de usuário é exibido (começa com xoxp-).
  5. Em Escopos, verifique se auditlogs:read aparece em Escopos de token do usuário.

Testar o acesso à API

  • Teste o token antes de prosseguir 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 o token e os 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 as funções do Cloud Run e o Cloud Scheduler para coletar registros de auditoria do Slack e ingeri-los diretamente no Google SecOps usando os scripts de ingestão do Google SecOps.

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

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

  • Um projeto do Google Cloud com as seguintes APIs ativadas:
    • API Cloud Run Admin
    • API Eventarc
    • API Pub/Sub
    • API Cloud Scheduler
    • API Secret Manager
  • Permissões para criar funções do Cloud Run, tópicos do Pub/Sub, gatilhos do Eventarc, 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 > Gerenciamento de dados > Agentes de coleta. Se você estiver em uma plataforma somente SIEM, acesse Configurações > Agentes de coleta.
  3. Clique em Fazer download para baixar o arquivo de autenticação de ingestão.
  4. Salve o arquivo JSON com segurança. Você vai fazer upload dele como um secret no Secret Manager do Google.

Preparar o código da função

Baixe os arquivos de implantação do repositório do GitHub de scripts de ingestão do Google SecOps:

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

  2. Na raiz do repositório, baixe 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 que a função do Cloud Run as acesse com segurança.

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

  1. No console doGoogle Cloud , 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: cole 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 um secret para o token do Slack

  1. Na página do Secret Manager, clique em Criar secret.
  2. Informe os seguintes detalhes de configuração:
    • Nome: insira slack-admin-token.
    • Valor da chave secreta: cole 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>: o ID de cliente do Google SecOps.
      • <PROJECT_ID>: o ID do projeto do 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.

Criar um tópico do Pub/Sub

O Cloud Scheduler aciona a função do Cloud Run por um tópico do Pub/Sub.

  1. No Console do GCP, acesse Pub/Sub > Tópicos.
  2. Selecione Criar tópico.
  3. No campo ID do tópico, insira slack-audit-trigger.
  4. Clique em Criar.

implantar a função do Cloud Run

  1. Abra um terminal ou o Cloud Shell no console do Google Cloud . Acesse o diretório de implantação e execute o seguinte comando:

    gcloud run deploy slack-audit-to-chronicle \
  --source . \
  --function main \
  --base-image google-22/python312 \
  --region <REGION> \
  --service-account <SERVICE_ACCOUNT_EMAIL> \
  --env-vars-file .env.yml \
  --memory 512Mi \
  --timeout 540 \
  --max-instances 1 \
  --no-allow-unauthenticated
    • Substitua <REGION> pela região (por exemplo, us-central1) e <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. Crie o gatilho do Pub/Sub para a função da seguinte maneira:

    gcloud eventarc triggers create slack-audit-trigger \
  --location <REGION> \
  --destination-run-service slack-audit-to-chronicle \
  --destination-run-region <REGION> \
  --event-filters "type=google.cloud.pubsub.topic.v1.messagePublished" \
  --transport-topic projects/<PROJECT_ID>/topics/slack-audit-trigger \
  --service-account <SERVICE_ACCOUNT_EMAIL>
    • Substitua <PROJECT_ID> pelo ID do projeto Google Cloud .

  3. Aguarde até que a implantação seja concluí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 Pub/Sub.
    • Tópico: selecione slack-audit-trigger.
    • Corpo da mensagem: insira run.

  5. 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 o Cloud Run.
  5. Clique no nome do serviço (slack-audit-to-chronicle).
  6. Clique na guia Registros.

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

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

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

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

  • 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 os papéis do IAM para uploads do S3

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

  2. Copie e cole 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 > Roles > Create role > AWS service > Lambda.

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

  8. Nomeie o papel como SlackAuditToS3Role e clique em Criar papel.

Criar a função do 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
    Papel 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 cole o código a seguir (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 o Tempo limite para 5 minutes (300 segundos) e clique em Salvar.

Criar uma programação do EventBridge

  1. Acesse Amazon EventBridge > Scheduler > Create schedule.
  2. Informe os seguintes detalhes de configuração:
    • Nome: insira slack-audit-1h.
    • Programação recorrente: selecione Programação baseada em taxa.
    • Expressão de taxa: insira 1 hours.
    • Janela de tempo flexível: selecione Desativado.
  3. Clique em Próxima.
  4. Selecione o 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 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. 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"
    }
  ]
}

  6. Clique em Próxima.

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

  8. Clique em Criar política.

  9. Volte para a 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 Create user.

  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 > Gerenciamento de dados > Feeds. Se você estiver em uma plataforma somente SIEM, acesse Configurações > 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.

  8. 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/
```

Replace `slack-audit-logs` with your actual S3 bucket name.

    • 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: inclua arquivos modificados nos últimos dias. O padrão é 180 dias.

    • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3 (do usuário do Identity and Access Management (IAM) do 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 desse feed.

  9. Clique em Próxima.

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

Tabela de mapeamento de UDM

Campo de registro Mapeamento de 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, 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 Defina como Enterprise Grid se date_create existir. Caso contrário, defina como 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, defina como MACHINE.
security_result.action O padrão é ALLOW. Defina como BLOCK se a ação for user_login_failed.
target.application Defina como Slack se date_create existir. Caso contrário, defina como SLACK se user_id existir.

Registro de alterações

Confira o registro de alterações deste analisador

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