Collecter les journaux du proxy Web Netskope

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer les journaux de proxy Web Netskope dans Google Security Operations à l'aide de Cloud Storage V2.

Netskope fournit une passerelle Web sécurisée cloud native qui inspecte et contrôle le trafic Web en temps réel. Les journaux de transactions Web (WebTx) enregistrent en détail chaque session HTTP et HTTPS traitée par le proxy Netskope, y compris l'identité de l'utilisateur, l'application, la catégorie d'URL, les verdicts sur les menaces et la protection contre la perte de données, ainsi que les métadonnées réseau.

Remarque : Le plug-in Google Chronicle du module d'expédition de journaux Netskope Cloud Exchange ne prend pas en charge les journaux WebTx. Pour ingérer des journaux WebTx dans Google SecOps, vous devez utiliser l'une des méthodes basées sur le stockage cloud décrites dans ce guide. Les deux options fournissent des journaux WebTx sous forme de fichiers .gzip compressés dans un bucket Cloud Storage, que Google SecOps lit ensuite via un flux Cloud Storage V2.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Un projet Google Cloud avec l'API Cloud Storage activée
• Autorisations de créer et de gérer des buckets Cloud Storage
• Autorisations de gérer les stratégies IAM (Identity and Access Management) sur les buckets Cloud Storage
• Accès privilégié au locataire Netskope avec des identifiants administrateur

Option 1 : Streaming des journaux Netskope vers Cloud Storage

Utilisez cette option si vous avez activé un abonnement Netskope Log Streaming sur votre locataire. Netskope Log Streaming envoie les fichiers journaux WebTx directement dans votre bucket Cloud Storage sous forme de fichiers .gzip compressés à un intervalle fixe de 240 secondes.

Remarque : Netskope Log Streaming est un abonnement payant. Contactez l'équipe chargée de votre compte Netskope pour vérifier que le streaming des journaux est activé sur votre locataire.

Créer un bucket Cloud Storage

1. Accédez à la consoleGoogle Cloud .
2. Sélectionnez votre projet ou créez-en un.
3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
4. Cliquez sur Créer un bucket.

5. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Attribuez un nom au bucket	Saisissez un nom unique (par exemple, netskope-webtx-logs).
   Type d'emplacement	Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
   Emplacement	Sélectionnez l'emplacement le plus proche de votre organisation (par exemple, us-central1).
   Classe de stockage	Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
   Access control (Contrôle des accès)	Uniforme (recommandé)
   Outils de protection	Facultatif : Activez la gestion des versions des objets ou la règle de conservation.

6. Cliquez sur Créer.

Créer un compte de service Google Cloud

Netskope Log Streaming nécessite un compte de service Google Cloud avec des autorisations d'écriture sur votre bucket Cloud Storage. Le fichier de clé JSON de ce compte de service est utilisé par Netskope pour l'authentification lors de l'envoi des fichiers journaux.

1. Dans la console Google Cloud , accédez à IAM et administration > Comptes de service.
2. Cliquez sur Créer un compte de service.
3. Fournissez les informations de configuration suivantes :
   • Nom du compte de service : saisissez netskope-log-streaming.
   • Description du compte de service : saisissez Service account for Netskope Log Streaming to push WebTx logs to GCS.
4. Cliquez sur Créer et continuer.
5. Dans la section Autoriser ce compte de service à accéder au projet :
   1. Cliquez sur Sélectionner un rôle.
   2. Recherchez et sélectionnez Créateur d'objets Storage.
6. Cliquez sur Continuer.
7. Cliquez sur OK.

Générer la clé JSON

1. Dans la console Google Cloud , accédez à IAM et administration > Comptes de service, puis cliquez sur le compte de service netskope-log-streaming.
2. Sélectionnez l'onglet Keys (clés).
3. Cliquez sur Ajouter une clé > Créer une clé.
4. Sélectionnez JSON comme type de clé.
5. Cliquez sur Créer.

6. Un fichier de clé JSON est téléchargé automatiquement. Enregistrez ce fichier de manière sécurisée. Vous collerez l'intégralité du contenu de ce fichier dans Netskope lors de la section suivante.

   Remarque : Vous ne pouvez télécharger le fichier de clé JSON qu'une seule fois. Si vous perdez ce fichier, vous devrez créer une nouvelle clé.

Accorder des autorisations d'écriture sur un bucket Cloud Storage

1. Dans la console Google Cloud , accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre bucket (par exemple, netskope-webtx-logs).
3. Accédez à l'onglet Autorisations.
4. Cliquez sur Accorder l'accès.
5. Fournissez les informations de configuration suivantes :
   • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, netskope-log-streaming@YOUR_PROJECT_ID.iam.gserviceaccount.com).
   • Attribuer des rôles : sélectionnez Créateur d'objets Storage.

6. Cliquez sur Enregistrer.

   Remarque : Si le projet du bucket se trouve dans un périmètre VPC Service Controls, les écritures de Netskope arrivent de l'extérieur du périmètre et sont bloquées jusqu'à ce que vous ajoutiez une règle d'entrée. Dans Sécurité > VPC Service Controls, modifiez le périmètre et ajoutez une règle d'entrée avec l'adresse e-mail du compte de service comme identité, Toutes les sources comme source et l'API Cloud Storage avec la méthode google.storage.objects.create comme cible. Sans cela, la validation du flux échoue même si l'autorisation IAM est correcte.

Créer le flux de journaux

1. Connectez-vous au locataire Netskope avec des identifiants administrateur.
2. Accédez à Paramètres> Outils > Streaming de journaux.
3. Cliquez sur Créer un flux.
4. Dans le champ Nom, saisissez un nom lisible par l'humain pour le flux. Exemple :Google SecOps WebTx GCS
5. Sélectionnez GCP Cloud Storage comme type de destination.

