Coletar registros do Symantec Web Security Service (WSS)

Compatível com:

Google SecOps SIEM

Observação: esse recurso é coberto pelos Termos de produtos pré-GA dos Termos específicos de serviço do Google Security Operations. Os recursos pré-GA podem ter suporte limitado, e as mudanças realizadas podem não ser compatíveis com outras versões pré-GA. Para mais informações, consulte as diretrizes do serviço de suporte técnico do Google SecOps e os Termos específicos de serviço do Google SecOps.

Este documento explica como ingerir registros do Symantec Web Security Service (WSS) no Google Security Operations usando o Google Cloud Storage. Primeiro, o analisador tenta analisar a mensagem de registro como JSON. Se isso falhar, ele usará uma série de padrões de grok cada vez mais específicos para extrair campos do texto bruto, mapeando os dados extraídos para o Modelo Unificado de Dados (UDM, na sigla em inglês). O Symantec Web Security Service (WSS) é uma solução de segurança da Web baseada na nuvem que oferece proteção em tempo real contra ameaças da Web, incluindo malware, phishing e perda de dados.

Antes de começar

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

• Uma instância do Google SecOps
• Um projeto do GCP com a API Cloud Storage ativada
• Permissões para criar e gerenciar buckets 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
• Acesso privilegiado ao portal do Symantec Web Security Service

Coletar credenciais da API do Symantec WSS

Acessar o URL do site do Symantec WSS

1. Faça login no portal do Symantec Web Security Service.
2. Anote o URL do portal na barra de endereço do navegador.
   • Formato: https://portal.threatpulse.com ou o URL específico da sua organização
   • Exemplo: se você acessar o WSS em https://portal.threatpulse.com/reportpod, o URL do seu site será https://portal.threatpulse.com

Criar credenciais de API

1. Faça login no portal do Symantec Web Security Service como administrador.
2. Acesse Conta > Credenciais da API.
3. Clique em Adicionar credenciais da API.
4. O portal mostra a caixa de diálogo Adicionar credencial de API com Nome de usuário e Senha gerados automaticamente.

5. Copie e salve o Nome de usuário e a Senha com segurança.

   Observação: essas credenciais são mostradas apenas uma vez. Se você perder as credenciais, será necessário gerar novas.

6. Selecione a opção Expiração da API:

   • Com base no tempo: defina a data e a hora em que o token expira.
   • Nunca expira: o token permanece válido indefinidamente (recomendado para produção).

7. Na opção Acesso, selecione Registros de acesso a relatórios.

8. Clique em Salvar.

Verifique as permissões

Para verificar se a conta tem as permissões necessárias:

1. Faça login no portal do Symantec Web Security Service.
2. Acesse Conta > Credenciais da API.
3. Se você conseguir ver as credenciais da API criadas com a opção Acesso definida como Registros de acesso a relatórios, significa que você tem as permissões necessárias.
4. Se essa opção não estiver disponível, entre em contato com seu administrador para conceder a permissão Registros de acesso a relatórios.

Testar o acesso à API

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

  # Replace with your actual credentials
  WSS_USERNAME="your-api-username"
  WSS_PASSWORD="your-api-password"
  WSS_SYNC_URL="https://portal.threatpulse.com/reportpod/logs/sync"
  
  # Test API access (note: sync endpoint requires time parameters)
  curl -v -H "X-APIUsername: ${WSS_USERNAME}" \
    -H "X-APIPassword: ${WSS_PASSWORD}" \
    "${WSS_SYNC_URL}?startDate=0&endDate=1000&token=none"
  

Resposta esperada: HTTP 200 com dados de registro ou resposta vazia se não houver registros no período.

Criar um bucket do Google Cloud Storage

1. Acesse o Console do Google Cloud.
2. Selecione seu 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, symantec-wss-logs.
   Tipo de local	Escolha com base nas 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.

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 symantec-wss-collector-sa.
   • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Symantec WSS 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 em um 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.
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, symantec-wss-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 symantec-wss-trigger.
   • Não altere as outras configurações.
4. Clique em Criar.

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

A função do Cloud Run é acionada por mensagens do Pub/Sub do Cloud Scheduler para buscar registros da API Symantec WSS Sync 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	symantec-wss-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 do Pub/Sub (symantec-wss-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 abra Contêineres, rede, segurança.

8. Acesse a guia Segurança:

   • Conta de serviço: selecione a conta de serviço (symantec-wss-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	symantec-wss-logs	Nome do bucket do GCS
   GCS_PREFIX	symantec/wss/	Prefixo para arquivos de registro
   STATE_KEY	symantec/wss/state.json	Caminho do arquivo de estado
   WINDOW_SECONDS	3600	Janela de tempo em segundos (1 hora)
   HTTP_TIMEOUT	60	Tempo limite da solicitação HTTP em segundos
   MAX_RETRIES	3	Máximo de tentativas de repetição
   USER_AGENT	symantec-wss-to-gcs/1.0	String do user agent
   WSS_SYNC_URL	https://portal.threatpulse.com/reportpod/logs/sync	Endpoint da API de sincronização do WSS
   WSS_API_USERNAME	your-api-username (em "Credenciais da API")	Nome de usuário da API WSS
   WSS_API_PASSWORD	your-api-password (em "Credenciais da API")	Senha da API WSS
   WSS_TOKEN_PARAM	none	Parâmetro de token para a API de sincronização

10. Na seção Variáveis e secrets, role a tela 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 é criado, o editor de código inline é aberto automaticamente.

Adicionar código da função

1. Insira main em Ponto de entrada da função.

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

   • Primeiro arquivo: main.py::

   import functions_framework
   from google.cloud import storage
   import json
   import os
   import urllib3
   from datetime import datetime, timezone
   import uuid
   import time
   
   # Initialize HTTP client with timeouts
   http = urllib3.PoolManager(
       timeout=urllib3.Timeout(connect=5.0, read=60.0),
       retries=False,
   )
   
   # Initialize Storage client
   storage_client = storage.Client()
   
   @functions_framework.cloud_event
   def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch logs from Symantec WSS Sync API and write to GCS.
   
       Args:
           cloud_event: CloudEvent object containing Pub/Sub message
       """
   
       # Get environment variables
       bucket_name = os.environ.get('GCS_BUCKET')
       prefix = os.environ.get('GCS_PREFIX', 'symantec/wss/')
       state_key = os.environ.get('STATE_KEY', 'symantec/wss/state.json')
       window_sec = int(os.environ.get('WINDOW_SECONDS', '3600'))
       http_timeout = int(os.environ.get('HTTP_TIMEOUT', '60'))
       max_retries = int(os.environ.get('MAX_RETRIES', '3'))
       user_agent = os.environ.get('USER_AGENT', 'symantec-wss-to-gcs/1.0')
       wss_sync_url = os.environ.get('WSS_SYNC_URL', 'https://portal.threatpulse.com/reportpod/logs/sync')
       api_username = os.environ.get('WSS_API_USERNAME')
       api_password = os.environ.get('WSS_API_PASSWORD')
       token_param = os.environ.get('WSS_TOKEN_PARAM', 'none')
   
       if not all([bucket_name, api_username, api_password]):
           print('Error: Missing required environment variables')
           return
   
       try:
           # Get GCS bucket
           bucket = storage_client.bucket(bucket_name)
   
           # Load state (last processed timestamp)
           state = load_state(bucket, state_key)
           now = datetime.now(timezone.utc).timestamp()
           from_ts = float(state.get('last_to_ts', now - window_sec))
           to_ts = now
   
           # Convert to milliseconds for WSS API
           start_ms = int(from_ts * 1000)
           end_ms = int(to_ts * 1000)
   
           print(f'Fetching Symantec WSS logs from {start_ms} to {end_ms}')
   
           # Fetch logs from WSS Sync API
           blob_data, content_type, content_encoding = fetch_wss_logs(
               wss_sync_url, api_username, api_password, token_param,
               start_ms, end_ms, user_agent, http_timeout, max_retries
           )
   
           print(f'Retrieved {len(blob_data)} bytes with content-type: {content_type}')
           if content_encoding:
               print(f'Content encoding: {content_encoding}')
   
           # Write to GCS
           if blob_data:
               blob_name = write_wss_data(
                   bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts
               )
               print(f'Wrote logs to {blob_name}')
   
           # Update state
           save_state(bucket, state_key, {
               'last_to_ts': to_ts,
               'last_successful_run': now
           })
   
           print(f'Successfully processed logs up to {to_ts}')
   
       except Exception as e:
           print(f'Error processing logs: {str(e)}')
           raise
   
   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: {str(e)}')
       return {}
   
   def save_state(bucket, key, state):
       """Save state to GCS."""
       try:
           blob = bucket.blob(key)
           blob.upload_from_string(
               json.dumps(state, separators=(',', ':')),
               content_type='application/json'
           )
       except Exception as e:
           print(f'Warning: Could not save state: {str(e)}')
   
   def fetch_wss_logs(sync_url, username, password, token, start_ms, end_ms, user_agent, timeout, max_retries):
       """Fetch logs from WSS Sync API with retry logic using custom HTTP headers."""
       params = f"startDate={start_ms}&endDate={end_ms}&token={token}"
       url = f"{sync_url}?{params}"
   
       attempt = 0
       backoff = 1.0
   
       while True:
           try:
               headers = {
                   'User-Agent': user_agent,
                   'X-APIUsername': username,
                   'X-APIPassword': password
               }
   
               response = http.request('GET', url, headers=headers, timeout=timeout)
   
               # 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:
                   content_type = response.headers.get('Content-Type', 'application/octet-stream')
                   content_encoding = response.headers.get('Content-Encoding', '')
                   return response.data, content_type, content_encoding
               else:
                   raise Exception(f'HTTP {response.status}: {response.data.decode("utf-8", errors="ignore")}')
   
           except Exception as e:
               attempt += 1
               print(f'HTTP error on attempt {attempt}: {e}')
               if attempt > max_retries:
                   raise
               # Exponential backoff with jitter
               time.sleep(min(60, 2 ** attempt) + (time.time() % 1))
   
   def determine_extension(content_type, content_encoding):
       """Determine file extension based on content type and encoding."""
       if 'zip' in content_type.lower():
           return '.zip'
       if 'gzip' in content_type.lower() or content_encoding.lower() == 'gzip':
           return '.gz'
       if 'json' in content_type.lower():
           return '.json'
       if 'csv' in content_type.lower():
           return '.csv'
       return '.bin'
   
   def write_wss_data(bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts):
       """Write WSS data to GCS with unique key."""
       ts_path = datetime.fromtimestamp(to_ts, tz=timezone.utc).strftime('%Y/%m/%d')
       uniq = f"{int(time.time() * 1e6)}_{uuid.uuid4().hex[:8]}"
       ext = determine_extension(content_type, content_encoding)
       blob_name = f"{prefix}{ts_path}/symantec_wss_{int(from_ts)}_{int(to_ts)}_{uniq}{ext}"
   
       blob = bucket.blob(blob_name)
       blob.upload_from_string(
           blob_data,
           content_type=content_type
       )
   
       # Set metadata
       blob.metadata = {
           'source': 'symantec-wss',
           'from_timestamp': str(int(from_ts)),
           'to_timestamp': str(int(to_ts)),
           'content_encoding': content_encoding
       }
       blob.patch()
   
       return blob_name
   

   • Segundo arquivo: 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 publica 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	symantec-wss-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 do Pub/Sub (symantec-wss-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
  Diário	0 0 * * *	Coleta de dados históricos

Testar a integração

1. No console do Cloud Scheduler, encontre seu job.
2. Clique em Executar à força para acionar o job manualmente.
3. Aguarde alguns segundos.
4. Acesse Cloud Run > Serviços.
5. Clique no nome da função (symantec-wss-collector).
6. Clique na guia Registros.

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

   Fetching Symantec WSS logs from [start_ms] to [end_ms]
   Retrieved X bytes with content-type: [type]
   Wrote logs to symantec/wss/YYYY/MM/DD/symantec_wss_[timestamps].[ext]
   Successfully processed logs up to [timestamp]
   

8. Acesse Cloud Storage > Buckets.

9. Clique no nome do bucket.

10. Navegue até a pasta de prefixo (symantec/wss/).

11. Verifique se um novo arquivo 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. Verifique se o nome de usuário e a senha estão corretos.
• HTTP 403: verifique se as credenciais da API têm a permissão "Relatórios de acesso" ativada no portal do WSS.
• HTTP 429: limitação de taxa. A função vai tentar novamente de forma automática com espera.
• Variáveis de ambiente ausentes: verifique se todas as variáveis necessárias estão definidas na configuração da função do Cloud Run.

Recuperar a conta de serviço do Google SecOps

O Google SecOps usa uma conta de serviço exclusiva para ler dados do seu bucket do GCS. Você precisa conceder a essa conta de serviço acesso ao seu bucket.

Receber o e-mail da conta de serviço

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, Symantec WSS logs).
5. Selecione Google Cloud Storage V2 como o Tipo de origem.
6. Selecione Symantec WSS como o Tipo de registro.

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

   [e-mail]
   

8. Copie esse endereço de e-mail para usar na próxima etapa.

   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.

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

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

1. Acesse Cloud Storage > Buckets.
2. Clique no nome do bucket.
3. Acesse a guia Permissões.
4. Clique em Conceder acesso.
5. Informe os seguintes detalhes de configuração:
   • Adicionar participantes: 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.

Configurar um feed no Google SecOps para ingerir registros do Symantec WSS

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, Symantec WSS logs).
5. Selecione Google Cloud Storage V2 como o Tipo de origem.
6. Selecione Symantec WSS como o Tipo de registro.
7. Clique em Próxima.

8. 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://symantec-wss-logs/symantec/wss/
     

     • Substitua:

       • symantec-wss-logs: o nome do bucket do GCS.
       • symantec/wss/: prefixo/caminho da pasta opcional onde os registros são armazenados (deixe em branco para a raiz).

     • Exemplos:

       • Bucket raiz: gs://company-logs/
       • Com prefixo: gs://company-logs/symantec-wss/
       • Com subpasta: gs://company-logs/symantec/wss/
       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 no último número de dias. O padrão é de 180 dias.

   • Namespace do recurso: o namespace do recurso.

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

9. Clique em Próxima.

10. 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
category_id	read_only_udm.metadata.product_event_type	Se category_id for 1, read_only_udm.metadata.product_event_type será definido como "Security". Se category_id for 5, read_only_udm.metadata.product_event_type será definido como "Policy".
collector_device_ip	read_only_udm.principal.ip, read_only_udm.principal.asset.ip	Valor do campo "collector_device_ip"
connection.bytes_download	read_only_udm.network.received_bytes	Valor do campo "connection.bytes_download" convertido em número inteiro.
connection.bytes_upload	read_only_udm.network.sent_bytes	Valor do campo "connection.bytes_upload" convertido em número inteiro.
connection.dst_ip	read_only_udm.target.ip	Valor do campo "connection.dst_ip"
connection.dst_location.country	read_only_udm.target.location.country_or_region	Valor do campo "connection.dst_location.country"
connection.dst_name	read_only_udm.target.hostname	Valor do campo "connection.dst_name"
connection.dst_port	read_only_udm.target.port	Valor do campo "connection.dst_port" convertido em número inteiro
connection.http_status	read_only_udm.network.http.response_code	Valor do campo "connection.http_status" convertido em número inteiro
connection.http_user_agent	read_only_udm.network.http.user_agent	Valor do campo "connection.http_user_agent".
connection.src_ip	read_only_udm.principal.ip, read_only_udm.src.ip	Valor do campo "connection.src_ip". Se src_ip ou collector_device_ip não estiver vazio, ele será mapeado para read_only_udm.src.ip
connection.tls.version	read_only_udm.network.tls.version_protocol	Valor do campo "connection.tls.version"
connection.url.host	read_only_udm.target.hostname	Valor do campo "connection.url.host"
connection.url.method	read_only_udm.network.http.method	Valor do campo "connection.url.method"
connection.url.path	read_only_udm.target.url	Valor do campo "connection.url.path"
connection.url.text	read_only_udm.target.url	Valor do campo "connection.url.text"
cs_connection_negotiated_cipher	read_only_udm.network.tls.cipher	Valor do campo "cs_connection_negotiated_cipher"
cs_icap_status	read_only_udm.security_result.description	Valor do campo cs_icap_status
device_id	read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id	Valor do campo device_id
device_ip	read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip	Valor do campo "device_ip"
device_time	read_only_udm.metadata.collected_timestamp, read_only_udm.metadata.event_timestamp	Valor do campo "device_time" convertido em string. Se "when" estiver vazio, ele será mapeado para "read_only_udm.metadata.event_timestamp".
nome do host	read_only_udm.principal.hostname, read_only_udm.principal.asset.hostname	Valor do campo de nome do host
log_time	read_only_udm.metadata.event_timestamp	Valor do campo "log_time" convertido em carimbo de data/hora. Se "when" e "device_time" estiverem vazios, o mapeamento será para "read_only_udm.metadata.event_timestamp".
msg_desc	read_only_udm.metadata.description	Valor do campo msg_desc
os_details	read_only_udm.target.asset.platform_software.platform, read_only_udm.target.asset.platform_software.platform_version	Valor do campo "os_details". Se os_details não estiver vazio, ele será analisado para extrair os_name e os_ver. Se os_name contiver Windows, read_only_udm.target.asset.platform_software.platform será definido como WINDOWS. os_ver será mapeado para read_only_udm.target.asset.platform_software.platform_version.
product_data.cs(Referer)	read_only_udm.network.http.referral_url	Valor do campo product_data.cs(Referer)
product_data.r-supplier-country	read_only_udm.principal.location.country_or_region	Valor do campo product_data.r-supplier-country
product_data.s-supplier-ip	read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip	Valor do campo product_data.s-supplier-ip
product_data.x-bluecoat-application-name	read_only_udm.target.application	Valor do campo product_data.x-bluecoat-application-name
product_data.x-bluecoat-transaction-uuid	read_only_udm.metadata.product_log_id	Valor do campo product_data.x-bluecoat-transaction-uuid
product_data.x-client-agent-sw	read_only_udm.observer.platform_version	Valor do campo product_data.x-client-agent-sw
product_data.x-client-agent-type	read_only_udm.observer.application	Valor do campo "product_data.x-client-agent-type"
product_data.x-client-device-id	read_only_udm.target.resource.type, read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id	Se não estiver vazio, read_only_udm.target.resource.type será definido como DEVICE. O valor do campo product_data.x-client-device-id é mapeado para read_only_udm.target.resource.id e read_only_udm.target.resource.product_object_id.
product_data.x-client-device-name	read_only_udm.src.hostname, read_only_udm.src.asset.hostname	Valor do campo product_data.x-client-device-name
product_data.x-cs-client-ip-country	read_only_udm.target.location.country_or_region	Valor do campo product_data.x-cs-client-ip-country
product_data.x-cs-connection-negotiated-cipher	read_only_udm.network.tls.cipher	Valor do campo "product_data.x-cs-connection-negotiated-cipher".
product_data.x-cs-connection-negotiated-ssl-version	read_only_udm.network.tls.version_protocol	Valor do campo "product_data.x-cs-connection-negotiated-ssl-version"
product_data.x-exception-id	read_only_udm.security_result.summary	Valor do campo product_data.x-exception-id
product_data.x-rs-certificate-hostname	read_only_udm.network.tls.client.server_name	Valor do campo product_data.x-rs-certificate-hostname
product_data.x-rs-certificate-hostname-categories	read_only_udm.security_result.category_details	Valor do campo product_data.x-rs-certificate-hostname-categories
product_data.x-rs-certificate-observed-errors	read_only_udm.network.tls.server.certificate.issuer	Valor do campo product_data.x-rs-certificate-observed-errors
product_data.x-rs-certificate-validate-status	read_only_udm.network.tls.server.certificate.subject	Valor do campo product_data.x-rs-certificate-validate-status
product_name	read_only_udm.metadata.product_name	Valor do campo "product_name"
product_ver	read_only_udm.metadata.product_version	Valor do campo "product_ver"
proxy_connection.src_ip	read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip	Valor do campo proxy_connection.src_ip
received_bytes	read_only_udm.network.received_bytes	Valor do campo "received_bytes" convertido em número inteiro
ref_uid	read_only_udm.metadata.product_log_id	Valor do campo ref_uid
s_action	read_only_udm.metadata.description	Valor do campo s_action
sent_bytes	read_only_udm.network.sent_bytes	Valor do campo "sent_bytes" convertido em número inteiro
severity_id	read_only_udm.security_result.severity	Se severity_id for 1 ou 2, read_only_udm.security_result.severity será definido como "LOW". Se severity_id for 3 ou 4, read_only_udm.security_result.severity será definido como MEDIUM. Se severity_id for 5 ou 6, read_only_udm.security_result.severity será definido como HIGH
supplier_country	read_only_udm.principal.location.country_or_region	Valor do campo "supplier_country"
target_ip	read_only_udm.target.ip, read_only_udm.target.asset.ip	Valor do campo "target_ip"
user.full_name	read_only_udm.principal.user.user_display_name	Valor do campo user.full_name
user.name	read_only_udm.principal.user.user_display_name	Valor do campo user.name
user_name	read_only_udm.principal.user.user_display_name	Valor do campo "user_name"
uuid	read_only_udm.metadata.product_log_id	Valor do campo UUID
quando	read_only_udm.metadata.event_timestamp	Valor de "when" convertido em carimbo de data/hora
read_only_udm.metadata.event_type		Definido como NETWORK_UNCATEGORIZED se o nome do host estiver vazio e connection.dst_ip não estiver. Definido como SCAN_NETWORK se o nome do host não estiver vazio. Definido como NETWORK_CONNECTION se has_principal e has_target forem verdadeiros. Definido como STATUS_UPDATE se has_principal for verdadeiro e has_target for falso. Definido como GENERIC_EVENT se has_principal e has_target forem falsos
read_only_udm.metadata.log_type		Sempre definido como SYMANTEC_WSS
read_only_udm.metadata.vendor_name		Sempre definido como SYMANTEC
read_only_udm.security_result.action		Defina como ALLOW se "product_data.sc-filter_result" for OBSERVED ou PROXIED. Definido como BLOCK se "product_data.sc-filter_result" for DENIED
read_only_udm.security_result.action_details		Valor do campo product_data.sc-filter_result
read_only_udm.target.resource.type		Definido como DEVICE se product_data.x-client-device-id não estiver vazio

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