Coletar registros do CASB do Cisco CloudLock

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 Cisco CloudLock CASB no Google Security Operations usando o Google Cloud Storage .O analisador extrai campos dos registros JSON, transforma e mapeia para o modelo unificado de dados (UDM, na sigla em inglês). Ele processa a análise de datas, converte campos específicos em strings, mapeia campos para entidades do UDM (metadados, destino, resultado de segurança, sobre) e itera pelas correspondências para extrair campos de detecção, mesclando todos os dados extraídos no campo @output.

O Cisco CloudLock é um agente de segurança de acesso à nuvem (CASB) nativo da nuvem que oferece visibilidade e controle sobre aplicativos na nuvem. Ele ajuda as organizações a descobrir a shadow IT, aplicar políticas de prevenção contra perda de dados, detectar ameaças e manter a conformidade em aplicativos SaaS.

Antes de começar

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

• Uma instância do Google SecOps
• 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 console de administrador do Cisco CloudLock

Conferir os pré-requisitos da API Cisco CloudLock

Para começar, entre em contato com o suporte do Cloudlock e receba o URL da API do Cloudlock. Gere um token de acesso no aplicativo Cloudlock. Para isso, selecione a guia "Autenticação e API" na página "Configurações" e clique em "Gerar".

1. Faça login no console de administrador do Cisco CloudLock.
2. Acesse Configurações > Autenticação e API.
3. Em API, clique em Gerar para criar seu token de acesso.
4. Copie e salve os seguintes detalhes em um local seguro:
   • Token de acesso à API
   • URL base da API (fornecido pelo suporte do Cisco CloudLock em [email protected])

Observação: chaves de API, senhas, secrets e tokens permitem o acesso aos seus dados particulares de clientes e nunca devem ser compartilhados com outro usuário ou organização.

Criar um bucket do Google Cloud Storage

1. Acesse o console doGoogle 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, cisco-cloudlock-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.

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 cloudlock-data-export-sa.
   • Descrição da conta de serviço: insira Service account for Cloud Run function to collect Cisco CloudLock logs.
4. Clique em Criar e continuar.
5. Na seção Conceda a essa conta de serviço acesso ao projeto:
   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.

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, cloudlock-data-export-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 cloudlock-data-export-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 será acionada por mensagens do Pub/Sub do Cloud Scheduler para buscar registros da API Cisco CloudLock 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	cloudlock-data-export
   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):

   • Clique em + Adicionar gatilho.
   • Selecione Cloud Pub/Sub.
   • Em Selecionar um tópico do Cloud Pub/Sub, escolha o tópico (cloudlock-data-export-trigger).
   • Clique em Salvar.

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

   • Selecione Exigir autenticação.
   • 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 (cloudlock-data-export-sa).

9. Acesse a guia Contêineres:

   • Clique em Variáveis e secrets.

   • Clique em + Adicionar variável para cada variável de ambiente:

     Nome da variável	Valor de exemplo
     GCS_BUCKET	cisco-cloudlock-logs
     GCS_PREFIX	cloudlock/
     STATE_KEY	cloudlock/state.json
     CLOUDLOCK_API_TOKEN	your-api-token
     CLOUDLOCK_API_BASE	https://api.cloudlock.com

10. Role a tela para baixo na guia Variáveis e secrets até Solicitações:

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

11. Acesse a guia Configurações em Contêineres:

    • Na seção Recursos:
      • Memória: selecione 512 MiB ou mais.
      • CPU: selecione 1.
    • Clique em Concluído.

12. Role até Ambiente de execução:

    • Selecione Padrão (recomendado).

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

14. Clique em Criar.

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

