Raccogli i log di Cisco Catalyst SD-WAN Manager

Versione del parser: 7.0

Supportato in:

Google SecOps SIEM

Questo documento spiega come importare i log di Cisco Catalyst SD-WAN Manager (precedentemente noto come vManage) in Google Security Operations utilizzando Google Cloud Storage. Cisco Catalyst SD-WAN Manager è un sistema di gestione di rete centralizzato che fornisce visibilità e controllo sulla struttura SD-WAN, consentendo agli amministratori di monitorare le prestazioni di rete, configurare i criteri e gestire la sicurezza nelle reti aziendali distribuite.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Un progetto GCP con l'API Storage Cloud 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 con privilegi alla console di gestione di Cisco Catalyst SD-WAN Manager
• Account utente Cisco Catalyst SD-WAN Manager con autorizzazioni di accesso API

Crea 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 cisco-sdwan-logs-bucket).
   Tipo di località	Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
   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.

Raccogli le credenziali API di Cisco Catalyst SD-WAN Manager

Crea un account utente API

1. Accedi alla console Cisco Catalyst SD-WAN Manager.
2. Nel menu, vai a Amministrazione > Gestisci utenti.
3. Fai clic su Aggiungi utente.
4. Fornisci i seguenti dettagli di configurazione:
   • Nome utente: inserisci un nome utente per l'accesso all'API (ad esempio, chronicle-api).
   • Password: inserisci una password efficace.
   • Conferma password: inserisci di nuovo la password.
   • Gruppo di utenti: seleziona un gruppo di utenti con le autorizzazioni appropriate (vedi la sezione successiva).
5. Fai clic su Aggiungi.

6. Copia e salva in una posizione sicura i seguenti dettagli:

   • Nome utente: il tuo nome utente di Catalyst SD-WAN Manager.
   • Password: la password di Catalyst SD-WAN Manager.
   • URL di base di Catalyst SD-WAN Manager: l'URL di base del server Catalyst SD-WAN Manager (ad esempio, https://sdwan-manager.example.com:8443).
   Nota: queste credenziali verranno utilizzate dalla funzione Cloud Run per l'autenticazione all'API Cisco Catalyst SD-WAN Manager.

Configurare le autorizzazioni utente

L'account utente API richiede autorizzazioni specifiche per accedere a log di controllo, allarmi ed eventi.

1. Nella console di Cisco Catalyst SD-WAN Manager, dal menu vai ad Administration > Manage Users > User Groups.
2. Seleziona il gruppo di utenti assegnato all'utente API (o fai clic su Aggiungi gruppo di utenti per creare un nuovo gruppo).
3. Fai clic su Modifica.
4. Nella sezione Funzionalità, assicurati che siano attive le seguenti autorizzazioni:
   • Log di controllo: seleziona l'autorizzazione Lettura.
   • Sveglie: seleziona l'autorizzazione Lettura.
   • Eventi: seleziona l'autorizzazione Lettura.
5. Fai clic su Aggiorna.

Verificare l'accesso API

Verifica le tue credenziali prima di procedere con l'integrazione:

1. Apri un terminale o un prompt dei comandi.

2. Esegui questo comando per testare l'autenticazione:

   # Replace with your actual credentials
   SDWAN_HOST="https://sdwan-manager.example.com:8443"
   SDWAN_USERNAME="chronicle-api"
   SDWAN_PASSWORD="your-password"
   
   # Test authentication using session-based login (returns JSESSIONID cookie)
   curl -c cookies.txt -X POST \
     "${SDWAN_HOST}/j_security_check" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "j_username=${SDWAN_USERNAME}&j_password=${SDWAN_PASSWORD}"
   
   # Get CSRF token (X-XSRF-TOKEN)
   curl -b cookies.txt \
     "${SDWAN_HOST}/dataservice/client/token"
   

Se l'autenticazione ha esito positivo, il secondo comando restituirà una stringa del token CSRF.

Nota :negli ambienti di produzione, configura certificati TLS validi in Catalyst SD-WAN Manager e verifica i certificati nel client HTTP. Gli esempi di codice utilizzano la verifica dei certificati disattivata solo a scopo di test.

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni per scrivere nel bucket GCS e per essere richiamato da Pub/Sub.

Crea service account

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 del service account: inserisci cisco-sdwan-collector-sa.
   • Descrizione service account: inserisci Service account for Cloud Run function to collect Cisco Catalyst SD-WAN Manager logs.
