Collecter les journaux Tenable Vulnerability Management

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer les journaux Tenable Vulnerability Management (anciennement Tenable.io) dans Google Security Operations. Il décrit deux méthodes d'ingestion : un pipeline Cloud Storage qui extrait les données de l'API d'exportation Tenable et un flux de données Tenable qui envoie les données vers un bucket Amazon S3. Choisissez la méthode qui correspond à votre environnement.

Tenable Vulnerability Management (anciennement Tenable.io) est une plate-forme cloud de gestion des failles basée sur la technologie Nessus. Elle offre une couverture complète des failles et permet de prédire les problèmes de sécurité à corriger en priorité.

L'analyseur extrait les résultats de vulnérabilité et d'éléments à partir des journaux JSON Tenable et mappe les champs à l'UDM, en gérant les indicateurs de domaine, IPv4 et IPv6, la gravité et les attributs des éléments.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Accès privilégié à la console Tenable Vulnerability Management (rôle Administrateur)
• Pour la méthode 1 (Google Cloud Storage) : un projet Google Cloud avec la facturation activée et les autorisations nécessaires pour créer des buckets Cloud Storage, des comptes de service, des thèmes Pub/Sub, des fonctions Cloud Run et des jobs Cloud Scheduler
• Pour la méthode 2 (Amazon S3) : un compte AWS disposant des autorisations nécessaires pour créer des buckets S3, ainsi que des rôles et des utilisateurs IAM (Identity and Access Management)

Sélectionnez l'une des méthodes suivantes :

• Méthode 1 : Google Cloud Storage Une fonction Cloud Run extrait les données sur les failles et les assets de l'API d'exportation Tenable et les écrit dans un bucket Cloud Storage. Utilisez cette méthode pour que le pipeline reste entièrement sur Google Cloud.
• Méthode 2 : Amazon S3 Tenable Data Stream envoie en continu vos données Tenable vers un bucket Amazon S3. Utilisez cette méthode si vous préférez l'intégration push Tenable intégrée. Tenable Data Stream n'est compatible qu'avec Amazon S3.

Méthode 1 : Google Cloud Storage

Cette méthode utilise une fonction Cloud Run, déclenchée par Cloud Scheduler via Pub/Sub, pour extraire les données sur les failles et les assets de l'API d'exportation Tenable Vulnerability Management et les écrire dans un bucket Cloud Storage. Google SecOps ingère ensuite les données du bucket.

Collecter les identifiants de l'API Tenable Vulnerability Management

1. Connectez-vous à Tenable Vulnerability Management sur https://cloud.tenable.com.
2. En haut à droite, cliquez sur l'icône de votre profil utilisateur, puis sélectionnez Mon compte.
3. Cliquez sur Clés API.
4. Cliquez sur Générer.

5. Copiez et enregistrez la clé d'accès et la clé secrète.

   Remarque : Les clés ne sont affichées qu'une seule fois. La génération de nouvelles clés invalide les clés existantes. Utilisez un utilisateur d'intégration dédié disposant au moins du rôle Basique.

Créer un bucket Google Cloud Storage

1. Dans la console Google Cloud, accédez à Cloud Storage > Buckets.
2. Cliquez sur Créer.
3. Fournissez les informations de configuration suivantes :
   • Nom : saisissez un nom unique (par exemple, tenable-vulnerability-logs).
   • Type d'emplacement : sélectionnez un emplacement.
   • Classe de stockage : sélectionnez Standard.
4. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

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 tenable-collector-sa.
   • Description du compte de service : saisissez Service account for the Tenable export collector.
4. Cliquez sur Créer et continuer.
5. Cliquez sur OK.

