Raccogliere i log del connettore SIEM di Akamai

Supportato in:

Google secops SIEM

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

Questo documento spiega come importare i log del connettore SIEM Akamai in Google Security Operations utilizzando Amazon S3. L'integrazione SIEM di Akamai fornisce eventi di sicurezza dalla piattaforma Akamai in formato JSON tramite l'API di integrazione SIEM. Questa integrazione utilizza AWS Lambda per recuperare periodicamente gli eventi dall'API Akamai e archiviarli in S3, dove vengono importati da Google SecOps.

Prima di iniziare

• Un'istanza Google SecOps
• Accesso privilegiato ad Akamai Control Center con il ruolo utente Gestisci SIEM
• Credenziali API Akamai con il servizio API SIEM abilitato (livello di accesso READ-WRITE)
• Accesso privilegiato ad AWS (S3, IAM, Lambda, EventBridge)

Abilitare l'integrazione SIEM in Akamai Control Center

1. Accedi ad Akamai Control Center.
2. Vai a WEB & DATA CENTER SECURITY > Security Configuration.
3. Apri la configurazione di sicurezza (e la versione appropriata) per cui vuoi raccogliere i dati SIEM.
4. Fai clic su Impostazioni avanzate ed espandi Raccolta dati per le integrazioni SIEM.
5. Fai clic su On per attivare SIEM.

6. Scegli le norme di sicurezza per le quali vuoi esportare i dati:

   • Tutte le norme di sicurezza: invia i dati SIEM per gli eventi che violano una o tutte le norme di sicurezza all'interno della configurazione di sicurezza.
   • Policy di sicurezza specifiche: seleziona una o più policy di sicurezza specifiche dall'elenco a discesa.

7. (Facoltativo) Se utilizzi Account Protector e vuoi includere il nome utente non criptato, seleziona la casella di controllo Includi nome utente.

   Nota: quando includi username, chiunque abbia accesso all'output SIEM può potenzialmente visualizzare questo valore e il relativo punteggio di rischio.

8. (Facoltativo) Se vuoi escludere eventi appartenenti a un tipo e a un'azione di protezione specifici, fai clic su Aggiungi eccezione, seleziona la protezione e le azioni associate che non vuoi che SIEM raccolga.

9. Fai clic su Salva.

10. Copia e salva l'ID configurazione di sicurezza (configId) dalla sezione Integrazione SIEM. Ti servirà per la configurazione di Lambda.

Crea credenziali API Akamai per l'integrazione SIEM

1. Accedi ad Akamai Control Center.
2. Vai ad AMMINISTRATORE ACCOUNT > Identità e accesso > Client API.
3. Fai clic su Crea client API.

4. Fornisci i seguenti dettagli di configurazione:

   • Nome client API: inserisci un nome descrittivo (ad esempio, Google SecOps Poller).
   • Servizio API: seleziona SIEM e imposta il livello di accesso su READ-WRITE.

5. Fai clic su Crea client API.

6. Copia e salva in modo sicuro le seguenti credenziali:

   • Client Token
   • Client secret
   • Token di accesso
   • Host (ad esempio, example.luna.akamaiapis.net)

Configura il bucket AWS S3 e IAM per Google SecOps

1. Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket
2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, akamai-siem-logs).
3. Crea un utente seguendo questa guida utente: Creazione di un utente IAM.
4. Seleziona l'utente creato.
5. Seleziona la scheda Credenziali di sicurezza.
6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
7. Seleziona Servizio di terze parti come Caso d'uso.
8. Fai clic su Avanti.
9. (Facoltativo) Aggiungi il tag della descrizione.
10. Fai clic su Crea chiave di accesso.
11. Fai clic su Scarica file .csv per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
12. Fai clic su Fine.
13. Seleziona la scheda Autorizzazioni.
14. Fai clic su Aggiungi autorizzazioni nella sezione Norme relative alle autorizzazioni.
15. Seleziona Aggiungi autorizzazioni.
16. Seleziona Allega direttamente i criteri.
17. Cerca i criteri AmazonS3FullAccess.
18. Seleziona la policy.
19. Fai clic su Avanti.
20. Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

1. Nella console AWS, vai a IAM > Policy > Crea policy > Scheda JSON.

2. Copia e incolla la seguente policy e sostituisci akamai-siem-logs con il nome del tuo bucket:

   JSON delle policy:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::akamai-siem-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::akamai-siem-logs/akamai-siem/state.json"
       }
     ]
   }
   

3. Fai clic su Avanti.

4. Inserisci il nome del criterio AkamaiSIEMtoS3Policy e fai clic su Crea criterio.

5. Vai a IAM > Ruoli > Crea ruolo.

6. Seleziona Servizio AWS.

7. Seleziona Lambda come caso d'uso.

8. Fai clic su Avanti.

9. Cerca e seleziona la policy AkamaiSIEMtoS3Policy che hai appena creato.

