Raccogliere i log di Tenable Vulnerability Management

Supportato in:

Google SecOps SIEM

Questo documento spiega come importare i log di Tenable Vulnerability Management (in precedenza Tenable.io) in Google Security Operations. Descrive due metodi di importazione: una pipeline Cloud Storage che estrae i dati dall'API di esportazione di Tenable e un flusso di dati Tenable che invia i dati a un bucket Amazon S3. Scegli il metodo che corrisponde al tuo ambiente.

Tenable Vulnerability Management (in precedenza Tenable.io) è una piattaforma di gestione delle vulnerabilità basata sul cloud e basata sulla tecnologia Nessus che offre una copertura completa delle vulnerabilità con la possibilità di prevedere quali problemi di sicurezza correggere per primi.

Il parser estrae i risultati relativi a vulnerabilità e asset dai log JSON di Tenable e mappa i campi all'UDM, gestendo indicatori di dominio, IPv4 e IPv6, gravità e attributi degli asset.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Accesso privilegiato alla console Tenable Vulnerability Management (ruolo Amministratore)
• Per il metodo 1 (Google Cloud Storage): un progetto Google Cloud con fatturazione abilitata e autorizzazioni per creare bucket Cloud Storage, service account, argomenti Pub/Sub, funzioni Cloud Run e job Cloud Scheduler
• Per il metodo 2 (Amazon S3): un account AWS con autorizzazioni per creare bucket S3 e ruoli e utenti Identity and Access Management (IAM)

Scegli uno dei seguenti metodi:

• Metodo 1: Google Cloud Storage. Una funzione Cloud Run estrae i dati sulle vulnerabilità e sugli asset dall'API di esportazione di Tenable e li scrive in un bucket Cloud Storage. Utilizza questo metodo per mantenere la pipeline interamente su Google Cloud.
• Metodo 2: Amazon S3. Tenable Data Stream invia continuamente i tuoi dati Tenable a un bucket Amazon S3. Utilizza questo metodo se preferisci l'integrazione push di Tenable integrata. Tenable Data Stream supporta solo Amazon S3.

Metodo 1: Google Cloud Storage

Questo metodo utilizza una funzione Cloud Run, attivata da Cloud Scheduler tramite Pub/Sub, per estrarre i dati sulle vulnerabilità e sugli asset dall'API di esportazione di Tenable Vulnerability Management e scriverli in un bucket Cloud Storage. Google SecOps inserisce quindi i dati dal bucket.

Raccogli le credenziali API di gestione di Tenable Vulnerability

1. Accedi a Tenable Vulnerability Management all'indirizzo https://cloud.tenable.com.
2. Nell'angolo in alto a destra, fai clic sull'icona del tuo profilo utente e seleziona Il mio account.
3. Fai clic su Chiavi API.
4. Fai clic su Genera.

5. Copia e salva la chiave di accesso e la chiave segreta.

   Nota: le chiavi vengono mostrate una sola volta. La generazione di nuove chiavi invalida quelle esistenti. Utilizza un utente di integrazione dedicato con almeno il ruolo Base.

Crea un bucket Google Cloud Storage

1. Nella console Google Cloud, vai a Cloud Storage > Bucket.
2. Fai clic su Crea.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome: inserisci un nome univoco globale (ad esempio tenable-vulnerability-logs).
   • Tipo di località: scegli una località.
   • Classe di archiviazione: seleziona Standard.
4. Fai clic su Crea.

Crea un account di servizio per la funzione Cloud Run

1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
2. Fai clic su Crea account di servizio.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome service account: inserisci tenable-collector-sa.
   • Descrizione del service account: inserisci Service account for the Tenable export collector.
4. Fai clic su Crea e continua.
5. Fai clic su Fine.

Concedi al account di servizio l'accesso al bucket

1. Vai a Cloud Storage > Bucket.
2. Fai clic sul nome del bucket (ad esempio tenable-vulnerability-logs).
3. Vai alla scheda Autorizzazioni.
4. Fai clic su Concedi l'accesso.
5. Fornisci i seguenti dettagli di configurazione:
   • Aggiungi entità: inserisci l'email del account di servizio (ad esempio, tenable-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Assegna i ruoli: seleziona Storage Object Admin.
6. Fai clic su Salva.

Crea un argomento Pub/Sub

1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
2. Fai clic su Crea argomento.
3. Inserisci un ID argomento (ad esempio, tenable-collector-trigger).
4. Fai clic su Crea.

Crea la funzione Cloud Run per raccogliere i log

La funzione Cloud Run viene attivata dai messaggi Pub/Sub di Cloud Scheduler. Esegue l'autenticazione all'API di esportazione di Tenable con le tue chiavi API, esegue le esportazioni di vulnerabilità e asset e scrive ogni blocco di esportazione nel bucket in formato JSON.