Accorder au compte de service l'accès au bucket

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre bucket (par exemple, tenable-vulnerability-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, tenable-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

1. Dans la console Google Cloud, accédez à Pub/Sub > Sujets.
2. Cliquez sur Créer un sujet.
3. Saisissez un ID de sujet (par exemple, tenable-collector-trigger).
4. Cliquez sur Créer.

Créer la fonction Cloud Run pour collecter les journaux

La fonction Cloud Run est déclenchée par les messages Pub/Sub de Cloud Scheduler. Il s'authentifie auprès de l'API d'exportation Tenable avec vos clés API, exécute les exportations de failles et d'assets, et écrit chaque bloc d'exportation dans le bucket au format JSON.

1. Dans la console Google Cloud, accédez à Cloud Run.
2. Cliquez sur Créer un service.
3. Sélectionnez Fonction pour utiliser l'éditeur de code intégré.
4. Fournissez les informations de configuration suivantes :
   • Nom du service : saisissez tenable-collector.
   • Région : sélectionnez la région correspondant à votre bucket (par exemple, us-central1).
   • Environnement d'exécution : sélectionnez Python 3.12 ou version ultérieure.
5. Dans la section Déclencheur :
   1. Cliquez sur Ajouter un déclencheur.
   2. Sélectionnez Cloud Pub/Sub.
   3. Dans Sélectionner un sujet Cloud Pub/Sub, sélectionnez tenable-collector-trigger.
   4. Cliquez sur Enregistrer.
6. Dans la section Authentification, sélectionnez Exiger l'authentification.
7. Développez Conteneurs, mise en réseau, sécurité, puis dans l'onglet Sécurité, définissez Compte de service sur tenable-collector-sa.

8. Dans l'onglet Conteneurs > Variables et secrets, ajoutez les variables d'environnement suivantes :

   Nom de la variable	Exemple de valeur
   TIO_ACCESS_KEY	your-tenable-access-key
   TIO_SECRET_KEY	your-tenable-secret-key
   GCS_BUCKET	tenable-vulnerability-logs
   GCS_PREFIX	tenable/
   NUM_ASSETS	1000
   ASSET_CHUNK_SIZE	1000
   SEVERITIES	low,medium,high,critical
   HTTP_TIMEOUT	120

   Remarque : Utilisez la clé d'accès et la clé secrète de la section Collecter les identifiants de l'API Tenable Vulnerability Management. Pour la production, stockez les clés dans Secret Manager et référencez-les en tant que secrets plutôt qu'en tant que variables d'environnement en texte brut.

9. Définissez le délai avant expiration de la requête sur 600 secondes et la mémoire sur 512 Mio ou plus.

10. Cliquez sur Créer. Une fois le service créé, l'éditeur de code intégré s'ouvre.

Ajouter le code de la fonction

1. Dans le champ Point d'entrée de la fonction, saisissez main.

2. Dans l'éditeur de code intégré, remplacez le contenu de requirements.txt par ce qui suit :

   functions-framework==3.*
   google-cloud-storage==2.*
   requests==2.*
   

3. Remplacez le contenu de main.py par le code suivant :

   import json
   import os
   import time
   
   import functions_framework
   import requests
   from google.cloud import storage
   
   BASE = "https://cloud.tenable.com"
   ACCESS_KEY = os.environ["TIO_ACCESS_KEY"]
   SECRET_KEY = os.environ["TIO_SECRET_KEY"]
   GCS_BUCKET = os.environ["GCS_BUCKET"]
   GCS_PREFIX = os.environ.get("GCS_PREFIX", "tenable/")
   NUM_ASSETS = int(os.environ.get("NUM_ASSETS", "1000"))
   ASSET_CHUNK_SIZE = int(os.environ.get("ASSET_CHUNK_SIZE", "1000"))
   SEVERITIES = [s for s in os.environ.get("SEVERITIES", "low,medium,high,critical").split(",") if s]
   HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "120"))
   
   HEADERS = {
       "X-ApiKeys": f"accessKey={ACCESS_KEY};secretKey={SECRET_KEY}",
       "Content-Type": "application/json",
       "Accept": "application/json",
   }
   
   storage_client = storage.Client()
   
   def _request(method, path, **kwargs):
       """Call the Tenable API, honoring HTTP 429 Retry-After. Do not multi-thread."""
       while True:
           resp = requests.request(method, f"{BASE}{path}", headers=HEADERS, timeout=HTTP_TIMEOUT, **kwargs)
           if resp.status_code == 429:
               time.sleep(int(resp.headers.get("Retry-After", "30")))
               continue
           resp.raise_for_status()
           return resp
   
   def _write_chunk(bucket, name, payload):
       """Write one export chunk (a JSON array) to the bucket."""
       blob = bucket.blob(f"{GCS_PREFIX}{name}")
       blob.upload_from_string(json.dumps(payload), content_type="application/json")
   
   def _run_export(bucket, label, request_path, status_kind, body):
       """Request an export, poll until FINISHED, and write each chunk to the bucket."""
       export_uuid = _request("POST", request_path, json=body).json()["export_uuid"]
       written = set()
       while True:
           status = _request("GET", f"/{status_kind}/export/{export_uuid}/status").json()
           for chunk_id in status.get("chunks_available", []):
               if chunk_id in written:
                   continue
               chunk = _request("GET", f"/{status_kind}/export/{export_uuid}/chunks/{chunk_id}").json()
               _write_chunk(bucket, f"{label}_{export_uuid}_{chunk_id}.json", chunk)
               written.add(chunk_id)
           state = status.get("status")
           if state == "FINISHED":
               break
           if state in ("ERROR", "CANCELLED"):
               raise RuntimeError(f"{label} export {export_uuid} ended as {state}")
           time.sleep(15)
       print(f"{label}: wrote {len(written)} chunk(s) for export {export_uuid}")
   
   @functions_framework.cloud_event
   def main(cloud_event):
       bucket = storage_client.bucket(GCS_BUCKET)
       # Vulnerabilities: request path and status/chunk paths both use /vulns/export; body uses num_assets.
       _run_export(
           bucket, "vulns", "/vulns/export", "vulns",
           {"num_assets": NUM_ASSETS, "include_unlicensed": False, "filters": {"severity": SEVERITIES}},
       )
       # Assets: request path is /assets/v2/export (body uses chunk_size); status/chunk paths drop the v2.
       _run_export(
           bucket, "assets", "/assets/v2/export", "assets",
           {"chunk_size": ASSET_CHUNK_SIZE},
       )
       return "ok"
   