6. Fournissez les informations de configuration suivantes :

   • Bucket : saisissez le nom du bucket Cloud Storage (par exemple, netskope-webtx-logs).

     Remarque : Suivez les conventions d'attribution de noms de buckets pour Cloud Storage.
     • Chemin d'accès (facultatif) : saisissez le chemin d'accès à un dossier dans le bucket où les journaux seront stockés (par exemple, `netskope/webtx/{%Y}`).
     Remarque : Dans Cloud Storage, les chemins d'accès fonctionnent comme des noms d'objet. Lorsque vous saisissez un chemin d'accès tel que netskope/webtx/{%Y}`, Cloud Storage doesn't create separate folders in the bucket. Instead, the objects are stored in one bucket and named with the path as a prefix (for example,netskope/webtx/2026/filename, consultez les consignes de dénomination des objets pour en savoir plus.

   • Clé privée : collez l'intégralité du contenu du fichier de clé JSON généré dans la section précédente, sous la forme d'un seul objet JSON commençant par { et se terminant par }. Il inclut les champs type, project_id, private_key_id, private_key, client_email et client_id.

     Remarque : Ne collez pas uniquement la valeur private_key. Malgré le nom du champ, Netskope attend l'intégralité du fichier de clé du compte de service. Une clé PEM autonome échoue à la validation des identifiants lorsque vous enregistrez le flux.

7. Examinez les options de diffusion : la fréquence de diffusion est de 240 secondes en continu.

8. Cliquez sur Enregistrer (ou Créer) pour activer le flux. Netskope valide les identifiants en écrivant un objet de test nommé netskope-test-file.txt dans le bucket.

   Remarque : L'activation du flux peut prendre jusqu'à 60 minutes après sa création. Après l'activation, Netskope transfère les fichiers journaux WebTx sous forme de fichiers .gzip compressés vers votre bucket Cloud Storage toutes les 240 secondes. Ces fichiers contiennent les données de transaction Web d'origine sans modification.

Configurer un flux dans Google SecOps pour ingérer les journaux Netskope WebTx depuis Cloud Storage

Suivez les étapes ci-dessous pour créer le flux Google SecOps et accorder les autorisations IAM :

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket Cloud Storage. Vous devez accorder à ce compte de service l'accès à votre bucket.

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Ajouter un flux d'actualités.
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Netskope WebTx Logs).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Proxy Web Netskope comme Type de journal.
7. Cliquez sur Get Service Account (Obtenir un compte de service).

8. Une adresse e-mail de compte de service unique s'affiche, par exemple :

   [e-mail]
   

9. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

   Remarque : Chaque instance Google SecOps possède un compte de service unique. N'utilisez pas de comptes de service provenant d'autres documents ou exemples.

10. Cliquez sur Suivant.

11. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket de stockage : saisissez l'URI du bucket Cloud Storage avec le chemin d'accès au préfixe :

      gs://netskope-webtx-logs/netskope/webtx/
      

      • Remplacez :
        • netskope-webtx-logs : nom de votre bucket Cloud Storage.
        • netskope/webtx/ : préfixe de chemin d'accès configuré dans Netskope Log Streaming (laissez ce champ vide pour la racine).
    Remarque : Incluez toujours la barre oblique (/) à la fin de l'URI.

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

      • Ne jamais supprimer les fichiers : ne supprimez jamais les fichiers de la source (recommandé pour les tests).
      • Supprimer les fichiers transférés et les répertoires vides : supprimez les fichiers et les répertoires vides de la source une fois la récupération terminée.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

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

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux

12. Cliquez sur Suivant.

13. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin de deux rôles sur votre bucket Cloud Storage : Lecteur des objets Storage pour lire les objets journaux et un rôle au niveau du bucket pour lire les métadonnées du bucket.

1. Accédez à Cloud Storage > Buckets.
2. cliquez sur le nom de votre bucket (par exemple, netskope-webtx-logs).
3. Accédez à l'onglet Autorisations.
4. Cliquez sur Accorder l'accès.
5. Fournissez les informations de configuration suivantes :
   • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps (par exemple, [e-mail]).
   • Attribuer des rôles : sélectionnez les deux rôles suivants :
     • Lecteur des objets de l'espace de stockage : lit les objets de journal.
     • Lecteur des anciens buckets Storage : lit les métadonnées du bucket. Si vous avez sélectionné l'option de suppression Supprimer les fichiers transférés et les répertoires vides, sélectionnez plutôt Rédacteur de bucket Storage hérité, qui accorde également l'autorisation de suppression.
6. Cliquez sur Enregistrer.

Remarque : Accordez les deux rôles. Le rôle Lecteur des objets Storage n'accorde pas l'autorisation au niveau du bucket dont le flux a besoin, et les rôles Ancien lecteur de bucket Storage n'accordent pas l'autorisation de lire le contenu des objets.

Option 2 : Utiliser le programme d'envoi de journaux Netskope Cloud Exchange vers Cloud Storage

Utilisez cette option si vous avez déployé la plate-forme Netskope Cloud Exchange avec le module Log Shipper configuré. Le Log Shipper extrait les journaux WebTx de votre locataire Netskope et les envoie sous forme de fichiers .gzip compressés vers un bucket Cloud Storage, que Google SecOps lit ensuite via un flux Cloud Storage V2.

Remarque : Le plug-in Google Chronicle pour Log Shipper (v3.0.0) n'est pas compatible avec l'ingestion WebTx. Pour les journaux WebTx, vous devez utiliser un plug-in de destination de stockage cloud (Google Cloud Storage, AWS S3 ou Microsoft Azure Blob Storage). Ces plug-ins transmettent les fichiers .gzip d'origine obtenus de Netskope au fournisseur de stockage cloud sans décompresser ni modifier le contenu.

Avant de commencer (Cloud Exchange)

Assurez-vous de remplir les conditions préalables supplémentaires suivantes pour cette option :

• Un locataire Netskope Cloud Exchange avec le plug-in Tenant et le module Log Shipper déjà configurés.
• Plug-in source Netskope CLS configuré dans Log Shipper (il extrait les données du locataire Netskope).
• Un bucket Cloud Storage créé pour stocker les journaux WebTx. Si vous n'en avez pas encore créé, suivez les étapes décrites dans Créer un bucket Cloud Storage.
• Un compte de service Google Cloud avec accès en écriture au bucket Cloud Storage. Si vous n'en avez pas créé, suivez les étapes décrites dans Créer un compte de service Google Cloud , Générer la clé JSON et Accorder des autorisations d'écriture sur un bucket Cloud Storage.

Configurer le plug-in de destination Cloud Storage

1. Dans Cloud Exchange, accédez à Settings > Plugin Store.
2. Recherchez et sélectionnez le plug-in Google Cloud SCC (Google GCS).
3. Cliquez sur Configure New Plugin (Configurer un nouveau plug-in) ou ajoutez une configuration de plug-in.
4. Fournissez les informations de configuration suivantes :
   • Nom de la configuration : saisissez un nom descriptif (par exemple, GCS WebTx Destination).
   • Mappage : sélectionnez un fichier de mappage. Aucune transformation de mappage n'est appliquée aux journaux WebTx envoyés en tant que fichiers .gzip d'origine.
   • Bucket : saisissez le nom du bucket Cloud Storage (par exemple, netskope-webtx-logs).
   • Chemin d'accès (facultatif) : saisissez le chemin d'accès à un dossier (par exemple, netskope/webtx/).
   • Fichier de clé : collez l'intégralité du contenu du fichier de clé JSON du compte de service, et pas seulement la valeur private_key.
5. Cliquez sur Enregistrer.
6. La nouvelle configuration du plug-in s'affiche sur la page Log Shipper > Plug-ins.

Configurer une règle d'entreprise (facultatif)

Par défaut, la règle commerciale Tous filtre toutes les alertes et tous les événements. Si vous souhaitez filtrer spécifiquement les journaux WebTx, créez une règle métier :

