Esta página foi traduzida pela API Cloud Translation.

Coletar registros do Forcepoint Web Security

Compatível com:

Google SecOps SIEM

Este documento explica como ingerir registros do Forcepoint Web Security no Google Security Operations usando o Bindplane.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

Uma instância do Google SecOps
Um host Windows 2016 ou mais recente ou Linux com systemd para o agente do Bindplane
Se você estiver executando por trás de um proxy, verifique se as portas do firewall estão abertas de acordo com os requisitos do agente Bindplane.
Acesso privilegiado ao console de gerenciamento do Forcepoint Web Security ou ao Forcepoint Security Manager
Conectividade de rede entre o Forcepoint Web Security e o host do agente Bindplane
Forcepoint Web Security versão 7.8 ou mais recente (recomendado para compatibilidade com o formato CEF)

Receber o arquivo de autenticação de ingestão do Google SecOps

Faça login no console do Google SecOps.
Acesse Configurações do SIEM > Agentes de coleta.
Baixe o arquivo de autenticação de ingestão. Salve o arquivo de forma segura no sistema em que o Bindplane será instalado.

Receber o ID de cliente do Google SecOps

Faça login no console do Google SecOps.
Acesse Configurações do SIEM > Perfil.
Copie e salve o ID do cliente na seção Detalhes da organização.

Instalar o agente do Bindplane

Instale o agente do Bindplane no seu sistema operacional Windows ou Linux de acordo com as instruções a seguir.

Instalação do Windows

Abra o Prompt de Comando ou o PowerShell como administrador.

Execute este comando:

msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet

Instalação do Linux

Abra um terminal com privilégios de root ou sudo.

Execute este comando:

sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh

Outros recursos de instalação

Para mais opções de instalação, consulte este guia de instalação.

Configurar o agente do Bindplane para ingerir o Syslog e enviar ao Google SecOps

É possível configurar o agente do Bindplane para receber mensagens syslog por TCP ou UDP. Escolha o protocolo mais adequado ao seu ambiente e aos requisitos de rede.

Escolher seu protocolo

TCP (recomendado para confiabilidade): oferece entrega e é adequado para a maioria dos ambientes. Use o TCP quando a entrega confiável de registros for essencial e você quiser garantir que nenhum registro seja perdido devido a problemas de rede.
UDP (recomendado para performance): oferece menor latência e menos sobrecarga. Use o UDP quando for necessária alta capacidade de processamento e a perda ocasional de registros for aceitável.

Configurar o agente do BindPlane

Acesse o arquivo de configuração:
- Localize o arquivo config.yaml. Normalmente, ele fica no diretório /etc/bindplane-agent/ no Linux ou no diretório de instalação no Windows.
- Abra o arquivo usando um editor de texto (por exemplo, nano, vi ou Bloco de Notas).

Edite o arquivo config.yaml com a configuração do protocolo escolhido:

Opção A: configuração de TCP (recomendada)

receivers:
   tcplog:
      # Replace with your desired port and IP address
      listen_address: "0.0.0.0:514"
      # Add operators if specific parsing is needed
      operators: []

exporters:
chronicle/chronicle_w_labels:
   compression: gzip
   # Adjust the path to the credentials file you downloaded in Step 1
   creds_file_path: '/path/to/ingestion-authentication-file.json'
   # Replace with your actual customer ID from Step 2
   customer_id: <YOUR_CUSTOMER_ID>
   # Replace with the appropriate regional endpoint
   endpoint: <CUSTOMER_REGION_ENDPOINT>
   # Log type for Forcepoint Web Security
   log_type: 'FORCEPOINT_WEBPROXY'
   raw_log_field: body
   # You can optionally add other custom ingestion labels here if needed
   ingestion_labels:

service:
   pipelines:
      logs/forcepoint_tcp_to_chronicle:
         receivers:
            - tcplog
         exporters:
            - chronicle/chronicle_w_labels

Opção B: configuração do UDP

receivers:
   udplog:
      # Replace with your desired port and IP address
      listen_address: "0.0.0.0:514"
      # Add operators if specific parsing is needed
      operators: []