4. Fai clic su Crea e continua.
5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
   1. Fai clic su Seleziona un ruolo.
   2. Cerca e seleziona Storage Object Admin.
   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:

• Storage Object Admin: 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 account di servizio 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 account di servizio (ad esempio, cisco-sdwan-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 cisco-sdwan-trigger.
   • Lascia invariate le altre impostazioni predefinite.
4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API Cisco Catalyst SD-WAN Manager 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	cisco-sdwan-log-collector
   Regione	Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)
   Tempo di esecuzione	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 (cisco-sdwan-trigger).
   4. Fai clic su Salva.

6. Nella sezione Autenticazione:

   1. Seleziona Richiedi autenticazione.
   2. Controlla Identity and Access Management (IAM).
   Nota: Pub/Sub gestirà automaticamente l'autenticazione quando richiama la funzione.

7. Scorri verso il basso ed espandi Container, networking, sicurezza.

8. Vai alla scheda Sicurezza:

   • Service account: seleziona il account di servizio (cisco-sdwan-collector-sa).

9. 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	cisco-sdwan-logs-bucket
   GCS_PREFIX	cisco-sdwan
   STATE_KEY	cisco-sdwan/state.json
   SDWAN_HOST	https://sdwan-manager.example.com:8443
   SDWAN_USERNAME	chronicle-api
   SDWAN_PASSWORD	your-sdwan-password
   LOOKBACK_HOURS	1

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

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

11. Vai alla scheda Impostazioni in Container:

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

12. Nella sezione Scalabilità della revisione:

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

13. Fai clic su Crea.

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

15. Dopo aver creato il servizio, si aprirà automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