4. Cliquez sur Enregistrer et déployer.

Créer une tâche Cloud Scheduler

1. Dans la console Google Cloud, accédez à Cloud Scheduler.
2. Cliquez sur Créer une tâche.
3. Fournissez les informations de configuration suivantes :
   • Nom : saisissez tenable-collector-schedule.
   • Région : sélectionnez la même région que la fonction Cloud Run.
   • Fréquence : saisissez une programmation Cron (par exemple, 0 */6 * * * pour une exécution toutes les six heures).
   • Fuseau horaire : sélectionnez votre fuseau horaire.
4. Dans Type de cible, sélectionnez Pub/Sub.
5. Sélectionnez le sujet tenable-collector-trigger.
6. Dans le champ Corps du message, saisissez run.
7. Cliquez sur Créer.

Configurer un flux dans Google SecOps pour ingérer des données depuis Google Cloud Storage

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Ajouter un flux.
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Tenable Vulnerability Management GCS).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez tenable.io comme type de journal.
7. Cliquez sur Obtenir un compte de service. Copiez l'adresse e-mail du compte de service affichée.
8. Cliquez sur Suivant.
9. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI du bucket de stockage : saisissez l'URI du bucket, y compris le préfixe (par exemple, gs://tenable-vulnerability-logs/tenable/).
   • Option 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 des derniers jours. La valeur par défaut est de 180 jours.
10. Cliquez sur Suivant, vérifiez la configuration, puis cliquez sur Envoyer.

Accorder au compte de service Google SecOps l'accès au bucket

1. Accédez à Cloud Storage > Buckets, puis cliquez sur le nom de votre bucket.
2. Accédez à l'onglet Autorisations, puis cliquez sur Accorder l'accès.
3. Dans Ajouter des comptes principaux, saisissez l'adresse e-mail du compte de service que vous avez copiée à partir du flux.
4. Attribuez le rôle Lecteur des objets Storage (ou Administrateur des objets Storage si vous avez sélectionné une option de suppression de la source).
5. Cliquez sur Enregistrer.

Méthode 2 : Amazon S3

Cette méthode utilise Tenable Data Stream pour transférer en continu vos données Tenable vers un bucket Amazon S3 au format JSON. Google SecOps ingère ensuite les données du bucket. Tenable Data Stream n'est compatible qu'avec Amazon S3 et s'authentifie auprès de votre compte AWS à l'aide d'un rôle IAM que Tenable assume (relation d'approbation inter-comptes avec un ID externe).

Créer un bucket Amazon S3

1. Créez un bucket Amazon S3 en suivant le guide AWS : Créer un bucket.
2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, tenable-vm-logs).

Créer un rôle IAM pour le flux de données Tenable

Tenable assume ce rôle pour écrire des données dans votre bucket. Tenable fournit la stratégie de confiance et la stratégie de bucket exactes dans la console, y compris le compte AWS Tenable et un ID externe généré.

