Akamai SIEM Connector-Logs erfassen

Unterstützt in:

Google SecOps SIEM

Hinweis: Dieses Feature unterliegt den Bedingungen des Pre-GA-Angebots in den dienstspezifischen Nutzungsbedingungen für Google Security Operations. Pre-GA-Features werden eventuell nur eingeschränkt unterstützt und Änderungen an diesen Features sind möglicherweise nicht mit anderen Pre-GA-Versionen kompatibel. Weitere Informationen finden Sie in den Richtlinien für den technischen Support von Google SecOps und den dienstspezifischen Nutzungsbedingungen für Google SecOps.

In diesem Dokument wird beschrieben, wie Sie Akamai SIEM Connector-Logs mit Amazon S3 in Google Security Operations aufnehmen. Die Akamai SIEM-Integration stellt Sicherheitsereignisse von der Akamai-Plattform im JSON-Format über die SIEM-Integrations-API bereit. Bei dieser Integration werden mit AWS Lambda regelmäßig Ereignisse aus der Akamai API abgerufen und in S3 gespeichert, wo sie von Google SecOps aufgenommen werden.

Hinweis

• Eine Google SecOps-Instanz
• Privilegierter Zugriff auf das Akamai Control Center mit der Nutzerrolle Manage SIEM
• Akamai-API-Anmeldedaten mit aktiviertem SIEM API-Dienst (READ-WRITE-Zugriffsebene)
• Privilegierter Zugriff auf AWS (S3, IAM, Lambda, EventBridge)

SIEM-Integration im Akamai Control Center aktivieren

1. Melden Sie sich im Akamai Control Center an.
2. Klicken Sie auf WEB- UND RECHENZENTRUMSSICHERHEIT > Sicherheitskonfiguration.
3. Öffnen Sie die Sicherheitskonfiguration (und die entsprechende Version), für die Sie SIEM-Daten erfassen möchten.
4. Klicken Sie auf Erweiterte Einstellungen und maximieren Sie Datenerfassung für SIEM-Integrationen.
5. Klicken Sie auf Ein, um SIEM zu aktivieren.

6. Wählen Sie die Sicherheitsrichtlinien aus, für die Sie Daten exportieren möchten:

   • Alle Sicherheitsrichtlinien: SIEM-Daten für Ereignisse senden, die gegen eine oder alle Sicherheitsrichtlinien in der Sicherheitskonfiguration verstoßen.
   • Bestimmte Sicherheitsrichtlinien: Wählen Sie eine oder mehrere bestimmte Sicherheitsrichtlinien aus der Drop-down-Liste aus.

7. Optional: Wenn Sie Account Protector verwenden und den unverschlüsselten Nutzernamen einbeziehen möchten, aktivieren Sie das Kästchen Nutzernamen einbeziehen.

   Hinweis :Wenn Sie username einfügen, kann jeder mit Zugriff auf Ihre SIEM-Ausgabe diesen Wert und den zugehörigen Risikowert sehen.

8. Optional: Wenn Sie Ereignisse ausschließen möchten, die zu einem bestimmten Schutztyp und einer bestimmten Aktion gehören, klicken Sie auf Ausnahme hinzufügen, wählen Sie den Schutz und die zugehörigen Aktionen aus, die nicht von SIEM erfasst werden sollen.

9. Klicken Sie auf Speichern.

10. Kopieren und speichern Sie die Sicherheitskonfigurations-ID (configId) aus dem Bereich „SIEM-Integration“. Sie benötigen diese für die Lambda-Konfiguration.

Akamai-API-Anmeldedaten für die SIEM-Integration erstellen

1. Melden Sie sich im Akamai Control Center an.
2. Gehen Sie zu KONTOADMINISTRATOR > Identität und Zugriff > API-Clients.
3. Klicken Sie auf API-Client erstellen.

4. Geben Sie die folgenden Konfigurationsdetails an:

   • Name des API-Clients: Geben Sie einen aussagekräftigen Namen ein, z. B. Google SecOps Poller.
   • API-Dienst: Wählen Sie SIEM aus und legen Sie die Zugriffsebene auf READ-WRITE fest.

5. Klicken Sie auf API-Client erstellen.

6. Kopieren und speichern Sie die folgenden Anmeldedaten sicher:

   • Client-Token
   • Client-Secret
   • Access Token
   • Host (z. B. example.luna.akamaiapis.net)

AWS S3-Bucket und IAM für Google SecOps konfigurieren

1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu der Anleitung unter Bucket erstellen.
2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. akamai-siem-logs).
3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
4. Wählen Sie den erstellten Nutzer aus.
5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
7. Wählen Sie Drittanbieterdienst als Anwendungsfall aus.
8. Klicken Sie auf Weiter.
9. Optional: Fügen Sie ein Beschreibungstag hinzu.
10. Klicken Sie auf Zugriffsschlüssel erstellen.
11. Klicken Sie auf CSV-Datei herunterladen, um den Access Key (Zugriffsschlüssel) und den Secret Access Key (geheimer Zugriffsschlüssel) für die zukünftige Verwendung zu speichern.
12. Klicken Sie auf Fertig.
13. Wählen Sie den Tab Berechtigungen aus.
14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
15. Wählen Sie Berechtigungen hinzufügen aus.
16. Wählen Sie Richtlinien direkt anhängen aus.
17. Suchen Sie nach der Richtlinie AmazonS3FullAccess.
18. Wählen Sie die Richtlinie aus.
19. Klicken Sie auf Weiter.
20. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und ‑Rolle für S3-Uploads konfigurieren