1. Inserisci main nel campo Entry point (Punto di ingresso).

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

   • main.py:

     import functions_framework
     from google.cloud import storage
     import json
     import os
     import urllib3
     import urllib.parse
     from datetime import datetime, timezone, timedelta
     import time
     
     # Disable SSL warnings for self-signed certificates (testing only)
     urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
     
     # Initialize HTTP client with timeouts
     http = urllib3.PoolManager(
         timeout=urllib3.Timeout(connect=10.0, read=60.0),
         cert_reqs='CERT_NONE',
         retries=urllib3.Retry(total=3, backoff_factor=1)
     )
     
     # Initialize Storage client
     storage_client = storage.Client()
     
     # Environment variables
     SDWAN_HOST = os.environ.get('SDWAN_HOST', '').rstrip('/')
     SDWAN_USERNAME = os.environ.get('SDWAN_USERNAME', '')
     SDWAN_PASSWORD = os.environ.get('SDWAN_PASSWORD', '')
     GCS_BUCKET = os.environ.get('GCS_BUCKET', '')
     GCS_PREFIX = os.environ.get('GCS_PREFIX', 'cisco-sdwan')
     STATE_KEY = os.environ.get('STATE_KEY', 'cisco-sdwan/state.json')
     LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))
     
     class CatalystSDWANAPI:
         """Client for Cisco Catalyst SD-WAN Manager API (formerly vManage)."""
     
         def __init__(self, host, username, password):
             self.host = host
             self.username = username
             self.password = password
             self.jsessionid = None
             self.xsrf_token = None
     
         def authenticate(self):
             """Authenticate using session-based login (j_security_check)."""
             try:
                 login_url = f"{self.host}/j_security_check"
                 login_data = urllib.parse.urlencode({
                     'j_username': self.username,
                     'j_password': self.password
                 }).encode('utf-8')
     
                 response = http.request(
                     'POST',
                     login_url,
                     body=login_data,
                     headers={'Content-Type': 'application/x-www-form-urlencoded'},
                 )
     
                 if b'<html>' in response.data or response.status != 200:
                     print(f"Authentication failed: HTTP {response.status}")
                     return False
     
                 # Extract JSESSIONID from Set-Cookie header
                 cookie_header = response.headers.get('Set-Cookie', '')
                 for part in cookie_header.split(','):
                     if 'JSESSIONID=' in part:
                         self.jsessionid = part.split('JSESSIONID=')[1].split(';')[0]
                         break
     
                 if not self.jsessionid:
                     print("Failed to extract JSESSIONID from response")
                     return False
     
                 # Get XSRF token
                 token_url = f"{self.host}/dataservice/client/token"
                 headers = {
                     'Content-Type': 'application/json',
                     'Cookie': f"JSESSIONID={self.jsessionid}"
                 }
                 response = http.request('GET', token_url, headers=headers)
     
                 if response.status == 200:
                     self.xsrf_token = response.data.decode('utf-8').strip()
                     print("Successfully authenticated with Catalyst SD-WAN Manager")
                     return True
                 else:
                     print(f"Failed to get XSRF token: HTTP {response.status}")
                     return False
     
             except Exception as e:
                 print(f"Authentication error: {e}")
                 return False
     
         def _get_headers(self):
             """Build headers for authenticated API requests."""
             return {
                 'Content-Type': 'application/json',
                 'Accept': 'application/json',
                 'Cookie': f"JSESSIONID={self.jsessionid}",
                 'X-XSRF-TOKEN': self.xsrf_token
             }
     
         def _build_query(self, last_epoch_ms=None):
             """Build a query payload with entry_time filter."""
             query = {
                 "query": {
                     "condition": "AND",
                     "rules": []
                 },
                 "size": 10000
             }
             if last_epoch_ms:
                 query["query"]["rules"].append({
                     "value": [str(last_epoch_ms)],
                     "field": "entry_time",
                     "type": "date",
                     "operator": "greater"
                 })
             else:
                 query["query"]["rules"].append({
                     "value": [str(LOOKBACK_HOURS)],
                     "field": "entry_time",
                     "type": "date",
                     "operator": "last_n_hours"
                 })
             return query
     
         def fetch_data(self, endpoint, last_epoch_ms=None):
             """Fetch data from a /dataservice endpoint using POST with query body."""
             url = f"{self.host}/dataservice/{endpoint}"
             headers = self._get_headers()
             query = self._build_query(last_epoch_ms)
     
             try:
                 response = http.request(
                     'POST',
                     url,
                     body=json.dumps(query),
                     headers=headers,
                 )
     
                 if response.status == 200:
                     return json.loads(response.data.decode('utf-8'))
                 else:
                     print(f"Failed to get {endpoint}: HTTP {response.status}")
                     return None
     
             except Exception as e:
                 print(f"Error fetching {endpoint}: {e}")
                 return None
     
     def load_state(bucket):
         """Load the last run timestamp (epoch ms) from GCS state file."""
         try:
             blob = bucket.blob(STATE_KEY)
             if blob.exists():
                 state_data = json.loads(blob.download_as_text())
                 return state_data.get('last_run_time')
         except Exception as e:
             print(f"Warning: Could not load state: {e}")
         return None
     
     def save_state(bucket, epoch_ms):
         """Save the current run timestamp (epoch ms) to GCS state file."""
         try:
             state_data = {
                 'last_run_time': epoch_ms,
                 'updated_at': datetime.now(timezone.utc).isoformat()
             }
             blob = bucket.blob(STATE_KEY)
             blob.upload_from_string(
                 json.dumps(state_data),
                 content_type='application/json'
             )
             print(f"Saved state: last_run_time={epoch_ms}")
         except Exception as e:
             print(f"Warning: Could not save state: {e}")
     
     def upload_to_gcs(bucket, records, log_type):
         """Upload log records to GCS as NDJSON."""
         if not records:
             print(f"No {log_type} records to upload")
             return 0
     
         dt = datetime.now(timezone.utc)
         object_key = (
             f"{GCS_PREFIX}/{log_type}/"
             f"{dt.strftime('%Y/%m/%d')}/"
             f"{log_type}_{dt.strftime('%Y%m%d_%H%M%S')}.ndjson"
         )
     
         ndjson = '\n'.join(
             json.dumps(record, ensure_ascii=False) for record in records
         ) + '\n'
     
         blob = bucket.blob(object_key)
         blob.upload_from_string(ndjson, content_type='application/x-ndjson')
         print(f"Uploaded {len(records)} {log_type} records to gs://{GCS_BUCKET}/{object_key}")
         return len(records)
     
     @functions_framework.cloud_event
     def main(cloud_event):
         """
         Cloud Run function triggered by Pub/Sub.
         Fetches audit logs, alarms, and events from Cisco Catalyst SD-WAN Manager
         API and writes them to GCS as NDJSON files.
     
         Args:
             cloud_event: CloudEvent object containing Pub/Sub message
         """
         print(f"Starting Cisco Catalyst SD-WAN Manager log collection at {datetime.now(timezone.utc).isoformat()}")
     
         if not all([SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD, GCS_BUCKET]):
             print("Error: Missing required environment variables")
             return
     
         try:
             bucket = storage_client.bucket(GCS_BUCKET)
     
             # Load last run timestamp
             last_run_time = load_state(bucket)
             if last_run_time:
                 print(f"Resuming from last_run_time={last_run_time}")
             else:
                 print(f"No previous state found, collecting last {LOOKBACK_HOURS} hour(s) of logs")
     
             # Authenticate
             api = CatalystSDWANAPI(SDWAN_HOST, SDWAN_USERNAME, SDWAN_PASSWORD)
             if not api.authenticate():
                 print("Failed to authenticate with Catalyst SD-WAN Manager")
                 return
     
             # Current timestamp for state tracking (epoch milliseconds)
             current_time = int(datetime.now(timezone.utc).timestamp() * 1000)
     
             # Collect audit logs, alarms, and events
             endpoints = [
                 ('audit_logs', 'auditlog'),
                 ('alarms', 'alarms'),
                 ('events', 'events'),
             ]
     
             total_records = 0
             for log_type, endpoint in endpoints:
                 try:
                     print(f"Collecting {log_type} from /dataservice/{endpoint}...")
                     response_data = api.fetch_data(endpoint, last_run_time)
                     if response_data and 'data' in response_data:
                         count = upload_to_gcs(bucket, response_data['data'], log_type)
                         total_records += count
                     else:
                         print(f"No {log_type} data returned")
                 except Exception as e:
                     print(f"Error processing {log_type}: {e}")
                     continue
     
             # Update state
             save_state(bucket, current_time)
     
             print(f"Collection completed. Total records processed: {total_records}")
     
         except Exception as e:
             print(f"Function execution error: {e}")
             raise
     

   • requirements.txt:

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

   Nota: questo script viene fornito come esempio e non è ufficialmente supportato. Accettiamo feedback su come possiamo migliorarlo. Per inviare un feedback, fai clic su Invia feedback > Feedback sul prodotto di sicurezza Google SecOps in questa pagina.

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 pubblicherà messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

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

3. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Nome	cisco-sdwan-log-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 (cisco-sdwan-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 tuo job.
2. Fai clic su Forza esecuzione per attivare il job manualmente.
3. Attendi qualche secondo.
4. Vai a Cloud Run > Servizi.
5. Fai clic sul nome della funzione (cisco-sdwan-log-collector).
6. Fai clic sulla scheda Log.

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

   Starting Cisco Catalyst SD-WAN Manager log collection at ...
   Successfully authenticated with Catalyst SD-WAN Manager
   Collecting audit_logs from /dataservice/auditlog...
   Uploaded N audit_logs records to gs://...
   Collection completed. Total records processed: N
   

8. Vai a Cloud Storage > Bucket.

9. Fai clic sul nome del bucket.

10. Vai alla cartella del prefisso (cisco-sdwan/).

11. Verifica che siano stati creati nuovi file .ndjson 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 utente disponga delle autorizzazioni di lettura richieste per il log di controllo, gli allarmi e gli eventi
• Autenticazione non riuscita: verifica che l'URL di base di Catalyst SD-WAN Manager includa la porta corretta (8443 per impostazione predefinita)
• Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate

Configura un feed in Google SecOps per importare i log di Cisco Catalyst SD-WAN Manager

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, Cisco Catalyst SD-WAN Manager logs).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona Cisco SD-WAN come tipo di log.

7. Fai clic su Ottieni service account. Verrà visualizzata un'email del account di servizio univoca, ad esempio:

   [e-mail]
   

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

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

9. Fai clic su Avanti.

10. 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://cisco-sdwan-logs-bucket/cisco-sdwan/
      

      • Sostituisci:
        • cisco-sdwan-logs-bucket: il nome del bucket GCS.
        • cisco-sdwan/: (Facoltativo) prefisso/percorso della cartella in cui vengono archiviati i log (lascia vuoto per la radice).
    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 i 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 account di servizio deve disporre del ruolo Storage Object Admin anziché Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.

    • Età massima 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.

11. Fai clic su Avanti.

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

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio 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 account di servizio Google SecOps.
   • Assegna 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.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logica
