Coletar registros do CASB da Skyhigh Security (antigo McAfee Skyhigh CASB)

Compatível com:

Google SecOps SIEM

Este documento explica como ingerir registros do CASB da Skyhigh Security (antigo McAfee Skyhigh CASB) no Google Security Operations usando o Google Cloud Storage V2.

O CASB da Skyhigh Security é um agente de segurança de acesso à nuvem (CASB) que oferece visibilidade, compliance, segurança de dados e proteção contra ameaças para serviços de nuvem. Ele monitora a atividade do usuário em ambientes SaaS, PaaS e IaaS, detectando anomalias, aplicando políticas de DLP e gerando registros de auditoria e incidentes com a API REST.

Antes de começar

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

• Uma instância do Google SecOps
• Um projeto do GCP com a API Storage ativada
• Permissões para criar e gerenciar intervalos do GCS
• Permissões para gerenciar políticas do IAM em buckets do GCS
• Permissões para criar serviços do Cloud Run, tópicos do Pub/Sub e jobs do Cloud Scheduler
• Um locatário do CASB da Skyhigh Security com acesso administrativo
• Credenciais da API do console da Skyhigh Security (ID e chave secreta do cliente)
• O Skyhigh Cloud Connector instalado e configurado

Criar um bucket do Google Cloud Storage

1. Acesse o Console do Google Cloud.
2. Selecione um projeto ou crie um novo.
3. No menu de navegação, acesse Cloud Storage > Buckets.
4. Clique em Criar bucket.

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

   Configuração	Valor
   Nomeie seu bucket	Insira um nome exclusivo globalmente, por exemplo, skyhigh-casb-logs.
   Tipo de local	Escolha de acordo com suas necessidades (região, birregional, multirregional)
   Local	Selecione o local (por exemplo, us-central1).
   Classe de armazenamento	Padrão (recomendado para registros acessados com frequência)
   Controle de acesso	Uniforme (recomendado)
   Ferramentas de proteção	Opcional: ativar o controle de versões de objetos ou a política de retenção

6. Clique em Criar.

Coletar credenciais da API CASB da Skyhigh Security

Criar credenciais de cliente da API

1. Faça login no console da Skyhigh Security.
2. Acesse Configurações > Infraestrutura > Integração de API.
3. Clique em Criar cliente de API.

4. Insira um nome para o cliente da API (por exemplo, Google SecOps Integration).

5. Selecione os seguintes escopos:

   • Incidentes: acesso de leitura aos dados de incidentes do CASB
   • Anomalias: acesso de leitura a eventos de anomalias
   • Registros de auditoria: acesso de leitura à trilha de auditoria

6. Clique em Criar.

7. Copie e salve os seguintes detalhes em um local seguro:

   • ID do cliente: o identificador do cliente gerado.
   • Chave secreta do cliente: a chave secreta do cliente gerada (mostrada apenas uma vez)
   Observação: o segredo do cliente é mostrado apenas uma vez no momento da criação. Se você perder as credenciais, será necessário gerar outras.

Receber o URL base do locatário

1. Faça login no console da Skyhigh Security.

2. Anote o URL base da barra de endereço do navegador. O formato depende da sua região:

   • EUA: https://www.myshn.net
   • UE: https://www.myshn.eu
   • SG: https://www.myshn.sg

Testar o acesso à API

• Teste suas credenciais antes de prosseguir com a integração:

  # Replace with your actual credentials
  CLIENT_ID="your-client-id"
  CLIENT_SECRET="your-client-secret"
  BASE_URL="https://www.myshn.net"
  
  # Get OAuth 2.0 access token
  TOKEN=$(curl -s -X POST "${BASE_URL}/shnapi/rest/external/api/v1/oauth/token" \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}" \
      | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
  
  # Test API access - list incidents
  curl -v -H "Authorization: Bearer ${TOKEN}" \
      "${BASE_URL}/shnapi/rest/external/api/v1/incidents?limit=1"
  

Criar uma conta de serviço para a função do Cloud Run