1. Dans Tenable Vulnerability Management, accédez à Settings > Tenable Data Stream, puis cliquez sur Add an Integration (Ajouter une intégration). Laissez cette boîte de dialogue ouverte pour copier la stratégie d'approbation et l'ID externe lors d'une étape ultérieure.
2. Dans la console AWS, accédez à IAM > Rôles > Créer un rôle.

3. Sélectionnez Stratégie de confiance personnalisée, puis collez la stratégie de confiance à partir du panneau Consignes concernant les rôles IAM de Tenable (cliquez sur Copier la stratégie de confiance). La forme de la règle de confiance est la suivante :

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": { "AWS": "arn:aws:iam::<TENABLE_AWS_ACCOUNT_ID>:root" },
               "Action": "sts:AssumeRole",
               "Condition": { "StringEquals": { "sts:ExternalId": "<TENABLE_EXTERNAL_ID>" } }
           }
       ]
   }
   

4. Cliquez sur Suivant, puis créez et associez une règle qui accorde à Tenable l'accès en écriture au bucket (remplacez tenable-vm-logs par le nom de votre bucket) :

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": ["s3:PutObject", "s3:GetBucketLocation", "s3:ListBucket"],
               "Resource": [
                   "arn:aws:s3:::tenable-vm-logs",
                   "arn:aws:s3:::tenable-vm-logs/*"
               ]
           }
       ]
   }
   

   Remarque : Si le bucket utilise le chiffrement SSE-KMS, accordez également le rôle kms:GenerateDataKey sur la clé KMS.

5. Saisissez un nom de rôle (par exemple, TenableDataStreamRole), puis cliquez sur Créer un rôle. Enregistrez le nom du rôle et votre ID de compte AWS.

Configurer le flux de données Tenable

1. Revenez à la boîte de dialogue Add an Integration (Ajouter une intégration) dans Tenable Vulnerability Management (Settings > Tenable Data Stream).
2. Fournissez les informations de configuration suivantes :
   • Nom de l'intégration : saisissez un nom descriptif (par exemple, Google SecOps Integration).
   • Type d'intégration : sélectionnez AWS S3 (la seule option disponible).
   • Données d'intégration : sélectionnez les types de données à diffuser (par exemple, Composants, Failles et Audit de l'hôte).
   • Notification par e-mail (facultatif) : saisissez une adresse e-mail pour être averti si l'état du flux change.
3. Cliquez sur Suivant et fournissez les informations sur le rôle IAM :
   • ID de compte AWS : saisissez l'ID de votre compte AWS.
   • Nom du rôle IAM : saisissez le rôle que vous avez créé (par exemple, TenableDataStreamRole).
   • ID externe : utilisez l'ID externe affiché par Tenable dans cette boîte de dialogue (la même valeur que celle référencée dans la règle de confiance).
4. Cliquez sur Suivant et fournissez les détails du bucket :
   • Nom du bucket S3 : saisissez le nom de votre bucket (par exemple, tenable-vm-logs).
   • Préfixe du chemin d'accès : saisissez un préfixe pour organiser les fichiers (par exemple, tenable/).

5. Cliquez sur Enregistrer. Tenable écrit en continu des données JSON dans votre bucket.

   Remarque : Après la configuration, ne supprimez pas le rôle, ne modifiez pas sa relation de confiance et ne supprimez pas les autorisations du bucket, car ce sont les causes les plus courantes d'échec du flux.

Créer un utilisateur IAM pour que Google SecOps puisse lire le bucket

Google SecOps lit le bucket à l'aide d'un utilisateur IAM en lecture seule distinct (cette identité est indépendante du rôle utilisé par Tenable pour écrire).

1. Dans la console AWS, accédez à IAM > Utilisateurs > Créer un utilisateur.
2. Saisissez un nom d'utilisateur (par exemple, secops-tenable-reader), puis cliquez sur Suivant.
3. Cliquez sur Suivant, puis sur Créer un utilisateur.

