Collecter les journaux Imperva WAF
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_WAFet 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
- Connectez-vous à la console Imperva Cloud Security à l'adresse
my.imperva.com. - Dans la barre de menu supérieure, cliquez sur Compte > Gestion du compte.
- Dans la barre latérale, cliquez sur Gestion des utilisateurs > Utilisateurs.
- Recherchez l'utilisateur utilisé par le flux, cliquez sur les points de suspension dans la colonne Actions, puis sur Modifier.
- Cliquez sur l'onglet Clés API.
- Cliquez sur Ajouter une clé API. Ajoutez un nom et une description qui identifient l'utilisation de la clé.
- 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).
- ID d'API : votre identifiant d'API unique (par exemple,
- 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
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Cliquez sur Ajouter un flux d'actualités.
- Sur la page suivante, cliquez sur Configurer un seul flux.
- Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple,
Imperva WAF Logs). - Sélectionnez API tierce comme type de source.
- Sélectionnez Imperva comme Type de journal.
- Cliquez sur Suivant.
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-valueChaque 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-Idetx-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.
Cliquez sur Suivant.
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
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Cliquez sur Ajouter un flux d'actualités.
- Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple,
Imperva WAF Webhook). - Sélectionnez Webhook comme type de source.
- Sélectionnez Imperva Cloud WAF comme Type de journal.
- Cliquez sur Suivant.
- 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.
- Cliquez sur Envoyer.
Configurer le push de webhook Imperva à l'aide de l'API
- Utilisez l'API Imperva Connections pour enregistrer le point de terminaison du webhook fourni par Google SecOps.
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.
Utilisez l'API Imperva Log Configurations pour associer la nouvelle connexion à vos flux de journaux de sécurité et d'accès Cloud WAF.
Dans la charge utile de l'API Log Configurations, assurez-vous que
batchPackaging.typeest 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
- Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
- Enregistrez le nom et la région du bucket pour une utilisation ultérieure.
- Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
- Sélectionnez l'utilisateur créé.
- Sélectionnez l'onglet Identifiants de sécurité.
- Cliquez sur Create Access Key (Créer une clé d'accès) dans la section Access Keys (Clés d'accès).
- Sélectionnez Service tiers comme Cas d'utilisation.
- Cliquez sur Suivant.
- Facultatif : ajoutez un tag de description.
- Cliquez sur Créer une clé d'accès.
- 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.
- Cliquez sur OK.
- Sélectionnez l'onglet Autorisations.
- Cliquez sur Ajouter des autorisations dans la section Stratégies d'autorisation.
- Sélectionnez Ajouter des autorisations.
- Sélectionnez Associer directement des stratégies.
- Recherchez et sélectionnez la règle AmazonS3FullAccess.
- Cliquez sur Suivant.
- Cliquez sur Ajouter des autorisations.
Configurer la connexion Imperva WAF Amazon S3
- Connectez-vous à la console Imperva Cloud Security à l'adresse
my.imperva.comavec un compte privilégié. - Dans la barre de menu supérieure, cliquez sur Compte > Gestion du compte.
- Dans la barre latérale, cliquez sur Journaux SIEM > Configuration des journaux.
- Dans le tableau Connexions, cliquez sur Ajouter une connexion.
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.
Sélectionnez Amazon S3 comme mode de diffusion.
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).
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é.
Cliquez sur Ajouter un type de journal, puis sélectionnez le service Cloud WAF.
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é.
Enregistrez la configuration du type de journal.
Configurer un flux dans Google SecOps pour ingérer les journaux Imperva WAF depuis Amazon S3 V2
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Cliquez sur Ajouter un flux d'actualités.
- Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple,
Imperva WAF Logs). - Sélectionnez Amazon S3 V2 comme Type de source.
- Sélectionnez Imperva Cloud WAF comme Type de journal.
- Cliquez sur Suivant.
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-namepar 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.
Cliquez sur Suivant.
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.