A função do Cloud Run precisa de uma conta de serviço com permissões para gravar no bucket do GCS e ser invocada pelo Pub/Sub.

Criar conta de serviço

1. No Console do GCP, acesse IAM e administrador > Contas de serviço.
2. Clique em Criar conta de serviço.
3. Informe os seguintes detalhes de configuração:
   • Nome da conta de serviço: insira skyhigh-casb-collector-sa
   • Descrição da conta de serviço: digite Service account for Cloud Run function to collect Skyhigh Security CASB logs

4. Clique em Criar e continuar.

5. Na seção Conceder acesso a essa conta de serviço ao projeto, adicione os seguintes papéis:

   1. Clique em Selecionar papel.
   2. Pesquise e selecione Administrador de objetos do Storage.
   3. Clique em + Adicionar outro papel.
   4. Pesquise e selecione Invocador do Cloud Run.
   5. Clique em + Adicionar outro papel.
   6. Pesquise e selecione Invocador do Cloud Functions.

6. Clique em Continuar.

7. Clique em Concluído.

Esses papéis são necessários para:

• Administrador de objetos do Storage: grava registros no bucket do GCS e gerencia arquivos de estado.
• Invocador do Cloud Run: permite que o Pub/Sub invoque a função.
• Invocador do Cloud Functions: permite a invocação de funções

Conceder permissões do IAM no bucket do GCS

Conceda permissões de gravação à conta de serviço no bucket do GCS:

1. Acesse Cloud Storage > Buckets.
2. Clique no nome do bucket (por exemplo, skyhigh-casb-logs).
3. Acesse a guia Permissões.