Tunnel_id_label	additional.fields	Unita
additional_tag	additional.fields	Unita
count_label	additional.fields	Unita
dst_vrf_label	additional.fields	Unita
logfeature_label	additional.fields	Unita
logmodule_label	additional.fields	Unita
meta_sequenceId_label	additional.fields	Unita
msg_label	additional.fields	Unita
qfp_label	additional.fields	Unita
result_label	additional.fields	Unita
rsa_sha256_label	additional.fields	Unita
rsa_type_label	additional.fields	Unita
sequence_label	additional.fields	Unita
src_vrf_label	additional.fields	Unita
tenant_vpn_id_label	additional.fields	Unita
thread_label	additional.fields	Unita
tos_label	additional.fields	Unita
unknown_tenant_label	additional.fields	Unita
vlan_id_label	additional.fields	Unita
vpn_id_label	additional.fields	Unita
description_1	extensions.auth.type	Mappato: (?i)closed → AUTHTYPE_UNSPECIFIED
msg1	extensions.auth.type	Mappato: authenticated → AUTHTYPE_UNSPECIFIED
msgs	extensions.auth.type	Mappato: (?i)success → AUTHTYPE_UNSPECIFIED
prod_type	extensions.auth.type	Mappato: (?i)LOGOUT → AUTHTYPE_UNSPECIFIED
host_name	intermediary.asset.hostname	Mappato direttamente
host_name	intermediary.hostname	Mappato direttamente
inter_host	intermediary.hostname	Mappato direttamente
logmsg	metadata.description	Mappato direttamente
message_value	metadata.description	Mappato direttamente
msgs	metadata.description	Mappato direttamente
date_time	metadata.event_timestamp	Analizzato come ISO8601
time	metadata.event_timestamp	Analizzato come ISO8601
time_t	metadata.event_timestamp	Analizzato come ISO8601
timestamp	metadata.event_timestamp	Analizzato come ISO8601
description_1	metadata.event_type	Mappato: (?i)closed → USER_LOGOUT
has_principal	metadata.event_type	Mappato: true → NETWORK_CONNECTION, true → STATUS_UPDATE
has_principal_user	metadata.event_type	Mappato: true → USER_UNCATEGORIZED
msg1	metadata.event_type	Mappato: authenticated → USER_LOGIN
msgs	metadata.event_type	Mappato: (?i)success → USER_LOGIN
prod_type	metadata.event_type	Mappato: (?i)LOGOUT → USER_LOGOUT
prod_type	metadata.product_event_type	Mappato direttamente
log_id	metadata.product_log_id	Mappato direttamente
logid	metadata.product_log_id	Mappato direttamente
application_protocol	network.application_protocol	Mappato: (?i)SSH → SSH
message	network.application_protocol	Mappato: (?i)SSH → SSH, (?i)netconf → NETCONF, (?i)dhcp → DHCP
type1	network.dhcp.type	Mappato: DHCPDISCOVER → DISCOVER
message	network.ip_protocol	Mappato: (?i)tcp → TCP
network_protocol	network.ip_protocol	Mappato direttamente
bytes	network.sent_bytes	Mappato direttamente
session_id	network.session_id	Mappato direttamente
network_host	network.tls.cipher	Mappato direttamente
hostname	principal.asset.hostname	Mappato direttamente
host	principal.asset.ip	Unita
initiator_ip	principal.asset.ip	Unita
ip	principal.asset.ip	Unita
ipaddress	principal.asset.ip	Unita
logusersrcip	principal.asset.ip	Unita
peer_ip	principal.asset.ip	Unita
principal_ip	principal.asset.ip	Unita
principal_ip1	principal.asset.ip	Unita
proxy_host	principal.asset.ip	Unita
src_ip	principal.asset.ip	Unita
system_ip	principal.asset.ip	Unita
addr	principal.hostname	Mappato direttamente
hostname	principal.hostname	Mappato direttamente
host	principal.ip	Unita
initiator_ip	principal.ip	Unita
ip	principal.ip	Unita
ipaddress	principal.ip	Unita
logusersrcip	principal.ip	Unita
peer_ip	principal.ip	Unita
principal_ip	principal.ip	Unita
principal_ip1	principal.ip	Unita
proxy_host	principal.ip	Unita
src_ip	principal.ip	Unita
system_ip	principal.ip	Unita
initiator_port	principal.port	Mappato direttamente
port	principal.port	Mappato direttamente
ports	principal.port	Mappato direttamente
principal_port	principal.port	Mappato direttamente
principal_port1	principal.port	Mappato direttamente
src_port	principal.port	Mappato direttamente
process_path	principal.process.file.full_path	Mappato direttamente
parent_pid	principal.process.parent_process.pid	Mappato direttamente
pid	principal.process.pid	Mappato direttamente
process_label	principal.resource.attribute.labels	Unita
process_name_label	principal.resource.attribute.labels	Unita
loguser	principal.user.userid	Mappato direttamente
user1	principal.user.userid	Mappato direttamente
user_id	principal.user.userid	Mappato direttamente
username	principal.user.userid	Mappato direttamente
action	security_result.action	Unita
message	security_result.action	Mappato: (?i)(succeeded/accounting start/open/occurred/update/successfully/success) → `acti...
classification	security_result.category_details	Unita
msg1	security_result.description	Mappato direttamente
Malware_label	security_result.detection_fields	Unita
direction_label	security_result.detection_fields	Unita
egress_interface_label	security_result.detection_fields	Unita
ingress_interface_label	security_result.detection_fields	Unita
log_prefix_label	security_result.detection_fields	Unita
log_reason_label	security_result.detection_fields	Unita
packet_label	security_result.detection_fields	Unita
policy_label	security_result.detection_fields	Unita
port_label	security_result.detection_fields	Unita
protocol_label	security_result.detection_fields	Unita
proxy_port_label	security_result.detection_fields	Unita
sent_bytes_1_label	security_result.detection_fields	Unita
sent_bytes_2_label	security_result.detection_fields	Unita
tty_label	security_result.detection_fields	Unita
type_label	security_result.detection_fields	Unita
udp_packets_label	security_result.detection_fields	Unita
priority	security_result.severity	Mappato: 1 → LOW
description_1	security_result.summary	Mappato direttamente
dst_ip	target.asset.ip	Unita
ipadres	target.asset.ip	Unita
logdeviceid	target.asset.ip	Unita
responder_ip	target.asset.ip	Unita
target_ip	target.asset.ip	Unita
target_ip1	target.asset.ip	Unita
filename	target.file.names	Unita
dst_ip	target.ip	Unita
ipadres	target.ip	Unita
logdeviceid	target.ip	Unita
responder_ip	target.ip	Unita
target_ip	target.ip	Unita
target_ip1	target.ip	Unita
dst_port	target.port	Mappato direttamente
prts	target.port	Mappato direttamente
responder_port	target.port	Mappato direttamente
target_port	target.port	Mappato direttamente
target_port1	target.port	Mappato direttamente
filetype	target.process.file.mime_type	Mappato direttamente
parent_identifier_label	target.resource.attribute.labels	Unita
specific_identifer_label	target.resource.attribute.labels	Unita
target_name	target.resource.name	Mappato direttamente
instance_id	target.resource.product_object_id	Mappato direttamente
target_username	target.user.userid	Mappato direttamente
user	target.user.userid	Mappato direttamente
N/D	extensions.auth.type	Costante: AUTHTYPE_UNSPECIFIED
N/D	metadata.event_type	Costante: USER_LOGIN
N/D	network.application_protocol	Costante: SSH
N/D	network.dhcp.type	Costante: DISCOVER
N/D	network.ip_protocol	Costante: TCP
N/D	security_result.severity	Costante: LOW
rsa_type	event.idm.read_only_udm.additional.fields	Mappato dal log delle modifiche
sha_256	event.idm.read_only_udm.additional.fields	Mappato dal log delle modifiche
NETCONF	event.idm.read_only_udm.network.application_protocol	Mappato dal log delle modifiche
TCP	event.idm.read_only_udm.network.ip_protocol	Mappato dal log delle modifiche
DHCP	event.idm.read_only_udm.network.application_protocol	Mappato dal log delle modifiche
username1	target.user.userid	Mappato dal log delle modifiche
security_result.action	ALLOW	Mappato dal log delle modifiche
ip_1	principal.ip	Mappato dal log delle modifiche
ip_2	target.ip	Mappato dal log delle modifiche
port_1	principal.port	Mappato dal log delle modifiche
port_2	target.port	Mappato dal log delle modifiche
message_1	metadata.description	Mappato dal log delle modifiche
malware	security_result.detection_fields	Mappato dal log delle modifiche

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.