1. Rufen Sie in der AWS-Konsole IAM > Richtlinien > Richtlinie erstellen > JSON-Tab auf.

2. Kopieren Sie die folgende Richtlinie und fügen Sie sie ein. Ersetzen Sie dabei akamai-siem-logs durch den Namen Ihres Buckets:

   Richtlinien-JSON:

   {
     "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. Klicken Sie auf Weiter.

4. Geben Sie den Richtliniennamen AkamaiSIEMtoS3Policy ein und klicken Sie auf Richtlinie erstellen.

5. Klicken Sie auf IAM > Rollen > Rolle erstellen.

6. Wählen Sie AWS-Dienst aus.

7. Wählen Sie Lambda als Anwendungsfall aus.

8. Klicken Sie auf Weiter.

9. Suchen Sie nach der Richtlinie AkamaiSIEMtoS3Policy, die Sie gerade erstellt haben, und wählen Sie sie aus.

10. Klicken Sie auf Weiter.

11. Geben Sie den Rollennamen AkamaiSIEMtoS3Role ein und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
2. Klicken Sie auf Von Grund auf erstellen.

3. Geben Sie die folgenden Konfigurationsdetails an:

   Einstellung	Wert
   Name	AkamaiSIEMtoS3Function
   Laufzeit	Python 3.13
   Architektur	x86_64
   Ausführungsrolle	Vorhandene Rolle verwenden
   Vorhandene Rolle	AkamaiSIEMtoS3Role

4. Klicken Sie auf Funktion erstellen.

5. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und fügen Sie den folgenden Code ein:

   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. Klicken Sie auf Bereitstellen, um den Code zu speichern.

7. Rufen Sie Konfiguration > Umgebungsvariablen auf.

8. Klicken Sie auf Bearbeiten.

9. Klicken Sie für jede der folgenden Variablen auf Umgebungsvariable hinzufügen:

   Umgebungsvariablen

   Schlüssel	Beispielwert
   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. Klicken Sie auf Speichern.

11. Rufen Sie Konfiguration > Allgemeine Konfiguration auf.

12. Klicken Sie auf Bearbeiten.

13. Ändern Sie Zeitlimit in 5 Minuten (300 Sekunden).

14. Klicken Sie auf Speichern.

    Hinweis :Das Zeitlimit ist eine harte Obergrenze. Wenn die Funktion noch ausgeführt wird, wenn der Timer 5 Minuten erreicht, wird sie von AWS Lambda beendet. Ihnen wird nur die tatsächliche Laufzeit in Rechnung gestellt.

EventBridge-Zeitplan erstellen

1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).

2. Geben Sie die folgenden Konfigurationsdetails an:

   • Name des Zeitplans: Geben Sie AkamaiSIEMtoS3-5min ein.
   • Zeitplanmuster: Wählen Sie Wiederkehrender Zeitplan aus.
   • Planungstyp: Wählen Sie Ratenbasierter Plan aus.
   • Raten-Ausdruck: Geben Sie 5 ein und wählen Sie Minuten aus.

3. Klicken Sie auf Weiter.

4. Geben Sie die folgenden Konfigurationsdetails an:

   • Ziel: Wählen Sie AWS Lambda Invoke aus.
   • Lambda-Funktion: Wählen Sie AkamaiSIEMtoS3Function aus.

5. Klicken Sie auf Weiter.

6. Klicken Sie auf Weiter (überspringen Sie optionale Einstellungen).

7. Prüfen Sie den Zeitplan und klicken Sie auf Zeitplan erstellen.

Feed in Google SecOps konfigurieren, um Akamai SIEM Connector-Logs aufzunehmen

1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
2. Klicken Sie auf + Neuen Feed hinzufügen.
3. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Akamai SIEM Connector.
4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
5. Wählen Sie Akamai SIEM Connector als Logtyp aus.
6. Klicken Sie auf Weiter.

7. Geben Sie Werte für die folgenden Eingabeparameter an:

   • S3-URI: s3://akamai-siem-logs/akamai-siem/
   • Optionen zum Löschen von Quellen: Wählen Sie die gewünschte Option zum Löschen aus.
   • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.
   • Zugriffsschlüssel-ID: Der Nutzerzugriffsschlüssel mit Zugriff auf den S3-Bucket.
   • Geheimer Zugriffsschlüssel: Der geheime Schlüssel des Nutzers mit Zugriff auf den S3-Bucket.
   • Asset-Namespace: Der Asset-Namespace.
   • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet wird.

8. Klicken Sie auf Weiter.

9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten