Raccogliere i log di Censys

Supportato in:

Google secops SIEM

Nota: questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini di servizio specifici del servizio Google Security Operations. Le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per saperne di più, consulta le linee guida per i servizi di assistenza tecnica di Google SecOps e i Termini di servizio specifici di Google SecOps.

Questo documento spiega come importare i log di Censys in Google Security Operations utilizzando Google Cloud Storage V2.

Censys fornisce una gestione completa della superficie di attacco e informazioni su internet tramite la sua API. Questa integrazione ti consente di raccogliere eventi di rilevamento degli host, eventi di rischio e modifiche agli asset da Censys ASM e inoltrarli a Google SecOps per l'analisi e il monitoraggio.

Prima di iniziare

Assicurati di disporre dei seguenti prerequisiti:

• Un'istanza Google SecOps
• Un progetto GCP con l'API Cloud Storage abilitata
• Autorizzazioni per creare e gestire bucket GCS
• Autorizzazioni per gestire le policy IAM nei bucket GCS
• Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
• Accesso privilegiato a Censys ASM

Raccogliere le credenziali API di Censys

1. Accedi alla console Censys ASM all'indirizzo app.censys.io.
2. Vai a Integrazioni nella parte superiore della pagina.
3. Copia e salva la chiave API e l'ID organizzazione.
4. Prendi nota dell'URL di base dell'API: https://api.platform.censys.io

Creazione di un bucket Google Cloud Storage

1. Vai alla console Google Cloud.
2. Seleziona il tuo progetto o creane uno nuovo.
3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
4. Fai clic su Crea bucket.

5. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Assegna un nome al bucket	Inserisci un nome univoco globale (ad esempio censys-logs).
   Tipo di località	Scegli in base alle tue esigenze (regione singola, doppia regione, più regioni)
   Località	Seleziona la posizione (ad esempio, us-central1).
   Classe di archiviazione	Standard (consigliato per i log a cui si accede di frequente)
   Controllo dell'accesso	Uniforme (consigliato)
   Strumenti di protezione	(Facoltativo) Attiva il controllo delle versioni degli oggetti o la policy di conservazione

6. Fai clic su Crea.

Crea un service account per la funzione Cloud Run

La funzione Cloud Run richiede un service account con autorizzazioni per scrivere nel bucket GCS.

Crea service account

1. Nella console Google Cloud, vai a IAM e amministrazione > Service Accounts.
2. Fai clic su Crea service account.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome del service account: inserisci censys-data-collector-sa.
   • Descrizione service account: inserisci Service account for Cloud Run function to collect Censys logs.
4. Fai clic su Crea e continua.
5. Nella sezione Concedi a questo service account l'accesso al progetto, aggiungi i seguenti ruoli:
   1. Fai clic su Seleziona un ruolo.
   2. Cerca e seleziona Amministratore oggetti di archiviazione.
   3. Fai clic su + Aggiungi un altro ruolo.
   4. Cerca e seleziona Cloud Run Invoker.
   5. Fai clic su + Aggiungi un altro ruolo.
   6. Cerca e seleziona Invoker di Cloud Functions.
6. Fai clic su Continua.
7. Fai clic su Fine.

Questi ruoli sono necessari per:

• Amministratore oggetti Storage: scrive i log nel bucket GCS e gestisce i file di stato
• Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
• Cloud Functions Invoker: consente la chiamata di funzioni

Concedi autorizzazioni IAM sul bucket GCS

Concedi al service account le autorizzazioni di scrittura sul bucket GCS:

1. Vai a Cloud Storage > Bucket.
2. Fai clic sul nome del bucket.
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 service account (ad es. censys-data-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
   • Assegna i ruoli: seleziona Storage Object Admin.
6. Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

1. Nella console GCP, vai a Pub/Sub > Argomenti.
2. Fai clic su Crea argomento.
3. Fornisci i seguenti dettagli di configurazione:
   • ID argomento: inserisci censys-data-trigger.
   • Lascia le altre impostazioni sui valori predefiniti.
4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run viene attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API Censys ASM e scriverli in GCS.

1. Nella console GCP, vai a Cloud Run.
2. Fai clic su Crea servizio.
3. Seleziona Funzione (usa un editor in linea per creare una funzione).

4. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Nome servizio	censys-data-collector
   Regione	Seleziona la regione corrispondente al tuo bucket GCS (ad esempio us-central1)
   Runtime	Seleziona Python 3.12 o versioni successive

5. Nella sezione Trigger (facoltativo):

   1. Fai clic su + Aggiungi trigger.
   2. Seleziona Cloud Pub/Sub.
   3. In Seleziona un argomento Cloud Pub/Sub, scegli l'argomento Pub/Sub (censys-data-trigger).
   4. Fai clic su Salva.

6. Nella sezione Autenticazione:

   • Seleziona Richiedi autenticazione.
   • Controlla Identity and Access Management (IAM).

Nota: Pub/Sub gestisce automaticamente l'autenticazione quando richiama la funzione.

1. Scorri verso il basso ed espandi Container, networking, sicurezza.
2. Vai alla scheda Sicurezza:
   • Service account: seleziona il service account (censys-data-collector-sa).

3. Vai alla scheda Container:

   1. Fai clic su Variabili e secret.

   2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:

      Nome variabile	Valore di esempio
      GCS_BUCKET	censys-logs
      GCS_PREFIX	censys/
      STATE_KEY	censys/state.json
      CENSYS_API_KEY	your-censys-api-key
      CENSYS_ORG_ID	your-organization-id
      API_BASE	https://api.platform.censys.io

4. Scorri verso il basso nella scheda Variabili e secret fino a Richieste:

   • Timeout richiesta: inserisci 600 secondi (10 minuti).

5. Vai alla scheda Impostazioni in Container:

   • Nella sezione Risorse:
     • Memoria: seleziona 512 MiB o un valore superiore.
     • CPU: seleziona 1.
   • Fai clic su Fine.

6. Scorri fino a Ambiente di esecuzione:

   • Seleziona Predefinito (opzione consigliata).

7. Nella sezione Scalabilità della revisione:

   • Numero minimo di istanze: inserisci 0.
   • Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).

8. Fai clic su Crea.

9. Attendi la creazione del servizio (1-2 minuti).

10. Dopo aver creato il servizio, si apre automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

1. Inserisci main in Entry point della funzione