4. Clique em Conceder acesso.

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

   • Adicionar principais: insira o e-mail da conta de serviço (por exemplo, skyhigh-casb-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Atribuir papéis: selecione Administrador de objetos do Storage.

6. Clique em Salvar.

Criar tópico Pub/Sub

Crie um tópico do Pub/Sub em que o Cloud Scheduler vai publicar e a função do Cloud Run vai se inscrever.

1. No Console do GCP, acesse Pub/Sub > Tópicos.

2. Selecione Criar tópico.

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

   • ID do tópico: insira skyhigh-casb-logs-trigger
   • Não mude as outras configurações.

4. Clique em Criar.

Criar uma função do Cloud Run para coletar registros

A função do Cloud Run será acionada por mensagens do Pub/Sub do Cloud Scheduler para buscar registros da API CASB da Skyhigh Security e gravá-los no GCS.

1. No console do GCP, acesse o Cloud Run.
2. Clique em Criar serviço.

3. Selecione Função (use um editor in-line para criar uma função).

4. Na seção Configurar, forneça os seguintes detalhes de configuração:

   Configuração	Valor
   Nome do serviço	skyhigh-casb-collector
   Região	Selecione a região que corresponde ao seu bucket do GCS (por exemplo, us-central1).
   Ambiente de execução	Selecione Python 3.12 ou uma versão mais recente.

5. Na seção Acionador (opcional):

   1. Clique em + Adicionar gatilho.
   2. Selecione Cloud Pub/Sub.
   3. Em Selecionar um tópico do Cloud Pub/Sub, escolha o tópico skyhigh-casb-logs-trigger.
   4. Clique em Salvar.

6. Na seção Autenticação:

   1. Selecione Exigir autenticação.
   2. Confira o Identity and Access Management (IAM).
   Observação: o Pub/Sub processa automaticamente a autenticação ao invocar a função.

7. Role a tela para baixo e expanda Contêineres, rede, segurança.

8. Acesse a guia Segurança:

   • Conta de serviço: selecione a conta de serviço skyhigh-casb-collector-sa.

9. Acesse a guia Contêineres:

   1. Clique em Variáveis e secrets.
   2. Clique em + Adicionar variável para cada variável de ambiente:

   Nome da variável	Valor de exemplo	Descrição
   GCS_BUCKET	skyhigh-casb-logs	Nome do bucket do GCS
   GCS_PREFIX	skyhigh-casb	Prefixo para arquivos de registro
   STATE_KEY	skyhigh-casb/state.json	Caminho do arquivo de estado
   SKYHIGH_BASE_URL	https://www.myshn.net	URL base da Skyhigh Security.
   SKYHIGH_CLIENT_ID	your-client-id	ID do cliente da API
   SKYHIGH_CLIENT_SECRET	your-client-secret	Chave secreta do cliente da API
   MAX_RECORDS	5000	Máximo de registros por execução
   PAGE_SIZE	100	Registros por página
   LOOKBACK_HOURS	24	Período de lookback inicial

10. Na seção Variáveis e secrets, role a tela para baixo até Solicitações:

    • Tempo limite da solicitação: insira 600 segundos (10 minutos)

11. Acesse a guia Configurações:

    • Na seção Recursos:
      • Memória: selecione 512 MiB ou mais.
      • CPU: selecione 1

12. Na seção Escalonamento de revisão:

    • Número mínimo de instâncias: insira 0
    • Número máximo de instâncias: insira 100 ou ajuste com base na carga esperada.

13. Clique em Criar.

14. Aguarde a criação do serviço (1 a 2 minutos).

15. Depois que o serviço for criado, o editor de código inline será aberto automaticamente.

Adicionar código da função

1. Insira main no campo Ponto de entrada.

2. No editor de código em linha, crie dois arquivos:

   • main.py:

   import functions_framework
   from google.cloud import storage
   import json
   import os
   import urllib3
   from datetime import datetime, timezone, timedelta
   import time
   import base64
   import urllib.parse
   
   # Initialize HTTP client with timeouts
   http = urllib3.PoolManager(
     timeout=urllib3.Timeout(connect=5.0, read=30.0),
     retries=False,
   )
   
   # Initialize Storage client
   storage_client = storage.Client()
   
   # Environment variables
   GCS_BUCKET = os.environ.get('GCS_BUCKET')
   GCS_PREFIX = os.environ.get('GCS_PREFIX', 'skyhigh-casb')
   STATE_KEY = os.environ.get('STATE_KEY', 'skyhigh-casb/state.json')
   SKYHIGH_BASE_URL = os.environ.get('SKYHIGH_BASE_URL', '[https://www.myshn.net](https://www.myshn.net)')
   SKYHIGH_CLIENT_ID = os.environ.get('SKYHIGH_CLIENT_ID')
   SKYHIGH_CLIENT_SECRET = os.environ.get('SKYHIGH_CLIENT_SECRET')
   MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
   PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100'))
   LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
   
   def get_access_token(base_url: str, client_id: str, client_secret: str) -> str:
     """Get OAuth 2.0 access token from Skyhigh Security."""
     token_url = f"{base_url}/shnapi/rest/external/api/v1/oauth/token"
     body = urllib.parse.urlencode({
       'grant_type': 'client_credentials',
       'client_id': client_id,
       'client_secret': client_secret,
     }).encode('utf-8')
   
     response = http.request(
       'POST',
       token_url,
       body=body,
       headers={'Content-Type': 'application/x-www-form-urlencoded'},
     )
   
     if response.status != 200:
       raise Exception(f"Failed to get access token: HTTP {response.status} - {response.data.decode('utf-8')}")
   
     token_data = json.loads(response.data.decode('utf-8'))
     return token_data['access_token']
   
   @functions_framework.cloud_event
   def main(cloud_event):
     """
     Cloud Run function triggered by Pub/Sub to fetch Skyhigh Security CASB
     logs and write to GCS.
   
     Args:
       cloud_event: CloudEvent object containing Pub/Sub message
     """
   
     if not all([GCS_BUCKET, SKYHIGH_BASE_URL, SKYHIGH_CLIENT_ID, SKYHIGH_CLIENT_SECRET]):
       print('Error: Missing required environment variables')
       return
   
     try:
       bucket = storage_client.bucket(GCS_BUCKET)
   
       # Load state
       state = load_state(bucket, STATE_KEY)
   
       # Determine time window
       now = datetime.now(timezone.utc)
       last_time = None
   
       if isinstance(state, dict) and state.get("last_event_time"):
         try:
           last_time = parse_datetime(state["last_event_time"])
           # Overlap by 2 minutes to catch any delayed events
           last_time = last_time - timedelta(minutes=2)
         except Exception as e:
           print(f"Warning: Could not parse last_event_time: {e}")
   
       if last_time is None:
         last_time = now - timedelta(hours=LOOKBACK_HOURS)
   
       print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")
   
       # Get OAuth token
       access_token = get_access_token(SKYHIGH_BASE_URL, SKYHIGH_CLIENT_ID, SKYHIGH_CLIENT_SECRET)
       print("Successfully obtained access token")
   
       all_records = []
       newest_time = None
   
       # Fetch incidents
       incidents, inc_newest = fetch_logs(
         base_url=SKYHIGH_BASE_URL,
         access_token=access_token,
         endpoint_path="/shnapi/rest/external/api/v1/incidents",
         start_time=last_time,
         end_time=now,
         page_size=PAGE_SIZE,
         max_records=MAX_RECORDS,
         log_category="incidents",
       )
       all_records.extend(incidents)
       if inc_newest:
         newest_time = inc_newest
   
       # Fetch anomalies
       anomalies, anom_newest = fetch_logs(
         base_url=SKYHIGH_BASE_URL,
         access_token=access_token,
         endpoint_path="/shnapi/rest/external/api/v1/anomalies",
         start_time=last_time,
         end_time=now,
         page_size=PAGE_SIZE,
         max_records=MAX_RECORDS,
         log_category="anomalies",
       )
       all_records.extend(anomalies)
       if anom_newest and (newest_time is None or parse_datetime(anom_newest) > parse_datetime(newest_time)):
         newest_time = anom_newest
   
       if not all_records:
         print("No new log records found.")
         save_state(bucket, STATE_KEY, now.isoformat())
         return
   
       # Write to GCS as NDJSON
       timestamp = now.strftime('%Y%m%d_%H%M%S')
       object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
       blob = bucket.blob(object_key)
   
       ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in all_records]) + '\n'
       blob.upload_from_string(ndjson, content_type='application/x-ndjson')
   
       print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")
   
       # Update state with newest event time
       if newest_time:
         save_state(bucket, STATE_KEY, newest_time)
       else:
         save_state(bucket, STATE_KEY, now.isoformat())
   
       print(f"Successfully processed {len(all_records)} records")
   
     except Exception as e:
       print(f'Error processing logs: {str(e)}')
       raise
   
   def parse_datetime(value: str) -> datetime:
     """Parse ISO datetime string to datetime object."""
     if value.endswith("Z"):
       value = value[:-1] + "+00:00"
     return datetime.fromisoformat(value)
   
   def load_state(bucket, key):
     """Load state from GCS."""
     try:
       blob = bucket.blob(key)
       if blob.exists():
         state_data = blob.download_as_text()
         return json.loads(state_data)
     except Exception as e:
       print(f"Warning: Could not load state: {e}")
   
     return {}
   
   def save_state(bucket, key, last_event_time_iso: str):
     """Save the last event timestamp to GCS state file."""
     try:
       state = {'last_event_time': last_event_time_iso}
       blob = bucket.blob(key)
       blob.upload_from_string(
         json.dumps(state, indent=2),
         content_type='application/json'
       )
       print(f"Saved state: last_event_time={last_event_time_iso}")
     except Exception as e:
       print(f"Warning: Could not save state: {e}")
   
   def fetch_logs(base_url: str, access_token: str, endpoint_path: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int, log_category: str):
     """
     Fetch logs from Skyhigh Security CASB API with pagination
     and rate limiting.
   
     Args:
       base_url: Skyhigh Security base URL
       access_token: OAuth 2.0 access token
       endpoint_path: API endpoint path
       start_time: Start time for log query
       end_time: End time for log query
       page_size: Number of records per page
       max_records: Maximum total records to fetch
       log_category: Category name for logging
   
     Returns:
       Tuple of (records list, newest_event_time ISO string)
     """
     endpoint = f"{base_url.rstrip('/')}{endpoint_path}"
   
     headers = {
       'Authorization': f'Bearer {access_token}',
       'Accept': 'application/json',
       'Content-Type': 'application/json',
       'User-Agent': 'GoogleSecOps-SkyhighCASBCollector/1.0'
     }
   
     records = []
     newest_time = None
     page_num = 0
     backoff = 1.0
     offset = 0
   
     start_iso = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
     end_iso = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')
   
     while True:
       page_num += 1
   
       if len(records) >= max_records:
         print(f"Reached max_records limit ({max_records}) for {log_category}")
         break
   
       limit = min(page_size, max_records - len(records))
       url = f"{endpoint}?start_time={start_iso}&end_time={end_iso}&offset={offset}&limit={limit}"
   
       try:
         response = http.request('GET', url, headers=headers)
   
         # Handle rate limiting with exponential backoff
         if response.status == 429:
           retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
           print(f"Rate limited (429). Retrying after {retry_after}s...")
           time.sleep(retry_after)
           backoff = min(backoff * 2, 30.0)
           continue
   
         backoff = 1.0
   
         if response.status != 200:
           print(f"HTTP Error: {response.status} for {log_category}")
           response_text = response.data.decode('utf-8')
           print(f"Response body: {response_text}")
           return [], None
   
         data = json.loads(response.data.decode('utf-8'))
   
         page_results = data.get('data', data.get('results', data.get('items', [])))
   
         if not page_results:
           print(f"No more results (empty page) for {log_category}")
           break
   
         print(f"Page {page_num}: Retrieved {len(page_results)} {log_category} events")
         records.extend(page_results)
   
         # Track newest event time
         for event in page_results:
           try:
             event_time = event.get('timestamp') or event.get('created_at') or event.get('eventTime')
             if event_time:
               if newest_time is None or parse_datetime(str(event_time)) > parse_datetime(str(newest_time)):
                 newest_time = str(event_time)
           except Exception as e:
             print(f"Warning: Could not parse event time: {e}")
   
         # If we got fewer results than requested, no more pages
         if len(page_results) < limit:
           print(f"Last page reached for {log_category}")
           break
   
         offset += len(page_results)
   
       except Exception as e:
         print(f"Error fetching {log_category} logs: {e}")
         return [], None
   
     print(f"Retrieved {len(records)} total {log_category} records from {page_num} pages")
     return records, newest_time
   

   • requirements.txt:

   functions-framework==3.*
   google-cloud-storage==2.*
   urllib3>=2.0.0
   

