Raccogli i log WAF di Imperva

Supportata in:

Google SecOps SIEM

Questo documento spiega come raccogliere i log di Imperva WAF configurando un feed di Google Security Operations utilizzando l'API di terze parti, il webhook (push HTTP generico) o Amazon S3.

Imperva WAF è un web application firewall basato su cloud che protegge siti web e applicazioni da attacchi basati sul web, tra cui SQL injection, cross-site scripting (XSS) e minacce DDoS. Imperva WAF analizza il traffico HTTP/HTTPS in entrata in tempo reale, applicando regole di sicurezza e policy di mitigazione dei bot per bloccare le richieste dannose prima che raggiungano il server di origine.

Differenze nei metodi di raccolta

L'integrazione di Imperva WAF con Google SecOps supporta i seguenti metodi per l'importazione dei log:

• Raccolta API: Google SecOps estrae i log direttamente dall'API Imperva. Si tratta di una connessione diretta, supporta solo il tipo di log IMPERVA_WAF e raccoglie solo i log di controllo, come descritto in Imperva Audit Trail. Google SecOps esegue query sull'API Imperva Audit Trail ogni 24 ore.
• Raccolta di bucket Amazon S3 V2: Imperva WAF invia i log a un bucket Amazon S3 designato, da cui Google SecOps li estrae. Questo metodo raccoglie gli eventi di sicurezza e i log di accesso generati dal WAF Cloud, come descritto in Integrazione dei log di Imperva. Poiché il bucket può ricevere log da molte origini, questo metodo supporta anche altri tipi di log Imperva, a condizione che tu configuri questi log in modo che vengano inviati esplicitamente al bucket.
• Connettore push HTTP generico (beta): Imperva WAF invia i log direttamente a Google SecOps utilizzando i webhook HTTPS. In questo modo, l'importazione avviene quasi in tempo reale utilizzando lo streaming diretto dell'API senza richiedere uno spazio di archiviazione S3 intermedio.

Nota: i diversi metodi di importazione utilizzano credenziali diverse. Il metodo di raccolta API utilizza un ID API dell'account e una chiave API generata nella console Imperva. Il metodo Amazon S3 utilizza le credenziali AWS configurate nell'integrazione dei log di Imperva. Il metodo Webhook utilizza intestazioni HTTP statiche per l'autenticazione.

Limitazioni dell'architettura

Quando scegli un metodo di importazione, tieni conto dei seguenti vincoli tecnici:

• Rischio di perdita di dati: lo streaming diretto di webhook non fornisce code di nuovi tentativi a lungo termine. Se l'endpoint Google SecOps non è raggiungibile o interrompe il traffico durante le interruzioni del servizio, i payload push non utilizzati potrebbero andare persi, a meno che non vengano memorizzati nel buffer upstream.
• Limiti di frequenza QPS: l'invio di log tramite webhook durante attacchi DDoS ad alto volume o picchi di traffico improvvisi potrebbe attivare limiti di frequenza API o limitazioni di distribuzione.
• Vincoli delle intestazioni: l'autenticazione si basa su intestazioni HTTP statiche. Assicurati che le chiavi vengano ruotate in modo sicuro in base alle policy di sicurezza della tua organizzazione.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Accesso con privilegi alla console Imperva Cloud Security (my.imperva.com)
• Un amministratore dell'account Imperva, per creare una chiave API per un altro utente. Un utente senza autorizzazioni di amministratore può creare una chiave API solo per il proprio account.
• Per il metodo Amazon S3: accesso con privilegi ad AWS (S3, IAM)
• Per il push del webhook: credenziali API con autorizzazioni per gestire le API Imperva Connections e Log Configurations.

Configura l'accesso API Imperva WAF

Il metodo di raccolta delle API esegue l'autenticazione con api.imperva.com utilizzando un ID API e una chiave API di Imperva. Genera queste credenziali nella console Imperva Cloud Security.

Genera credenziali API

1. Accedi alla console Imperva Cloud Security all'indirizzo my.imperva.com.
2. Nella barra dei menu in alto, fai clic su Account > Gestione dell'account.
3. Nella barra laterale, fai clic su Gestione utenti > Utenti.
4. Individua l'utente utilizzato dal feed, fai clic sui puntini di sospensione nella colonna Azioni e poi su Modifica.
5. Fai clic sulla scheda Chiavi API.
6. Fai clic su Aggiungi chiave API. Aggiungi un nome e una descrizione che identifichino lo scopo della chiave.
7. Copia e salva i seguenti valori dalla finestra popup:
   • ID API: il tuo identificatore API univoco (ad esempio, 12345).
   • Chiave API: la tua chiave API (ad esempio, abcdef-123456-ghijkl-789012).
   Nota: dopo aver chiuso la finestra popup, non puoi più recuperare la chiave API. Puoi solo rigenerarla.

• In alternativa, un utente senza autorizzazioni di amministratore può generare una chiave per il proprio account. Nella barra dei menu in alto, fai clic su Account > My Profile (Account > Il mio profilo), quindi, in API keys (Chiavi API), fai clic su Add API Key (Aggiungi chiave API).

Nota: l'ID API e la chiave API utilizzati dall'integrazione dei log di Imperva sono credenziali diverse. Imperva li genera nella pagina SIEM Logs > Log Configuration per il metodo di distribuzione Imperva API, non li elenca nella pagina Users e li applica al repository dei log di Imperva anziché a api.imperva.com. Non utilizzarle per questo feed.

Importante: archivia l'ID API e la chiave API in modo sicuro. Queste credenziali forniscono l'accesso ai dati del tuo account Imperva tramite l'API.

Configura un feed in Google SecOps per importare i log di Imperva WAF

1. Vai a Impostazioni > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Nella pagina successiva, fai clic su Configura un singolo feed.
4. Nel campo Nome feed, inserisci un nome per il feed (ad es. Imperva WAF Logs).
5. Seleziona API di terze parti come Tipo di origine.
6. Seleziona Imperva come Tipo di log.
7. Fai clic su Avanti.

8. Specifica i valori per i seguenti parametri di input:

   • Intestazione HTTP di autenticazione: inserisci le credenziali di autenticazione nel seguente formato:

     x-API-Id:your-api-id-value
     x-API-Key:your-api-key-value
     

     Ogni credenziale deve essere su una riga separata nel formato key:value.

     Inserisci i nomi delle intestazioni esattamente come mostrato. L'API Imperva Audit Trail accetta l'ID API e la chiave API solo come intestazioni HTTP x-API-Id e x-API-Key.

   • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

   • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

9. Fai clic su Avanti.

10. Controlla la nuova configurazione del feed di notizie nella schermata Finalizza e poi fai clic su Invia.

Dopo la configurazione, il feed recupera gli eventi della traccia di audit di Imperva, che registrano le azioni eseguite nel tuo account da utenti dell'account, processi di sistema e amministratori di Imperva. Per raccogliere gli eventi di sicurezza e i log di accesso di Cloud WAF, utilizza il connettore push HTTP generico o il metodo Amazon S3.

Raccogli i log di Imperva WAF utilizzando il connettore push HTTP generico (beta)

Configura un feed in Google SecOps per l'importazione dei webhook

1. Vai a Impostazioni > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Nel campo Nome feed, inserisci un nome per il feed (ad es. Imperva WAF Webhook).
4. Seleziona Webhook come Tipo di origine.
5. Seleziona Imperva Cloud WAF come Tipo di log.
6. Fai clic su Avanti.
7. Configura le intestazioni di autenticazione e copia l'URL endpoint e l'intestazione/token secret generati.
8. Fai clic su Invia.

Configura il push del webhook Imperva utilizzando l'API

1. Utilizza l'API Imperva Connections per registrare l'endpoint webhook fornito da Google SecOps.

2. Includi le seguenti intestazioni di autenticazione statiche nella richiesta API:

   • X-goog-api-key: la tua chiave API Google SecOps.
   • X-Webhook-Access-Key: la chiave di accesso al feed generata da Google SecOps.

3. Utilizza l'API Imperva Log Configurations per collegare la nuova connessione ai flussi di log di accesso e sicurezza di Cloud WAF.

4. Nel payload dell'API Log Configurations, assicurati che batchPackaging.type sia impostato su "NONE" per facilitare l'invio immediato.

Raccogli i log di Imperva WAF utilizzando Amazon S3

Configura AWS IAM e S3

1. Crea un bucket Amazon S3 seguendo questa guida dell'utente: Creazione di un bucket
2. Salva il Nome e la Regione del bucket per utilizzarli in un secondo momento.
3. Crea un utente seguendo questa guida dell'utente: Creazione di un utente IAM.
4. Seleziona l'utente creato.
5. Seleziona la scheda Credenziali di sicurezza.
6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
7. Seleziona Servizio di terze parti come Caso d'uso.
8. Fai clic su Avanti.
9. (Facoltativo) Aggiungi un tag di descrizione.
10. Fai clic su Crea chiave di accesso.
11. Fai clic su Download .csv file (Scarica file .csv) e salva la Access Key (Chiave di accesso) e la Secret Access Key (Chiave di accesso segreta) per utilizzarle in un secondo momento.
12. Fai clic su Fine.
13. Seleziona la scheda Autorizzazioni.
14. Fai clic su Aggiungi autorizzazioni nella sezione Policy sulle autorizzazioni.
15. Seleziona Aggiungi autorizzazioni.
16. Seleziona Collega direttamente i criteri.
17. Cerca e seleziona la policy AmazonS3FullAccess.
18. Fai clic su Avanti.
19. Fai clic su Aggiungi autorizzazioni.

Configura la connessione Amazon S3 di Imperva WAF

1. Accedi alla console Imperva Cloud Security all'indirizzo my.imperva.com con un account con privilegi.
2. Nella barra dei menu in alto, fai clic su Account > Gestione dell'account.
3. Nella barra laterale, fai clic su Log SIEM > Configurazione log.
4. Nella tabella Connessioni, fai clic su Aggiungi connessione.

5. (Facoltativo) Seleziona un fornitore SIEM. Google SecOps non è offerto come fornitore SIEM, quindi salta questo passaggio e seleziona il metodo di invio.

   Nota: se selezioni un fornitore SIEM, Imperva mostra solo i metodi di invio supportati dal fornitore.

6. Seleziona Amazon S3 come metodo di pubblicazione.

7. Fornisci i seguenti dettagli di configurazione:

   • Chiave di accesso: la chiave di accesso dell'utente IAM che hai creato.
   • Chiave segreta: la chiave di accesso segreta dell'utente IAM che hai creato.
   • Percorso: il percorso del bucket, nel formato <bucket-name>/<folder> (ad esempio, imperva-waf-logs/logs).

8. Fai clic su Verifica connessione per eseguire un ciclo di test completo in cui un file di test viene trasferito nella cartella specificata.

9. Fai clic su Aggiungi tipo di log, quindi seleziona il servizio Cloud WAF.

10. Fornisci i seguenti dettagli di configurazione:

    • Nome configurazione: inserisci un nome univoco all'interno del tuo account.
    • Seleziona i tipi di log: Imperva fornisce i log di sicurezza e i log di accesso di Cloud WAF insieme.
    • Format (Formato): seleziona CEF. Il parser legge anche LEEF, ma non W3C.
    • Comprimi i log: deseleziona questa opzione. Imperva comprime i file di log per impostazione predefinita e il parser non può decomprimerli.
    • Crittografia: lascia la crittografia disattivata. Il parser non può decriptare i file di log criptati.
    • State (Stato): imposta su Enabled (Attivato).

11. Salva la configurazione del tipo di log.

Nota: Imperva antepone un blocco di intestazione (ad esempio |==|, format: e startTime:) a ogni file di log. Il parser elimina queste righe per impostazione predefinita, quindi vengono segnalate come non supportate anziché analizzate.

Configura un feed in Google SecOps per importare i log di Imperva WAF da Amazon S3 V2

1. Vai a Impostazioni > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Nel campo Nome feed, inserisci un nome per il feed (ad es. Imperva WAF Logs).
4. Seleziona Amazon S3 V2 come Tipo di origine.
5. Seleziona Imperva Cloud WAF come Tipo di log.
6. Fai clic su Avanti.

7. Specifica i valori per i seguenti parametri di input:

   • URI S3: l'URI del bucket.

     s3://your-log-bucket-name/
     

     Sostituisci your-log-bucket-name con il nome effettivo del bucket.

   • Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.

     Nota: se selezioni l'opzione Elimina i file trasferiti o Elimina i file trasferiti e le directory vuote, assicurati di aver concesso le autorizzazioni appropriate al service account.

   • Età massima del file: includi i file modificati negli ultimi giorni. Il valore predefinito è 180 giorni.

   • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.

   • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.

   • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

   • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

8. Fai clic su Avanti.

9. Controlla la nuova configurazione del feed di notizie nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logica
csv_message	about	Mappatura: CEF: → about
csv_message	about.asset.ip	Mappatura: CEF: → kv.dvc
kv.dvc	about.asset.ip	Unita
csv_message	about.ip	Mappatura: CEF: → kv.dvc
kv.dvc	about.ip	Unita
additional_devicedata	additional.fields	Unita
additional_factors_label	additional.fields	Unita
additional_severity	additional.fields	Unita
cn1_value_label	additional.fields	Unita
csv_message	additional.fields	Mappatura: CEF: → additional_severity, CEF: → cn1_value_label
random_id_label	additional.fields	Unita
site_id_label	additional.fields	Unita
site_name_label	additional.fields	Unita
zuid_labels	additional.fields	Unita
csv_message	extensions.vulns.vulnerabilities	Mappatura: CEF: → vuln
message	extensions.vulns.vulnerabilities	Mappatura: LEEF: → vuln
vuln	extensions.vulns.vulnerabilities	Unita
message	intermediary	Mappatura: LEEF: → intermediary
forwardedIp	intermediary.asset.hostname	Mappatura diretta
forwardedIp	intermediary.asset.ip	Unita
xff	intermediary.asset.ip	Unita
forwardedIp	intermediary.hostname	Mappatura diretta
forwardedIp	intermediary.ip	Unita
log.mx-ip	intermediary.ip	Unita
xff	intermediary.ip	Unita
popName	intermediary.location.country_or_region	Rinominato/mappato
csv.description	metadata.description	Mappatura eseguita quando csv_message =~ CEF:
log.message	metadata.description	Mappato quando json_array != ``
deviceReceiptTime	metadata.event_timestamp	Analizzato come MMM dd HH:mm:ss
log.@timestamp	metadata.event_timestamp	Analizzato come UNIX_MS
log.time	metadata.event_timestamp	Analizzato come UNIX
log_timestamp	metadata.event_timestamp	Analizzato come UNIX_MS
start	metadata.event_timestamp	Analizzato come UNIX_MS
timestamp	metadata.event_timestamp	Analizzato come MMM dd yyyy HH:mm:ss
csv_message	metadata.event_type	Valori mappati (6 in totale, ad es. CEF: → NETWORK_HTTP, CEF: → SCAN_UNCATEGORIZED, CEF: …
has_principal	metadata.event_type	Mappatura: true → NETWORK_CONNECTION
message	metadata.event_type	Mappatura: LEEF: → NETWORK_HTTP
principal_present	metadata.event_type	Mapped: true → NETWORK_HTTP, true → NETWORK_CONNECTION, true → STATUS_UPDATE
csv.event_id	metadata.product_event_type	Mappatura diretta
log.type_key	metadata.product_event_type	Mappato quando json_array != ``
log.imperva.ids.account_id	metadata.product_log_id	Mappato quando json_array != ``
log.header.product-version	metadata.product_version	Mappato quando json_array != ``
product_version	metadata.product_version	Mappatura eseguita quando csv_message =~ CEF:
csv_message	network.application_protocol	Mappatura: CEF: → HTTPS, CEF: → HTTP
proto	network.application_protocol	Rinominato/mappato
deviceExternalId	network.community_id	Rinominato/mappato
message	network.direction	Mappatura: LEEF: → INBOUND
kv.cs8	network.http.method	Mappatura eseguita quando csv_message =~ CEF:
kv.requestMethod	network.http.method	Rinominato/mappato
log.http.request.method	network.http.method	Mappato quando json_array != ``
requestMethod	network.http.method	Rinominato/mappato
http_user_agent	network.http.parsed_user_agent	Rinominato/mappato
log.http.request.user-agent	network.http.parsed_user_agent	Rinominato/mappato
log.imperva.abp.headers_referer	network.http.referral_url	Mappato quando json_array != ``
log.imperva.referrer	network.http.referral_url	Mappato quando json_array != ``
ref	network.http.referral_url	Rinominato/mappato
cn1	network.http.response_code	Rinominato/mappato
cn1_value	network.http.response_code	Rinominato/mappato
kv.flexString1	network.http.response_code	Rinominato/mappato
kv.flexString2	network.http.response_code	Rinominato/mappato
log.http.response.code	network.http.response_code	Rinominato/mappato
kv.requestClientApplication	network.http.user_agent	Mappatura eseguita quando csv_message =~ CEF:
log.http.request.user-agent	network.http.user_agent	Mappato quando json_array != ``
requestClientApplication	network.http.user_agent	Rinominato/mappato
user_agent	network.http.user_agent	Rinominato/mappato
kv.proto	network.ip_protocol	Rinominato/mappato
log.protocol	network.ip_protocol	Mappato quando json_array != ``
message	network.ip_protocol	Mappatura: LEEF: → TCP
kv.Customer	network.organization_name	Mappatura eseguita quando csv_message =~ CEF:
csv_message	network.received_bytes	Mappatura: CEF: → uinteger
in	network.received_bytes	Rinominato/mappato
kv.in	network.received_bytes	Mappatura eseguita quando csv_message =~ CEF:
message	network.received_bytes	Mappatura: LEEF: → uinteger
log.http.request.body.bytes	network.sent_bytes	Rinominato/mappato
fileId	network.session_id	Rinominato/mappato
log.http.session-id	network.session_id	Mappato quando json_array != ``
log.imperva.abp.customer_request_id	network.session_id	Mappato quando json_array != ``
log.imperva.request_session_id	network.session_id	Mappato quando json_array != ``
tls_cipher	network.tls.cipher	Rinominato/mappato
tls_version	network.tls.version	Rinominato/mappato
cs6	principal.application	Rinominato/mappato
log.client.domain	principal.asset.hostname	Mappato quando json_array != ``
csv_message	principal.asset.ip	Mappatura: CEF: → kvsrc
kvsrc	principal.asset.ip	Unita
log.client.ip	principal.asset.ip	Unita
log.source-ip	principal.asset.ip	Unita
message	principal.asset.ip	Mappatura: LEEF: → src
src	principal.asset.ip	Unita
log.client.domain	principal.hostname	Mappato quando json_array != ``
csv_message	principal.ip	Mappatura: CEF: → kvsrc
kvsrc	principal.ip	Unita
log.client.ip	principal.ip	Unita
log.source-ip	principal.ip	Unita
message	principal.ip	Mappatura: LEEF: → src
src	principal.ip	Unita
request_type_label	principal.labels	Unita
cicode	principal.location.city	Rinominato/mappato
kv.cicode	principal.location.city	Mappatura eseguita quando csv_message =~ CEF:
calCountryOrRegion	principal.location.country_or_region	Rinominato/mappato
kv.ccode	principal.location.country_or_region	Mappatura eseguita quando csv_message =~ CEF:
log.client.geo.country_iso_code	principal.location.country_or_region	Mappato quando json_array != ``
log.imperva.country	principal.location.country_or_region	Mappato quando json_array != ``
cs7	principal.location.region_latitude	Rinominato/mappato
csv_message	principal.location.region_latitude	Mappatura: CEF: → float
kv.cs7	principal.location.region_latitude	Rinominato/mappato
message	principal.location.region_latitude	Mappatura: LEEF: → float
cs8	principal.location.region_longitude	Rinominato/mappato
csv_message	principal.location.region_longitude	Mappatura: CEF: → float
kv.cs8	principal.location.region_longitude	Rinominato/mappato
message	principal.location.region_longitude	Mappatura: LEEF: → float
log.source-port	principal.port	Rinominato/mappato
port	principal.port	Mappatura eseguita quando csv_message =~ CEF:
srcPort	principal.port	Rinominato/mappato
log.imperva.path	principal.process.file.full_path	Mappato quando json_array != ``
log.imperva.abp.pid	principal.process.pid	Mappato quando json_array != ``
header_map_label	principal.resource.attribute.labels	Unita
log.user.email	principal.user.email_addresses	Unita
log.user_details	principal.user.email_addresses	Unita
log.event.provider	principal.user.user_display_name	Mappato quando json_array != ``
log.http.user-name	principal.user.userid	Mappato quando json_array != ``
log.user_id	principal.user.userid	Mappato quando json_array != ``
user_name	principal.user.userid	Mappato quando json_array != ``
csv_message	security_result	Mappatura: CEF: → security_result
message	security_result	Mappatura: LEEF: → security_result
_action	security_result.action	Unita
action	security_result.action	Unita
csv_message	security_result.action	Mappatura: CEF: → action
message	security_result.action	Mappatura: LEEF: → _action
security_action	security_result.action	Unita
cat	security_result.action_details	Mappatura diretta
kv.act	security_result.action_details	Mappatura diretta
kv.cat	security_result.action_details	Mappatura diretta
log.action	security_result.action_details	Mappatura diretta
csv_message	security_result.category_details	Mappatura: CEF: → kv.cat
dproc	security_result.category_details	Unita
kv.cat	security_result.category_details	Unita
message	security_result.category_details	Mappatura: LEEF: → dproc
log.description	security_result.description	Mappatura diretta
log.imperva.abp.tls_fingerprint	security_result.description	Mappatura diretta
log.imperva.risk_reason	security_result.description	Mappatura diretta
accept_encoding_label	security_result.detection_fields	Unita
accept_language_label	security_result.detection_fields	Unita
apollo_rule	security_result.detection_fields	Unita
behavior	security_result.detection_fields	Unita
class_label	security_result.detection_fields	Unita
cn1_field	security_result.detection_fields	Unita
cn2_field	security_result.detection_fields	Unita
condition_id	security_result.detection_fields	Unita
condition_name	security_result.detection_fields	Unita
cs10Label_field	security_result.detection_fields	Unita
cs11_field	security_result.detection_fields	Unita
cs12Label_field	security_result.detection_fields	Unita
cs1_field	security_result.detection_fields	Unita
cs2_field	security_result.detection_fields	Unita
cs3_field	security_result.detection_fields	Unita
cs4_field	security_result.detection_fields	Unita
cs5Label_field	security_result.detection_fields	Unita
cs5_field	security_result.detection_fields	Unita
cs6_field	security_result.detection_fields	Unita
cs8_label	security_result.detection_fields	Unita
cs97Label_field	security_result.detection_fields	Unita
cs98_field	security_result.detection_fields	Unita
cs99_field	security_result.detection_fields	Unita
cs9_field	security_result.detection_fields	Unita
cs9_label	security_result.detection_fields	Unita
csv_message	security_result.detection_fields	Valori mappati (30 in totale, ad es. CEF: → flexString1_field, CEF: → cs1_field, CEF: → `…
detection_fields_domain_risk	security_result.detection_fields	Unita
detection_fields_event_action	security_result.detection_fields	Unita
detection_fields_event_context	security_result.detection_fields	Unita
detection_fields_significant_domain_name	security_result.detection_fields	Unita
detection_fields_violated_directive	security_result.detection_fields	Unita
deviceExternalId_label	security_result.detection_fields	Unita
deviceFacility_field	security_result.detection_fields	Unita
dproc_label	security_result.detection_fields	Unita
end_label	security_result.detection_fields	Unita
filePermission_field	security_result.detection_fields	Unita
fileType_field	security_result.detection_fields	Unita
flexNumber1_field	security_result.detection_fields	Unita
flexString1_field	security_result.detection_fields	Unita
flexString2_field	security_result.detection_fields	Unita
fname_field	security_result.detection_fields	Unita
gateway_name_label	security_result.detection_fields	Unita
headers_connection_label	security_result.detection_fields	Unita
hsig	security_result.detection_fields	Unita
log_imperva_classified_client_field	security_result.detection_fields	Unita
log_imperva_credentials_leaked_field	security_result.detection_fields	Unita
log_imperva_declared_client_field	security_result.detection_fields	Unita
log_imperva_failed_logins_last_24h_field	security_result.detection_fields	Unita
log_imperva_fingerprint_field	security_result.detection_fields	Unita
log_imperva_successful_logins_last_24h_field	security_result.detection_fields	Unita
message	security_result.detection_fields	Valori mappati (11 in totale, ad es. LEEF: → siteid_label, LEEF: → start_label, LEEF: → `…
policy_id	security_result.detection_fields	Unita
policy_label	security_result.detection_fields	Unita
policy_name	security_result.detection_fields	Unita
postbody_field	security_result.detection_fields	Unita
postbody_label	security_result.detection_fields	Unita
request_user_label	security_result.detection_fields	Unita
selector	security_result.detection_fields	Unita
selector_derived_id	security_result.detection_fields	Unita
siteTag_field	security_result.detection_fields	Unita
siteid_label	security_result.detection_fields	Unita
start_label	security_result.detection_fields	Unita
tag_label	security_result.detection_fields	Unita
triggered_condition_id	security_result.detection_fields	Unita
triggered_condition_name	security_result.detection_fields	Unita
violation	security_result.detection_fields	Unita
violation_id_label	security_result.detection_fields	Unita
violation_type_label	security_result.detection_fields	Unita
cs9	security_result.rule_name	Mappatura diretta
kv.cs9	security_result.rule_name	Mappatura diretta
fileType	security_result.rule_type	Mappatura eseguita quando message =~ LEEF:
kv.fileType	security_result.rule_type	Mappatura diretta
csv_message	security_result.severity	Mappatura: CEF: → HIGH, CEF: → MEDIUM, CEF: → LOW, CEF: → UNKNOWN_SEVERITY
log.severity	security_result.severity	Mappatura diretta
severity	security_result.severity	Mappatura: High → HIGH, Medium → MEDIUM, Low → LOW, Unknown → UNKNOWN_SEVERITY
sevs	security_result.severity	Mapped: "error", "warning" → HIGH, critical → CRITICAL, "medium","notice" → `MED…
log.imperva.risk_level	security_result.severity_details	Mappatura diretta
severity	security_result.threat_id	Mappatura diretta
description	security_result.threat_name	Mappatura diretta
log.application-name	target.application	Mappato quando json_array != ``
kv.dhost	target.asset.hostname	Mappatura eseguita quando csv_message =~ CEF:
kv.sourceServiceName	target.asset.hostname	Mappatura eseguita quando csv_message =~ CEF:
log.server.domain	target.asset.hostname	Mappato quando json_array != ``
csv_message	target.asset.ip	Mappatura: CEF: → kv.dst, CEF: → kv.sip
dst	target.asset.ip	Unita
kv.dst	target.asset.ip	Unita
kv.sip	target.asset.ip	Unita
log.dest-ip	target.asset.ip	Unita
message	target.asset.ip	Mappatura: LEEF: → dst
kv.dhost	target.hostname	Mappatura eseguita quando csv_message =~ CEF:
kv.sourceServiceName	target.hostname	Mappatura eseguita quando csv_message =~ CEF:
log.server.domain	target.hostname	Mappato quando json_array != ``
sourceServiceName	target.hostname	Rinominato/mappato
csv_message	target.ip	Mappatura: CEF: → kv.dst, CEF: → kv.sip
dst	target.ip	Unita
kv.dst	target.ip	Unita
kv.sip	target.ip	Unita
log.dest-ip	target.ip	Unita
message	target.ip	Mappatura: LEEF: → dst
log.server.geo.name	target.location.name	Mappato quando json_array != ``
dstPort	target.port	Rinominato/mappato
kv.cpt	target.port	Rinominato/mappato
kv.dpt	target.port	Rinominato/mappato
log.dest-port	target.port	Rinominato/mappato
kv.deviceProcessName	target.process.file.full_path	Mappatura eseguita quando csv_message =~ CEF:
log.url.path	target.process.file.full_path	Mappato quando json_array != ``
header_map_label	target.resource.attribute.labels	Unita
server_group_label	target.resource.attribute.labels	Unita
server_group_simulation_mode_label	target.resource.attribute.labels	Unita
service_label	target.resource.attribute.labels	Unita
log.resource_id	target.resource.id	Mappato quando json_array != ``
log.context_key	target.resource.name	Mappato quando json_array != ``
log.imperva.audit_trail.resource_name	target.resource.name	Mappato quando json_array != ``
kv.fileId	target.resource.product_object_id	Mappatura eseguita quando csv_message =~ CEF:
log.imperva.abp.token_id	target.resource.product_object_id	Mappato quando json_array != ``
log.resource_type_key	target.resource.type	Mappato quando json_array != ``
kv.request	target.url	Rinominato/mappato
url	target.url	Rinominato/mappato
Customer	target.user.user_display_name	Rinominato/mappato
log.imperva.ids.account_name	target.user.user_display_name	Mappato quando json_array != ``
kv.duser	target.user.userid	Rinominato/mappato
kv.suid	target.user.userid	Mappatura eseguita quando csv_message =~ CEF:
log.account_id	target.user.userid	Mappato quando json_array != ``
suid	target.user.userid	Rinominato/mappato
N/D	metadata.event_type	Costante: NETWORK_HTTP
N/D	network.direction	Costante: INBOUND
N/D	network.ip_protocol	Costante: TCP
N/D	security_result.severity	Costante: HIGH

Log delle modifiche

Visualizza il log delle modifiche per questo parser

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