10. Fai clic su Avanti.

11. Inserisci il nome del ruolo AkamaiSIEMtoS3Role e fai clic su Crea ruolo.

Crea la funzione Lambda

1. Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
2. Fai clic su Autore da zero.

3. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Nome	AkamaiSIEMtoS3Function
   Runtime	Python 3.13
   Architettura	x86_64
   Ruolo di esecuzione	Utilizzare un ruolo esistente
   Ruolo esistente	AkamaiSIEMtoS3Role

4. Fai clic su Crea funzione.

5. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e incolla il seguente codice:

   import json
   import boto3
   import os
   import urllib3
   import hmac
   import hashlib
   import base64
   from datetime import datetime
   from urllib.parse import urlparse, urljoin
   
   # Configuration from environment variables
   S3_BUCKET = os.environ['S3_BUCKET']
   S3_PREFIX = os.environ.get('S3_PREFIX', 'akamai-siem/')
   STATE_KEY = os.environ.get('STATE_KEY', 'akamai-siem/state.json')
   
   AKAMAI_HOST = os.environ['AKAMAI_HOST']
   AKAMAI_CLIENT_TOKEN = os.environ['AKAMAI_CLIENT_TOKEN']
   AKAMAI_CLIENT_SECRET = os.environ['AKAMAI_CLIENT_SECRET']
   AKAMAI_ACCESS_TOKEN = os.environ['AKAMAI_ACCESS_TOKEN']
   AKAMAI_CONFIG_IDS = os.environ['AKAMAI_CONFIG_IDS'].split(',')
   
   LIMIT = int(os.environ.get('LIMIT', '10000'))
   
   s3_client = boto3.client('s3')
   http = urllib3.PoolManager()
   
   def load_state():
       """Load offset state from S3"""
       try:
           response = s3_client.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
           return json.loads(response['Body'].read().decode('utf-8'))
       except s3_client.exceptions.NoSuchKey:
           return {}
       except Exception as e:
           print(f"Error loading state: {e}")
           return {}
   
   def save_state(state):
       """Save offset state to S3"""
       try:
           s3_client.put_object(
               Bucket=S3_BUCKET,
               Key=STATE_KEY,
               Body=json.dumps(state, indent=2).encode('utf-8'),
               ContentType='application/json'
           )
       except Exception as e:
           print(f"Error saving state: {e}")
   
   def make_edgegrid_auth_header(url, method='GET'):
       """Create EdgeGrid authentication header"""
       timestamp = datetime.utcnow().strftime('%Y%m%dT%H:%M:%S+0000')
       nonce = base64.b64encode(os.urandom(16)).decode('utf-8')
   
       parsed_url = urlparse(url)
       relative_url = parsed_url.path
       if parsed_url.query:
           relative_url += '?' + parsed_url.query
   
       auth_header = f'EG1-HMAC-SHA256 ' \
                   f'client_token={AKAMAI_CLIENT_TOKEN};' \
                   f'access_token={AKAMAI_ACCESS_TOKEN};' \
                   f'timestamp={timestamp};' \
                   f'nonce={nonce};'
   
       data_to_sign = '\t'.join([
           method,
           parsed_url.scheme,
           parsed_url.netloc,
           relative_url,
           '',  # Request body for GET
           '',  # No additional headers
       ])
   
       signing_key = hmac.new(
           AKAMAI_CLIENT_SECRET.encode('utf-8'),
           timestamp.encode('utf-8'),
           hashlib.sha256
       ).digest()
   
       auth_signature = base64.b64encode(
           hmac.new(
               signing_key,
               (data_to_sign + auth_header).encode('utf-8'),
               hashlib.sha256
           ).digest()
       ).decode('utf-8')
   
       return auth_header + f'signature={auth_signature}'
   
   def fetch_akamai_events(config_id, offset=None):
       """Fetch events from Akamai SIEM API"""
       base_url = f'https://{AKAMAI_HOST}'
       endpoint = f'/siem/v1/configs/{config_id}'
   
       params = f'limit={LIMIT}'
       if offset:
           params += f'&offset={offset}'
   
       url = f'{base_url}{endpoint}?{params}'
   
       try:
           headers = {
               'Authorization': make_edgegrid_auth_header(url)
           }
   
           response = http.request('GET', url, headers=headers, timeout=120)
   
           if response.status != 200:
               print(f"Error response {response.status}: {response.data.decode('utf-8')}")
               return [], offset
   
           # Parse multi-JSON response (newline-delimited JSON)
           lines = response.data.decode('utf-8').strip().split('\n')
           events = []
           new_offset = offset
   
           for line in lines:
               if not line.strip():
                   continue
               try:
                   obj = json.loads(line)
   
                   # Check if this is offset context (metadata object with offset)
                   if 'offset' in obj and ('total' in obj or 'responseContext' in obj):
                       new_offset = obj.get('offset')
                       continue
   
                   # This is an event
                   events.append(obj)
               except json.JSONDecodeError as e:
                   print(f"Warning: Failed to parse line: {e}")
                   continue
   
           return events, new_offset
   
       except Exception as e:
           print(f"Error fetching events for config {config_id}: {e}")
           return [], offset
   
   def lambda_handler(event, context):
       """Lambda handler - fetches Akamai events and writes to S3"""
       print(f"Starting Akamai SIEM fetch at {datetime.utcnow().isoformat()}Z")
   
       state = load_state()
       total_events = 0
   
       for config_id in AKAMAI_CONFIG_IDS:
           config_id = config_id.strip()
           if not config_id:
               continue
   
           print(f"Fetching events for config: {config_id}")
   
           current_offset = state.get(config_id)
           events, new_offset = fetch_akamai_events(config_id, current_offset)
   
           if events:
               print(f"Fetched {len(events)} events for config {config_id}")
   
               # Write events to S3 as newline-delimited JSON
               timestamp = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
               s3_key = f'{S3_PREFIX}{config_id}/{timestamp}.json'
   
               payload = '\n'.join(json.dumps(event) for event in events)
   
               try:
                   s3_client.put_object(
                       Bucket=S3_BUCKET,
                       Key=s3_key,
                       Body=payload.encode('utf-8'),
                       ContentType='application/json'
                   )
                   print(f"Wrote {len(events)} events to s3://{S3_BUCKET}/{s3_key}")
   
                   # Update offset only after successful write
                   if new_offset:
                       state[config_id] = new_offset
                       total_events += len(events)
               except Exception as e:
                   print(f"Error writing to S3: {e}")
           else:
               print(f"No new events for config {config_id}")
   
       # Save updated state
       save_state(state)
   
       return {
           'statusCode': 200,
           'body': json.dumps({
               'message': f'Successfully processed {total_events} events',
               'configs_processed': len(AKAMAI_CONFIG_IDS)
           })
       }
   