1. Nella console Google Cloud, vai a Cloud Run.
2. Fai clic su Crea servizio.
3. Seleziona Funzione per utilizzare l'editor di codice incorporato.
4. Fornisci i seguenti dettagli di configurazione:
   • Nome del servizio: inserisci tenable-collector.
   • Regione: seleziona la regione corrispondente al tuo bucket (ad esempio us-central1).
   • Runtime: seleziona Python 3.12 o versioni successive.
5. Nella sezione Trigger:
   1. Fai clic su Aggiungi trigger.
   2. Seleziona Cloud Pub/Sub.
   3. In Seleziona un argomento Cloud Pub/Sub, seleziona tenable-collector-trigger.
   4. Fai clic su Salva.
6. Nella sezione Autenticazione, seleziona Richiedi autenticazione.
7. Espandi Container, networking, sicurezza e nella scheda Sicurezza imposta Service account su tenable-collector-sa.

8. Nella scheda Container > Variabili e secret, aggiungi le seguenti variabili di ambiente:

   Nome variabile	Valore di esempio
   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

   Nota: utilizza la chiave di accesso e la chiave segreta della sezione Raccogli le credenziali dell'API di gestione di Tenable Vulnerability Management. Per la produzione, archivia le chiavi in Secret Manager e fai riferimento a queste come secret anziché come variabili di ambiente non criptate.

9. Imposta Timeout richiesta su 600 secondi e Memoria su 512 MiB o un valore superiore.

10. Fai clic su Crea. Una volta creato il servizio, si apre l'editor di codice incorporato.

Aggiungi il codice per la funzione

1. Nel campo Entry point della funzione, inserisci main.

2. Nell'editor di codice incorporato, sostituisci i contenuti di requirements.txt con quanto segue:

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

3. Sostituisci i contenuti di main.py con il seguente codice:

   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. Fai clic su Salva e implementa.

Crea un job Cloud Scheduler

1. Nella console Google Cloud, vai a Cloud Scheduler.
2. Fai clic su Crea job.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome: inserisci tenable-collector-schedule.
   • Regione: seleziona la stessa regione della funzione Cloud Run.
   • Frequenza: inserisci una pianificazione cron (ad esempio, 0 */6 * * * per l'esecuzione ogni sei ore).
   • Fuso orario: seleziona il tuo fuso orario.
4. Per Tipo di destinazione, seleziona Pub/Sub.
5. Seleziona l'argomento tenable-collector-trigger.
6. Nel corpo del messaggio, inserisci run.
7. Fai clic su Crea.

Configura un feed in Google SecOps per l'importazione da Google Cloud Storage

1. Vai a Impostazioni SIEM > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Fai clic su Configura un singolo feed.
4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Tenable Vulnerability Management GCS).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona tenable.io come Tipo di log.
7. Fai clic su Ottieni service account. Copia l'indirizzo email del account di servizio visualizzato.
8. Fai clic su Avanti.
9. Specifica i valori per i seguenti parametri di input:
   • URI bucket di archiviazione: inserisci l'URI del bucket, incluso il prefisso (ad esempio, gs://tenable-vulnerability-logs/tenable/).
   • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
   • Età massima file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
10. Fai clic su Avanti, esamina la configurazione e poi fai clic su Invia.

Concedi al account di servizio Google SecOps l'accesso al bucket

1. Vai a Cloud Storage > Bucket e fai clic sul nome del bucket.
2. Vai alla scheda Autorizzazioni e fai clic su Concedi accesso.
3. In Aggiungi entità, inserisci l'indirizzo email del account di servizio che hai copiato dal feed.
4. Assegna il ruolo Visualizzatore oggetti Storage (o Storage Object Admin se hai selezionato un'opzione di eliminazione dell'origine).
5. Fai clic su Salva.

Metodo 2: Amazon S3

Questo metodo utilizza Tenable Data Stream per inviare continuamente i dati Tenable a un bucket Amazon S3 in formato JSON. Google SecOps inserisce quindi i dati dal bucket. Tenable Data Stream supporta solo Amazon S3 e si autentica nel tuo account AWS utilizzando un ruolo IAM che Tenable assume (una relazione di attendibilità tra account con un ID esterno).

Crea un bucket Amazon S3

1. Crea un bucket Amazon S3 seguendo la guida AWS: Creazione di un bucket.
2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, tenable-vm-logs).

Crea un ruolo IAM per Tenable Data Stream

Tenable assume questo ruolo per scrivere dati nel tuo bucket. Tenable fornisce i criteri di attendibilità e i criteri del bucket esatti nella console, inclusi l'account AWS Tenable e un ID esterno generato.

1. In Tenable Vulnerability Management, vai a Impostazioni > Stream di dati Tenable e fai clic su Aggiungi un'integrazione. Tieni aperta questa finestra di dialogo per copiare la policy di attendibilità e l'ID esterno in un passaggio successivo.
2. Nella console AWS, vai a IAM > Ruoli > Crea ruolo.

