Raccogli i log di Cisco Catalyst SD-WAN Manager

Versione parser: 7.0

Supportata 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 della rete centralizzato che offre visibilità e controllo sul fabric SD-WAN, consentendo agli amministratori di monitorare le prestazioni della rete, configurare le policy 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 di Cloud Storage abilitata
• Autorizzazioni per creare e gestire i bucket GCS
• Autorizzazioni per gestire le policy IAM sui 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 all'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 globalmente univoco (ad esempio cisco-sdwan-logs-bucket)
   Tipo di località	Scegli in base alle tue esigenze (Regione, a due regioni, multiregionale)
   Località	Seleziona la località (ad esempio us-central1)
   Classe di archiviazione	Standard (consigliato per i log ad accesso frequente)
   Controllo degli accessi	Uniforme (consigliato)
   Strumenti di protezione	(Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione

6. Fai clic su Crea.

Raccogli le credenziali dell'API Cisco Catalyst SD-WAN Manager

Crea un account utente API

1. Accedi alla console Cisco Catalyst SD-WAN Manager.
2. Dal menu, vai ad 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 (consulta la sezione successiva).
5. Fai clic su Aggiungi.

6. Copia e salva in un luogo sicuro 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 nell'API Cisco Catalyst SD-WAN Manager.

Configura le autorizzazioni utente

L'account utente API richiede autorizzazioni specifiche per accedere ai log di controllo, agli allarmi e agli eventi.

1. Nella console Cisco Catalyst SD-WAN Manager, dal menu, vai ad Administration (Amministrazione) > Manage Users (Gestisci utenti) > User Groups (Gruppi di utenti).
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 abilitate le seguenti autorizzazioni:
   • Audit Log: seleziona l'autorizzazione Read.
   • Sveglie: seleziona l'autorizzazione Lettura.
   • Eventi: seleziona l'autorizzazione Lettura.
5. Fai clic su Aggiorna.

Verifica l'accesso all'API

Testa 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 di token CSRF.

Nota: negli ambienti di produzione, configura certificati TLS validi su Catalyst SD-WAN Manager e verifica i certificati nel client HTTP. Gli esempi di codice utilizzano la verifica del certificato 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 le autorizzazioni per scrivere nel bucket GCS ed essere richiamata da Pub/Sub.

Crea service account

1. Nella console Google Cloud, vai a IAM e amministrazione > Account di servizio.
2. Fai clic su Crea account di servizio.
3. Fornisci i seguenti dettagli di configurazione:
   • Nome 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 Cloud Functions Invoker.
6. Fai clic su Continua.
7. Fai clic su Fine.

Questi ruoli sono obbligatori 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 della funzione

Concedi le autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni in 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'indirizzo 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 in cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

1. Nella console Google Cloud, 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 Google Cloud, vai a Cloud Run.
2. Fai clic su Crea servizio.
3. Seleziona Funzione (utilizza un editor di modifica 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 della 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 regola 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, l'editor di codice incorporato si aprirà automaticamente.

Aggiungi codice per la funzione

1. Inserisci main nel campo 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 è supportato ufficialmente. Apprezziamo i 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à i messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

1. Nella console Google Cloud, 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, allo scoccare dell'ora)
   Fuso orario	Seleziona il fuso orario (consigliato UTC)
   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 * * *	Basso volume, elaborazione batch
Ogni giorno	0 0 * * *	Raccolta dei dati storici

Testa l'integrazione

1. Nella console Cloud Scheduler, trova il tuo job.
2. Fai clic su Forza esecuzione per attivare il job manualmente.
3. Attendi alcuni secondi.
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 i nuovi file .ndjson siano stati creati 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 in lettura richieste per l'audit log, gli allarmi e gli eventi
• Autenticazione non riuscita: verifica che l'URL di base di Catalyst SD-WAN Manager includa la porta corretta (predefinita 8443)
• Variabili di ambiente mancanti: verifica 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 > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > 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 es. 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à visualizzato un indirizzo email univoco del account di servizio, ad esempio:

   [e-mail]
   

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

   Nota: ogni istanza Google SecOps ha un account di servizio univoco. Non utilizzare i service account di altri esempi o documentazione.

9. Fai clic su Avanti.

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

    • URL 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 tuo bucket GCS.
        • cisco-sdwan/: prefisso/percorso della cartella facoltativo in cui sono archiviati i log (lascia vuoto per la directory principale).
    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 i file trasferiti e le 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 avere il ruolo Storage Object Admin anziché Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.

    • Età massima del file: includi i file modificati negli ultimi 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 di notizie 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 Storage Object Viewer 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'indirizzo 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 i file trasferiti" o "Elimina i file trasferiti e le directory vuote", concedi 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	Mappatura: (?i)closed → AUTHTYPE_UNSPECIFIED
msg1	extensions.auth.type	Mappatura: authenticated → AUTHTYPE_UNSPECIFIED
msgs	extensions.auth.type	Mappatura: (?i)success → AUTHTYPE_UNSPECIFIED
prod_type	extensions.auth.type	Mappatura: (?i)LOGOUT → AUTHTYPE_UNSPECIFIED
host_name	intermediary.asset.hostname	Mappatura diretta
host_name	intermediary.hostname	Mappatura diretta
inter_host	intermediary.hostname	Mappatura diretta
logmsg	metadata.description	Mappatura diretta
message_value	metadata.description	Mappatura diretta
msgs	metadata.description	Mappatura diretta
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	Mappatura: (?i)closed → USER_LOGOUT
has_principal	metadata.event_type	Mappatura: true → NETWORK_CONNECTION, true → STATUS_UPDATE
has_principal_user	metadata.event_type	Mappatura: true → USER_UNCATEGORIZED
msg1	metadata.event_type	Mappatura: authenticated → USER_LOGIN
msgs	metadata.event_type	Mappatura: (?i)success → USER_LOGIN
prod_type	metadata.event_type	Mappatura: (?i)LOGOUT → USER_LOGOUT
prod_type	metadata.product_event_type	Mappatura diretta
log_id	metadata.product_log_id	Mappatura diretta
logid	metadata.product_log_id	Mappatura diretta
application_protocol	network.application_protocol	Mappatura: (?i)SSH → SSH
message	network.application_protocol	Mapped: (?i)SSH → SSH, (?i)netconf → NETCONF, (?i)dhcp → DHCP
type1	network.dhcp.type	Mappatura: DHCPDISCOVER → DISCOVER
message	network.ip_protocol	Mappatura: (?i)tcp → TCP
network_protocol	network.ip_protocol	Mappatura diretta
bytes	network.sent_bytes	Mappatura diretta
session_id	network.session_id	Mappatura diretta
network_host	network.tls.cipher	Mappatura diretta
hostname	principal.asset.hostname	Mappatura diretta
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	Mappatura diretta
hostname	principal.hostname	Mappatura diretta
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	Mappatura diretta
port	principal.port	Mappatura diretta
ports	principal.port	Mappatura diretta
principal_port	principal.port	Mappatura diretta
principal_port1	principal.port	Mappatura diretta
src_port	principal.port	Mappatura diretta
process_path	principal.process.file.full_path	Mappatura diretta
parent_pid	principal.process.parent_process.pid	Mappatura diretta
pid	principal.process.pid	Mappatura diretta
process_label	principal.resource.attribute.labels	Unita
process_name_label	principal.resource.attribute.labels	Unita
loguser	principal.user.userid	Mappatura diretta
user1	principal.user.userid	Mappatura diretta
user_id	principal.user.userid	Mappatura diretta
username	principal.user.userid	Mappatura diretta
action	security_result.action	Unita
message	security_result.action	Mapped: (?i)(succeeded/accounting start/open/occurred/update/successfully/success) → `acti…
classification	security_result.category_details	Unita
msg1	security_result.description	Mappatura diretta
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	Mappatura: 1 → LOW
description_1	security_result.summary	Mappatura diretta
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	Mappatura diretta
prts	target.port	Mappatura diretta
responder_port	target.port	Mappatura diretta
target_port	target.port	Mappatura diretta
target_port1	target.port	Mappatura diretta
filetype	target.process.file.mime_type	Mappatura diretta
parent_identifier_label	target.resource.attribute.labels	Unita
specific_identifer_label	target.resource.attribute.labels	Unita
target_name	target.resource.name	Mappatura diretta
instance_id	target.resource.product_object_id	Mappatura diretta
target_username	target.user.userid	Mappatura diretta
user	target.user.userid	Mappatura diretta
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.