Collecter les journaux Imperva WAF

Compatible avec :

Ce document explique comment collecter les journaux Imperva WAF en configurant un flux Google Security Operations à l'aide de l'API tierce, d'un webhook (push HTTP générique) ou d'Amazon S3.

Imperva WAF est un pare-feu d'application Web dans le cloud qui protège les sites Web et les applications contre les attaques Web, y compris l'injection SQL, les scripts intersites (XSS) et les menaces DDoS. Imperva WAF analyse le trafic HTTP/HTTPS entrant en temps réel, en appliquant des règles de sécurité et des règles d'atténuation des bots pour bloquer les requêtes malveillantes avant qu'elles n'atteignent le serveur d'origine.

Différences concernant la méthode de collecte

L'intégration d'Imperva WAF à Google SecOps est compatible avec les méthodes d'ingestion de journaux suivantes :

  • Collecte d'API : Google SecOps extrait les journaux directement de l'API Imperva. Il s'agit d'une connexion directe, qui n'accepte que le type de journal IMPERVA_WAF et ne collecte que les journaux d'audit, comme décrit dans Imperva Audit Trail. Google SecOps interroge l'API Imperva Audit Trail toutes les 24 heures.
  • Collection de buckets Amazon S3 V2 : Imperva WAF transfère les journaux vers un bucket Amazon S3 désigné, puis Google SecOps extrait les journaux de ce bucket. Cette méthode collecte les événements liés à la sécurité et les journaux d'accès générés par le WAF Cloud, comme décrit dans la section Intégration des journaux Imperva. Étant donné que le bucket peut recevoir des journaux de nombreuses sources, cette méthode est également compatible avec d'autres types de journaux Imperva, à condition de configurer ces journaux pour qu'ils soient explicitement envoyés au bucket.
  • Connecteur push HTTP générique (bêta) : Imperva WAF envoie les journaux directement à Google SecOps à l'aide de webhooks HTTPS. Cela permet une ingestion en temps quasi réel à l'aide du streaming d'API direct, sans nécessiter de stockage S3 intermédiaire.

Limites architecturales

Lorsque vous choisissez une méthode d'ingestion, tenez compte des contraintes techniques suivantes :

  • Risque de perte de données : le streaming direct par webhook ne fournit pas de files d'attente de nouvelles tentatives à long terme. Si le point de terminaison Google SecOps est inaccessible ou supprime le trafic lors d'interruptions de service, les charges utiles push non consommées peuvent être perdues, sauf si elles sont mises en mémoire tampon en amont.
  • Limites de débit de RPS : l'envoi de journaux à l'aide de webhooks lors d'attaques DDoS à volume élevé ou de pics de trafic soudains peut déclencher des limites de débit d'API ou des limitations de distribution.
  • Contraintes d'en-tête : l'authentification repose sur des en-têtes HTTP statiques. Assurez-vous que la rotation des clés est effectuée de manière sécurisée, conformément aux règles de sécurité de votre organisation.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Accès privilégié à la console Imperva Cloud Security (my.imperva.com)
  • Un administrateur de compte Imperva, pour créer une clé API pour un autre utilisateur. Un utilisateur ne disposant pas d'autorisations d'administrateur ne peut créer une clé API que pour son propre compte.
  • Pour la méthode Amazon S3 : accès privilégié à AWS (S3, IAM)
  • Pour le push Webhook : identifiants API avec les autorisations nécessaires pour gérer les API Imperva Connections et Log Configurations.

Configurer l'accès à l'API Imperva WAF

La méthode de collecte d'API s'authentifie auprès de api.imperva.com avec un ID d'API et une clé API Imperva. Générez ces identifiants dans la console Imperva Cloud Security.

Générer des identifiants d'API

  1. Connectez-vous à la console Imperva Cloud Security à l'adresse my.imperva.com.
  2. Dans la barre de menu supérieure, cliquez sur Compte > Gestion du compte.
  3. Dans la barre latérale, cliquez sur Gestion des utilisateurs > Utilisateurs.
  4. Recherchez l'utilisateur utilisé par le flux, cliquez sur les points de suspension dans la colonne Actions, puis sur Modifier.
  5. Cliquez sur l'onglet Clés API.
  6. Cliquez sur Ajouter une clé API. Ajoutez un nom et une description qui identifient l'utilisation de la clé.
  7. Copiez et enregistrez les valeurs suivantes à partir de la fenêtre pop-up :
    • ID d'API : votre identifiant d'API unique (par exemple, 12345).
    • Clé API : votre clé API (par exemple, abcdef-123456-ghijkl-789012).
  • Un utilisateur ne disposant pas d'autorisations d'administrateur peut également générer une clé pour son propre compte. Dans la barre de menu supérieure, cliquez sur Account > My Profile (Compte > Mon profil), puis sous API keys (Clés API), cliquez sur Add API Key (Ajouter une clé API).

Configurer un flux dans Google SecOps pour ingérer les journaux Imperva WAF

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Sur la page suivante, cliquez sur Configurer un seul flux.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Imperva WAF Logs).
  5. Sélectionnez API tierce comme type de source.
  6. Sélectionnez Imperva comme Type de journal.
  7. Cliquez sur Suivant.
  8. Spécifiez les valeurs des paramètres d'entrée suivants :

    • En-tête HTTP d'authentification : saisissez les identifiants d'authentification au format suivant :

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

      Chaque identifiant doit figurer sur une ligne distincte au format key:value.

      Saisissez les noms d'en-tête exactement comme indiqué. L'API Imperva Audit Trail n'accepte l'ID et la clé API que comme en-têtes HTTP x-API-Id et x-API-Key.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Après la configuration, le flux récupère les événements de la piste d'audit Imperva, qui enregistrent les actions effectuées dans votre compte par les utilisateurs du compte, les processus système et les administrateurs Imperva. Pour collecter les événements liés à la sécurité et les journaux d'accès de Cloud WAF, utilisez le connecteur push HTTP générique ou la méthode Amazon S3.

Collecter les journaux Imperva WAF à l'aide du connecteur Generic HTTP Push (bêta)

Configurer un flux dans Google SecOps pour l'ingestion de webhooks

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Imperva WAF Webhook).
  4. Sélectionnez Webhook comme type de source.
  5. Sélectionnez Imperva Cloud WAF comme Type de journal.
  6. Cliquez sur Suivant.
  7. Configurez les en-têtes d'authentification, puis copiez l'URL du point de terminaison et l'en-tête/jeton secret générés.
  8. Cliquez sur Envoyer.

Configurer le push de webhook Imperva à l'aide de l'API

  1. Utilisez l'API Imperva Connections pour enregistrer le point de terminaison du webhook fourni par Google SecOps.
  2. Incluez les en-têtes d'authentification statiques suivants dans votre requête API :

    • X-goog-api-key : votre clé API Google SecOps.
    • X-Webhook-Access-Key : clé d'accès au flux générée par Google SecOps.
  3. Utilisez l'API Imperva Log Configurations pour associer la nouvelle connexion à vos flux de journaux de sécurité et d'accès Cloud WAF.

  4. Dans la charge utile de l'API Log Configurations, assurez-vous que batchPackaging.type est défini sur "NONE" pour faciliter l'envoi immédiat.

Collecter les journaux Imperva WAF à l'aide d'Amazon S3

Configurer AWS IAM et S3

  1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
  2. Enregistrez le nom et la région du bucket pour une utilisation ultérieure.
  3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
  4. Sélectionnez l'utilisateur créé.
  5. Sélectionnez l'onglet Identifiants de sécurité.
  6. Cliquez sur Create Access Key (Créer une clé d'accès) dans la section Access Keys (Clés d'accès).
  7. Sélectionnez Service tiers comme Cas d'utilisation.
  8. Cliquez sur Suivant.
  9. Facultatif : ajoutez un tag de description.
  10. Cliquez sur Créer une clé d'accès.
  11. Cliquez sur Télécharger le fichier .csv, puis enregistrez la clé d'accès et la clé d'accès secrète pour une utilisation ultérieure.
  12. Cliquez sur OK.
  13. Sélectionnez l'onglet Autorisations.
  14. Cliquez sur Ajouter des autorisations dans la section Stratégies d'autorisation.
  15. Sélectionnez Ajouter des autorisations.
  16. Sélectionnez Associer directement des stratégies.
  17. Recherchez et sélectionnez la règle AmazonS3FullAccess.
  18. Cliquez sur Suivant.
  19. Cliquez sur Ajouter des autorisations.

Configurer la connexion Imperva WAF Amazon S3

  1. Connectez-vous à la console Imperva Cloud Security à l'adresse my.imperva.com avec un compte privilégié.
  2. Dans la barre de menu supérieure, cliquez sur Compte > Gestion du compte.
  3. Dans la barre latérale, cliquez sur Journaux SIEM > Configuration des journaux.
  4. Dans le tableau Connexions, cliquez sur Ajouter une connexion.
  5. Facultatif : sélectionnez un fournisseur de SIEM. Google SecOps n'est pas proposé en tant que fournisseur de SIEM. Ignorez donc cette étape et sélectionnez plutôt la méthode de diffusion.

  6. Sélectionnez Amazon S3 comme mode de diffusion.

  7. Fournissez les informations de configuration suivantes :

    • Clé d'accès : clé d'accès de l'utilisateur IAM que vous avez créé.
    • Clé secrète : clé d'accès secrète de l'utilisateur IAM que vous avez créé.
    • Chemin d'accès : chemin d'accès au bucket, au format <bucket-name>/<folder> (par exemple, imperva-waf-logs/logs).
  8. Cliquez sur Tester la connexion pour exécuter un cycle de test complet au cours duquel un fichier de test est transféré vers le dossier que vous avez spécifié.

  9. Cliquez sur Ajouter un type de journal, puis sélectionnez le service Cloud WAF.

  10. Fournissez les informations de configuration suivantes :

    • Nom de la configuration : saisissez un nom unique dans votre compte.
    • Sélectionner les types de journaux : Imperva fournit à la fois les journaux de sécurité et les journaux d'accès Cloud WAF.
    • Format : sélectionnez CEF. L'analyseur lit également le format LEEF, mais pas le format W3C.
    • Compresser les journaux : décochez cette option. Imperva compresse les fichiers journaux par défaut, et l'analyseur ne peut pas les décompresser.
    • Chiffrement : laissez le chiffrement désactivé. L'analyseur ne peut pas déchiffrer les fichiers journaux chiffrés.
    • État : défini sur Activé.
  11. Enregistrez la configuration du type de journal.

Configurer un flux dans Google SecOps pour ingérer les journaux Imperva WAF depuis Amazon S3 V2

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Imperva WAF Logs).
  4. Sélectionnez Amazon S3 V2 comme Type de source.
  5. Sélectionnez Imperva Cloud WAF comme Type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URI S3 : URI du bucket.

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

      Remplacez your-log-bucket-name par le nom réel du bucket.

    • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours. La valeur par défaut est de 180 jours.

    • ID de clé d'accès : clé d'accès utilisateur permettant d'accéder au bucket S3.

    • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  8. Cliquez sur Suivant.

  9. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

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

Journal des modifications

Afficher le journal des modifications de cet analyseur

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.