3. Seleziona Norme di attendibilità personalizzate e incolla le norme di attendibilità dal riquadro Linee guida per i ruoli IAM di Tenable (fai clic su Copia norme di attendibilità). La policy di attendibilità ha la seguente forma:

   {
       "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. Fai clic su Avanti, poi crea e collega una policy che conceda a Tenable l'accesso in scrittura al bucket (sostituisci tenable-vm-logs con il nome del 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/*"
               ]
           }
       ]
   }
   

   Nota: se il bucket utilizza la crittografia SSE-KMS, concedi anche il ruolo kms:GenerateDataKey sulla chiave KMS.

5. Inserisci un nome per il ruolo (ad esempio, TenableDataStreamRole) e fai clic su Crea ruolo. Salva il Nome ruolo e il tuo ID account AWS.

Configura Tenable Data Stream

1. Torna alla finestra di dialogo Aggiungi un'integrazione in Tenable Vulnerability Management (Impostazioni > Stream di dati Tenable).
2. Fornisci i seguenti dettagli di configurazione:
   • Nome integrazione: inserisci un nome descrittivo (ad esempio, Google SecOps Integration).
   • Tipo di integrazione: seleziona AWS S3 (l'unica opzione disponibile).
   • Dati di integrazione: seleziona i tipi di dati da trasmettere in streaming (ad esempio Asset, Vulnerabilità e Controllo host).
   • Notifica via email (facoltativo): inserisci un indirizzo email per ricevere una notifica in caso di modifica dello stato dello stream.
3. Fai clic su Avanti e fornisci i dettagli del ruolo IAM:
   • ID account AWS: inserisci l'ID account AWS.
   • Nome del ruolo IAM: inserisci il ruolo che hai creato (ad esempio TenableDataStreamRole).
   • ID esterno: utilizza l'ID esterno mostrato da Tenable in questa finestra di dialogo (lo stesso valore a cui viene fatto riferimento nella policy di attendibilità).
4. Fai clic su Avanti e fornisci i dettagli del bucket:
   • Nome bucket S3: inserisci il nome del bucket (ad esempio tenable-vm-logs).
   • Prefisso percorso: inserisci un prefisso per organizzare i file (ad esempio, tenable/).

5. Fai clic su Salva. Tenable scrive continuamente dati JSON nel tuo bucket.

   Nota: non eliminare il ruolo, non modificare la relazione di attendibilità e non rimuovere le autorizzazioni del bucket dopo la configurazione, perché queste sono le cause più comuni di un flusso non riuscito.

Crea un utente IAM per Google SecOps per leggere il bucket

Google SecOps legge il bucket utilizzando un utente IAM di sola lettura separato (questa identità è indipendente dal ruolo utilizzato da Tenable per la scrittura).

1. Nella console AWS, vai a IAM > Utenti > Crea utente.
2. Inserisci un nome utente (ad esempio, secops-tenable-reader) e fai clic su Avanti.
3. Fai clic su Avanti e poi su Crea utente.

4. Seleziona l'utente, vai alla scheda Autorizzazioni e fai clic su Aggiungi autorizzazioni > Crea policy in linea > JSON. Incolla la seguente policy di sola lettura (sostituisci tenable-vm-logs con il nome del tuo 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/*"
               ]
           }
       ]
   }
   

   Nota :se selezioni un'opzione di eliminazione dell'origine nel feed, concedi anche s3:DeleteObject su arn:aws:s3:::tenable-vm-logs/*.

5. Vai alla scheda Credenziali di sicurezza e fai clic su Crea chiave di accesso.

6. Seleziona Servizio di terze parti come caso d'uso, fai clic su Avanti e poi su Crea chiave di accesso.

7. Copia e salva la chiave di accesso e la chiave di accesso segreta.

Configura un feed in Google SecOps per l'importazione da Amazon S3

1. Vai a Impostazioni SIEM > Feed.
2. Fai clic su Aggiungi nuovo feed.
3. Fai clic su Configura un singolo feed.
4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Tenable Vulnerability Management S3).
5. Seleziona Amazon S3 V2 come Tipo di origine.
6. Seleziona tenable.io come Tipo di log.
7. Fai clic su Avanti.
8. Specifica i valori per i seguenti parametri di input:
   • URI S3: inserisci l'URI del bucket, incluso il prefisso (ad esempio, s3://tenable-vm-logs/tenable/).
   • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
   • Età massima file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
   • ID chiave di accesso: inserisci la chiave di accesso dell'utente IAM di sola lettura.
   • Chiave di accesso segreta: inserisci la chiave segreta dell'utente IAM di sola lettura.
9. Fai clic su Avanti, esamina la configurazione e poi fai clic su Invia.

Tabella di mappatura UDM

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

Log delle modifiche

Visualizza il log delle modifiche per questo parser

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