16. 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 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, timedelta
     import time
     
     # Initialize HTTP client
     http = urllib3.PoolManager()
     
     # 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 Cisco CloudLock 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', 'cloudlock/')
         state_key = os.environ.get('STATE_KEY', 'cloudlock/state.json')
         api_token = os.environ.get('CLOUDLOCK_API_TOKEN')
         api_base = os.environ.get('CLOUDLOCK_API_BASE')
     
         if not all([bucket_name, api_token, api_base]):
             print('Error: Missing required environment variables')
             return
     
         try:
             # Get GCS bucket
             bucket = storage_client.bucket(bucket_name)
     
             # Load state (last processed offset for each endpoint)
             state = load_state(bucket, state_key)
     
             print(f'Processing logs with state: {state}')
     
             # Create Authorization header
             headers = {
                 'Authorization': f'Bearer {api_token}',
                 'Content-Type': 'application/json'
             }
     
             # Fetch incidents data (using offset-based pagination)
             incidents_offset = state.get('incidents_offset', 0)
             incidents, new_incidents_offset = fetch_cloudlock_incidents(
                 http, api_base, headers, incidents_offset
             )
     
             if incidents:
                 upload_to_gcs_ndjson(bucket, prefix, 'incidents', incidents)
                 print(f'Uploaded {len(incidents)} incidents to GCS')
                 state['incidents_offset'] = new_incidents_offset
     
             # Fetch activities data (using time-based filtering with offset pagination)
             activities_last_time = state.get('activities_last_time')
             if not activities_last_time:
                 activities_last_time = (datetime.now(timezone.utc) - timedelta(hours=24)).isoformat()
     
             activities_offset = state.get('activities_offset', 0)
             activities, new_activities_offset, newest_activity_time = fetch_cloudlock_activities(
                 http, api_base, headers, activities_last_time, activities_offset
             )
     
             if activities:
                 upload_to_gcs_ndjson(bucket, prefix, 'activities', activities)
                 print(f'Uploaded {len(activities)} activities to GCS')
                 state['activities_offset'] = new_activities_offset
                 if newest_activity_time:
                     state['activities_last_time'] = newest_activity_time
     
             # Fetch entities data (using offset-based pagination)
             entities_offset = state.get('entities_offset', 0)
             entities, new_entities_offset = fetch_cloudlock_entities(
                 http, api_base, headers, entities_offset
             )
     
             if entities:
                 upload_to_gcs_ndjson(bucket, prefix, 'entities', entities)
                 print(f'Uploaded {len(entities)} entities to GCS')
                 state['entities_offset'] = new_entities_offset
     
             # Update consolidated state
             state['updated_at'] = datetime.now(timezone.utc).isoformat()
             save_state(bucket, state_key, state)
     
             print('CloudLock data export completed successfully')
     
         except Exception as e:
             print(f'Error processing logs: {str(e)}')
             raise
     
     def make_api_request(http, url, headers, retries=3):
         """Make API request with exponential backoff retry logic."""
         for attempt in range(retries):
             try:
                 response = http.request('GET', url, headers=headers)
     
                 if response.status == 200:
                     return response
                 elif response.status == 429:
                     # Rate limit
                     retry_after = int(response.headers.get('Retry-After', 60))
                     print(f'Rate limited, waiting {retry_after} seconds')
                     time.sleep(retry_after)
                 else:
                     print(f'API request failed with status {response.status}: {response.data.decode("utf-8")}')
             except Exception as e:
                 print(f'Request attempt {attempt + 1} failed: {str(e)}')
                 if attempt < retries - 1:
                     wait_time = 2 ** attempt
                     time.sleep(wait_time)
                 else:
                     raise
     
         return None
     
     def fetch_cloudlock_incidents(http, api_base, headers, start_offset=0):
         """
         Fetch incidents data from Cisco CloudLock API using offset-based pagination.
     
         Note: The CloudLock API does not support updated_after parameter. This function
         uses offset-based pagination. For production use, consider implementing time-based
         filtering using created_at or updated_at fields in the response data.
         """
         url = f"{api_base}/api/v2/incidents"
     
         limit = 1000
         offset = start_offset
         all_data = []
     
         try:
             while True:
                 # Build URL with parameters
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching incidents with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
     
                 # CloudLock API returns items in 'items' array
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more incidents to fetch")
                     break
     
                 all_data.extend(batch_data)
     
                 # Check if we've reached the end
                 total = data.get('total', 0)
                 results = data.get('results', len(batch_data))
     
                 print(f"Fetched {results} incidents (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of incidents")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total incidents")
             return all_data, offset
     
         except Exception as e:
             print(f"Error fetching incidents: {str(e)}")
             return [], start_offset
     
     def fetch_cloudlock_activities(http, api_base, headers, from_time, start_offset=0):
         """
         Fetch activities data from Cisco CloudLock API using time-based filtering and offset pagination.
         """
         url = f"{api_base}/api/v2/activities"
     
         limit = 1000
         offset = start_offset
         all_data = []
         newest_time = None
     
         try:
             while True:
                 # Build URL with time filter and pagination
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching activities with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more activities to fetch")
                     break
     
                 # Filter activities by time (client-side filtering since API may not support time parameters)
                 filtered_batch = []
                 for item in batch_data:
                     item_time = item.get('timestamp') or item.get('created_at')
                     if item_time and item_time >= from_time:
                         filtered_batch.append(item)
                         if not newest_time or item_time > newest_time:
                             newest_time = item_time
     
                 all_data.extend(filtered_batch)
     
                 results = data.get('results', len(batch_data))
                 total = data.get('total', 0)
     
                 print(f"Fetched {results} activities, {len(filtered_batch)} after time filter (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of activities")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total activities")
             return all_data, offset, newest_time
     
         except Exception as e:
             print(f"Error fetching activities: {str(e)}")
             return [], start_offset, None
     
     def fetch_cloudlock_entities(http, api_base, headers, start_offset=0):
         """
         Fetch entities data from Cisco CloudLock API using offset-based pagination.
     
         Note: This endpoint requires the Entity Cache feature. If not enabled,
         use the incident entities endpoint as an alternative.
         """
         url = f"{api_base}/api/v2/entities"
     
         limit = 1000
         offset = start_offset
         all_data = []
     
         try:
             while True:
                 full_url = f"{url}?limit={limit}&offset={offset}"
     
                 print(f"Fetching entities with offset: {offset}")
     
                 response = make_api_request(http, full_url, headers)
                 if not response:
                     break
     
                 data = json.loads(response.data.decode('utf-8'))
                 batch_data = data.get('items', [])
     
                 if not batch_data:
                     print("No more entities to fetch")
                     break
     
                 all_data.extend(batch_data)
     
                 results = data.get('results', len(batch_data))
                 total = data.get('total', 0)
     
                 print(f"Fetched {results} entities (total available: {total})")
     
                 if results < limit or offset + results >= total:
                     print("Reached end of entities")
                     break
     
                 offset += limit
     
             print(f"Fetched {len(all_data)} total entities")
             return all_data, offset
     
         except Exception as e:
             print(f"Error fetching entities: {str(e)}")
             return [], start_offset
     
     def upload_to_gcs_ndjson(bucket, prefix, data_type, data):
         """Upload data to GCS bucket in NDJSON format (one JSON object per line)."""
         timestamp = datetime.now(timezone.utc).strftime('%Y/%m/%d/%H')
         filename = f"{prefix}{data_type}/{timestamp}/cloudlock_{data_type}_{int(datetime.now(timezone.utc).timestamp())}.jsonl"
     
         try:
             # Convert to NDJSON format
             ndjson_content = '\n'.join([json.dumps(item, separators=(',', ':')) for item in data])
     
             blob = bucket.blob(filename)
             blob.upload_from_string(
                 ndjson_content,
                 content_type='application/x-ndjson'
             )
     
             print(f"Successfully uploaded {filename} to GCS")
     
         except Exception as e:
             print(f"Error uploading to GCS: {str(e)}")
             raise
     
     def load_state(bucket, key):
         """Load state from GCS with separate tracking for each endpoint."""
         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)}')
     
         print("No previous state found, starting fresh")
         return {}
     
     def save_state(bucket, key, state):
         """Save consolidated state to GCS."""
         try:
             blob = bucket.blob(key)
             blob.upload_from_string(
                 json.dumps(state, indent=2),
                 content_type='application/json'
             )
             print("Updated state successfully")
         except Exception as e:
             print(f"Error updating state: {str(e)}")
             raise
     

     • 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: este script usa endpoints da API Cisco CloudLock com paginação baseada em deslocamento, conforme documentado na especificação oficial da API. A API CloudLock não aceita o parâmetro updated_after para sincronização incremental em endpoints de incidentes e entidades. Para implantações de produção, considere implementar outra lógica de filtragem com base no tempo ou entre em contato com o suporte do Cisco CloudLock em [email protected] para verificar os recursos mais recentes da API para seu locatário.

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	cloudlock-data-export-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 assunto (cloudlock-data-export-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 o job do programador

1. No console do Cloud Scheduler, encontre seu job.
2. Clique em Forçar execução para acionar manualmente.
3. Aguarde alguns segundos e acesse Cloud Run > Serviços > cloudlock-data-export > Registros.
4. Verifique se a função foi executada com sucesso.
5. Verifique o bucket do GCS para confirmar se os registros foram gravados.

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

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, Cisco CloudLock logs).
5. Selecione Google Cloud Storage V2 como o Tipo de origem.
6. Selecione Cisco CloudLock 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://cisco-cloudlock-logs/cloudlock/
     

     • Substitua:

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

     • Exemplos:

       • Bucket raiz: gs://cisco-cloudlock-logs/
       • Com prefixo: gs://cisco-cloudlock-logs/cloudlock/
       • Com subpasta: gs://cisco-cloudlock-logs/cloudlock/incidents/
   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