3. Clique em Implantar para salvar e implantar a função.

4. Aguarde a conclusão da implantação (2 a 3 minutos).

   Observação: a configuração do acionador do Pub/Sub cria automaticamente as assinaturas e permissões necessárias.

Criar o job do Cloud Scheduler

O Cloud Scheduler vai publicar mensagens no tópico do Pub/Sub em intervalos regulares, acionando a função do Cloud Run.

1. No Console do GCP, acesse o Cloud Scheduler.

2. Clique em Criar job.

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

   Configuração	Valor
   Nome	skyhigh-casb-collector-hourly
   Região	Selecione a mesma região da função do Cloud Run
   Frequência	0 * * * * (a cada hora, na hora)
   Fuso horário	Selecione o fuso horário (UTC recomendado)
   Tipo de destino	Pub/Sub
   Tópico	Selecione o tópico skyhigh-casb-logs-trigger.
   Corpo da mensagem	{} (objeto JSON vazio)

4. 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 * * * *	Alto volume e baixa latência
A cada 15 minutos	*/15 * * * *	Volume médio
A cada hora	0 * * * *	Padrão (recomendado)
A cada 6 horas	0 */6 * * *	Baixo volume, processamento em lote
Diariamente	0 0 * * *	Coleta de dados históricos

Testar a integração