2. Nell'editor di codice incorporato, crea due file:

   • Primo file: main.py:

   import functions_framework
   from google.cloud import storage
   import json
   import urllib3
   import gzip
   import os
   from datetime import datetime, timedelta, timezone
   from typing import Dict, List, Any, Optional
   from urllib.parse import urlencode
   
   # Initialize HTTP client with timeouts
   http = urllib3.PoolManager(
       timeout=urllib3.Timeout(connect=5.0, read=30.0),
       retries=False,
   )
   
   # Initialize Storage client
   storage_client = storage.Client()
   
   @functions_framework.cloud_event
   def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch logs from Censys ASM API and write to GCS.
   
       Args:
           cloud_event: CloudEvent object containing Pub/Sub message
       """
   
       # Get environment variables
       bucket_name = os.environ.get('GCS_BUCKET')
       prefix = os.environ.get('GCS_PREFIX', 'censys/')
       state_key = os.environ.get('STATE_KEY', 'censys/state.json')
       censys_api_key = os.environ.get('CENSYS_API_KEY')
       censys_org_id = os.environ.get('CENSYS_ORG_ID')
       api_base = os.environ.get('API_BASE', 'https://api.platform.censys.io')
   
       if not all([bucket_name, censys_api_key, censys_org_id]):
           print('Error: Missing required environment variables')
           return
   
       try:
           collector = CensysCollector(
               bucket_name=bucket_name,
               prefix=prefix,
               state_key=state_key,
               api_key=censys_api_key,
               org_id=censys_org_id,
               api_base=api_base
           )
   
           # Get last collection time
           last_collection_time = collector.get_last_collection_time()
           current_time = datetime.now(timezone.utc)
   
           print(f'Collecting events since {last_collection_time}')
   
           # Collect different types of events
           logbook_events = collector.collect_logbook_events()
           risk_events = collector.collect_risks_events()
   
           # Save events to GCS
           collector.save_events_to_gcs(logbook_events, 'logbook')
           collector.save_events_to_gcs(risk_events, 'risks')
   
           # Update state
           collector.save_collection_time(current_time)
   
           print(f'Successfully processed {len(logbook_events)} logbook events and {len(risk_events)} risk events')
   
       except Exception as e:
           print(f'Error processing logs: {str(e)}')
           raise
   
   class CensysCollector:
       def __init__(self, bucket_name: str, prefix: str, state_key: str, 
                    api_key: str, org_id: str, api_base: str):
           self.bucket_name = bucket_name
           self.prefix = prefix
           self.state_key = state_key
           self.headers = {
               'Authorization': f'Bearer {api_key}',
               'X-Organization-ID': org_id,
               'Content-Type': 'application/json'
           }
           self.api_base = api_base
           self.bucket = storage_client.bucket(bucket_name)
   
       def get_last_collection_time(self) -> Optional[datetime]:
           """Get the last collection timestamp from GCS state file."""
           try:
               blob = self.bucket.blob(self.state_key)
               if blob.exists():
                   state_data = blob.download_as_text()
                   state = json.loads(state_data)
                   return datetime.fromisoformat(state.get('last_collection_time', '2024-01-01T00:00:00Z'))
           except Exception as e:
               print(f'No state file found or error reading state: {e}')
           return datetime.now(timezone.utc) - timedelta(hours=1)
   
       def save_collection_time(self, collection_time: datetime):
           """Save the current collection timestamp to GCS state file."""
           state = {'last_collection_time': collection_time.strftime('%Y-%m-%dT%H:%M:%SZ')}
           blob = self.bucket.blob(self.state_key)
           blob.upload_from_string(
               json.dumps(state),
               content_type='application/json'
           )
   
       def collect_logbook_events(self, cursor: str = None) -> List[Dict[str, Any]]:
           """Collect logbook events from Censys ASM API using cursor-based pagination."""
           events = []
           url = f"{self.api_base}/v3/logbook"
   
           params = {}
           if cursor:
               params['cursor'] = cursor
   
           try:
               query_string = urlencode(params) if params else ''
               full_url = f"{url}?{query_string}" if query_string else url
   
               response = http.request('GET', full_url, headers=self.headers)
   
               # Handle rate limiting with exponential backoff
               if response.status == 429:
                   retry_after = int(response.headers.get('Retry-After', '60'))
                   print(f'Rate limited (429). Retrying after {retry_after}s...')
                   import time
                   time.sleep(retry_after)
                   return self.collect_logbook_events(cursor)
   
               if response.status != 200:
                   print(f'API request failed with status {response.status}: {response.data}')
                   return []
   
               data = json.loads(response.data.decode('utf-8'))
               events.extend(data.get('logbook_entries', []))
   
               # Handle cursor-based pagination
               next_cursor = data.get('next_cursor')
               if next_cursor:
                   events.extend(self.collect_logbook_events(next_cursor))
   
               print(f'Collected {len(events)} logbook events')
               return events
   
           except Exception as e:
               print(f'Error collecting logbook events: {e}')
               return []
   
       def collect_risks_events(self) -> List[Dict[str, Any]]:
           """Collect risk events from Censys ASM API."""
           events = []
           url = f"{self.api_base}/v3/risks"
   
           try:
               response = http.request('GET', url, headers=self.headers)
   
               # Handle rate limiting with exponential backoff
               if response.status == 429:
                   retry_after = int(response.headers.get('Retry-After', '60'))
                   print(f'Rate limited (429). Retrying after {retry_after}s...')
                   import time
                   time.sleep(retry_after)
                   return self.collect_risks_events()
   
               if response.status != 200:
                   print(f'API request failed with status {response.status}: {response.data}')
                   return []
   
               data = json.loads(response.data.decode('utf-8'))
               events.extend(data.get('risks', []))
   
               print(f'Collected {len(events)} risk events')
               return events
   
           except Exception as e:
               print(f'Error collecting risk events: {e}')
               return []
   
       def save_events_to_gcs(self, events: List[Dict[str, Any]], event_type: str):
           """Save events to GCS in compressed NDJSON format."""
           if not events:
               return
   
           timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
           filename = f"{self.prefix}{event_type}_{timestamp}.json.gz"
   
           try:
               # Convert events to newline-delimited JSON
               ndjson_content = '\n'.join(json.dumps(event, separators=(',', ':')) for event in events)
   
               # Compress with gzip
               gz_bytes = gzip.compress(ndjson_content.encode('utf-8'))
   
               blob = self.bucket.blob(filename)
               blob.upload_from_string(
                   gz_bytes,
                   content_type='application/gzip'
               )
   
               print(f'Saved {len(events)} {event_type} events to {filename}')
   
           except Exception as e:
               print(f'Error saving {event_type} events to GCS: {e}')
               raise
   

   • Secondo file: requirements.txt::

   functions-framework==3.*
   google-cloud-storage==2.*
   urllib3>=2.0.0
   

3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

4. Attendi il completamento del deployment (2-3 minuti).

Nota: la configurazione del trigger Pub/Sub crea automaticamente le sottoscrizioni e le autorizzazioni necessarie.

Crea job Cloud Scheduler

Cloud Scheduler pubblica messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

1. Nella console di GCP, vai a Cloud Scheduler.
2. Fai clic su Crea job.

3. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Nome	censys-data-collector-hourly
   Regione	Seleziona la stessa regione della funzione Cloud Run
   Frequenza	0 * * * * (ogni ora, all'ora)
   Fuso orario	Seleziona il fuso orario (UTC consigliato)
   Tipo di target	Pub/Sub
   Argomento	Seleziona l'argomento Pub/Sub (censys-data-trigger)
   Corpo del messaggio	{} (oggetto JSON vuoto)

4. Fai clic su Crea.

Opzioni di frequenza di pianificazione

• Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

  Frequenza	Espressione cron	Caso d'uso
  Ogni 5 minuti	*/5 * * * *	Volume elevato, bassa latenza
  Ogni 15 minuti	*/15 * * * *	Volume medio
  Ogni ora	0 * * * *	Standard (consigliato)
  Ogni 6 ore	0 */6 * * *	Volume basso, elaborazione batch
  Ogni giorno	0 0 * * *	Raccolta dei dati storici

Testare l'integrazione

1. Nella console Cloud Scheduler, trova il job.
2. Fai clic su Forza esecuzione per attivare il job manualmente.
3. Aspetta alcuni secondi.
4. Vai a Cloud Run > Servizi.
5. Fai clic sul nome della funzione (censys-data-collector).
6. Fai clic sulla scheda Log.

7. Verifica che la funzione sia stata eseguita correttamente. Cerca quanto segue:

   Collecting events since YYYY-MM-DDTHH:MM:SS+00:00
   Collected X logbook events
   Collected X risk events
   Saved X logbook events to censys/logbook_YYYYMMDD_HHMMSS.json.gz
   Saved X risks events to censys/risks_YYYYMMDD_HHMMSS.json.gz
   Successfully processed X logbook events and X risk events
   

8. Vai a Cloud Storage > Bucket.

9. Fai clic sul nome del bucket.

10. Vai alla cartella del prefisso (censys/).

11. Verifica che siano stati creati nuovi file .json.gz con il timestamp corrente.

Se visualizzi errori nei log:

• HTTP 401: controlla le credenziali API nelle variabili di ambiente
• HTTP 403: verifica che l'account disponga delle autorizzazioni richieste
• HTTP 429: limitazione della frequenza: la funzione riproverà automaticamente con backoff
• Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate

Recuperare il service account Google SecOps

Google SecOps utilizza un service account univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo service account l'accesso al tuo bucket.

Recuperare l'email del service account

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, Censys logs).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona CENSYS come Tipo di log.
7. Fai clic su Ottieni service account.

8. Verrà visualizzata un'email univoca del service account, ad esempio:

   [e-mail]
   

9. Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

Nota: ogni istanza di Google SecOps ha un service account univoco. Non utilizzare service account di altre documentazioni o esempi.

Concedi le autorizzazioni IAM al service account Google SecOps

Il service account Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel bucket GCS.

1. Vai a Cloud Storage > Bucket.
2. Fai clic sul nome del bucket.
3. Vai alla scheda Autorizzazioni.
4. Fai clic su Concedi l'accesso.
5. Fornisci i seguenti dettagli di configurazione:
   • Aggiungi entità: incolla l'email del service account Google SecOps.
   • Assegna i ruoli: seleziona Visualizzatore oggetti Storage.
6. Fai clic su Salva.

Nota: se prevedi di utilizzare l'opzione di eliminazione "Elimina file trasferiti" o "Elimina file trasferiti e directory vuote", assegna il ruolo Storage Object Admin anziché Storage Object Viewer.

Configura un feed in Google SecOps per importare i log di Censys

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, Censys logs).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona CENSYS come Tipo di log.
7. Fai clic su Avanti.

8. Specifica i valori per i seguenti parametri di input:

   • URL del bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

     gs://censys-logs/censys/
     

     • Sostituisci:

       • censys-logs: il nome del bucket GCS.
       • censys/: (Facoltativo) prefisso/percorso della cartella in cui vengono archiviati i log (lascia vuoto per la radice).

     • Esempi:

       • Bucket radice: gs://censys-logs/
       • Con prefisso: gs://censys-logs/censys/
     Nota: includi sempre la barra finale (/) alla fine dell'URI.

   • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

     • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
     • Elimina file trasferiti: elimina i file dopo il trasferimento riuscito.

     • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

       Nota :se selezioni un'opzione di eliminazione, il service account deve disporre del ruolo Storage Object Admin anziché di Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.

   • Età massima del file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.

   • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

   • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

9. Fai clic su Avanti.

10. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Funzione logica
assetId	read_only_udm.principal.asset.hostname	Se il campo assetId non è un indirizzo IP, viene mappato a principal.asset.hostname.
assetId	read_only_udm.principal.asset.ip	Se il campo assetId è un indirizzo IP, viene mappato su principal.asset.ip.
assetId	read_only_udm.principal.hostname	Se il campo assetId non è un indirizzo IP, viene mappato a principal.hostname.
assetId	read_only_udm.principal.ip	Se il campo assetId è un indirizzo IP, viene mappato su principal.ip.
associatedAt	read_only_udm.security_result.detection_fields.value	Il campo associatedAt è mappato a security_result.detection_fields.value.
autonomousSystem.asn	read_only_udm.additional.fields.value.string_value	Il campo autonomousSystem.asn viene convertito in una stringa e mappato su additional.fields.value.string_value con la chiave "autonomousSystem_asn".
autonomousSystem.bgpPrefix	read_only_udm.additional.fields.value.string_value	Il campo autonomousSystem.bgpPrefix viene mappato a additional.fields.value.string_value con la chiave "autonomousSystem_bgpPrefix".
banner	read_only_udm.principal.resource.attribute.labels.value	Il campo banner è mappato a principal.resource.attribute.labels.value con la chiave "banner".
cloud	read_only_udm.metadata.vendor_name	Il campo cloud è mappato a metadata.vendor_name.
comments.refUrl	read_only_udm.network.http.referral_url	Il campo comments.refUrl è mappato a network.http.referral_url.
data.cve	read_only_udm.additional.fields.value.string_value	Il campo data.cve è mappato a additional.fields.value.string_value con la chiave "data_cve".
data.cvss	read_only_udm.additional.fields.value.string_value	Il campo data.cvss è mappato a additional.fields.value.string_value con la chiave "data_cvss".
data.ipAddress	read_only_udm.principal.asset.ip	Se il campo data.ipAddress non è uguale al campo assetId, viene mappato a principal.asset.ip.
data.ipAddress	read_only_udm.principal.ip	Se il campo data.ipAddress non è uguale al campo assetId, viene mappato a principal.ip.
data.location.city	read_only_udm.principal.location.city	Se il campo location.city è vuoto, il campo data.location.city viene mappato a principal.location.city.
data.location.countryCode	read_only_udm.principal.location.country_or_region	Se il campo location.country è vuoto, il campo data.location.countryCode viene mappato a principal.location.country_or_region.
data.location.latitude	read_only_udm.principal.location.region_coordinates.latitude	Se i campi location.coordinates.latitude e location.geoCoordinates.latitude sono vuoti, il campo data.location.latitude viene convertito in un numero in virgola mobile e mappato su principal.location.region_coordinates.latitude.
data.location.longitude	read_only_udm.principal.location.region_coordinates.longitude	Se i campi location.coordinates.longitude e location.geoCoordinates.longitude sono vuoti, il campo data.location.longitude viene convertito in un numero in virgola mobile e mappato su principal.location.region_coordinates.longitude.
data.location.province	read_only_udm.principal.location.state	Se il campo location.province è vuoto, il campo data.location.province viene mappato a principal.location.state.
data.mailServers	read_only_udm.additional.fields.value.list_value.values.string_value	Ogni elemento dell'array data.mailServers viene mappato a una voce additional.fields separata con la chiave "Mail Servers" e il valore value.list_value.values.string_value impostato sul valore dell'elemento.
data.names.forwardDns[].name	read_only_udm.network.dns.questions.name	Ogni elemento dell'array data.names.forwardDns viene mappato a una voce network.dns.questions separata con il campo name impostato sul campo name dell'elemento.
data.nameServers	read_only_udm.additional.fields.value.list_value.values.string_value	Ogni elemento dell'array data.nameServers viene mappato a una voce additional.fields separata con la chiave "Name nameServers" e il valore value.list_value.values.string_value impostato sul valore dell'elemento.
data.protocols[].transportProtocol	read_only_udm.network.ip_protocol	Se il campo data.protocols[].transportProtocol è uno dei seguenti: TCP, EIGRP, ESP, ETHERIP, GRE, ICMP, IGMP, IP6IN4, PIM, UDP o VRRP, viene mappato a network.ip_protocol.
data.protocols[].transportProtocol	read_only_udm.principal.resource.attribute.labels.value	Il campo data.protocols[].transportProtocol viene mappato a principal.resource.attribute.labels.value con la chiave "data_protocols {index}".
http.request.headers[].key, http.request.headers[].value.headers.0	read_only_udm.network.http.user_agent	Se il campo http.request.headers[].key è "User-Agent", il campo http.request.headers[].value.headers.0 corrispondente viene mappato a network.http.user_agent.
http.request.headers[].key, http.request.headers[].value.headers.0	read_only_udm.network.http.parsed_user_agent	Se il campo http.request.headers[].key è "User-Agent", il campo http.request.headers[].value.headers.0 corrispondente viene analizzato come stringa dello user agent e mappato a network.http.parsed_user_agent.
http.request.headers[].key, http.request.headers[].value.headers.0	read_only_udm.principal.resource.attribute.labels.key, read_only_udm.principal.resource.attribute.labels.value	Per ogni elemento dell'array http.request.headers, il campo della chiave viene mappato su principal.resource.attribute.labels.key e il campo value.headers.0 viene mappato su principal.resource.attribute.labels.value.
http.request.uri	read_only_udm.principal.asset.hostname	La parte del nome host del campo http.request.uri viene estratta e mappata a principal.asset.hostname.
http.request.uri	read_only_udm.principal.hostname	La parte del nome host del campo http.request.uri viene estratta e mappata a principal.hostname.
http.response.body	read_only_udm.principal.resource.attribute.labels.value	Il campo http.response.body è mappato a principal.resource.attribute.labels.value con la chiave "http_response_body".
http.response.headers[].key, http.response.headers[].value.headers.0	read_only_udm.target.hostname	Se il campo http.response.headers[].key è "Server", il campo http.response.headers[].value.headers.0 corrispondente viene mappato a target.hostname.
http.response.headers[].key, http.response.headers[].value.headers.0	read_only_udm.principal.resource.attribute.labels.key, read_only_udm.principal.resource.attribute.labels.value	Per ogni elemento dell'array http.response.headers, il campo della chiave viene mappato su principal.resource.attribute.labels.key e il campo value.headers.0 viene mappato su principal.resource.attribute.labels.value.
http.response.statusCode	read_only_udm.network.http.response_code	Il campo http.response.statusCode viene convertito in un numero intero e mappato a network.http.response_code.
ip	read_only_udm.target.asset.ip	Il campo ip è mappato a target.asset.ip.
ip	read_only_udm.target.ip	Il campo ip è mappato a target.ip.
isSeed	read_only_udm.additional.fields.value.string_value	Il campo isSeed viene convertito in una stringa e mappato su additional.fields.value.string_value con la chiave "isSeed".
location.city	read_only_udm.principal.location.city	Il campo location.city è mappato a principal.location.city.
location.continent	read_only_udm.additional.fields.value.string_value	Il campo location.continent viene mappato a additional.fields.value.string_value con la chiave "location_continent".
location.coordinates.latitude	read_only_udm.principal.location.region_coordinates.latitude	Il campo location.coordinates.latitude viene convertito in un valore float e mappato a principal.location.region_coordinates.latitude.
location.coordinates.longitude	read_only_udm.principal.location.region_coordinates.longitude	Il campo location.coordinates.longitude viene convertito in un numero in virgola mobile e mappato su principal.location.region_coordinates.longitude.
location.country	read_only_udm.principal.location.country_or_region	Il campo location.country è mappato a principal.location.country_or_region.
location.geoCoordinates.latitude	read_only_udm.principal.location.region_coordinates.latitude	Se il campo location.coordinates.latitude è vuoto, il campo location.geoCoordinates.latitude viene convertito in un valore float e mappato su principal.location.region_coordinates.latitude.
location.geoCoordinates.longitude	read_only_udm.principal.location.region_coordinates.longitude	Se il campo location.coordinates.longitude è vuoto, il campo location.geoCoordinates.longitude viene convertito in un valore float e mappato a principal.location.region_coordinates.longitude.
location.postalCode	read_only_udm.additional.fields.value.string_value	Il campo location.postalCode è mappato a additional.fields.value.string_value con la chiave "Postal code".
location.province	read_only_udm.principal.location.state	Il campo location.province è mappato a principal.location.state.
operazione	read_only_udm.security_result.action_details	Il campo operation è mappato a security_result.action_details.
perspectiveId	read_only_udm.principal.group.product_object_id	Il campo perspectiveId è mappato a principal.group.product_object_id.
porta	read_only_udm.principal.port	Il campo della porta viene convertito in un numero intero e mappato a principal.port.
risks[].severity, risks[].title	read_only_udm.security_result.category_details	Il campo risks[].severity viene concatenato al campo risks[].title e mappato a security_result.category_details.
serviceName	read_only_udm.network.application_protocol	Se il campo serviceName è "HTTP" o "HTTPS", viene mappato a network.application_protocol.
sourceIp	read_only_udm.principal.asset.ip	Il campo sourceIp è mappato a principal.asset.ip.
sourceIp	read_only_udm.principal.ip	Il campo sourceIp è mappato a principal.ip.
timestamp	read_only_udm.metadata.event_timestamp	Il campo timestamp viene analizzato come timestamp e mappato a metadata.event_timestamp.
transportFingerprint.id	read_only_udm.metadata.product_log_id	Il campo transportFingerprint.id viene convertito in una stringa e mappato a metadata.product_log_id.
transportFingerprint.raw	read_only_udm.additional.fields.value.string_value	Il campo transportFingerprint.raw viene mappato su additional.fields.value.string_value con la chiave "transportFingerprint_raw".
tipo	read_only_udm.metadata.product_event_type	Il campo Tipo è mappato a metadata.product_event_type.
-	read_only_udm.metadata.product_name	Il valore "CENSYS_ASM" viene assegnato a metadata.product_name.
-	read_only_udm.metadata.vendor_name	Il valore "CENSYS" viene assegnato a metadata.vendor_name.
-	read_only_udm.metadata.event_type	Il tipo di evento viene determinato in base alla presenza di campi specifici: NETWORK_CONNECTION se has_princ_machine_id e has_target_machine sono true e has_network_flow è false, NETWORK_DNS se has_network_flow è true, STATUS_UPDATE se has_princ_machine_id è true e GENERIC_EVENT altrimenti.

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