Questa pagina è stata tradotta dall'API Cloud Translation.

Raccogliere i log WAF di Akamai

Supportato in:

Google secops SIEM

Questo documento spiega come esportare e importare i log WAF di Akamai in Google Security Operations utilizzando Google Cloud Storage o AWS S3. Il parser gestisce i log, supportando i formati syslog e CEF. Estrae campi come indirizzi IP, URL, metodi HTTP, codici di risposta, user agent e informazioni sulle regole di sicurezza, mappandoli al modello UDM (Unified Data Model) per una rappresentazione coerente. Il parser gestisce anche campi Akamai specifici come attackData e clientReputation, eseguendo le trasformazioni dei dati necessarie e arricchendo l'output UDM.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

Istanza Google SecOps
Accesso privilegiato a Google Cloud o AWS
Accesso privilegiato ad Akamai

Esportazione e importazione dei log WAF Akamai da Cloud Storage

Questa sezione descrive il passaggio iniziale della procedura: la configurazione dello spazio di archiviazione necessario per i log WAF di Akamai.

Crea un Google Cloud bucket di archiviazione

Accedi alla Google Cloud console.
Vai alla pagina Bucket Cloud Storage.

Vai a Bucket
Fai clic su Crea.
Nella pagina Crea un bucket, inserisci le informazioni del bucket. Dopo ogni passaggio riportato di seguito, fai clic su Continua per passare al passaggio successivo:
1. Nella sezione Inizia:
  - Inserisci un nome univoco che soddisfi i requisiti per i nomi dei bucket (ad esempio, akamai-waf-logs).
  - Per attivare lo spazio dei nomi gerarchico, fai clic sulla freccia di espansione per espandere la sezione Ottimizza per workload orientati ai file e con uso intensivo dei dati, poi seleziona Abilita uno spazio dei nomi gerarchico in questo bucket.
  Nota: non puoi abilitare lo spazio dei nomi gerarchico in un bucket esistente.
  - Per aggiungere un'etichetta del bucket, fai clic sulla freccia di espansione per espandere la sezione Etichette.
  - Fai clic su Aggiungi etichetta e specifica una chiave e un valore per l'etichetta.
2. Nella sezione Scegli dove archiviare i tuoi dati, segui questi passaggi:
  - Seleziona un Tipo di località.
  - Utilizza il menu a discesa del tipo di località per selezionare una località in cui verranno archiviati in modo permanente i dati degli oggetti all'interno del bucket.
  Nota: se selezioni il tipo di località a doppia regione, puoi anche scegliere di attivare la replica turbo utilizzando la casella di controllo pertinente.
  - Per configurare la replica tra bucket, espandi la sezione Configura replica tra bucket.
3. Nella sezione Scegli una classe di archiviazione per i tuoi dati, seleziona una classe di archiviazione predefinita per il bucket oppure Autoclass per la gestione automatica della classe di archiviazione dei dati del bucket.
4. Nella sezione Scegli come controllare l'accesso agli oggetti, seleziona No per applicare la prevenzione dell'accesso pubblico e seleziona un modello di controllo dell'accesso per gli oggetti del bucket.
  
  Nota: se la prevenzione dell'accesso pubblico è già applicata dal criterio dell'organizzazione del progetto, la casella di controllo Impedisci accesso pubblico è bloccata.
5. Nella sezione Scegli come proteggere i dati degli oggetti, segui questi passaggi:
  - Seleziona una delle opzioni in Protezione dei dati che vuoi impostare per il bucket.
  - Per scegliere come criptare i dati degli oggetti, fai clic sulla freccia di espansione con l'etichetta Crittografia dei dati e seleziona un metodo di crittografia dei dati.
Fai clic su Crea.

Importante: assicurati che all'account di servizio Google SecOps siano concesse le autorizzazioni Lettura o Lettura e scrittura per questo bucket.

Configura le autorizzazioni per Cloud Storage

Vai alla pagina Crea account di servizio.

Vai a Crea service account
Seleziona un progetto Google Cloud.
Inserisci un nome service account da visualizzare nella Google Cloud console.

Nota: la console Google Cloud genera un ID account di servizio in base a questo nome. Modifica l'ID, se necessario. Non potrai modificare l'ID in un secondo momento.
Fai clic su Crea e continua.
Concedi il ruolo roles/storage.admin sul bucket.
Fai clic su Fine per completare la creazione del service account.

Crea e scarica Google Cloud il file della chiave del service account

Vai alla pagina Account di servizio.

