Raccogli i log di Akamai Guardicore Segmentation (in precedenza Guardicore Centra)

Supportata in:

Google SecOps SIEM

Questo documento spiega come configurare Akamai Guardicore Segmentation (precedentemente Guardicore Centra) per inviare i log a Google Security Operations utilizzando Akamai Unified Log Streamer (ULS) con output HTTP.

Guardicore Centra è una piattaforma di microsegmentazione che fornisce sicurezza di rete Zero Trust per data center, ambienti cloud ed endpoint. Offre visibilità sulle dipendenze delle applicazioni, rilevamento delle violazioni tramite tecnologia di inganno e controlli di segmentazione granulari per impedire il movimento laterale e contenere le minacce.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Un'istanza Google SecOps
• Istanza Guardicore Centra (cloud o on-premise)
• Un server Linux per eseguire Akamai ULS (minimo: 1 vCPU, 1 GB di RAM, 500 MB di disco)
• Python 3.9 o versioni successive installato sul server ULS
• Accesso amministratore a Guardicore Centra per creare un utente API di sola lettura
• Accesso HTTPS in uscita dal server ULS agli endpoint di importazione di Google SecOps
• Accesso alla console Google Cloud (per la creazione della chiave API)

Crea il feed in Google SecOps

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. Nella pagina successiva, fai clic su Configura un singolo feed.
4. Nel campo Nome feed, inserisci un nome per il feed. Ad esempio, Guardicore Centra Logs.
5. Seleziona Webhook come Tipo di origine.
6. Seleziona Guardicore Centra come Tipo di log.
7. Fai clic su Avanti.
8. Specifica i valori per i seguenti parametri di input:
   • Delimitatore di suddivisione: inserisci \n per suddividere gli eventi su più righe (ULS invia JSON delimitato da nuova riga).
   • 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 di notizie nella schermata Finalizza e poi fai clic su Invia.

Genera e salva la chiave segreta

Dopo aver creato il feed, devi generare una chiave segreta per l'autenticazione nel seguente modo:

1. Nella pagina dei dettagli del feed, fai clic su Genera chiave segreta.
2. Viene visualizzata una finestra di dialogo con la chiave segreta.
3. Copia e salva la chiave segreta in modo sicuro.

Importante: la chiave segreta viene visualizzata una sola volta e non può essere recuperata in un secondo momento. Se la perdi, devi generare una nuova chiave segreta.

Ottieni l'URL dell'endpoint del feed

1. Vai alla scheda Dettagli del feed.
2. Nella sezione Endpoint Information (Informazioni sull'endpoint), copia l'URL endpoint del feed.

3. Il formato dell'URL è:

   https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs
   

   o

   https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs
   

4. Salva questo URL per i passaggi successivi.

5. Fai clic su Fine.

Crea una chiave API Google Cloud

Google SecOps richiede una chiave API per l'autenticazione. Crea una chiave API limitata nella console Google Cloud .

Crea la chiave API

1. Vai alla pagina Credenziali della consoleGoogle Cloud .
2. Seleziona il progetto. Questo è il progetto associato alla tua istanza Google SecOps.
3. Fai clic su Crea credenziali > Chiave API.
4. Viene creata una chiave API, che viene visualizzata in una finestra di dialogo.
5. Fai clic su Modifica chiave API per limitare la chiave.

Limita la chiave API

1. Nella pagina delle impostazioni della chiave API:
   • Nome: inserisci un nome descrittivo (ad esempio Google SecOps Guardicore Webhook API Key).
2. In Restrizioni API:
   1. Seleziona Limita chiave.
   2. Nel menu a discesa Seleziona API, cerca e seleziona API Chronicle.
3. Fai clic su Salva.
4. Copia il valore della chiave API dal campo Chiave API nella parte superiore della pagina.
5. Salva la chiave API in modo sicuro.

Nota: la limitazione della chiave API garantisce che possa essere utilizzata solo con l'API Chronicle, riducendo il rischio per la sicurezza in caso di compromissione della chiave.

Configura le credenziali di Guardicore Centra

Crea un utente API di sola lettura in Guardicore Centra

ULS si autentica nell'API Centra con un utente del portale. Crea un utente dedicato con autorizzazioni di sola lettura anziché utilizzare un account amministratore, come segue:

1. Accedi alla console di gestione di Guardicore Centra.
2. Vai ad Amministrazione > Utenti.
3. Fai clic su Create User (Crea utente).
4. Fornisci i seguenti dettagli di configurazione:
   • Nome utente: inserisci un nome per l'utente dell'integrazione (ad esempio secops-uls).
   • Password: inserisci una password.
   • Schema di autorizzazione: seleziona Assistenza (accesso di sola lettura).
5. Fai clic su Salva.
6. Esci e accedi con il nuovo utente, quindi completa la modifica obbligatoria della password.
7. Prendi nota del nome host della console di gestione Centra (senza https://). ULS lo utilizza come nome host dell'API.

Crea il file .edgerc per l'autenticazione di Guardicore

Akamai ULS legge le credenziali di Guardicore dal file .edgerc, dalle chiavi gc_hostname, gc_username e gc_password.

1. Sul server ULS, crea il file .edgerc nella home directory nel seguente modo:

   nano ~/.edgerc
   

2. Aggiungi la seguente configurazione:

   [default]
   gc_hostname = your-instance.cloud.guardicore.com
   gc_username = your_username
   gc_password = your_password
   

   Sostituisci i seguenti valori:

   • your-instance.cloud.guardicore.com: il nome host di gestione di Guardicore Centra (senza https://)
   • your_username: il nome utente dell'utente API di sola lettura creato nella sezione precedente
   • your_password: la password dell'utente

   Esempio:

   [default]
   gc_hostname = cus-1234.cloud.guardicore.com
   gc_username = secops-uls
   gc_password = MySecurePassword123
   

3. Salva e chiudi il file.

4. Imposta le autorizzazioni appropriate come segue:

   chmod 600 ~/.edgerc
   

Nota: ULS verifica che tutte e tre le chiavi gc_* siano presenti prima di avviare un feed Guardicore. Le chiavi linode_hostname e linode_token appartengono all'integrazione Linode separata e non vengono lette per Guardicore.

Installa Akamai ULS

Installa ULS da GitHub

1. Sul server ULS, clona il repository ULS come segue:

   git clone https://github.com/akamai/uls.git
   cd uls
   

2. Installa le dipendenze Python:

   pip3 install -r requirements.txt
   

3. Installa il modulo di recupero dei log di Guardicore (gc-logs) nella directory ext del checkout di ULS:

   git clone -q --depth 1 -b v0.0.8 --single-branch https://github.com/MikeSchiessl/gc-logs.git ext/cli-gc
   pip3 install -r ext/cli-gc/bin/requirements.txt
   

   Nota: ULS carica il modulo Guardicore da ext/cli-gc. Il modulo è pubblicato nel repository gc-logs a cui fanno riferimento la documentazione di installazione di ULS e il Dockerfile; il precedente repository guardicore/log-fetcher non esiste più. Il tag v0.0.8 è la versione bloccata dal Dockerfile ULS (GC_CLI_VERSION); utilizza il tag della release ULS che installi.

4. Verifica l'installazione:

   python3 bin/uls.py --help
   

Configura ULS per inviare i log a Google SecOps

Crea l'URL webhook di Google SecOps

• Combina l'URL dell'endpoint Google SecOps e la chiave API come segue:

  <ENDPOINT_URL>?key=<API_KEY>
  

• Esempio:

  https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=AIzaSyD...
  

Esegui ULS per il feed NETLOG di Guardicore

Il feed NETLOG contiene i log dei flussi di rete degli agenti Guardicore.

1. Esegui ULS con il seguente comando:

   python3 bin/uls.py \
       --input gc \
       --feed NETLOG \
       --output http \
       --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
       --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
       --httpformat '%s'
   

   • Sostituisci i seguenti valori:
     • YOUR_API_KEY: la chiave API Google Cloud creata in precedenza
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps generata in precedenza

2. ULS inizia a trasmettere gli eventi NETLOG a Google SecOps.

Esegui ULS per il feed Guardicore INCIDENT

Il feed INCIDENT contiene gli incidenti di sicurezza rilevati da Guardicore.

1. Esegui ULS con il seguente comando:

   python3 bin/uls.py \
       --input gc \
       --feed INCIDENT \
       --output http \
       --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
       --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
       --httpformat '%s'
   

   • Sostituisci i seguenti valori:
     • YOUR_API_KEY: la chiave API Google Cloud creata in precedenza
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps generata in precedenza

2. ULS inizia a trasmettere gli eventi INCIDENT a Google SecOps.

Esegui ULS per il feed Guardicore AGENT

Il feed AGENT contiene informazioni sullo stato e sull'integrità dell'agente.

1. Esegui ULS con il seguente comando:

   python3 bin/uls.py \
       --input gc \
       --feed AGENT \
       --output http \
       --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
       --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
       --httpformat '%s'
   

   • Sostituisci i seguenti valori:
     • YOUR_API_KEY: la chiave API Google Cloud creata in precedenza
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps generata in precedenza

2. ULS inizierà a trasmettere in streaming gli eventi AGENT a Google SecOps.

Esegui ULS per il feed Guardicore SYSTEM

Il feed SYSTEM contiene avvisi ed eventi di sistema.

1. Esegui ULS con il seguente comando:

   python3 bin/uls.py \
       --input gc \
       --feed SYSTEM \
       --output http \
       --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
       --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
       --httpformat '%s'
   

   • Sostituisci i seguenti valori:
     • YOUR_API_KEY: la chiave API Google Cloud creata in precedenza
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps generata in precedenza

2. ULS inizierà a trasmettere in streaming gli eventi SYSTEM a Google SecOps.

Esegui ULS per il feed AUDIT di Guardicore

Il feed AUDIT contiene gli audit log delle azioni amministrative.

1. Esegui ULS con il seguente comando:

   python3 bin/uls.py \
       --input gc \
       --feed AUDIT \
       --output http \
       --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
       --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
       --httpformat '%s'
   

   • Sostituisci i seguenti valori:
     • YOUR_API_KEY: la chiave API Google Cloud creata in precedenza
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps generata in precedenza

2. ULS inizierà a trasmettere in streaming gli eventi AUDIT a Google SecOps.

Esegui ULS come servizio in background

Per garantire che ULS venga eseguito in modo continuo, configuralo come servizio systemd.

Crea un file di servizio systemd per il feed NETLOG

1. Crea un file di servizio:

   sudo nano /etc/systemd/system/uls-guardicore-netlog.service
   

2. Aggiungi i seguenti contenuti:

   [Unit]
   Description=Akamai ULS - Guardicore NETLOG
   After=network.target
   
   [Service]
   Type=simple
   User=root
   WorkingDirectory=/root/uls
   ExecStart=/usr/bin/python3 /root/uls/bin/uls.py --input gc --feed NETLOG --output http --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' --httpformat '%%s'
   Restart=always
   RestartSec=10
   
   [Install]
   WantedBy=multi-user.target
   

   • Sostituisci i seguenti valori:
     • /root/uls: il percorso in cui hai clonato il repository ULS
     • YOUR_API_KEY: la chiave API Google Cloud
     • YOUR_SECRET_KEY: la chiave segreta di Google SecOps

3. Salva e chiudi il file.

4. Attiva e avvia il servizio:

   sudo systemctl daemon-reload
   sudo systemctl enable uls-guardicore-netlog.service
   sudo systemctl start uls-guardicore-netlog.service
   

5. Controlla lo stato del servizio:

   sudo systemctl status uls-guardicore-netlog.service
   

Crea servizi aggiuntivi per altri feed

Ripeti i passaggi precedenti per ogni feed che vuoi raccogliere (INCIDENT, AGENT, SYSTEM, AUDIT), creando file di servizio separati come segue:

• /etc/systemd/system/uls-guardicore-incident.service
• /etc/systemd/system/uls-guardicore-agent.service
• /etc/systemd/system/uls-guardicore-system.service
• /etc/systemd/system/uls-guardicore-audit.service

Modifica il parametro --feed e il nome del servizio di conseguenza in ogni file.

Verifica l'importazione dei log

1. Attendi 5-10 minuti per l'importazione e l'elaborazione dei log.
2. Nella console Google SecOps, vai a Ricerca.

3. Esegui la seguente query di ricerca UDM:

   metadata.vendor_name = "Guardicore"
   

4. Se i log vengono importati correttamente, dovresti visualizzare gli eventi Guardicore nei risultati di ricerca.

5. Puoi anche cercare tipi di feed specifici:

   metadata.vendor_name = "Guardicore" AND metadata.product_name = "Centra"
   

Risoluzione dei problemi

Errori di connessione ULS

Se ULS non riesce a connettersi a Guardicore, segui questi passaggi:

1. Verifica che il file .edgerc contenga il nome host e le credenziali corretti.

2. Testa la connettività alla tua istanza Guardicore nel seguente modo:

   curl -u "username:password" https://your-instance.cloud.guardicore.com/api/v3.0/visibility
   

3. Verifica che l'istanza Guardicore sia accessibile dal server ULS.

Errori di output HTTP ULS

Se ULS non riesce a inviare i log a Google SecOps, segui questi passaggi:

1. Verifica che le chiavi API e segrete siano corrette.
2. Verifica che l'URL dell'endpoint Google SecOps sia corretto per la tua regione.

3. Verifica la connettività HTTPS in uscita dal server ULS:

   curl -I https://malachiteingestion-pa.googleapis.com
   

4. Esamina i log ULS per individuare i messaggi di errore:

   sudo journalctl -u uls-guardicore-netlog.service -f
   

I log non vengono visualizzati nella piattaforma

Se i log non vengono visualizzati in Google SecOps, segui questi passaggi:

1. Verifica che il feed del webhook sia in stato Attivo in Impostazioni > Gestione dei dati > Feed.
2. Controlla la scheda Integrità del feed per verificare la presenza di errori di importazione.
3. Verifica che il delimitatore di suddivisione sia impostato su \n nella configurazione del feed.
4. Assicurati che il tipo di log sia impostato su Guardicore Centra.

Errori dei certificati autofirmati

Se l'istanza Guardicore utilizza un certificato autofirmato, ULS potrebbe non riuscire con errori di verifica SSL. Per bypassare la verifica SSL (non consigliato per la produzione), segui questi passaggi:

• Aggiungi il flag --httpinsecure al comando ULS:

  python3 bin/uls.py \
      --input gc \
      --feed NETLOG \
      --output http \
      --httpurl "https://<REGION>-chronicle.googleapis.com/v1alpha/projects/<PROJECT_NUMBER>/locations/<REGION>/instances/<INSTANCE_ID>/feeds/<FEED_ID>:importPushLogs?key=YOUR_API_KEY" \
      --httpauthheader '{"X-Webhook-Access-Key": "YOUR_SECRET_KEY"}' \
      --httpformat '%s' \
      --httpinsecure
  

Nota: l'utilizzo di --httpinsecure disattiva la verifica del certificato SSL e deve essere utilizzato solo in ambienti di test.

Feed Guardicore disponibili

Akamai ULS supporta i seguenti feed Guardicore:

Nome feed	Descrizione	Parametro del feed ULS
NETLOG	Log di flusso di rete dagli agenti Guardicore	NETLOG
INCIDENT	Incidenti di sicurezza rilevati da Guardicore	INCIDENT
AGENT	Stato dell'agente e informazioni sull'integrità	AGENT
SYSTEM	Avvisi di sistema**	Avvisi ed eventi a livello di sistema
AUDIT Logs	Azioni amministrative e modifiche alla configurazione	AUDIT

Riferimento ai metodi di autenticazione

I feed webhook di Google SecOps supportano diversi metodi di autenticazione. Akamai ULS utilizza il metodo ibrido con la chiave API nell'URL e la chiave segreta nell'intestazione.

Metodo utilizzato da ULS: ibrido (URL + intestazione)

• Formato della richiesta:

  POST <ENDPOINT_URL>?key=<API_KEY> HTTP/1.1
  Content-Type: application/json
  X-Webhook-Access-Key: <SECRET_KEY>
  
  {"event": "data", "timestamp": "2025-01-15T10:30:00Z"}
  

• Formato del comando ULS:

  --httpurl "<ENDPOINT_URL>?key=<API_KEY>"
  --httpauthheader '{"X-Webhook-Access-Key": "<SECRET_KEY>"}'
  

Nomi delle intestazioni di autenticazione

Google SecOps accetta i seguenti nomi di intestazione per l'autenticazione:

Per la chiave API:

• X-goog-api-key (consigliata)
• X-goog-api-key (senza distinzione tra maiuscole e minuscole)

Per la chiave segreta:

• X-Webhook-Access-Key (consigliata)
• X-Webhook-Access-Key (senza distinzione tra maiuscole e minuscole)

Limiti e best practice dei webhook

Limiti per le richieste

Limite	Valore
Max single log line	1 MB
QPS (query al secondo) max	15.000
Timeout richieste	90 secondi
Comportamento dei nuovi tentativi	Gestito dal mittente. Google SecOps restituisce l'errore HTTP 429 quando viene superato il limite di burst; il sistema di invio deve eseguire il buffering e riprovare.

Best practice

• Esegui istanze ULS separate per ogni tipo di feed per migliorare l'affidabilità e la risoluzione dei problemi.
• Monitora lo stato del servizio ULS utilizzando systemd e configura gli avvisi per gli errori del servizio.
• Ruota periodicamente le credenziali di Guardicore e aggiorna il file .edgerc.
• Utilizza un account di servizio dedicato in Guardicore con accesso API di sola lettura.
• Configura la rotazione dei log per i log ULS per evitare problemi di spazio su disco.
• Testa gli scenari di failover eseguendo ULS su più server con bilanciamento del carico.

Tabella di mappatura UDM

La tabella seguente elenca i campi del log di Guardicore Centra e i campi UDM corrispondenti.

Campo log	Campo UDM	Descrizione
timestamp	metadata.event_timestamp	Timestamp evento
source_ip	principal.ip	Indirizzo IP di origine
destination_ip	target.ip	Indirizzo IP di destinazione
source_port	principal.port	Numero di porta di origine
destination_port	target.port	Numero di porta di destinazione
protocol	network.ip_protocol	Protocollo di rete
action	security_result.action	Azione di sicurezza intrapresa
severity	security_result.severity	Gravità dell'evento
user	principal.user.userid	Nome utente
hostname	principal.hostname	Nome host di origine
process_name	principal.process.file.full_path	Nome processo
incident_id	security_result.detection_fields.key	Identificatore incidente
description	security_result.description	Descrizione evento

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.