4. Sélectionnez l'utilisateur, accédez à l'onglet Autorisations, puis cliquez sur Ajouter des autorisations > Créer une règle intégrée > JSON. Collez la règle en lecture seule suivante (remplacez tenable-vm-logs par le nom de votre bucket) :

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": ["s3:GetObject", "s3:ListBucket", "s3:GetBucketLocation"],
               "Resource": [
                   "arn:aws:s3:::tenable-vm-logs",
                   "arn:aws:s3:::tenable-vm-logs/*"
               ]
           }
       ]
   }
   

   Remarque : Si vous sélectionnez une option de suppression de la source dans le flux, accordez également s3:DeleteObject sur arn:aws:s3:::tenable-vm-logs/*.

5. Accédez à l'onglet Identifiants de sécurité, puis cliquez sur Créer une clé d'accès.

6. Sélectionnez le cas d'utilisation Service tiers, cliquez sur Suivant, puis sur Créer une clé d'accès.

7. Copiez et enregistrez la clé d'accès et la clé d'accès secrète.

Configurer un flux dans Google SecOps pour ingérer des données depuis Amazon S3

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Ajouter un flux.
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Tenable Vulnerability Management S3).
5. Sélectionnez Amazon S3 V2 comme Type de source.
6. Sélectionnez tenable.io comme type de journal.
7. Cliquez sur Suivant.
8. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : saisissez l'URI du bucket, y compris le préfixe (par exemple, s3://tenable-vm-logs/tenable/).
   • Option 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 des derniers jours. La valeur par défaut est de 180 jours.
   • ID de clé d'accès : saisissez la clé d'accès de l'utilisateur IAM en lecture seule.
   • Clé d'accès secrète : saisissez la clé secrète de l'utilisateur IAM en lecture seule.
9. Cliquez sur Suivant, vérifiez la configuration, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
payload.path	about.file.full_path	Mappé directement
payload.md5	about.file.md5	Mappé directement
asset.uuid	entity.asset.asset_id	Mappé directement
id	entity.asset.asset_id	Mappé directement
payload_id	entity.asset.asset_id	Mappé directement
ssh_fingerprints.0	entity.asset.attribute.labels.value	Mappé directement
system_types.0	entity.asset.attribute.labels.value	Mappé directement
asset.hostname	entity.asset.hostname	Mappé directement
asset.last_scan_target	entity.asset.hostname	Mappé directement
host	entity.asset.hostname	Mappé directement
scan.target	entity.asset.hostname	Mappé directement
asset.ipv4	entity.asset.ip	Fusionné
ip	entity.asset.ip	Fusionné
ipaddr	entity.asset.ip	Fusionné
prinIP	entity.asset.ip	Fusionné
scan_ipaddr	entity.asset.ip	Fusionné
updateIndex	entity.asset.ip	Mappé : 0 → update_ipv4_0
update_ipv4_0	entity.asset.ip	Fusionné
asset.mac_address	entity.asset.mac	Fusionné
mac	entity.asset.mac	Fusionné
fqdns.0	entity.asset.network_domain	Mappé directement
netbios_names.0	entity.asset.network_domain	Mappé directement
os_family	entity.asset.platform_software.platform	Mappé directement
asset.operating_system.0	entity.asset.platform_software.platform_version	Mappé directement
asset.uuid	entity.asset.product_object_id	Mappé directement
id	entity.asset.product_object_id	Mappé directement
payload_id	entity.asset.product_object_id	Mappé directement
vuln.vulnerabilities	entity.asset.vulnerabilities	Fusionné
vuln1.vulnerabilities	entity.asset.vulnerabilities	Fusionné
vuln2.vulnerabilities	entity.asset.vulnerabilities	Fusionné
asset.device_type	metadata.description	Mappé directement
plugin.description	metadata.description	Mappé directement
has_entity_asset	metadata.entity_type	Mappé : true → ASSET
first_found	metadata.event_timestamp	Analysé en tant que ISO8601
last_found	metadata.event_timestamp	Analysé en tant que ISO8601
scan.completed_at	metadata.event_timestamp	Analysé en tant que ISO8601
scan.started_at	metadata.event_timestamp	Analysé en tant que ISO8601
has_entity_asset	metadata.product_name	Mappé : true → Tenable IO
has_entity_asset	metadata.vendor_name	Mappé : true → Tenable IO
port.protocol	network.ip_protocol	Mappé directement
asset.network_id	network.session_id	Mappé directement
sec_res.description	security_result.description	Mappé directement
asset_agent_uuid_label	security_result.detection_fields	Fusionné
asset_bios_uuid_label	security_result.detection_fields	Fusionné
asset_netbios_name_label	security_result.detection_fields	Fusionné
finding_id_label	security_result.detection_fields	Fusionné
plugin_family_id_label	security_result.detection_fields	Fusionné
plugin_family_label	security_result.detection_fields	Fusionné
plugin_risk_factor_label	security_result.detection_fields	Fusionné
plugin_xrefs_label	security_result.detection_fields	Fusionné
risk_factor_label	security_result.detection_fields	Fusionné
scan_label	security_result.detection_fields	Fusionné
scan_schedule_uuid_label	security_result.detection_fields	Fusionné
scan_started_at_label	security_result.detection_fields	Fusionné
scan_uuid_label	security_result.detection_fields	Fusionné
see_also_label	security_result.detection_fields	Fusionné
severity_default_id_label	security_result.detection_fields	Fusionné
severity_id_label	security_result.detection_fields	Fusionné
severity_label	security_result.detection_fields	Fusionné
severity_modification_type_label	security_result.detection_fields	Fusionné
update_finding_id_label	security_result.detection_fields	Fusionné
update_first_scan_time_label	security_result.detection_fields	Fusionné
update_last_licensed_scan_date_label	security_result.detection_fields	Fusionné
update_last_scan_id_label	security_result.detection_fields	Fusionné
update_last_scan_time_label	security_result.detection_fields	Fusionné
update_last_schedule_id_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_access_complexity_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_access_vector_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_authentication_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_availability_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_confidentiality_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_integrity_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_privileges_required_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_raw_label	security_result.detection_fields	Fusionné
update_plugin_cvss3_vector_user_interaction_label	security_result.detection_fields	Fusionné
update_plugin_cvss_base_score_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_access_complexity_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_access_vector_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_authentication_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_availability_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_confidentiality_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_integrity_impact_label	security_result.detection_fields	Fusionné
update_plugin_cvss_vector_raw_label	security_result.detection_fields	Fusionné
update_plugin_see_also_label	security_result.detection_fields	Fusionné
update_plugin_stig_severity_label	security_result.detection_fields	Fusionné
update_plugin_vpr_driver_cvss3_impact_score_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_age_of_vuln_lower_bound_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_age_of_vuln_upper_bound_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_cvss_impact_score_predicted_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_exploit_code_maturity_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_product_coverage_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_threat_intensity_last28_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_threat_recency_lower_bound_label	security_result.detection_fields	Fusionné
update_plugin_vpr_drivers_threat_recency_upper_bound_label	security_result.detection_fields	Fusionné
update_plugin_vpr_score_label	security_result.detection_fields	Fusionné
update_plugin_vpr_updated_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_cve_id_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_exploit_code_maturity_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_in_the_news_intensity_last30_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_in_the_news_recency_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_malware_observations_intensity_last30_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_malware_observations_recency_label	security_result.detection_fields	Fusionné
update_plugin_vpr_v2_on_cisa_kev_label	security_result.detection_fields	Fusionné
update_plugin_vuln_publication_date_label	security_result.detection_fields	Fusionné
update_plugin_xrefs_id_type_label	security_result.detection_fields	Fusionné
update_plugin_xrefs_type_label	security_result.detection_fields	Fusionné
update_scan_started_at_label	security_result.detection_fields	Fusionné
update_severity_default_id_label	security_result.detection_fields	Fusionné
update_severity_id_label	security_result.detection_fields	Fusionné
update_severity_modification_type_label	security_result.detection_fields	Fusionné
updates_asset_netbios_name_label	security_result.detection_fields	Fusionné
updates_plugin_vpr_v2_exploit_probability_label	security_result.detection_fields	Fusionné
updates_plugin_vpr_v2_label	security_result.detection_fields	Fusionné
updates_plugin_vpr_v2_percentile_label	security_result.detection_fields	Fusionné
updates_plugin_vpr_v2_vpr_severity_label	security_result.detection_fields	Fusionné
version_label	security_result.detection_fields	Fusionné
xref_label	security_result.detection_fields	Fusionné
severity	security_result.severity	Mappé directement
N/A	entity.asset.attribute.labels.key	Constante : ssh_fingerprints
N/A	metadata.entity_type	Constante : ASSET
N/A	metadata.product_name	Constante : Tenable IO
N/A	metadata.vendor_name	Constante : Tenable IO
N/A	security_result.severity	Constante : CRITICAL

Journal des modifications

Afficher le journal des modifications pour ce parseur

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