created_at	about.resource.attribute.labels.key	O valor do campo "created_at" é atribuído à chave "labels".
created_at	about.resource.attribute.labels.value	O valor do campo "created_at" é atribuído ao valor dos rótulos.
created_at	about.resource.attribute.creation_time	O campo "created_at" é analisado como um carimbo de data/hora e mapeado.
entity.id	target.asset.product_object_id	O campo "entity.id" foi renomeado.
entity.ip	target.ip	O campo "entity.ip" é mesclado ao campo de IP de destino.
entity.mime_type	target.file.mime_type	O campo "entity.mime_type" é renomeado quando "entity.origin_type" é "document".
entity.name	target.application	O campo "entity.name" é renomeado quando "entity.origin_type" é "app".
entity.name	target.file.full_path	O campo "entity.name" é renomeado quando "entity.origin_type" é "document".
entity.origin_id	target.resource.product_object_id	O campo "entity.origin_id" foi renomeado.
entity.origin_type	target.resource.resource_subtype	O campo "entity.origin_type" foi renomeado.
entity.owner_email	target.user.email_addresses	O campo "entity.owner_email" é mesclado ao campo de e-mail do usuário de destino se corresponder a uma expressão regular de e-mail.
entity.owner_email	target.user.user_display_name	O campo "entity.owner_email" será renomeado se não corresponder a uma regex de e-mail.
entity.owner_name	target.user.user_display_name	O campo "entity.owner_name" é renomeado quando "entity.owner_email" corresponde a uma expressão regular de e-mail.
entity.vendor.name	target.platform_version	O campo "entity.vendor.name" foi renomeado.
ID	metadata.product_log_id	O campo "id" é renomeado.
incident_status	metadata.product_event_type	O campo "incident_status" foi renomeado.
	metadata.event_timestamp	O valor é fixado como "updated_at". O valor é derivado do campo "updated_at". O campo "updated_at" é analisado como um carimbo de data/hora e mapeado.
	security_result.detection_fields.key	Definido como "true" se a gravidade for "ALERT" e o incident_status for "NEW". Convertido para booleano.
	security_result.detection_fields.value	Definido como "true" se a gravidade for "ALERT" e o incident_status for "NEW". Convertido para booleano.
	metadata.event_type	O valor é codificado como "GENERIC_EVENT".
	metadata.product_name	O valor é codificado como "CISCO_CLOUDLOCK_CASB".
	metadata.vendor_name	O valor é codificado como "CloudLock".
	metadata.product_version	O valor é codificado como "Cisco".
	security_result.alert_state	Definido como "ALERTING" se a gravidade for "ALERT" e incident_status não for "RESOLVED" ou "DISMISSED". Defina como "NOT_ALERTING" se a gravidade for "ALERT" e o incident_status for "RESOLVED" ou "DISMISSED".
	security_result.detection_fields.key	Derivado da matriz "matches", especificamente a chave de cada objeto de correspondência.
	security_result.detection_fields.value	Derivado da matriz "matches", especificamente o valor de cada objeto de correspondência.
	security_result.rule_id	Derivado de policy.id.
	security_result.rule_name	Derivado de "policy.name".
	security_result.severity	Definido como "INFORMATIVO" se a gravidade for "INFO". Definido como "CRITICAL" se a gravidade for "CRITICAL". Derivada da gravidade.
	security_result.summary	O valor é definido como "match count: " concatenado com o valor de match_count.
	target.resource.resource_type	Defina como "STORAGE_OBJECT" quando entity.origin_type for "document".
	target.url	Derivado de "entity.direct_url" quando "entity.origin_type" é "document".
policy.id	security_result.rule_id	O campo "policy.id" foi renomeado.
policy.name	security_result.rule_name	O campo "policy.name" foi renomeado.
gravidade,	security_result.severity_details	O campo "Gravidade" foi renomeado.
updated_at	about.resource.attribute.labels.key	O valor do campo "updated_at" é atribuído à chave "labels".
updated_at	about.resource.attribute.labels.value	O valor do campo "updated_at" é atribuído ao valor dos rótulos.
updated_at	about.resource.attribute.last_update_time	O campo "updated_at" é analisado como um carimbo de data/hora e mapeado.

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