exporters:
   chronicle/chronicle_w_labels:
      compression: gzip
      # Adjust the path to the credentials file you downloaded in Step 1
      creds_file_path: '/path/to/ingestion-authentication-file.json'
      # Replace with your actual customer ID from Step 2
      customer_id: <YOUR_CUSTOMER_ID>
      # Replace with the appropriate regional endpoint
      endpoint: <CUSTOMER_REGION_ENDPOINT>
      # Log type for Forcepoint Web Security
      log_type: 'FORCEPOINT_WEBPROXY'
      raw_log_field: body
      # You can optionally add other custom ingestion labels here if needed
      ingestion_labels:

service:
   pipelines:
      logs/forcepoint_udp_to_chronicle:
         receivers:
            - udplog
         exporters:
            - chronicle/chronicle_w_labels

Substitua a porta e o endereço IP conforme necessário na sua infraestrutura. O padrão é 0.0.0.0:514.

Observação: a porta 514 é a porta syslog padrão. Se essa porta já estiver em uso ou restrita, escolha uma alternativa (por exemplo, 1514, 5514) e configure a mesma porta no Forcepoint Web Security.

Reinicie o agente do Bindplane para aplicar as mudanças

Para reiniciar o agente do Bindplane no Linux, execute o seguinte comando:
```
sudo systemctl restart bindplane-agent
```
Para reiniciar o agente do Bindplane no Windows, use o console Serviços ou insira o seguinte comando:
```
net stop BindPlaneAgent && net start BindPlaneAgent
```
Para verificar se o agente está em execução no Linux, execute o seguinte comando:
```
sudo systemctl status observiq-otel-collector
```
Para verificar se o agente está em execução no Windows, execute o seguinte comando:
```
sc query observiq-otel-collector
```

Configurar o encaminhamento do Syslog no Forcepoint Web Security

Configure o Forcepoint Web Security para encaminhar registros ao agente do Bindplane no formato CEF (Common Event Format).

Como usar o Forcepoint Security Manager

Faça login no Forcepoint Security Manager com credenciais de administrador.
Acesse Configurações > Registro.
Na navegação à esquerda, selecione Servidores de registros.
Clique em Adicionar para criar uma configuração de servidor de registros.
Informe os seguintes detalhes de configuração:
- Tipo de servidor: selecione Servidor Syslog ou Servidor CEF.
- Nome: insira um nome descritivo, por exemplo, Google Security Operations Bindplane CEF.
- Host: insira o endereço IP ou o nome do host do agente do Bindplane.
- Porta: insira o número da porta do agente Bindplane (por exemplo, 514).
- Protocolo: selecione o protocolo que corresponde à sua configuração do Bindplane:
  - Selecione TCP se você configurou o receptor tcplog no Bindplane (recomendado).
  - Selecione UDP se você configurou o receptor udplog no Bindplane.
- Formato: selecione CEF (Common Event Format).
- Instalação: selecione Local0 (ou outra instalação disponível).
- Gravidade: selecione Informativo para capturar todos os níveis de registro.
Em Categorias de registros ou Tipos de eventos, selecione os eventos a serem encaminhados:
- ☑ Registros de acesso à Web (registros de transações)
- ☑ Eventos de segurança (detecções de ameaças)
- ☑ Eventos de autenticação (login/logout do usuário)
- ☑ Eventos do sistema (alterações no sistema e na configuração)
- Ou selecione Todos os eventos para encaminhar todos os tipos de registros disponíveis.
Opcional: configure outras opções:
- Tamanho do lote: defina como 1 para encaminhamento em tempo real ou um valor maior para processamento em lote.
- Formato da mensagem: verifique se o formato CEF está selecionado.
- Incluir informações do usuário: ative para incluir a identidade do usuário nos registros.
Clique em Testar conexão para verificar a conectividade com o agente do Bindplane.
- Uma mensagem de teste vai aparecer nos registros do agente do Bindplane.
- Se o teste falhar, verifique a conectividade de rede e as regras de firewall.
Clique em Salvar para aplicar a configuração.
Clique em Implantar para enviar a configuração a todos os gateways do Forcepoint Web Security.