1. Dans Log Shipper, accédez à Business Rules (Règles d'entreprise).
2. Cliquez sur Créer une règle.
3. Saisissez un nom de règle (par exemple, WebTx Only).
4. Configurez vos filtres pour n'inclure que les données WebTx.
5. Cliquez sur Enregistrer.

Configurer la diffusion des journaux

1. Dans Log Shipper, accédez à Log Delivery.
2. Cliquez sur Ajouter une configuration de diffusion des journaux.
3. Fournissez les informations de configuration suivantes :
   • Configuration de la source : sélectionnez le plug-in source Netskope CLS (par exemple, WebTxCLS ou Netskope CLS).
   • Configuration de la destination : sélectionnez le plug-in de destination Cloud Storage que vous avez configuré (par exemple, GCS WebTx Destination).
   • Règle métier : sélectionnez une règle métier (par exemple, All ou WebTx Only).

4. Cliquez sur Enregistrer.

   Remarque : Dès que la diffusion des journaux est enregistrée, Cloud Exchange effectue une extraction de l'historique des événements (période par défaut : 1 heure) et des alertes (période par défaut : 7 jours).

5. Pour obtenir des données historiques supplémentaires, cliquez sur l'icône Extraire les données historiques dans les actions Distribution des journaux.

6. Sélectionnez une plage de dates Historique de et à, puis cliquez sur Extraire.

Configurer un flux dans Google SecOps pour ingérer les journaux Netskope WebTx depuis Cloud Storage

Suivez la même procédure que pour l'option de streaming des journaux Netskope afin de créer un flux Google SecOps et d'accorder des autorisations IAM :

1. Récupérez le compte de service Google SecOps : créez un flux avec Google Cloud Storage V2 comme type de source et Proxy Web Netskope comme type de journal.
2. Accorder des autorisations IAM au compte de service Google SecOps : accordez les rôles Lecteur des objets Storage et Lecteur des anciens buckets Storage (utilisez Rédacteur des anciens buckets Storage si vous utilisez l'option de suppression) sur le bucket Cloud Storage au compte de service Google SecOps.

Vérifier la diffusion des journaux

Pour vérifier que les journaux WebTx sont envoyés au bucket Cloud Storage :

1. Dans Cloud Exchange, accédez à Log Shipper> Log Delivery (Expéditeur de journaux > Distribution des journaux).
2. Consultez les colonnes Nombre total de journaux/WebTx envoyés au récepteur externe et Nombre total de WebTx envoyés au bucket de stockage pour vérifier que les données sont bien transférées vers la destination.
3. Dans le bucket GCS, vérifiez que les fichiers .gzip sont bien écrits par l'outil d'envoi de journaux.

Configurer les paramètres globaux de l'outil d'expédition des journaux (facultatif)

Seuls les administrateurs peuvent modifier les paramètres généraux de Log Shipper. Accédez à Settings> Log Shipper (Paramètres > Expéditeur de journaux). Il existe deux onglets : "Général" et "Mappages".

Dans l'onglet Général, vous pouvez configurer la stratégie de réessai pour la diffusion des journaux :

• Par défaut (3 tentatives) : en cas d'échec de l'envoi des journaux, Log Shipper effectue trois tentatives pour les transférer vers la destination. Si les trois tentatives échouent, le lot de journaux correspondant est supprimé.

• Réessayer jusqu'à ce que la diffusion aboutisse : tentatives illimitées jusqu'à ce que la diffusion des journaux aboutisse.

  Remarque : L'option "Retry till Successful Delivery" (Réessayer jusqu'à ce que la diffusion aboutisse) peut avoir un impact sur les performances globales de Cloud Exchange, y compris sur les autres modules Cloud Exchange.

Vous pouvez également activer l'encodage UTF-8 pour les alertes, les événements et WebTx afin d'assurer une gestion fluide des données encodées en UTF-8. Par défaut, cette fonctionnalité est désactivée.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
applicationType	security_result.detection_fields[].key: "applicationType", security_result.detection_fields[].value: applicationType	Mappé directement à partir du champ CEF correspondant
appcategory	security_result.category_details[]: appcategory	Mappé directement à partir du champ CEF correspondant
navigateur	security_result.detection_fields[].key: "browser", security_result.detection_fields[].value: browser	Mappé directement à partir du champ CEF correspondant
c-ip	principal.asset.ip[]: c-ip, principal.ip[]: c-ip	Directement mappé à partir du champ JSON correspondant
cci	security_result.detection_fields[].key: "cci", security_result.detection_fields[].value: cci	Mappé directement à partir du champ CEF correspondant
ccl	security_result.confidence : valeur dérivée, security_result.confidence_details : ccl	security_result.confidence est dérivé de la valeur de ccl : "excellent" ou "high" correspond à HIGH_CONFIDENCE, "medium" correspond à MEDIUM_CONFIDENCE, "low" ou "poor" correspond à LOW_CONFIDENCE, et "unknown" ou "not_defined" correspond à UNKNOWN_CONFIDENCE. security_result.confidence_details est directement mappé à partir de ccl.
clientBytes	network.sent_bytes: clientBytes	Mappé directement à partir du champ CEF correspondant
cs-access-method	additional.fields[].key: "accessMethod", additional.fields[].value.string_value: cs-access-method	Mappé directement à partir du champ JSON correspondant
cs-app	additional.fields[].key: "x-cs-app", additional.fields[].value.string_value: cs-app, principal.application: cs-app	Directement mappé à partir du champ JSON correspondant
cs-app-activity	additional.fields[].key: "x-cs-app-activity", additional.fields[].value.string_value: cs-app-activity	Mappé directement à partir du champ JSON correspondant
cs-app-category	additional.fields[].key: "x-cs-app-category", additional.fields[].value.string_value: cs-app-category	Directement mappé à partir du champ JSON correspondant
cs-app-cci	additional.fields[].key: "x-cs-app-cci", additional.fields[].value.string_value: cs-app-cci	Directement mappé à partir du champ JSON correspondant
cs-app-ccl	additional.fields[].key: "x-cs-app-ccl", additional.fields[].value.string_value: cs-app-ccl	Directement mappé à partir du champ JSON correspondant
cs-app-from-user	additional.fields[].key: "x-cs-app-from-user", additional.fields[].value.string_value: cs-app-from-user, principal.user.email_addresses[]: cs-app-from-user	Mappé directement à partir du champ JSON correspondant
cs-app-instance-id	additional.fields[].key: "x-cs-app-instance-id", additional.fields[].value.string_value: cs-app-instance-id	Directement mappé à partir du champ JSON correspondant
cs-app-object-name	additional.fields[].key: "x-cs-app-object-name", additional.fields[].value.string_value: cs-app-object-name	Directement mappé à partir du champ JSON correspondant
cs-app-object-type	additional.fields[].key: "x-cs-app-object-type", additional.fields[].value.string_value: cs-app-object-type	Mappé directement à partir du champ JSON correspondant
cs-app-suite	additional.fields[].key: "x-cs-app-suite", additional.fields[].value.string_value: cs-app-suite	Mappé directement à partir du champ JSON correspondant
cs-app-tags	additional.fields[].key: "x-cs-app-tags", additional.fields[].value.string_value: cs-app-tags	Directement mappé à partir du champ JSON correspondant
cs-bytes	network.sent_bytes: cs-bytes	Directement mappé à partir du champ JSON correspondant
cs-content-type	additional.fields[].key: "sc-content-type", additional.fields[].value.string_value: cs-content-type	Directement mappé à partir du champ JSON correspondant
cs-dns	target.asset.hostname[]: cs-dns, target.hostname: cs-dns	Directement mappé à partir du champ JSON correspondant
cs-host	target.asset.hostname[]: cs-host, target.hostname: cs-host	Directement mappé à partir du champ JSON correspondant
cs-method	network.http.method: cs-method	Directement mappé à partir du champ JSON correspondant
cs-referer	network.http.referral_url: cs-referer	Mappé directement à partir du champ JSON correspondant
cs-uri	additional.fields[].key: "cs-uri", additional.fields[].value.string_value: cs-uri	Mappé directement à partir du champ JSON correspondant
cs-uri-path	additional.fields[].key: "x-cs-uri-path", additional.fields[].value.string_value: cs-uri-path	Mappé directement à partir du champ JSON correspondant
cs-uri-port	additional.fields[].key: "cs-uri-port", additional.fields[].value.string_value: cs-uri-port	Directement mappé à partir du champ JSON correspondant
cs-uri-scheme	network.application_protocol: cs-uri-scheme	Mappé directement à partir du champ JSON correspondant après conversion en majuscules
cs-user-agent	network.http.parsed_user_agent: Parsed user agent, network.http.user_agent: cs-user-agent	network.http.parsed_user_agent est dérivé de l'analyse du champ cs-user-agent à l'aide du filtre "parseduseragent".
cs-username	principal.user.userid: cs-username	Directement mappé à partir du champ JSON correspondant
date	metadata.event_timestamp.seconds : secondes Epoch à partir des champs de date et d'heure, metadata.event_timestamp.nanos : 0	La date et l'heure sont combinées et converties en secondes et nanosecondes epoch. Les nanosecondes sont définies sur 0.
appareil	intermediary.hostname: device	Mappé directement à partir du champ CEF correspondant
dst	target.ip[]: dst	Mappé directement à partir du champ CEF correspondant
dst_country	target.location.country_or_region: dst_country	Mappé directement à partir du champ grokké correspondant
dst_ip	target.asset.ip[]: dst_ip, target.ip[]: dst_ip	Mappé directement à partir du champ grokké correspondant
dst_location	target.location.city: dst_location	Mappé directement à partir du champ grokké correspondant
dst_region	target.location.state: dst_region	Mappé directement à partir du champ grokké correspondant
dst_zip	Non mappé	Ce champ n'est pas mappé sur l'UDM
duser	target.user.email_addresses[]: duser, target.user.user_display_name: duser	Mappé directement à partir du champ CEF correspondant
dvchost	about.hostname: dvchost, target.asset.hostname[]: dvchost, target.hostname: dvchost	Mappé directement à partir du champ CEF correspondant
event_timestamp	metadata.event_timestamp.seconds: event_timestamp	Mappé directement à partir du champ grokké correspondant
nom d'hôte	target.asset.hostname[]: hostname, target.hostname: hostname	Mappé directement à partir du champ CEF correspondant
ID de l'incident	security_result.detection_fields[].key: "IncidentID", security_result.detection_fields[].value: IncidentID	Mappé directement à partir du champ CEF correspondant
intermédiaire	intermediary: intermediary	Mappé directement à partir du champ CEF correspondant
md5	target.file.md5: md5	Mappé directement à partir du champ CEF correspondant
message	Différents champs UDM	Le champ de message est analysé en fonction de sa teneur en "CEF". Si c'est le cas, il est traité comme un journal CEF. Sinon, il est analysé sous forme de chaîne délimitée par des espaces ou au format JSON.
mwDetectionEngine	additional.fields[].key: "mwDetectionEngine", additional.fields[].value.string_value: mwDetectionEngine	Mappé directement à partir du champ CEF correspondant
mwType	metadata.description: mwType	Mappé directement à partir du champ CEF correspondant
os	principal.platform : valeur dérivée	La plate-forme est dérivée du champ "os" : "Windows" correspond à WINDOWS, "MAC" correspond à MAC et "LINUX" correspond à LINUX.
dans	network.http.referral_url: page	Mappé directement à partir du champ CEF correspondant
URL de provenance	network.http.referral_url: referer	Mappé directement à partir du champ CEF correspondant
requestClientApplication	network.http.parsed_user_agent : user-agent analysé, network.http.user_agent : requestClientApplication	network.http.parsed_user_agent est dérivé de l'analyse du champ requestClientApplication à l'aide du filtre "parseduseragent".
request_method	network.http.method: request_method	Mappé directement à partir du champ grokké correspondant
rs-status	additional.fields[].key: "rs-status", additional.fields[].value.string_value: rs-status, network.http.response_code: rs-status	Directement mappé à partir du champ JSON correspondant
s-ip	target.asset.ip[]: s-ip, target.ip[]: s-ip	Mappé directement à partir du champ JSON correspondant
sc-bytes	network.received_bytes: sc-bytes	Mappé directement à partir du champ JSON correspondant
sc-content-type	additional.fields[].key: "sc-content-type", additional.fields[].value.string_value: sc-content-type	Directement mappé à partir du champ JSON correspondant
sc-status	network.http.response_code: sc-status	Directement mappé à partir du champ JSON correspondant
serverBytes	network.received_bytes: serverBytes	Mappé directement à partir du champ CEF correspondant
sha256	target.file.sha256: sha256	Mappé directement à partir du champ CEF correspondant
src	principal.ip[]: src	Mappé directement à partir du champ CEF correspondant
src_country	principal.location.country_or_region: src_country	Mappé directement à partir du champ grokké correspondant
src_ip	principal.asset.ip[]: src_ip, principal.ip[]: src_ip	Mappé directement à partir du champ grokké correspondant
src_location	principal.location.city: src_location	Mappé directement à partir du champ grokké correspondant
src_region	principal.location.state: src_region	Mappé directement à partir du champ grokké correspondant
src_latitude	Non mappé	Ce champ n'est pas mappé sur l'UDM
src_longitude	Non mappé	Ce champ n'est pas mappé sur l'UDM
src_zip	Non mappé	Ce champ n'est pas mappé sur l'UDM
suser	principal.user.user_display_name: suser	Mappé directement à partir du champ CEF correspondant
target_host	target.asset.hostname[]: target_host, target.hostname: target_host	Mappé directement à partir du champ grokké correspondant
heure	metadata.event_timestamp.seconds : secondes Epoch à partir des champs de date et d'heure, metadata.event_timestamp.nanos : 0	La date et l'heure sont combinées et converties en secondes et nanosecondes epoch. Les nanosecondes sont définies sur 0.
code temporel	metadata.event_timestamp.seconds: code temporel	Mappé directement à partir du champ CEF correspondant
ts	metadata.event_timestamp.seconds : secondes Epoch à partir de ts, metadata.event_timestamp.nanos : 0	Le code temporel est converti en secondes et nanosecondes d'epoch. Les nanosecondes sont définies sur 0.
url	target.url : url	Mappé directement à partir du champ CEF correspondant
user_agent	network.http.parsed_user_agent: Parsed user agent, network.http.user_agent: user_agent	network.http.parsed_user_agent est dérivé de l'analyse du champ user_agent à l'aide du filtre "parseduseragent"
user_key	principal.user.email_addresses[]: user_key	Mappé directement à partir du champ grokké correspondant
version	Non mappé	Ce champ n'est pas mappé sur l'UDM
x-c-browser	additional.fields[].key: "x-c-browser", additional.fields[].value.string_value: x-c-browser	Mappé directement à partir du champ JSON correspondant
x-c-browser-version	additional.fields[].key: "x-c-browser-version", additional.fields[].value.string_value: x-c-browser-version	Directement mappé à partir du champ JSON correspondant
x-c-country	principal.location.country_or_region: x-c-country	Directement mappé à partir du champ JSON correspondant
x-c-device	additional.fields[].key: "x-c-device", additional.fields[].value.string_value: x-c-device	Directement mappé à partir du champ JSON correspondant
x-c-latitude	principal.location.region_coordinates.latitude: x-c-latitude	Directement mappé à partir du champ JSON correspondant
x-c-local-time	security_result.detection_fields[].key: "x-c-local-time", security_result.detection_fields[].value: x-c-local-time	Directement mappé à partir du champ JSON correspondant
x-c-location	principal.location.name: x-c-location	Directement mappé à partir du champ JSON correspondant
x-c-longitude	principal.location.region_coordinates.longitude: x-c-longitude	Mappé directement à partir du champ JSON correspondant
x-c-os	principal.platform : valeur dérivée	La plate-forme est dérivée du champ x-c-os : "Windows" correspond à WINDOWS, "MAC" correspond à MAC et "LINUX" correspond à LINUX.
x-c-region	principal.location.state: x-c-region	Mappé directement à partir du champ JSON correspondant
x-c-zipcode	additional.fields[].key: "x-c-zipcode", additional.fields[].value.string_value: x-c-zipcode	Mappé directement à partir du champ JSON correspondant
x-category	additional.fields[].key: "x-category", additional.fields[].value.string_value: x-category	Directement mappé à partir du champ JSON correspondant
x-category-id	additional.fields[].key: "x-category-id", additional.fields[].value.string_value: x-category-id	Directement mappé à partir du champ JSON correspondant
x-cs-access-method	additional.fields[].key: "accessMethod", additional.fields[].value.string_value: x-cs-access-method	Directement mappé à partir du champ JSON correspondant
x-cs-app	principal.application: x-cs-app, additional.fields[].key: "x-cs-app", additional.fields[].value.string_value: x-cs-app	Directement mappé à partir du champ JSON correspondant
x-cs-app-activity	additional.fields[].key: "x-cs-app-activity", additional.fields[].value.string_value: x-cs-app-activity	Directement mappé à partir du champ JSON correspondant
x-cs-app-category	additional.fields[].key: "x-cs-app-category", additional.fields[].value.string_value: x-cs-app-category	Mappé directement à partir du champ JSON correspondant
x-cs-app-cci	additional.fields[].key: "x-cs-app-cci", additional.fields[].value.string_value: x-cs-app-cci	Directement mappé à partir du champ JSON correspondant
x-cs-app-from-user	additional.fields[].key: "x-cs-app-from-user", additional.fields[].value.string_value: x-cs-app-from-user	Directement mappé à partir du champ JSON correspondant
x-cs-app-object-id	additional.fields[].key: "x-cs-app-object-id", additional.fields[].value.string_value: x-cs-app-object-id	Directement mappé à partir du champ JSON correspondant
x-cs-app-object-name	additional.fields[].key: "x-cs-app-object-name", additional.fields[].value.string_value: x-cs-app-object-name	Mappé directement à partir du champ JSON correspondant
x-cs-app-object-type	additional.fields[].key: "x-cs-app-object-type", additional.fields[].value.string_value: x-cs-app-object-type	Mappé directement à partir du champ JSON correspondant
x-cs-app-suite	additional.fields[].key: "x-cs-app-suite", additional.fields[].value.string_value: x-cs-app-suite	Directement mappé à partir du champ JSON correspondant
x-cs-app-tags	additional.fields[].key: "x-cs-app-tags", additional.fields[].value.string_value: x-cs-app-tags	Directement mappé à partir du champ JSON correspondant
x-cs-app-to-user	additional.fields[].key: "x-cs-app-to-user", additional.fields[].value.string_value: x-cs-app-to-user	Mappé directement à partir du champ JSON correspondant
x-cs-dst-ip	security_result.detection_fields[].key: "x-cs-dst-ip", security_result.detection_fields[].value: x-cs-dst-ip, target.asset.ip[]: x-cs-dst-ip, target.ip[]: x-cs-dst-ip	Directement mappé à partir du champ JSON correspondant
x-cs-dst-port	security_result.detection_fields[].key: "x-cs-dst-port", security_result.detection_fields[].value: x-cs-dst-port, target.port: x-cs-dst-port	Directement mappé à partir du champ JSON correspondant
x-cs-http-version	security_result.detection_fields[].key: "x-cs-http-version", security_result.detection_fields[].value: x-cs-http-version	Directement mappé à partir du champ JSON correspondant
x-cs-page-id	additional.fields[].key: "x-cs-page-id", additional.fields[].value.string_value: x-cs-page-id	Directement mappé à partir du champ JSON correspondant
x-cs-session-id	network.session_id: x-cs-session-id	Directement mappé à partir du champ JSON correspondant
x-cs-site	additional.fields[].key: "x-cs-site", additional.fields[].value.string_value: x-cs-site	Directement mappé à partir du champ JSON correspondant
x-cs-sni	network.tls.client.server_name: x-cs-sni	Mappé directement à partir du champ JSON correspondant
x-cs-src-ip	principal.asset.ip[]: x-cs-src-ip, principal.ip[]: x-cs-src-ip, security_result.detection_fields[].key: "x-cs-src-ip", security_result.detection_fields[].value: x-cs-src-ip	Mappé directement à partir du champ JSON correspondant
x-cs-src-ip-egress	principal.asset.ip[]: x-cs-src-ip-egress, principal.ip[]: x-cs-src-ip-egress, security_result.detection_fields[].key: "x-cs-src-ip-egress", security_result.detection_fields[].value: x-cs-src-ip-egress	Directement mappé à partir du champ JSON correspondant
x-cs-src-port	principal.port: x-cs-src-port, security_result.detection_fields[].key: "x-cs-src-port", security_result.detection_fields[].value: x-cs-src-port	Directement mappé à partir du champ JSON correspondant
x-cs-ssl-cipher	network.tls.cipher: x-cs-ssl-cipher	Directement mappé à partir du champ JSON correspondant
x-cs-ssl-fronting-error	security_result.detection_fields[].key: "x-cs-ssl-fronting-error", security_result.detection_fields[].value: x-cs-ssl-fronting-error	Directement mappé à partir du champ JSON correspondant
x-cs-ssl-handshake-error	security_result.detection_fields[].key: "x-cs-ssl-handshake-error", security_result.detection_fields[].value: x-cs-ssl-handshake-error	Directement mappé à partir du champ JSON correspondant
x-cs-ssl-ja3	network.tls.client.ja3: x-cs-ssl-ja3	Directement mappé à partir du champ JSON correspondant
x-cs-ssl-version	network.tls.version: x-cs-ssl-version	Mappé directement à partir du champ JSON correspondant
x-cs-timestamp	metadata.event_timestamp.seconds: x-cs-timestamp	Mappé directement à partir du champ JSON correspondant
x-cs-traffic-type	additional.fields[].key: "trafficType", additional.fields[].value.string_value: x-cs-traffic-type	Directement mappé à partir du champ JSON correspondant
x-cs-tunnel-src-ip	security_result.detection_fields[].key: "x-cs-tunnel-src-ip", security_result.detection_fields[].value: x-cs-tunnel-src-ip	Directement mappé à partir du champ JSON correspondant
x-cs-uri-path	additional.fields[].key: "x-cs-uri-path", additional.fields[].value.string_value: x-cs-uri-path	Directement mappé à partir du champ JSON correspondant
x-cs-url	target.url : x-cs-url	Directement mappé à partir du champ JSON correspondant
x-cs-userip	security_result.detection_fields[].key: "x-cs-userip", security_result.detection_fields[].value: x-cs-userip	Directement mappé à partir du champ JSON correspondant
x-other-category	security_result.category_details[]: x-other-category	Directement mappé à partir du champ JSON correspondant
x-other-category-id	security_result.detection_fields[].key: "x-other-category-id", security_result.detection_fields[].value: x-other-category-id	Directement mappé à partir du champ JSON correspondant
x-policy-action	security_result.action : valeur dérivée, security_result.action_details : x-policy-action	security_result.action est dérivé de la conversion de x-policy-action en majuscules. Si la valeur en majuscules est "ALLOW" ou "BLOCK", elle est utilisée directement. Sinon, il n'est pas mappé. security_result.action_details est directement mappé à partir de x-policy-action.
x-policy-dst-host	security_result.detection_fields[].key: "x-policy-dst-host", security_result.detection_fields[].value: x-policy-dst-host	Mappé directement à partir du champ JSON correspondant
x-policy-dst-host-source	security_result.detection_fields[].key: "x-policy-dst-host-source", security_result.detection_fields[].value: x-policy-dst-host-source	Mappé directement à partir du champ JSON correspondant
x-policy-dst-ip	security_result.detection_fields[].key: "x-policy-dst-ip", security_result.detection_fields[].value: x-policy-dst-ip	Directement mappé à partir du champ JSON correspondant
x-policy-name	security_result.rule_name: x-policy-name	Directement mappé à partir du champ JSON correspondant
x-policy-src-ip	security_result.detection_fields[].key: "x-policy-src-ip", security_result.detection_fields[].value: x-policy-src-ip	Mappé directement à partir du champ JSON correspondant
x-r-cert-enddate	network.tls.server.certificate.not_after.seconds : secondes depuis l'époque x-r-cert-enddate	La date est convertie en secondes depuis l'epoch.
x-r-cert-expired	additional.fields[].key: "x-r-cert-expired", additional.fields[].value.string_value: x-r-cert-expired	Directement mappé à partir du champ JSON correspondant
x-r-cert-incomplete-chain	additional.fields[].key: "x-r-cert-incomplete-chain", additional.fields[].value.string_value: x-r-cert-incomplete-chain	Directement mappé à partir du champ JSON correspondant
x-r-cert-issuer-cn	network.tls.server.certificate.issuer: x-r-cert-issuer-cn	Directement mappé à partir du champ JSON correspondant
x-r-cert-mismatch	additional.fields[].key: "x-r-cert-mismatch", additional.fields[].value.string_value: x-r-cert-mismatch	Directement mappé à partir du champ JSON correspondant
x-r-cert-revoked	additional.fields[].key: "x-r-cert-revoked", additional.fields[].value.string_value: x-r-cert-revoked	Mappé directement à partir du champ JSON correspondant
x-r-cert-self-signed	additional.fields[].key: "x-r-cert-self-signed", additional.fields[].value.string_value: x-r-cert-self-signed	Directement mappé à partir du champ JSON correspondant
x-r-cert-startdate	network.tls.server.certificate.not_before.seconds : secondes de l'époque à partir de x-r-cert-startdate	La date est convertie en secondes depuis l'epoch.
x-r-cert-subject-cn	network.tls.server.certificate.subject: x-r-cert-subject-cn	Directement mappé à partir du champ JSON correspondant
x-r-cert-untrusted-root	additional.fields[].key: "x-r-cert-untrusted-root", additional.fields[].value.string_value: x-r-cert-untrusted-root	Mappé directement à partir du champ JSON correspondant
x-r-cert-valid	additional.fields[].key: "x-r-cert-valid", additional.fields[].value.string_value: x-r-cert-valid	Mappé directement à partir du champ JSON correspondant
x-request-id	additional.fields[].key: "requestId", additional.fields[].value.string_value: x-request-id	Directement mappé à partir du champ JSON correspondant
x-rs-file-category	additional.fields[].key: "x-rs-file-category", additional.fields[].value.string_value: x-rs-file-category	Mappé directement à partir du champ JSON correspondant
x-rs-file-type	additional.fields[].key: "x-rs-file-type", additional.fields[].value.string_value: x-rs-file-type	Directement mappé à partir du champ JSON correspondant
x-s-country	target.location.country_or_region: x-s-country	Directement mappé à partir du champ JSON correspondant
x-s-dp-name	additional.fields[].key: "x-s-dp-name", additional.fields[].value.string_value: x-s-dp-name	Directement mappé à partir du champ JSON correspondant
x-s-latitude	target.location.region_coordinates.latitude: x-s-latitude	Directement mappé à partir du champ JSON correspondant
x-s-location	target.location.name: x-s-location	Directement mappé à partir du champ JSON correspondant
x-s-longitude	target.location.region_coordinates.longitude: x-s-longitude	Directement mappé à partir du champ JSON correspondant
x-s-region	target.location.state: x-s-region	Directement mappé à partir du champ JSON correspondant
x-s-zipcode	additional.fields[].key: "x-s-zipcode", additional.fields[].value.string_value: x-s-zipcode	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-cipher	security_result.detection_fields[].key: "x-sr-ssl-cipher", security_result.detection_fields[].value: x-sr-ssl-cipher	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-client-certificate-error	security_result.detection_fields[].key: "x-sr-ssl-client-certificate-error", security_result.detection_fields[].value: x-sr-ssl-client-certificate-error	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-engine-action	security_result.detection_fields[].key: "x-sr-ssl-engine-action", security_result.detection_fields[].value: x-sr-ssl-engine-action	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-engine-action-reason	security_result.detection_fields[].key: "x-sr-ssl-engine-action-reason", security_result.detection_fields[].value: x-sr-ssl-engine-action-reason	Mappé directement à partir du champ JSON correspondant
x-sr-ssl-handshake-error	security_result.detection_fields[].key: "x-sr-ssl-handshake-error", security_result.detection_fields[].value: x-sr-ssl-handshake-error	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-ja3s	network.tls.server.ja3s: x-sr-ssl-ja3s	Mappé directement à partir du champ JSON correspondant
x-sr-ssl-malformed-ssl	security_result.detection_fields[].key: "x-sr-ssl-malformed-ssl", security_result.detection_fields[].value: x-sr-ssl-malformed-ssl	Directement mappé à partir du champ JSON correspondant
x-sr-ssl-version	security_result.detection_fields[].key: "x-sr-ssl-version", security_result.detection_fields[].value: x-sr-ssl-version	Directement mappé à partir du champ JSON correspondant
x-s-custom-signing-ca-error	security_result.detection_fields[].key: "x-s-custom-signing-ca-error", security_result.detection_fields[].value: x-s-custom-signing-ca-error	Directement mappé à partir du champ JSON correspondant
x-ssl-bypass	security_result.detection_fields[].key: "SSL BYPASS", security_result.detection_fields[].value: x-ssl-bypass ou x-ssl-bypass-reason	Si x-ssl-bypass est défini sur "Yes" et que x-ssl-bypass-reason est présent, la valeur de x-ssl-bypass-reason est utilisée. Sinon, la valeur de x-ssl-bypass est utilisée.
x-ssl-policy-action	security_result.detection_fields[].key: "x-ssl-policy-action", security_result.detection_fields[].value: x-ssl-policy-action	Directement mappé à partir du champ JSON correspondant
x-ssl-policy-categories	security_result.category_details[]: x-ssl-policy-categories	Mappé directement à partir du champ JSON correspondant
x-ssl-policy-dst-host	security_result.detection_fields[].key: "x-ssl-policy-dst-host", security_result.detection_fields[].value: x-ssl-policy-dst-host	Directement mappé à partir du champ JSON correspondant
x-ssl-policy-dst-host-source	security_result.detection_fields[].key: "x-ssl-policy-dst-host-source", security_result.detection_fields[].value: x-ssl-policy-dst-host-source	Mappé directement à partir du champ JSON correspondant
x-ssl-policy-dst-ip	security_result.detection_fields[].key: "x-ssl-policy-dst-ip", security_result.detection_fields[].value: x-ssl-policy-dst-ip	Mappé directement à partir du champ JSON correspondant
x-ssl-policy-name	security_result.rule_name: x-ssl-policy-name	Directement mappé à partir du champ JSON correspondant
x-ssl-policy-src-ip	security_result.detection_fields[].key: "x-ssl-policy-src-ip", security_result.detection_fields[].value: x-ssl-policy-src-ip	Mappé directement à partir du champ JSON correspondant
x-sr-dst-ip	security_result.detection_fields[].key: "x-sr-dst-ip", security_result.detection_fields[].value: x-sr-dst-ip	Directement mappé à partir du champ JSON correspondant
x-sr-dst-port	security_result.detection_fields[].key: "x-sr-dst-port", security_result.detection_fields[].value: x-sr-dst-port	Directement mappé à partir du champ JSON correspondant
x-type	additional.fields[].key: "xType", additional.fields[].value.string_value: x-type	Directement mappé à partir du champ JSON correspondant
x-transaction-id	additional.fields[].key: "transactionId", additional.fields[].value.string_value: x-transaction-id	Directement mappé à partir du champ JSON correspondant
	metadata.vendor_name	Définissez la valeur sur "Netskope".
	metadata.product_name	Définissez la valeur sur "Netskope Webproxy" si elle n'est pas déjà définie.
	metadata.log_type	Définissez cette option sur "NETSKOPE_WEBPROXY".

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.