1. No console do Cloud Scheduler, encontre seu job.
2. Clique em Forçar execução para acionar o job manualmente.
3. Aguarde alguns segundos.
4. Acesse Cloud Run > Serviços.
5. Clique em skyhigh-casb-collector.
6. Clique na guia Registros.

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

   Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   Successfully obtained access token
   Page 1: Retrieved X incidents events
   Page 1: Retrieved X anomalies events
   Wrote X records to gs://skyhigh-casb-logs/skyhigh-casb/logs_YYYYMMDD_HHMMSS.ndjson
   Successfully processed X records
   

8. Acesse Cloud Storage > Buckets.

9. Clique no nome do bucket (skyhigh-casb-logs).

10. Navegue até a pasta skyhigh-casb/.

11. Verifique se um novo arquivo .ndjson foi criado com o carimbo de data/hora atual.

Se você encontrar erros nos registros:

• HTTP 401: verifique as credenciais da API nas variáveis de ambiente ou se o token expirou.
• HTTP 403: verifique se o cliente da API tem os escopos necessários no console da Skyhigh Security.
• HTTP 429: limitação de taxa. A função vai tentar de novo automaticamente com espera.
• Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas.

Configurar um feed no Google SecOps para ingerir registros do CASB da Skyhigh Security

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, Skyhigh Security CASB Logs).
5. Selecione Google Cloud Storage V2 como o Tipo de origem.
6. Selecione McAfee Skyhigh CASB como o Tipo de registro.