Usar o appliance de segurança da Web da Forcepoint (configuração direta)

Se você estiver configurando diretamente no dispositivo:

Faça login na interface de gerenciamento do Forcepoint Web Security Appliance.
Acesse Sistema > Servidor de registros.
Clique em Adicionar ou Editar para criar ou modificar um servidor de registros.
Informe os seguintes detalhes de configuração:
- Endereço do servidor: insira o endereço IP do agente do Bindplane.
- Porta: insira 514 (ou sua porta personalizada).
- Protocolo: selecione TCP ou UDP para corresponder à sua configuração do Bindplane.
- Formato: selecione CEF ou Formato de evento comum.
- Unidade: selecione Local0.
Em Tipos de registro, selecione os registros a serem encaminhados:
- ☑ Registros de acesso
- ☑ Registros de segurança
- ☑ Registros do administrador
Clique em Aplicar ou Salvar.
Se você estiver usando vários aparelhos, repita essa configuração em cada um deles.

Verificação do formato CEF

O Forcepoint Web Security envia registros no formato CEF com a seguinte estrutura:

CEF:0|Forcepoint|Web Security|<version>|<event_id>|<event_name>|<severity>|<extensions>

Exemplo de registro CEF:

 CEF:0|Forcepoint|Web Security|8.5|100|Web Request|5|src=192.168.1.100 dst=93.184.216.34 spt=54321 dpt=80 requestMethod=GET request=http://example.com/ cs1=Allow cs1Label=Action cs2=News and Media cs2Label=Category suser=john.doe@company.com
 ```

O analisador do Google SecOps espera o formato CEF e extrai os seguintes campos principais:

src: endereço IP de origem
dst: endereço IP de destino
spt: porta de origem.
dpt: porta de destino
requestMethod: método HTTP
request ou url: URL solicitado
cs1: ação (permitir/bloquear)
cs2: categoria de URL
suser: nome de usuário

Verificar se os registros estão sendo ingeridos

Após a configuração, verifique se os registros estão fluindo do Forcepoint Web Security para o Google SecOps:

No console do Forcepoint, verifique se os registros estão sendo enviados:
- Acesse Configurações > Logging > Servidores de registros.
- Verifique a coluna Status do servidor configurado. Ela deve mostrar Ativo ou Conectado.
- Confira Estatísticas para ver o número de registros enviados.
No host do agente do Bindplane, verifique os registros do agente para mensagens syslog recebidas:
- Linux:
```
 sudo journalctl -u observiq-otel-collector -f
```
  - Procure entradas de registro que contenham mensagens no formato CEF:
```
   CEF:0|Forcepoint|Web Security|...
