Raccogliere i log di Forcepoint Web Security

Supportato in:

Google secops SIEM

Nota: questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini specifici del servizio Google Security Operations. Le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per saperne di più, consulta le linee guida per i servizi di assistenza tecnica di Google SecOps e i Termini di servizio specifici di Google SecOps.

Questo documento spiega come importare i log di Forcepoint Web Security in Google Security Operations utilizzando Bindplane.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Un host Windows 2016 o versioni successive o Linux con systemd per l'agente Bindplane
• Se l'agente viene eseguito dietro un proxy, assicurati che le porte del firewall siano aperte in base ai requisiti dell'agente Bindplane.
• Accesso con privilegi alla console di gestione di Forcepoint Web Security o a Forcepoint Security Manager
• Connettività di rete tra Forcepoint Web Security e l'host dell'agente Bindplane
• Forcepoint Web Security versione 7.8 o successive (consigliato per il supporto del formato CEF)

Recuperare il file di autenticazione importazione di Google SecOps

1. Accedi alla console Google SecOps.
2. Vai a Impostazioni SIEM > Agenti di raccolta.
3. Scarica il file di autenticazione importazione. Salva il file in modo sicuro sul sistema in cui verrà installato Bindplane.

Recuperare l'ID cliente Google SecOps

1. Accedi alla console Google SecOps.
2. Vai a Impostazioni SIEM > Profilo.
3. Copia e salva l'ID cliente dalla sezione Dettagli dell'organizzazione.

Installa l'agente Bindplane

Installa l'agente Bindplane sul sistema operativo Windows o Linux seguendo le istruzioni riportate di seguito.

Installazione di Windows

1. Apri il prompt dei comandi o PowerShell come amministratore.

2. Esegui questo comando:

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

Installazione di Linux

1. Apri un terminale con privilegi root o sudo.

2. Esegui questo comando:

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

Risorse aggiuntive per l'installazione

• Per ulteriori opzioni di installazione, consulta questa guida all'installazione.

Configura l'agente Bindplane per importare Syslog e inviarlo a Google SecOps

Puoi configurare l'agente Bindplane per ricevere messaggi syslog tramite TCP o UDP. Scegli il protocollo più adatto al tuo ambiente e ai requisiti di rete.

Scegliere il protocollo