7. Clique em Receber conta de serviço. Um e-mail exclusivo da conta de serviço será exibido, por exemplo:

   [e-mail]
   

8. Copie o endereço de e-mail.

   Observação: cada instância do Google SecOps tem uma conta de serviço exclusiva. Não use contas de serviço de outras documentações ou exemplos.

9. Clique em Próxima.

10. Especifique valores para os seguintes parâmetros de entrada:

    • URL do bucket de armazenamento: insira o URI do bucket do GCS com o caminho do prefixo:

      gs://skyhigh-casb-logs/skyhigh-casb/
      

      • Substitua:
        • skyhigh-casb-logs: o nome do bucket do GCS.
        • skyhigh-casb: prefixo/caminho da pasta opcional onde os registros são armazenados (deixe em branco para a raiz).
    Observação: sempre inclua a barra (/) no final do URI.

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

      • Nunca: nunca exclui arquivos após as transferências (recomendado para testes).
      • Excluir arquivos transferidos: exclui os arquivos após a transferência bem-sucedida.

      • Excluir arquivos transferidos e diretórios vazios: exclui arquivos e diretórios vazios após a transferência bem-sucedida.

        Observação: se você selecionar uma opção de exclusão, a conta de serviço precisará ter o papel Administrador de objetos do Storage em vez de Leitor de objetos do Storage. Atualize as permissões do IAM de acordo com a necessidade.

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

    • Namespace do recurso: o namespace do recurso

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

11. Clique em Próxima.

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

Conceder permissões do IAM à conta de serviço do Google SecOps

A conta de serviço do Google SecOps precisa do papel Leitor de objetos do Storage no seu bucket do GCS.

1. Acesse Cloud Storage > Buckets.
2. Clique no nome do seu bucket.
3. Acesse a guia Permissões.

4. Clique em Conceder acesso.

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

   • Adicionar principais: cole o e-mail da conta de serviço do Google SecOps.
   • Atribuir papéis: selecione Leitor de objetos do Storage.

6. Clique em Salvar.

Observação: se você planeja usar a opção de exclusão "Excluir arquivos transferidos" ou "Excluir arquivos transferidos e diretórios vazios", conceda o papel Administrador de objetos do Storage em vez de Leitor de objetos do Storage.

Tabela de mapeamento do UDM