```
- Windows:
  1. Selecione o Visualizador de eventos do Windows em Registros de aplicativos e serviços > observIQ.
  2. No Google SecOps, verifique se os registros estão aparecendo:
    - Acesse Pesquisa > Pesquisa do UDM.
    - Use a seguinte consulta:
```
metadata.vendor_name = "Forcepoint" AND metadata.product_name = "Forcepoint Webproxy"
```
    - Ajuste o período para as horas recentes (por exemplo, Última hora).
    - Verifique se os eventos aparecem nos resultados.
  3. Verifique se os campos específicos estão sendo analisados corretamente:
```
metadata.vendor_name = "Forcepoint" AND principal.ip != "" AND target.url != ""
```
  4. Acesse Configurações do SIEM > Agentes de coleta para conferir as estatísticas de ingestão:
    - Selecione a contagem de Eventos recebidos.
    - Verifique se o carimbo de data/hora Última execução bem-sucedida em é recente.

Solução de problemas

Nenhum registro aparece no Google SecOps

Sintomas: o agente do Bindplane está em execução, mas nenhum registro aparece no Google SecOps.

Possíveis causas:

Problemas de conectividade de rede entre o Forcepoint e o agente do Bindplane.
O firewall está bloqueando a porta do syslog.
Incompatibilidade de protocolo (TCP configurado no Bindplane, mas UDP configurado no Forcepoint ou vice-versa).
Endereço IP ou porta incorretos do agente do Bindplane na configuração do Forcepoint.
Endpoint regional incorreto configurado no Bindplane.
O formato CEF não está ativado no Forcepoint.

Solução:

Verifique a conectividade de rede:

# From Forcepoint gateway, test connectivity to BindPlane host
telnet <BINDPLANE_IP> 514
# Or for UDP
nc -u <BINDPLANE_IP> 514

Verifique as regras de firewall no host do Bindplane:

# Linux - Allow port 514 TCP
sudo ufw allow 514/tcp
# Or for UDP
sudo ufw allow 514/udp

# Verify firewall status
sudo ufw status

Verificar a correspondência de protocolo:
- Verifique o Bindplane config.yaml para tcplog ou udplog.
- Verifique a configuração do servidor de registros do Forcepoint para o protocolo correspondente.
Verifique se o formato CEF está ativado:
- No Forcepoint Security Manager, acesse Settings > Logging > Log Servers.
- Verifique se o Formato está definido como CEF ou Formato de evento comum.
Verificar o endpoint regional:
- Verifique se o endpoint em config.yaml corresponde à região da sua instância do Google SecOps.
- Consulte a documentação sobre endpoints regionais.
Verifique se há erros nos registros do agente do Bindplane:
```
sudo journalctl -u observiq-otel-collector -n 100 --no-pager
```
Procure mensagens de erro como:
- connection refused - Problema de rede/firewall
- authentication failed: problema de credencial
- invalid endpoint: problema com o endpoint regional

Erros de incompatibilidade de protocolo

Sintomas: os registros não são recebidos, há erros de conexão no teste do Forcepoint ou erros Connection refused nos registros do Bindplane.

Solução:

Verifique se o protocolo configurado no Bindplane (tcplog ou udplog) corresponde ao protocolo configurado no Forcepoint (TCP ou UDP).

Se você estiver usando TCP e tiver problemas de conexão, verifique se o agente do Bindplane está detectando:

# Linux - Check if port is listening
sudo netstat -tuln | grep 514
# Or
sudo ss -tuln | grep 514

Se a porta não estiver escutando, reinicie o agente do Bindplane.

Erros de autenticação

Sintomas: os registros do agente do Bindplane mostram erros de autenticação no Google SecOps.

Possíveis causas:

ID de cliente incorreto.
Arquivo de autenticação de ingestão inválido ou expirado.
Caminho incorreto para o arquivo de autenticação de ingestão.
Endpoint regional incorreto.

Solução:

Verifique se o ID do cliente em config.yaml corresponde ao ID em Configurações do SIEM > Perfil.
Faça o download novamente do arquivo de autenticação de ingestão em Configurações do SIEM > Agentes de coleta.
Verifique se o caminho em config.yaml aponta para o local correto.
Verifique se o endpoint regional corresponde à região da sua instância do Google SecOps.

Verifique se o agente do Bindplane tem permissões de leitura no arquivo de autenticação:

sudo chmod 644 /path/to/ingestion-authentication-file.json
sudo chown root:root /path/to/ingestion-authentication-file.json

Os registros aparecem, mas os campos não são analisados

Sintomas: os registros aparecem no Google SecOps, mas campos como principal.ip e target.url estão vazios.

Possíveis causas:

Os registros não estão no formato CEF.
O formato CEF está incorreto ou não é padrão.
Incompatibilidade de tipo de registro na configuração do Bindplane.

Solução:

Verifique o formato CEF nos registros brutos:
- No Google SecOps, acesse Pesquisa > Pesquisa de registros brutos.
- Pesquise registros recentes do Forcepoint.
- Verifique se os registros começam com CEF:0|Forcepoint|Web Security|.
Se os registros não estiverem no formato CEF:
- No Forcepoint, mude Formato para CEF ou Formato de evento comum.
- Implante novamente a configuração.
Verifique o tipo de registro no Bindplane config.yaml:
- Verifique se o log_type: 'FORCEPOINT_PROXY' está definido corretamente.
Verifique as variações de nome de campo do CEF:
- Algumas versões do Forcepoint podem usar nomes de campo CEF diferentes.
- Verifique se os nomes dos campos correspondem às extensões CEF esperadas na tabela de mapeamento da UDM.

Latência alta ou atrasos no registro

Sintomas: os registros aparecem no Google SecOps com um atraso significativo (mais de cinco minutos).

Possíveis causas:

Latência de rede entre o Forcepoint e o agente do Bindplane.
Restrições de recursos do agente Bindplane (CPU/memória).
O processamento em lote está ativado no Forcepoint.
Backlog de ingestão do Google SecOps.

Solução:

Verifique a latência da rede:

ping <BINDPLANE_IP>
# Check for high latency (>50ms) or packet loss

Verifique o uso de recursos do agente do Bindplane:

top
# Look for observiq-otel-collector process
# Verify CPU < 80% and memory is available

No Forcepoint, ajuste as configurações de lote:
- Acesse Configurações > Logging > Servidores de registros.
- Defina o Tamanho do lote como 1 para encaminhamento em tempo real.
- Ou reduza o intervalo de lote para envios mais frequentes.
Considere escalonar o host do agente Bindplane (mais CPU/memória) se houver restrição de recursos.
Se estiver usando UDP, verifique se a infraestrutura de rede oferece suporte ao throughput necessário sem perda de pacotes.

Falha na conexão de teste do Forcepoint

Sintomas: ao clicar em Testar conexão no Forcepoint, o teste falha.

Solução:

Verifique se o agente do Bindplane está em execução:
```
sudo systemctl status observiq-otel-collector
```
Verifique se o agente do Bindplane está aguardando conexões na porta configurada:
```
sudo netstat -tuln | grep 514
```

Desative temporariamente o firewall para testar:

# Linux
sudo ufw disable
# Test connection from Forcepoint
# Then re-enable
sudo ufw enable

Verifique os registros do agente do Bindplane durante o teste:
```
sudo journalctl -u observiq-otel-collector -f
```
- Você vai ver uma tentativa de conexão recebida.
Se o teste ainda falhar, verifique se o endereço IP e a porta estão corretos na configuração do Forcepoint.

Tabela de mapeamento do UDM

Campo de registro	Mapeamento do UDM	Lógica
`action`	`security_result.summary`	Se `action_msg` não estiver vazio, ele será mapeado para `security_result.summary`. Caso contrário, se `action` não estiver vazio, ele será mapeado para `security_result.summary`. Caso contrário, se `act` não estiver vazio, ele será mapeado para `security_result.summary`.
`action_msg`	`security_result.summary`	Se `action_msg` não estiver vazio, ele será mapeado para `security_result.summary`. Caso contrário, se `action` não estiver vazio, ele será mapeado para `security_result.summary`. Caso contrário, se `act` não estiver vazio, ele será mapeado para `security_result.summary`.
`app`	`target.application`	Se `destinationServiceName` não estiver vazio, ele será mapeado para `app_name`. Caso contrário, se `app` não estiver vazio e não contiver http ou HTTP, ele será mapeado para `app_name`. Por fim, `app_name` é mapeado para `target.application`.
`bytes_in`	`network.received_bytes`	Se `in` não estiver vazio, ele será mapeado para `bytes_in`. Por fim, `bytes_in` é mapeado para `network.received_bytes`.
`bytes_out`	`network.sent_bytes`	Se `out` não estiver vazio, ele será mapeado para `bytes_out`. Por fim, `bytes_out` é mapeado para `network.sent_bytes`.
`cat`	`security_result.category_details`	Se `cat` não estiver vazio, ele será mapeado para `category`. Por fim, `category` é mapeado para `security_result.category_details`.
`category_no`	`security_result.detection_fields.value`	Se `category_no` não estiver vazio, ele será mapeado para `security_result.detection_fields.value` com a chave `Category Number`.
`cn1`	`security_result.detection_fields.value`	Se `cn1` não estiver vazio, ele será mapeado para `security_result.detection_fields.value` com a chave `Disposition Number`.
`ContentType`	`target.file.mime_type`	Se `contentType` não estiver vazio, ele será mapeado para `ContentType`. Por fim, `ContentType` é mapeado para `target.file.mime_type`.
`cs1`	`target_role.description`	`cs1` está mapeado para `target_role.description`.
`cs2`	`security_result.category_details`	Se `cs2` não estiver vazio e não for `0`, ele será mapeado para `security_result.category_details` com o prefixo `Dynamic Category:`.
`cs3`	`target.file.mime_type`	`cs3` está mapeado para `target.file.mime_type`.
`description`	`metadata.description`	Se `description` não estiver vazio, ele será mapeado para `metadata.description`.
`destinationServiceName`	`target.application`	Se `destinationServiceName` não estiver vazio, ele será mapeado para `app_name`. Por fim, `app_name` é mapeado para `target.application`.
`deviceFacility`	`metadata.product_event_type`	Se `product_event` e `deviceFacility` não estiverem vazios, eles serão concatenados com `-` e mapeados para `metadata.product_event_type`. Caso contrário, `product_event` será mapeado para `metadata.product_event_type`.
`disposition`	`security_result.detection_fields.value`	Se `disposition` não estiver vazio, ele será mapeado para `security_result.detection_fields.value` com a chave `Disposition Number`.
`dst`	`target.ip`	Se `dst` não estiver vazio e `dvchost` estiver, ele será mapeado para `dst_ip`. Por fim, `dst_ip` é mapeado para `target.ip`.
`dst_host`	`target.hostname`	Se `dst` não estiver vazio e `dvchost` estiver, ele será mapeado para `dst_host`. Por fim, `dst_host` é mapeado para `target.hostname`.
`dst_ip`	`target.ip`	Se `dst` não estiver vazio e `dvchost` estiver, ele será mapeado para `dst_ip`. Por fim, `dst_ip` é mapeado para `target.ip`.
`dst_port`	`target.port`	Se `dst` não estiver vazio e `dvchost` estiver, ele será mapeado para `dst_port`. Por fim, `dst_port` é mapeado para `target.port`.
`duration`	`network.session_duration.seconds`	Se `duration` não estiver vazio e não for `0`, ele será mapeado para `network.session_duration.seconds`.
`dvchost`	`intermediary.ip`	Se `dvchost` não estiver vazio, ele será mapeado para `int_ip`. Por fim, `int_ip` é mapeado para `intermediary.ip` se for um endereço IP válido. Caso contrário, é mapeado para `intermediary.hostname`.
`file_path`	`target.file.full_path`	Se `file_path` não estiver vazio, ele será mapeado para `target.file.full_path`.
`host`	`principal.ip`	Se `host` não estiver vazio, ele será mapeado para `src`. Por fim, `src` é mapeado para `principal.ip`.
`http_method`	`network.http.method`	Se `requestMethod` não estiver vazio, ele será mapeado para `http_method`. Caso contrário, se `method` não estiver vazio, ele será mapeado para `http_method`. Por fim, `http_method` é mapeado para `network.http.method`.
`http_proxy_status_code`	`network.http.response_code`	Se `http_response` estiver vazio ou for `0` ou `-`, e `http_proxy_status_code` não estiver vazio, ele será mapeado para `network.http.response_code`.
`http_response`	`network.http.response_code`	Se `http_response` não estiver vazio, não for `0` nem `-`, ele será mapeado para `network.http.response_code`.
`http_user_agent`	`network.http.user_agent`	Se `http_user_agent` não estiver vazio e não for `-`, ele será mapeado para `network.http.user_agent`.
`in`	`network.received_bytes`	Se `in` não estiver vazio, ele será mapeado para `bytes_in`. Por fim, `bytes_in` é mapeado para `network.received_bytes`.
`int_host`	`intermediary.hostname`	Se `int_ip` não estiver vazio e `int_host` não estiver vazio e for diferente de `int_ip`, ele será mapeado para `intermediary.hostname`.
`int_ip`	`intermediary.ip`	Se `dvchost` não estiver vazio, ele será mapeado para `int_ip`. Por fim, `int_ip` é mapeado para `intermediary.ip` se for um endereço IP válido. Caso contrário, é mapeado para `intermediary.hostname`.
`level`	`target_role.name`	Se `level` não estiver vazio e `role` estiver, ele será mapeado para `role`. Por fim, `role` é mapeado para `target_role.name`.
`log_level`	`security_result.severity`	Se `severity` for `1` ou `log_level` contiver `info` ou `message` contiver `notice`, `security_result.severity` será definido como `INFORMATIONAL`. Se `severity` for `7`, `security_result.severity` será definido como `HIGH`.
`loginID`	`principal.user.userid`	Se `loginID` não estiver vazio, ele será mapeado para `user`. Por fim, se `user` não estiver vazio, não for `-` e não contiver `LDAP`, ele será mapeado para `principal.user.userid`.
`method`	`network.http.method`	Se `requestMethod` não estiver vazio, ele será mapeado para `http_method`. Caso contrário, se `method` não estiver vazio, ele será mapeado para `http_method`. Por fim, `http_method` é mapeado para `network.http.method`.
`NatRuleId`	`security_result.detection_fields.value`	Se `NatRuleId` não estiver vazio, ele será mapeado para `security_result.detection_fields.value` com a chave `NatRuleId`.
`out`	`network.sent_bytes`	Se `out` não estiver vazio, ele será mapeado para `bytes_out`. Por fim, `bytes_out` é mapeado para `network.sent_bytes`.
`pid`	`target.process.pid`	Se `pid` não estiver vazio, ele será mapeado para `target.process.pid`.
`policy`	`target_role.description`	Se `Policy` não estiver vazio, ele será mapeado para `policy`. Se `policy` não estiver vazio e não for `-`, ele será mapeado para `target_role.description`.
`Policy`	`target_role.description`	Se `Policy` não estiver vazio, ele será mapeado para `policy`. Se `policy` não estiver vazio e não for `-`, ele será mapeado para `target_role.description`.
`product_event`	`metadata.product_event_type`	Se `product` não estiver vazio, ele será mapeado para `product_event`. Se `product_event` e `deviceFacility` não estiverem vazios, eles serão concatenados com `-` e mapeados para `metadata.product_event_type`. Caso contrário, `product_event` será mapeado para `metadata.product_event_type`.
`proxyStatus-code`	`network.http.response_code`	Se `http_response` estiver vazio ou for `0` ou `-`, e `http_proxy_status_code` estiver vazio e `proxyStatus-code` não estiver, ele será mapeado para `network.http.response_code`.
`refererUrl`	`network.http.referral_url`	Se `refererUrl` não estiver vazio e não for `-`, ele será mapeado para `network.http.referral_url`.
`requestClientApplication`	`network.http.user_agent`	Se `requestMethod` não estiver vazio, ele será mapeado para `http_user_agent`. Por fim, `http_user_agent` é mapeado para `network.http.user_agent`.
`requestMethod`	`network.http.method`	Se `requestMethod` não estiver vazio, ele será mapeado para `http_method`. Por fim, `http_method` é mapeado para `network.http.method`.
`role`	`target_role.name`	Se `level` não estiver vazio e `role` estiver, ele será mapeado para `role`. Por fim, `role` é mapeado para `target_role.name`.
`RuleID`	`security_result.rule_id`	Se `RuleID` não estiver vazio, ele será mapeado para `security_result.rule_id`.
`serverStatus-code`	`network.http.response_code`	Se `http_response` estiver vazio ou for `0` ou `-`, e `http_proxy_status_code` estiver vazio e `proxyStatus-code` não estiver, ele será mapeado para `network.http.response_code`.
`severity`	`security_result.severity`	Se `severity` for `1` ou `log_level` contiver `info` ou `message` contiver `notice`, `security_result.severity` será definido como `INFORMATIONAL`. Se `severity` for `7`, `security_result.severity` será definido como `HIGH`.
`spt`	`principal.port`	Se `spt` não estiver vazio, ele será mapeado para `src_port`. Por fim, `src_port` é mapeado para `principal.port`.
`src`	`principal.ip`	Se `src_host` não estiver vazio, ele será mapeado para `source_ip_temp`. Se `source_ip_temp` for um endereço IP válido e `src` estiver vazio, ele será mapeado para `src`. Se `host` não estiver vazio, ele será mapeado para `src`. Por fim, `src` é mapeado para `principal.ip`.
`src_host`	`principal.hostname`	Se `src_host` não estiver vazio, ele será mapeado para `source_ip_temp`. Se `source_ip_temp` não for um endereço IP válido, ele será mapeado para `principal.hostname`. Se `source_ip_temp` for um endereço IP válido e `src` estiver vazio, ele será mapeado para `src`. Por fim, `src` é mapeado para `principal.ip`.
`src_port`	`principal.port`	Se `src_port` não estiver vazio, ele será mapeado para `principal.port`.
`suser`	`principal.user.userid`	Se `loginID` não estiver vazio, ele será mapeado para `user`. Se `suser` não estiver vazio, ele será mapeado para `user`. Por fim, se `user` não estiver vazio, não for `-` e não contiver `LDAP`, ele será mapeado para `principal.user.userid`.
`url`	`target.url`	Se `url` não estiver vazio, ele será mapeado para `target.url`.
`user`	`principal.user.userid`	Se `loginID` não estiver vazio, ele será mapeado para `user`. Se `suser` não estiver vazio, ele será mapeado para `user`. Caso contrário, se `usrName` não estiver vazio, ele será mapeado para `user`. Por fim, se `user` não estiver vazio, não for `-` e não contiver `LDAP`, ele será mapeado para `principal.user.userid`.
`usrName`	`principal.user.userid`	Se `loginID` não estiver vazio, ele será mapeado para `user`. Se `suser` não estiver vazio, ele será mapeado para `user`. Caso contrário, se `usrName` não estiver vazio, ele será mapeado para `user`. Por fim, se `user` não estiver vazio, não for `-` e não contiver `LDAP`, ele será mapeado para `principal.user.userid`.
`when`	`metadata.event_timestamp`	Se `when` não estiver vazio, ele será analisado e mapeado para `metadata.event_timestamp`.
N/A	`metadata.log_type`	O valor `FORCEPOINT_WEBPROXY` é codificado em `metadata.log_type`.
N/A	`metadata.product_name`	O valor `Forcepoint Webproxy` é codificado em `metadata.product_name`.
N/A	`metadata.vendor_name`	O valor `Forcepoint` é codificado em `metadata.vendor_name`.
N/A	`network.application_protocol`	Se `dst_port` for `80`, `network.application_protocol` será definido como `HTTP`. Se `dst_port` for `443`, `network.application_protocol` será definido como `HTTPS`.
N/A	`principal.user.group_identifiers`	Se `user` não estiver vazio, não for `-` e contiver `LDAP`, a parte da OU da string do usuário será extraída e mapeada para `principal.user.group_identifiers`.
N/A	`principal.user.user_display_name`	Se `user` não estiver vazio, não for `-` e contiver `LDAP`, a parte do nome de usuário da string do usuário será extraída e mapeada para `principal.user.user_display_name`.
N/A	`security_result.action`	Se `action_msg`, `action` ou `act` não estiverem vazios, `sec_action` será definido como `ALLOW` ou `BLOCK` com base nos valores deles. Por fim, `sec_action` é mapeado para `security_result.action`.
N/A	`security_result.detection_fields.key`	O valor `Disposition Number` é codificado em `security_result.detection_fields.key` ao mapear `disposition` ou `cn1`. O valor `NatRuleId` é fixado no código de `security_result.detection_fields.key` ao mapear `NatRuleId`. O valor `Category Number` é fixado no código `security_result.detection_fields.key` ao mapear `category_no`.

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