6. Fai clic su Esegui il deployment per salvare il codice.

7. Vai a Configurazione > Variabili di ambiente.

8. Fai clic su Modifica.

9. Fai clic su Aggiungi variabile di ambiente per ciascuna delle seguenti variabili:

   Variabili di ambiente

   Chiave	Valore di esempio
   S3_BUCKET	akamai-siem-logs
   S3_PREFIX	akamai-siem/
   STATE_KEY	akamai-siem/state.json
   AKAMAI_HOST	example.luna.akamaiapis.net
   AKAMAI_CLIENT_TOKEN	your-client-token
   AKAMAI_CLIENT_SECRET	your-client-secret
   AKAMAI_ACCESS_TOKEN	your-access-token
   AKAMAI_CONFIG_IDS	12345,67890
   LIMIT	10000

10. Fai clic su Salva.

11. Vai a Configurazione > Configurazione generale.

12. Fai clic su Modifica.

13. Modifica Timeout impostandolo su 5 minuti (300 secondi).

14. Fai clic su Salva.

    Nota: il timeout è un limite superiore rigido. Se la funzione è ancora in esecuzione quando il timer raggiunge i 5 minuti, AWS Lambda la termina. Ti viene addebitato solo il tempo di esecuzione effettivo.

Creare una pianificazione EventBridge

1. Vai a Amazon EventBridge > Scheduler > Crea pianificazione.

2. Fornisci i seguenti dettagli di configurazione:

   • Nome pianificazione: inserisci AkamaiSIEMtoS3-5min.
   • Modello di programmazione: seleziona Programmazione ricorrente.
   • Tipo di programmazione: seleziona Programmazione basata sulla tariffa.
   • Espressione di frequenza: inserisci 5 e seleziona Minuti.

3. Fai clic su Avanti.

4. Fornisci i seguenti dettagli di configurazione:

   • Destinazione: seleziona AWS Lambda Invoke.
   • Funzione Lambda: seleziona AkamaiSIEMtoS3Function.

5. Fai clic su Avanti.

6. Fai clic su Avanti (salta le impostazioni facoltative).

7. Rivedi e fai clic su Crea pianificazione.

Configura un feed in Google SecOps per importare i log del connettore SIEM Akamai

1. Vai a Impostazioni SIEM > Feed.
2. Fai clic su + Aggiungi nuovo feed.
3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Akamai SIEM Connector).
4. Seleziona Amazon S3 V2 come Tipo di origine.
5. Seleziona Akamai SIEM Connector come Tipo di log.
6. Fai clic su Avanti.

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

   • URI S3: s3://akamai-siem-logs/akamai-siem/
   • Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
   • Età massima del file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
   • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.
   • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.
   • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
   • Etichette di importazione: l'etichetta applicata agli eventi di questo feed.

8. Fai clic su Avanti.

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

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