Campo de registro	Mapeamento do UDM	Lógica
EventReceivedTime	metadata.event_timestamp	Convertido para carimbo de data/hora do formato yyyy-MM-dd HH:mm:ss
FileSize	target.file.size	Mapeado diretamente, convertido para uinteger
Nome do host	principal.hostname	Mapeado diretamente
MessageSourceAddress	principal.ip	Mapeado diretamente, mesclado se houver várias instâncias
Gravidade	additional.fields.value.string_value (chave: SEVERITY)	Mapeado diretamente
SeverityValue	additional.fields.value.string_value (chave: SEVERITY_VALUE)	Mapeado diretamente
SourceModuleName	additional.fields.value.string_value (chave: SOURCE_MODULE_NAME)	Mapeado diretamente
SourceModuleType	principal.resource.resource_subtype	Mapeado diretamente
SyslogFacility	security_result.about.resource.attribute.labels.value (key: SYSLOG_FACILITY)	Mapeado diretamente
SyslogFacilityValue	security_result.about.resource.attribute.labels.value (key: SYSLOG_FACILITY_VALUE)	Mapeado diretamente
SyslogSeverity	security_result.about.resource.attribute.labels.value (key: SYSLOG_SEVERITY)	Mapeado diretamente
SyslogSeverityValue	security_result.about.resource.attribute.labels.value (key: SYSLOG_SEVERITY_VALUE)	Mapeado diretamente
activityName	metadata.product_event_type	Mapeado diretamente, colchetes removidos
actorId	principal.user.userid	Mapeado diretamente, também adicionado a "email_addresses" se for um e-mail.
actorIdType	principal.user.attribute.roles.name	Mapeado diretamente
collaborationSharedLink	security_result.about.resource.attribute.labels.value (chave: COLLABORATION_SHARED_LINK)	Mapeado diretamente
contentItemId	target.file.full_path (se contentItemType for FILE)	Mapeado diretamente, aspas removidas
contentItemId	target.url (se contentItemType for SAAS_RESOURCE)	Mapeado diretamente, aspas removidas
contentItemHierarchy	additional.fields.value.string_value (chave: CONTENT_ITEM_HIERARCHY)	Mapeado diretamente, aspas removidas
contentItemName	target.resource.name	Mapeado diretamente, aspas removidas
contentItemType	additional.fields.value.string_value (key: CONTENT_ITEM_TYPE)	Mapeado diretamente
incidentGroup	security_result.detection_fields.value (chave: INCIDENT_GROUP)	Mapeado diretamente
incidentId	metadata.product_log_id	Mapeado diretamente
incidentRiskScore	security_result.detection_fields.value (key: INCIDENT_RISK_SCORE)	Mapeado diretamente
incidentRiskSeverityId		Usado em combinação com riskSeverity para determinar security_result.severity
informationAccountId	target.resource.product_object_id	Mapeado diretamente
informationAnomalyCategory	security_result.category_details	Mapeado diretamente, aspas removidas
informationAnomalyCause	security_result.detection_fields.value (key: INFO_ANOMALY_CAUSE)	Mapeado diretamente, aspas removidas
informationCategory	security_result.category_details	Mapeado diretamente
informationConfigType	additional.fields.value.string_value (key: INFORMATION_CONFIG_TYPE)	Mapeado diretamente, aspas removidas
informationContentItemParent	target.resource.parent	Mapeado diretamente, aspas removidas
informationEventId	additional.fields.value.string_value (key: INFORMATION_EVENT_ID)	Mapeado diretamente
informationExternalCollaboratorsCount	additional.fields.value.string_value (chave: INFORMATION_COLLAB_COUNT)	Mapeado diretamente
informationFileTypes	additional.fields.value.list_value.values.string_value (key: FILE_TYPE)	Extraído de uma string semelhante a JSON, com remoção de colchetes e aspas
informationLastExecutedResponseLabel	additional.fields.value.string_value (chave: INFORMATION_LAST_RESPONSE)	Mapeado diretamente
informationScanName	metadata.description	Mapeado diretamente, aspas removidas
informationScanRunDate		Não mapeado para UDM
informationSource	additional.fields.value.string_value (chave: INFORMATION_SOURCE)	Mapeado diretamente
informationUniqueMatchCount	additional.fields.value.string_value (chave: INFORMATION_UNQ_MATCH_COUNT)	Mapeado diretamente
informationUserAttributesSAMAccountName	principal.user.user_display_name	Mapeado diretamente, colchetes removidos
instanceId	principal.resource.product_object_id	Mapeado diretamente
instanceName	principal.resource.name	Mapeado diretamente, aspas removidas
policyId	security_result.rule_id	Mapeado diretamente
policyName	security_result.summary	Mapeado diretamente, aspas removidas
resposta		Usado para determinar security_result.action (ALLOW ou BLOCK)
riskSeverity		Usado em combinação com incidentRiskSeverityId para determinar security_result.severity, convertido para maiúsculas.
serviceNames	target.application	Mapeamento direto, colchetes, aspas e espaços extras removidos
sourceIps	principal.ip	Extraído de uma string semelhante a JSON, mesclado se houver várias instâncias
status	additional.fields.value.string_value (chave: STATUS)	Mapeado diretamente
threatCategory	security_result.threat_name	Mapeado diretamente, aspas removidas
totalMatchCount	security_result.detection_fields.value (key: TOTAL_MATCH_COUNT)	Mapeado diretamente
N/A	metadata.vendor_name	MCAFEE: valor estático
N/A	metadata.product_name	MCAFEE_SKYHIGH_CASB: valor estático
N/A	metadata.log_type	MCAFEE_SKYHIGH_CASB: valor estático
N/A	principal.resource.type	VIRTUAL_MACHINE: definido se "instanceName" ou "instanceId" estiverem presentes.
N/A	metadata.event_type	Determinado com base em um conjunto de condições: - USER_RESOURCE_UPDATE_CONTENT se actorId, contentItemId ou contentItemName estiverem presentes - USER_UNCATEGORIZED se actorId e target estiverem presentes - STATUS_UPDATE se Hostname ou MessageSourceAddress estiverem presentes - GENERIC_EVENT caso contrário
N/A	security_result.severity	Determinado com base na combinação de riskSeverity e incidentRiskSeverityId: - LOW se riskSeverity for LOW e incidentRiskSeverityId for 0 - MEDIUM se riskSeverity for MEDIUM e incidentRiskSeverityId for 1 - HIGH se riskSeverity for HIGH e incidentRiskSeverityId for 2 - INFORMATIONAL se riskSeverity for INFO e incidentRiskSeverityId for 3
column2	event.idm.read_only_udm.principal.ip e event.idm.read_only_udm.principal.asset.ip	Mapeado do registro de mudanças
intermediary_host	event.idm.read_only_udm.intermediary.hostname e event.idm.read_only_udm.intermediary.asset.hostname	Mapeado do registro de mudanças
column3	event.idm.read_only_udm.network.http.response_code	Mapeado do registro de mudanças
column8	event.idm.read_only_udm.network.received_bytes	Mapeado do registro de mudanças
column9	event.idm.read_only_udm.network.sent_bytes	Mapeado do registro de mudanças
column10	event.idm.read_only_udm.network.http.user_agent	Mapeado do registro de mudanças
column10	event.idm.read_only_udm.network.http.parsed_user_agent	Mapeado do registro de mudanças
http_method	event.idm.read_only_udm.network.http.method	Mapeado do registro de mudanças
tar_host	event.idm.read_only_udm.target.hostname e event.idm.read_only_udm.target.asset.hostname	Mapeado do registro de mudanças
tar_port	event.idm.read_only_udm.target.port	Mapeado do registro de mudanças
application_protocol	event.idm.read_only_udm.network.application_protocol	Mapeado do registro de mudanças
tar_url	event.idm.read_only_udm.target.url	Mapeado do registro de mudanças
http_version	event.idm.read_only_udm.additional.fields	Mapeado do registro de mudanças
column1	event.idm.read_only_udm.additional.fields	Mapeado do registro de mudanças
intermediary_application	event.idm.read_only_udm.intermediary.application	Mapeado do registro de mudanças
column5	event.idm.read_only_udm.security_result.category_details	Mapeado do registro de mudanças
column6	event.idm.read_only_udm.security_result.detection_fields	Mapeado do registro de mudanças
column12	event.idm.read_only_udm.security_result.detection_fields	Mapeado do registro de mudanças
column7	event.idm.read_only_udm.target.file.mime_type	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.