Vai ad Account di servizio
Seleziona un progetto Google Cloud.
Fai clic sull'indirizzo email del account di servizio appena creato.
Fai clic sulla scheda Chiavi.
Fai clic sul menu Aggiungi chiave, quindi seleziona Crea nuova chiave.
Seleziona JSON come tipo di chiave e fai clic su Crea.
- Facendo clic su Crea viene scaricato un file della chiave del service account. Una volta scaricato, il file della chiave non potrà essere scaricato di nuovo.
- La chiave scaricata ha il seguente formato, dove PRIVATE_KEY è la parte privata della coppia di chiavi pubbliche/private.

Configura Akamai WAF per inviare i log a Cloud Storage

Accedi ad Akamai Control Center.
Vai alla sezione Sicurezza.
Seleziona Log.
Configura una nuova distribuzione dei log:
- Origine log:seleziona la configurazione WAF.
- Destinazione:seleziona Google Cloud Storage.
- Nome visualizzato: inserisci una descrizione del nome univoca.
- Bucket:specifica il nome del bucket Cloud Storage che hai creato (ad esempio, gs://akamai-waf-logs).
- ID progetto: inserisci l'ID univoco del tuo Google Cloud progetto.
- Nome service account: inserisci il nome del account di servizio che hai creato in precedenza.
- Chiave privata:inserisci il valore private_key della chiave JSON che hai generato e scaricato in precedenza. Devi inserire la chiave privata in formato PEM con simboli di interruzione (\n), ad esempio -----BEGIN PRIVATE KEY-----\nprivate_key\n-----END PRIVATE KEY-----\n.
- Formato log:scegli il formato log che preferisci (ad esempio, JSON).
- Frequenza push:seleziona la frequenza con cui vuoi ricevere i log (ad esempio, every 60 seconds).
Fai clic su Convalida e salva per convalidare la connessione alla destinazione e salvare i dettagli che hai fornito.

Nota :nell'ambito della procedura di convalida, il sistema utilizza l'identificatore e la chiave di accesso segreta forniti per creare un file di verifica nel bucket Cloud Storage, con un timestamp nel nome file nel formato Akamai_access_verification_[TimeStamp].txt. Puoi visualizzare questo file solo se la procedura di convalida va a buon fine e se hai accesso al bucket Storage Google Cloud a cui stai tentando di inviare i log.
Fai clic su Avanti per passare alla scheda Riepilogo.

Configurare i feed

Esistono due diversi punti di accesso per configurare i feed nella piattaforma Google SecOps:

Impostazioni SIEM > Feed
Hub dei contenuti > Pacchetti di contenuti

Configura i feed da Impostazioni SIEM > Feed utilizzando Google Cloud Storage

Per configurare un feed:

Vai a Impostazioni SIEM > Feed.
Fai clic su Aggiungi nuovo feed.
Nella pagina successiva, fai clic su Configura un singolo feed.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Akamai WAF Logs).
Seleziona Google Cloud Storage come Tipo di origine.
Seleziona Akamai WAF come Tipo di log.
Fai clic su Ottieni account di servizio come Account di servizio Chronicle.
Fai clic su Avanti.
Specifica i valori per i seguenti parametri di input:
- URI bucket di archiviazione: Google Cloud URL del bucket di archiviazione (ad esempio, gs://akamai-waf-logs).
- URI Is A: seleziona Directory which includes subdirectories (Directory che include sottodirectory).
- Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
Nota: se selezioni l'opzione Delete transferred files o Delete transferred files and empty directories, assicurati di aver concesso le autorizzazioni appropriate al service account.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Configurare i feed dall'hub dei contenuti

Specifica i valori per i seguenti campi:

URI bucket di archiviazione: Google Cloud URL del bucket di archiviazione (ad esempio, gs://akamai-waf-logs).
URI Is A: seleziona Directory which includes subdirectories (Directory che include sottodirectory).
Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.

Nota: se selezioni l'opzione Delete transferred files o Delete transferred files and empty directories, assicurati di aver concesso le autorizzazioni appropriate al service account.

Opzioni avanzate

Nome feed: un valore precompilato che identifica il feed.
Tipo di origine: metodo utilizzato per raccogliere i log in Google SecOps.
Spazio dei nomi dell'asset: lo spazio dei nomi associato al feed.
Etichette di importazione: etichette applicate a tutti gli eventi di questo feed.

Esportare e importare i log Akamai WAF da AWS S3

Questa sezione spiega i passaggi iniziali per configurare il bucket Amazon S3 per ricevere e archiviare i log WAF di Akamai.

Configura il bucket Amazon S3

Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket.
Salva il Nome e la Regione del bucket per riferimento futuro.
Crea un utente seguendo questa guida utente: Creazione di un utente IAM.
Seleziona l'utente creato.
Seleziona la scheda Credenziali di sicurezza.
Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
Seleziona Servizio di terze parti come Caso d'uso.
Fai clic su Avanti.
(Facoltativo) Aggiungi il tag della descrizione.
Fai clic su Crea chiave di accesso.
Fai clic su Scarica file CSV per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
Fai clic su Fine.
Seleziona la scheda Autorizzazioni.
Fai clic su Aggiungi autorizzazioni nella sezione Criteri per le autorizzazioni.
Seleziona Aggiungi autorizzazioni.
Seleziona Allega direttamente le norme.
Cerca il criterio AmazonS3FullAccess.
Seleziona la policy.
Fai clic su Avanti.
Fai clic su Aggiungi autorizzazioni.

Configura Akamai WAF per inviare i log ad Amazon S3

Accedi ad Akamai Control Center.
Vai alla sezione Sicurezza.
Seleziona Log.
Configura una nuova distribuzione dei log:
- Origine log:seleziona la configurazione WAF.
- Destinazione:scegli Amazon S3.
- Bucket S3:specifica il nome del bucket S3 che hai creato.
- Regione:seleziona la regione AWS in cui si trova il bucket S3.
- ID chiave di accesso e chiave di accesso segreta:fornisci le credenziali che hai generato.
- Formato log:scegli il formato log che preferisci (ad esempio, JSON).
- Frequenza di consegna:seleziona la frequenza con cui vuoi ricevere i log (ad esempio, ogni 5 minuti).
  
  Nota: per la pubblicazione continua, scegli l'opzione più frequente disponibile.
Verifica la pubblicazione dei log:
- Dopo aver configurato LDS, monitora il bucket S3 per i file di log in entrata.

Configura i feed da Impostazioni SIEM > Feed utilizzando AWS S3

Per configurare un feed:

Vai a Impostazioni SIEM > Feed.
Fai clic su Aggiungi nuovo feed.
Nella pagina successiva, fai clic su Configura un singolo feed.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Akamai WAF Logs).
Seleziona Amazon S3 come Tipo di origine.
Seleziona Akamai WAF come Tipo di log.
Fai clic su Avanti.
Specifica i valori per i seguenti parametri di input:
- Region (Regione): la regione in cui si trova il bucket Amazon S3.
- URI S3: l'URI del bucket. s3:/BUCKET_NAME Sostituisci quanto segue:
  - BUCKET_NAME: il nome del bucket.
- URI è un: seleziona TIPO DI URI in base alla configurazione del flusso di log: Singolo file | Directory | Directory che include sottodirectory.
- Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
Nota: se selezioni l'opzione Delete transferred files o Delete transferred files and empty directories, assicurati di aver concesso le autorizzazioni appropriate al service account.
- ID chiave di accesso: la chiave di accesso utente con accesso al bucket S3.
- Chiave di accesso segreta: la chiave segreta dell'utente con accesso al bucket S3.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log (crescente)	Mappatura UDM	Logic
`attackData.clientIP`	`principal.ip`, `principal.asset.ip`	Indirizzo IP del client che avvia la richiesta. Estratto dal campo `attackData.clientIP` nei log akamai_siem.
`attackData.configId`	`metadata.product_log_id`	ID configurazione di sicurezza. Estratto dal campo `attackData.configId` nei log akamai_siem. Aggiunto anche come detection_field nell'oggetto security_result.
`attackData.policyId`	N/D	Utilizzato nella logica del parser per compilare `security_result.summary` con il valore `PolicyId:[value]`.
`attackData.ruleActions`	`security_result.action`, `security_result.action_details`	Azioni intraprese in base alla regola attivata. Estratto dal campo `attackData.ruleActions` nei log akamai_siem. "deny" è mappato a BLOCK, gli altri valori ("alert", "monitor", "allow", "tarpit") sono mappati a ALLOW. Il valore originale è memorizzato anche in `action_details`.
`attackData.ruleData`	`security_result.detection_fields`	Dati associati alla regola attivata. Estratto dal campo `attackData.ruleData` nei log akamai_siem. Aggiunto a `security_result.detection_fields` con la chiave "RuleData".
`attackData.ruleMessages`	`security_result.threat_name`	Messaggi associati alla regola attivata. Estratto dal campo `attackData.ruleMessages` nei log akamai_siem.
`attackData.ruleSelectors`	`security_result.detection_fields`	Selettori associati alla regola attivata. Estratto dal campo `attackData.ruleSelectors` nei log akamai_siem. Aggiunta a `security_result.detection_fields` con la chiave "RuleSelector".
`attackData.ruleTags`	`security_result.category_details`	Tag associati alla regola attivata. Estratto dal campo `attackData.ruleTags` nei log akamai_siem.
`attackData.ruleVersions`	`security_result.detection_fields`	Versioni delle regole attivate. Estratto dal campo `attackData.ruleVersions` nei log akamai_siem. Aggiunto a `security_result.detection_fields` con la chiave "Rule Version".
`clientReputation`	`principal.labels`	Informazioni sulla reputazione del cliente. Estratto dal campo `clientReputation` nei log akamai_siem. Aggiunta come etichetta all'entità con la chiave "reputation".
`cliIP`, `cli_ip`, `principal_ip`	`principal.ip`, `principal.asset.ip`	Indirizzo IP client. Estratto da `cliIP` o `cli_ip` o `principal_ip` a seconda del formato del log.
`cp`	`additional.fields`	Codice CP. Estratto dal campo `cp`. Aggiunto a `additional.fields` con la chiave "cp".
`eventId`	`metadata.product_log_id`	ID evento. Estratto dal campo `eventId`.
`eventTime`, `log_date`	`metadata.event_timestamp`	Timestamp dell'evento. Estratto da `eventTime` o analizzato da `log_date` a seconda del formato del log.
`eventType.eventDefinition.eventDefinitionId`	`target.resource.product_object_id`	ID definizione evento. Estratto da `eventType.eventDefinition.eventDefinitionId`.
`eventType.eventDefinition.eventDescription`	`metadata.description`	Descrizione dell'evento. Estratto da `eventType.eventDefinition.eventDescription`.
`eventType.eventDefinition.eventName`	`metadata.product_event_type`	Nome dell'evento. Estratto da `eventType.eventDefinition.eventName`.
`eventType.eventTypeId`	`additional.fields`	ID tipo di evento. Estratto da `eventType.eventTypeId`. Aggiunto a `additional.fields` con la chiave "eventTypeId".
`eventType.eventTypeName`	`additional.fields`	Nome del tipo di evento. Estratto da `eventType.eventTypeName`. Aggiunto a `additional.fields` con la chiave "eventTypeName".
`format`	N/D	Utilizzato dal parser per determinare il formato del log.
`geo.asn`	`principal.location.name`	Numero di sistema autonomo (ASN). Estratto da `geo.asn` o `AkamaiSiemASN` a seconda del formato del log. Il valore è preceduto da "ASN ".
`geo.city`	`principal.location.city`	Città. Estratto da `geo.city` o `AkamaiSiemCity` a seconda del formato del log.
`geo.country`	`principal.location.country_or_region`	Paese. Estratto da `geo.country` o `AkamaiSiemContinent` a seconda del formato del log.
`httpMessage.bytes`	`network.sent_bytes`	Byte inviati nel messaggio HTTP. Estratto da `httpMessage.bytes`.
`httpMessage.host`	`target.hostname`, `target.asset.hostname`	Nome host. Estratto da `httpMessage.host` o `reqHost` a seconda del formato del log.
`httpMessage.method`	`network.http.method`	Metodo HTTP. Estratto da `httpMessage.method` o `network_http_method` o `reqMethod` a seconda del formato del log. Convertito in maiuscolo.
`httpMessage.path`	`target.url`	Percorso richiesta. Estratto da `httpMessage.path` o `target_url` o `reqPath` a seconda del formato del log. Se `httpMessage.query` è presente, viene aggiunto al percorso con un separatore "?".
`httpMessage.port`	`target.port`	Porta. Estratto da `httpMessage.port` o `reqPort` a seconda del formato del log.
`httpMessage.protocol`	N/D	Utilizzato dal parser per determinare il protocollo.
`httpMessage.query`	N/D	Utilizzato nella logica del parser per l'aggiunta a `httpMessage.path`, se presente.
`httpMessage.requestId`	`network.session_id`	ID richiesta. Estratto da `httpMessage.requestId` o `reqId` a seconda del formato del log.
`httpMessage.requestHeaders`, `AkamaiSiemRequestHeaders`	`additional.fields`	Intestazioni delle richieste. Estratto da `httpMessage.requestHeaders` o `AkamaiSiemRequestHeaders` a seconda del formato del log. Aggiunto a `additional.fields` con la chiave "AkamaiSiemRequestHeaders".
`httpMessage.responseHeaders`, `AkamaiSiemResponseHeaders`	`additional.fields`	Intestazioni della risposta. Estratto da `httpMessage.responseHeaders` o `AkamaiSiemResponseHeaders` a seconda del formato del log. Aggiunto a `additional.fields` con la chiave "AkamaiSiemResponseHeaders".
`httpMessage.status`, `AkamaiSiemResponseStatus`, `network_http_response_code`, `statusCode`	`network.http.response_code`	Codice di risposta HTTP. Estratto da `httpMessage.status` o `AkamaiSiemResponseStatus` o `network_http_response_code` o `statusCode` a seconda del formato del log.
`httpMessage.tls`, `AkamaiSiemTLSVersion`, `tlsVersion`	`network.tls.version`	Versione TLS. Estratto da `httpMessage.tls` o `AkamaiSiemTLSVersion` o `tlsVersion` a seconda del formato del log.
`httpMessage.useragent`, `network_http_user_agent`, `UA`, `useragent`	`network.http.user_agent`	User agent. Estratto da `httpMessage.useragent` o `network_http_user_agent` o `UA` o `useragent` a seconda del formato del log.
`log_description`	`metadata.description`	Descrizione del log. Estratto da `log_description`.
`log_rule`	`security_result.rule_name`	Regola Log. Estratto da `log_rule`.
`message`	N/D	Il messaggio di log non elaborato. Utilizzato dal parser per varie estrazioni.
`network_http_referral_url`	`network.http.referral_url`	URL di referral HTTP. Estratto da `network_http_referral_url`.
`proto`	N/D	Utilizzato nella logica del parser per compilare `security_result.summary` se `attackData.policyId` non è presente.
`reqHost`	`target.hostname`, `target.asset.hostname`	Richiedi host. Estratto da `reqHost`.
`reqId`	`metadata.product_log_id`, `network.session_id`	ID richiesta. Estratto da `reqId`.
`reqMethod`	`network.http.method`	Metodo di richiesta. Estratto da `reqMethod`.
`reqPath`	`target.url`	Percorso richiesta. Estratto da `reqPath`.
`reqPort`	`target.port`	Porta richiesta. Estratto da `reqPort`.
`rspContentType`	`target.file.mime_type`	Tipo di contenuti della risposta. Estratto da `rspContentType`.
`securityRules`	`security_result.rule_name`, `security_result.about.resource.attribute.labels`	Regole di sicurezza. Estratto da `securityRules`. La prima parte è mappata a `rule_name`, mentre il resto viene aggiunto come etichette con le chiavi "non_deny_rules" e "deny_rule_format".
`statusCode`	`network.http.response_code`	Codice di stato. Estratto da `statusCode`.
`state`	`principal.location.state`, `target.user.personal_address.state`	Stato. Estratto da `state`.
`tlsVersion`	`network.tls.version`	Versione TLS. Estratto da `tlsVersion`.
`type`	`metadata.product_event_type`	Tipo di evento. Estratto da `type`.
`UA`	`network.http.user_agent`	User agent. Estratto da `UA`.
`version`	`metadata.product_version`, `principal.asset.software.version`	Versione. Estratto da `version`.
N/D	`metadata.event_timestamp`	Il timestamp dell'evento deriva dal campo `_ts` nei log akamai_lds, dal campo `httpMessage.start` nei log akamai_siem o dal campo `log_date` in altri formati.
N/D	`metadata.vendor_name`	Codificato in modo permanente su "Akamai".
N/D	`metadata.product_name`	Codificato su "Kona".
N/D	`metadata.log_type`	Codificato in modo permanente su "AKAMAI_WAF".
N/D	`network.application_protocol`	Imposta "HTTP" per i log akamai_siem e akamai_lds oppure "DNS" per altri formati.
N/D	`security_result.severity`	Imposta il valore su MEDIA per l'azione "avviso", su CRITICA per l'azione "nega" e su ALTA per le altre azioni.
N/D	`event.idm.read_only_udm.metadata.event_type`	Imposta "NETWORK_HTTP" per la maggior parte dei formati di log, "GENERIC_EVENT" per gli eventi con campi `eventId` o `eventData` oppure "STATUS_UPDATE" per gli eventi con campi `cli_ip` o `p_ip`, ma senza `reqHost`.

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