• TCP (consigliato per l'affidabilità): fornisce la distribuzione ed è adatto alla maggior parte degli ambienti. Utilizza TCP quando l'invio affidabile dei log è fondamentale e vuoi assicurarti che nessun log venga perso a causa di problemi di rete.
• UDP (consigliato per le prestazioni): offre una latenza inferiore e un overhead minore. Utilizza UDP quando è necessario un throughput elevato e la perdita occasionale di log è accettabile.

Nota: assicurati che il protocollo scelto in Bindplane corrisponda a quello configurato in Forcepoint Web Security nei passaggi successivi.

Configura l'agente BindPlane

1. Accedi al file di configurazione:

   • Individua il file config.yaml. In genere si trova nella directory /etc/bindplane-agent/ su Linux o nella directory di installazione su Windows.
   • Apri il file utilizzando un editor di testo (ad esempio nano, vi o Blocco note).

2. Modifica il file config.yaml con la configurazione per il protocollo scelto:

   • Opzione A: configurazione TCP (consigliata)

     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
     

   • Opzione B: configurazione 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
     

     • Sostituisci la porta e l'indirizzo IP in base alle esigenze della tua infrastruttura (il valore predefinito è 0.0.0.0:514).

       Nota: la porta 514 è la porta syslog standard. Se questa porta è già in uso o limitata, scegli una porta alternativa (ad esempio 1514, 5514) e configura la stessa porta in Forcepoint Web Security.

Riavvia l'agente Bindplane per applicare le modifiche

• Per riavviare l'agente Bindplane in Linux, esegui questo comando:

  sudo systemctl restart bindplane-agent
  

• Per riavviare l'agente Bindplane in Windows, puoi utilizzare la console Servizi o inserire il seguente comando:

  net stop BindPlaneAgent && net start BindPlaneAgent
  

• Per verificare che l'agente sia in esecuzione in Linux, esegui questo comando:

  sudo systemctl status observiq-otel-collector
  

• Per verificare che l'agente sia in esecuzione in Windows, esegui questo comando:

  sc query observiq-otel-collector
  

Configura l'inoltro di Syslog su Forcepoint Web Security

Configura Forcepoint Web Security per inoltrare i log all'agente Bindplane in formato CEF (Common Event Format).

Utilizzo di Forcepoint Security Manager

1. Accedi a Forcepoint Security Manager con le credenziali amministrative.
2. Vai a Impostazioni > Registrazione.
3. Nel riquadro di navigazione a sinistra, seleziona Server di log.
4. Fai clic su Aggiungi per creare una nuova configurazione del server di log.
5. Fornisci i seguenti dettagli di configurazione:
   • Server Type (Tipo di server): seleziona Syslog Server (Server Syslog) o CEF Server (Server CEF).
   • Nome: inserisci un nome descrittivo (ad esempio, Google Security Operations Bindplane CEF).
   • Host: inserisci l'indirizzo IP o il nome host dell'agente Bindplane.
   • Porta: inserisci il numero di porta dell'agente Bindplane (ad esempio, 514).
   • Protocollo: seleziona il protocollo corrispondente alla configurazione di Bindplane:
     • Se hai configurato il ricevitore tcplog in Bindplane (opzione consigliata), seleziona TCP.
     • Seleziona UDP se hai configurato il ricevitore udplog in Bindplane.
   • Formato: seleziona CEF (Common Event Format).
   • Struttura: seleziona Local0 (o un'altra struttura disponibile).
   • Gravità: seleziona Informativa (per acquisire tutti i livelli di log).
6. In Categorie log o Tipi di eventi, seleziona gli eventi da inoltrare:
   • ☑ Log di accesso web (log delle transazioni)
   • ☑ Eventi di sicurezza (rilevamenti di minacce)
   • ☑ Eventi di autenticazione (accesso/disconnessione utente)
   • ☑ Eventi di sistema (modifiche al sistema e alla configurazione)
   • In alternativa, seleziona Tutti gli eventi per inoltrare tutti i tipi di log disponibili.
7. (Facoltativo) Configura le impostazioni aggiuntive:
   • Dimensione batch: impostala su 1 per l'inoltro in tempo reale o su un valore superiore per l'elaborazione batch.
   • Formato messaggio: assicurati che sia selezionato il formato CEF.
   • Includi informazioni utente: attiva questa opzione per includere l'identità utente nei log.
8. Fai clic su Prova connessione per verificare la connettività all'agente Bindplane.
   • Nei log dell'agente Bindplane dovrebbe essere visualizzato un messaggio di test.
   • Se il test non va a buon fine, verifica la connettività di rete e le regole firewall.
9. Fai clic su Salva per applicare la configurazione.
10. Fai clic su Esegui il deployment per eseguire il push della configurazione su tutti i gateway Forcepoint Web Security.

Utilizzo dell'appliance di sicurezza web Forcepoint (configurazione diretta)

Se esegui la configurazione direttamente sull'appliance:

1. Accedi all'interfaccia di gestione dell'appliance di sicurezza web Forcepoint.
2. Vai a Sistema > Server log.
3. Fai clic su Aggiungi o Modifica per creare o modificare un server di log.
4. Fornisci i seguenti dettagli di configurazione:
   • Indirizzo server: inserisci l'indirizzo IP dell'agente Bindplane.
   • Porta: inserisci 514 (o la tua porta personalizzata).
   • Protocollo: seleziona TCP o UDP in base alla configurazione di Bindplane.
   • Formato: seleziona CEF o Common Event Format.
   • Facility (Struttura): seleziona Local0.
5. In Tipi di log, seleziona i log da inoltrare:
   • ☑ Log degli accessi
   • ☑ Log di sicurezza
   • ☑ Log amministratore
6. Fai clic su Applica o Salva.
7. Se utilizzi più elettrodomestici, ripeti questa configurazione su ciascuno di essi.

Verifica del formato CEF

• Forcepoint Web Security invia i log in formato CEF con la seguente struttura:

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

  • Esempio di log 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=[e-mail]
     ```
    

Il parser Google SecOps prevede il formato CEF ed estrae i seguenti campi chiave:

• src: indirizzo IP di origine
• dst - Indirizzo IP di destinazione
• spt - Porta di origine
• dpt - Porta di destinazione
• requestMethod - Metodo HTTP
• request o url - URL richiesto
• cs1 - Azione (Consenti/Blocca)
• cs2 - Categoria URL
• suser - Nome utente

Verifica che i log vengano importati

Dopo la configurazione, verifica che i log vengano trasferiti da Forcepoint Web Security a Google SecOps:

1. Nella console Forcepoint, verifica che i log vengano inviati:

   • Vai a Impostazioni > Registrazione > Server di log.
   • Controlla la colonna Stato del server configurato. Dovrebbe essere visualizzato Attivo o Connesso.
   • Visualizza Statistiche per vedere il numero di log inviati.

2. Sull'host dell'agente BindPlane, controlla i log dell'agente per i messaggi syslog in arrivo:

   • Linux:

      sudo journalctl -u observiq-otel-collector -f
     

     • Cerca le voci di log contenenti messaggi in formato CEF:

          CEF:0|Forcepoint|Web Security|...
       

   • Windows:

     1. Seleziona il Visualizzatore eventi di Windows in Log di applicazioni e servizi > observIQ.

     2. In Google SecOps, verifica che vengano visualizzati i log:

        • Vai a Ricerca > Ricerca UDM.
        • Utilizza la query seguente:

        metadata.vendor_name = "Forcepoint" AND metadata.product_name = "Forcepoint Webproxy"
        

        • Regola l'intervallo di tempo sulle ore recenti (ad esempio, Ultima ora).
        • Verifica che gli eventi vengano visualizzati nei risultati.

     3. Verifica che campi specifici vengano analizzati correttamente:

        metadata.vendor_name = "Forcepoint" AND principal.ip != "" AND target.url != ""
        

     4. Vai a Impostazioni SIEM > Agenti di raccolta per visualizzare le statistiche di importazione:

        • Seleziona il conteggio Eventi ricevuti.
        • Verifica che il timestamp di Ultima operazione riuscita il giorno sia recente.

Risoluzione dei problemi

Nessun log visualizzato in Google SecOps

Sintomi: l'agente Bindplane è in esecuzione, ma in Google SecOps non vengono visualizzati log.

Possibili cause:

1. Problemi di connettività di rete tra Forcepoint e l'agente Bindplane.
2. Il firewall blocca la porta syslog.
3. Mancata corrispondenza del protocollo (TCP configurato in Bindplane ma UDP configurato in Forcepoint o viceversa).
4. Indirizzo IP o porta dell'agente Bindplane errati nella configurazione di Forcepoint.
5. Endpoint regionale errato configurato in Bindplane.
6. Il formato CEF non è attivato in Forcepoint.

Soluzione:

1. Verifica la connettività di rete:

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

2. Controlla le regole firewall sull'host 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
   

3. Verifica la corrispondenza del protocollo:

   • Controlla Bindplane config.yaml per tcplog o udplog.
   • Controlla la configurazione del server di log Forcepoint per il protocollo corrispondente.

4. Verifica che il formato CEF sia abilitato:

   • In Forcepoint Security Manager, vai a Impostazioni > Logging > Server di log.
   • Verifica che Formato sia impostato su CEF o Common Event Format.

5. Verifica l'endpoint regionale:

   • Verifica che endpoint in config.yaml corrisponda alla regione dell'istanza Google SecOps.
   • Consulta la documentazione sugli endpoint regionali.

6. Controlla la presenza di errori nei log dell'agente Bindplane:

   sudo journalctl -u observiq-otel-collector -n 100 --no-pager
   

   Cerca messaggi di errore come:

   • connection refused - Problema di rete/firewall
   • authentication failed - Credenziale
   • invalid endpoint - Problema relativo all'endpoint regionale

Errori di mancata corrispondenza del protocollo

Sintomi: i log non vengono ricevuti, si verificano errori di connessione nel test Forcepoint o errori Connection refused nei log Bindplane.

Soluzione:

1. Assicurati che il protocollo configurato in Bindplane (tcplog o udplog) corrisponda a quello configurato in Forcepoint (TCP o UDP).

2. Se utilizzi TCP e riscontri problemi di connessione, verifica che l'agente Bindplane sia in ascolto:

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

3. Se la porta non è in ascolto, riavvia l'agente Bindplane.

Errori di autenticazione

Sintomi: i log dell'agente Bindplane mostrano errori di autenticazione in Google SecOps.

Possibili cause:

1. ID cliente errato.
2. File di autenticazione per l'importazione non valido o scaduto.
3. Percorso errato del file di autenticazione dell'importazione.
4. Endpoint regionale errato.

Soluzione:

1. Verifica che l'ID cliente in config.yaml corrisponda all'ID in Impostazioni SIEM > Profilo.
2. Scarica di nuovo il file di autenticazione dell'importazione da Impostazioni SIEM > Agenti di raccolta.
3. Verifica che il percorso in config.yaml punti alla posizione corretta.
4. Verifica che l'endpoint regionale corrisponda alla regione dell'istanza Google SecOps.

5. Assicurati che l'agente Bindplane disponga delle autorizzazioni di lettura sul file di autenticazione:

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

Log visualizzati ma campi non analizzati

Sintomi: i log vengono visualizzati in Google SecOps, ma i campi come principal.ip e target.url sono vuoti.

Possibili cause:

1. I log non sono in formato CEF.
2. Il formato CEF non è valido o non è standard.
3. Mancata corrispondenza del tipo di log nella configurazione di Bindplane.

Soluzione:

1. Verifica il formato CEF nei log non elaborati:

   • In Google SecOps, vai a Ricerca > Ricerca nei log non elaborati.
   • Cerca i log Forcepoint recenti.
   • Verifica che i log inizino con CEF:0|Forcepoint|Web Security|.

2. Se i log non sono in formato CEF:

   • In Forcepoint, imposta Formato su CEF o Common Event Format.
   • Esegui di nuovo il deployment della configurazione.

3. Verifica il tipo di log in Bindplane config.yaml:

   • Assicurati che log_type: 'FORCEPOINT_PROXY' sia impostato correttamente.

4. Controlla le variazioni del nome del campo CEF:

   • Alcune versioni di Forcepoint potrebbero utilizzare nomi di campi CEF diversi.
   • Verifica che i nomi dei campi corrispondano alle estensioni CEF previste nella tabella di mappatura UDM.

Latenza elevata o ritardi nei log

Sintomi: i log vengono visualizzati in Google SecOps con un ritardo significativo (superiore a 5 minuti).

Possibili cause:

1. Latenza di rete tra Forcepoint e l'agente Bindplane.
2. Vincoli delle risorse dell'agente Bindplane (CPU/memoria).
3. Elaborazione batch abilitata in Forcepoint.
4. Backlog di importazione di Google SecOps.

Soluzione:

1. Verifica la latenza di rete:

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

2. Controlla l'utilizzo delle risorse dell'agente Bindplane:

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

3. In Forcepoint, modifica le impostazioni batch:

   • Vai a Impostazioni > Registrazione > Server di log.
   • Imposta Dimensione batch su 1 per l'inoltro in tempo reale.
   • In alternativa, riduci l'intervallo batch per invii più frequenti.

4. Se le risorse sono limitate, valuta la possibilità di scalare l'host dell'agente Bindplane (più CPU/memoria).

5. Se utilizzi UDP, verifica che l'infrastruttura di rete supporti la velocità effettiva richiesta senza perdita di pacchetti.

Il test di connessione di Forcepoint non riesce

Sintomi: quando fai clic su Prova connessione in Forcepoint, il test non va a buon fine.

Soluzione:

1. Verifica che l'agente Bindplane sia in esecuzione:

   sudo systemctl status observiq-otel-collector
   

2. Verifica che l'agente Bindplane sia in ascolto sulla porta configurata:

   sudo netstat -tuln | grep 514
   

3. Disattiva temporaneamente il firewall per eseguire il test:

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

4. Controlla i log dell'agente Bindplane durante il test:

   sudo journalctl -u observiq-otel-collector -f
   

   • Dovresti visualizzare un tentativo di connessione in entrata.

5. Se il test continua a non riuscire, verifica che l'indirizzo IP e la porta siano corretti nella configurazione di Forcepoint.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logic
action	security_result.summary	Se action_msg non è vuoto, viene mappato a security_result.summary. In caso contrario, se action non è vuoto, viene mappato a security_result.summary. In caso contrario, se act non è vuoto, viene mappato a security_result.summary.
action_msg	security_result.summary	Se action_msg non è vuoto, viene mappato a security_result.summary. In caso contrario, se action non è vuoto, viene mappato a security_result.summary. In caso contrario, se act non è vuoto, viene mappato a security_result.summary.
app	target.application	Se destinationServiceName non è vuoto, viene mappato a app_name. In caso contrario, se app non è vuoto e non contiene http o HTTP, viene mappato a app_name. Infine, app_name è mappato a target.application.
bytes_in	network.received_bytes	Se in non è vuoto, viene mappato a bytes_in. Infine, bytes_in è mappato a network.received_bytes.
bytes_out	network.sent_bytes	Se out non è vuoto, viene mappato a bytes_out. Infine, bytes_out è mappato a network.sent_bytes.
cat	security_result.category_details	Se cat non è vuoto, viene mappato a category. Infine, category è mappato a security_result.category_details.
category_no	security_result.detection_fields.value	Se category_no non è vuoto, viene mappato a security_result.detection_fields.value con la chiave Category Number.
cn1	security_result.detection_fields.value	Se cn1 non è vuoto, viene mappato a security_result.detection_fields.value con la chiave Disposition Number.
ContentType	target.file.mime_type	Se contentType non è vuoto, viene mappato a ContentType. Infine, ContentType è mappato a target.file.mime_type.
cs1	target_role.description	cs1 è mappato a target_role.description.
cs2	security_result.category_details	Se cs2 non è vuoto e non è 0, viene mappato a security_result.category_details con il prefisso Dynamic Category:.
cs3	target.file.mime_type	cs3 è mappato a target.file.mime_type.
description	metadata.description	Se description non è vuoto, viene mappato a metadata.description.
destinationServiceName	target.application	Se destinationServiceName non è vuoto, viene mappato a app_name. Infine, app_name è mappato a target.application.
deviceFacility	metadata.product_event_type	Se product_event e deviceFacility non sono vuoti, vengono concatenati con - e mappati a metadata.product_event_type. In caso contrario, product_event viene mappato a metadata.product_event_type.
disposition	security_result.detection_fields.value	Se disposition non è vuoto, viene mappato a security_result.detection_fields.value con la chiave Disposition Number.
dst	target.ip	Se dst non è vuoto e dvchost è vuoto, viene mappato a dst_ip. Infine, dst_ip è mappato a target.ip.
dst_host	target.hostname	Se dst non è vuoto e dvchost è vuoto, viene mappato a dst_host. Infine, dst_host è mappato a target.hostname.
dst_ip	target.ip	Se dst non è vuoto e dvchost è vuoto, viene mappato a dst_ip. Infine, dst_ip è mappato a target.ip.
dst_port	target.port	Se dst non è vuoto e dvchost è vuoto, viene mappato a dst_port. Infine, dst_port è mappato a target.port.
duration	network.session_duration.seconds	Se duration non è vuoto e non è 0, viene mappato a network.session_duration.seconds.
dvchost	intermediary.ip	Se dvchost non è vuoto, viene mappato a int_ip. Infine, int_ip viene mappato a intermediary.ip se è un indirizzo IP valido, altrimenti viene mappato a intermediary.hostname.
file_path	target.file.full_path	Se file_path non è vuoto, viene mappato a target.file.full_path.
host	principal.ip	Se host non è vuoto, viene mappato a src. Infine, src è mappato a principal.ip.
http_method	network.http.method	Se requestMethod non è vuoto, viene mappato a http_method. In caso contrario, se method non è vuoto, viene mappato a http_method. Infine, http_method è mappato a network.http.method.
http_proxy_status_code	network.http.response_code	Se http_response è vuoto o 0 o - e http_proxy_status_code non è vuoto, viene mappato a network.http.response_code.
http_response	network.http.response_code	Se http_response non è vuoto, non è 0 e non è -, viene mappato a network.http.response_code.
http_user_agent	network.http.user_agent	Se http_user_agent non è vuoto e non è -, viene mappato a network.http.user_agent.
in	network.received_bytes	Se in non è vuoto, viene mappato a bytes_in. Infine, bytes_in è mappato a network.received_bytes.
int_host	intermediary.hostname	Se int_ip non è vuoto e int_host non è vuoto e diverso da int_ip, viene mappato a intermediary.hostname.
int_ip	intermediary.ip	Se dvchost non è vuoto, viene mappato a int_ip. Infine, int_ip viene mappato a intermediary.ip se è un indirizzo IP valido, altrimenti viene mappato a intermediary.hostname.
level	target_role.name	Se level non è vuoto e role è vuoto, viene mappato a role. Infine, role è mappato a target_role.name.
log_level	security_result.severity	Se severity è 1 o log_level contiene info o message contiene notice, security_result.severity è impostato su INFORMATIONAL. Se severity è 7, security_result.severity è impostato su HIGH.
loginID	principal.user.userid	Se loginID non è vuoto, viene mappato a user. Infine, se user non è vuoto e non è - e non contiene LDAP, viene mappato a principal.user.userid.
method	network.http.method	Se requestMethod non è vuoto, viene mappato a http_method. In caso contrario, se method non è vuoto, viene mappato a http_method. Infine, http_method è mappato a network.http.method.
NatRuleId	security_result.detection_fields.value	Se NatRuleId non è vuoto, viene mappato a security_result.detection_fields.value con la chiave NatRuleId.
out	network.sent_bytes	Se out non è vuoto, viene mappato a bytes_out. Infine, bytes_out è mappato a network.sent_bytes.
pid	target.process.pid	Se pid non è vuoto, viene mappato a target.process.pid.
policy	target_role.description	Se Policy non è vuoto, viene mappato a policy. Se policy non è vuoto e non è -, viene mappato a target_role.description.
Policy	target_role.description	Se Policy non è vuoto, viene mappato a policy. Se policy non è vuoto e non è -, viene mappato a target_role.description.
product_event	metadata.product_event_type	Se product non è vuoto, viene mappato a product_event. Se product_event e deviceFacility non sono vuoti, vengono concatenati con - e mappati a metadata.product_event_type. In caso contrario, product_event viene mappato a metadata.product_event_type.
proxyStatus-code	network.http.response_code	Se http_response è vuoto o 0 o - e http_proxy_status_code è vuoto e proxyStatus-code non è vuoto, viene mappato a network.http.response_code.
refererUrl	network.http.referral_url	Se refererUrl non è vuoto e non è -, viene mappato a network.http.referral_url.
requestClientApplication	network.http.user_agent	Se requestMethod non è vuoto, viene mappato a http_user_agent. Infine, http_user_agent è mappato a network.http.user_agent.
requestMethod	network.http.method	Se requestMethod non è vuoto, viene mappato a http_method. Infine, http_method è mappato a network.http.method.
role	target_role.name	Se level non è vuoto e role è vuoto, viene mappato a role. Infine, role è mappato a target_role.name.
RuleID	security_result.rule_id	Se RuleID non è vuoto, viene mappato a security_result.rule_id.
serverStatus-code	network.http.response_code	Se http_response è vuoto o 0 o - e http_proxy_status_code è vuoto e proxyStatus-code non è vuoto, viene mappato a network.http.response_code.
severity	security_result.severity	Se severity è 1 o log_level contiene info o message contiene notice, security_result.severity è impostato su INFORMATIONAL. Se severity è 7, security_result.severity è impostato su HIGH.
spt	principal.port	Se spt non è vuoto, viene mappato a src_port. Infine, src_port è mappato a principal.port.
src	principal.ip	Se src_host non è vuoto, viene mappato a source_ip_temp. Se source_ip_temp è un indirizzo IP valido e src è vuoto, viene mappato a src. Se host non è vuoto, viene mappato a src. Infine, src è mappato a principal.ip.
src_host	principal.hostname	Se src_host non è vuoto, viene mappato a source_ip_temp. Se source_ip_temp non è un indirizzo IP valido, viene mappato a principal.hostname. Se source_ip_temp è un indirizzo IP valido e src è vuoto, viene mappato a src. Infine, src è mappato a principal.ip.
src_port	principal.port	Se src_port non è vuoto, viene mappato a principal.port.
suser	principal.user.userid	Se loginID non è vuoto, viene mappato a user. Se suser non è vuoto, viene mappato a user. Infine, se user non è vuoto e non è - e non contiene LDAP, viene mappato a principal.user.userid.
url	target.url	Se url non è vuoto, viene mappato a target.url.
user	principal.user.userid	Se loginID non è vuoto, viene mappato a user. Se suser non è vuoto, viene mappato a user. In caso contrario, se usrName non è vuoto, viene mappato a user. Infine, se user non è vuoto e non è - e non contiene LDAP, viene mappato a principal.user.userid.
usrName	principal.user.userid	Se loginID non è vuoto, viene mappato a user. Se suser non è vuoto, viene mappato a user. In caso contrario, se usrName non è vuoto, viene mappato a user. Infine, se user non è vuoto e non è - e non contiene LDAP, viene mappato a principal.user.userid.
when	metadata.event_timestamp	Se when non è vuoto, viene analizzato e mappato a metadata.event_timestamp.
N/D	metadata.log_type	Il valore FORCEPOINT_WEBPROXY è hardcoded in metadata.log_type.
N/D	metadata.product_name	Il valore Forcepoint Webproxy è hardcoded in metadata.product_name.
N/D	metadata.vendor_name	Il valore Forcepoint è hardcoded in metadata.vendor_name.
N/D	network.application_protocol	Se dst_port è 80, network.application_protocol è impostato su HTTP. Se dst_port è 443, network.application_protocol è impostato su HTTPS.
N/D	principal.user.group_identifiers	Se user non è vuoto e non è - e contiene LDAP, la parte dell'unità organizzativa della stringa utente viene estratta e mappata a principal.user.group_identifiers.
N/D	principal.user.user_display_name	Se user non è vuoto e non è - e contiene LDAP, la parte del nome utente della stringa utente viene estratta e mappata a principal.user.user_display_name.
N/D	security_result.action	Se action_msg, action o act non sono vuoti, sec_action è impostato su ALLOW o BLOCK in base ai loro valori. Infine, sec_action è mappato a security_result.action.
N/D	security_result.detection_fields.key	Il valore Disposition Number è hardcoded in security_result.detection_fields.key quando viene mappato disposition o cn1. Il valore NatRuleId è hardcoded in security_result.detection_fields.key durante la mappatura di NatRuleId. Il valore Category Number è hardcoded in security_result.detection_fields.key durante la mappatura di category_no.

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.