Collecter les journaux du connecteur Akamai SIEM

Compatible avec :

Google SecOps SIEM

Remarque : Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions spécifiques du service Google Security Operations. Les fonctionnalités pré-DG (avant disponibilité générale) sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les Instructions relatives aux services d'assistance technique Google SecOps et les Conditions spécifiques du service Google SecOps.

Ce document explique comment ingérer les journaux du connecteur Akamai SIEM dans Google Security Operations à l'aide d'Amazon S3. L'intégration Akamai SIEM fournit des événements de sécurité de la plate-forme Akamai au format JSON via l'API SIEM Integration. Cette intégration utilise AWS Lambda pour extraire régulièrement les événements de l'API Akamai et les stocker dans S3, où Google SecOps les ingère.

Avant de commencer

• Une instance Google SecOps
• Accès privilégié à Akamai Control Center avec le rôle utilisateur Manage SIEM
• Identifiants de l'API Akamai avec le service SIEM API activé (niveau d'accès LECTURE-ÉCRITURE)
• Accès privilégié à AWS (S3, IAM, Lambda, EventBridge)

Activer l'intégration SIEM dans Akamai Control Center

1. Connectez-vous à Akamai Control Center.
2. Accédez à SÉCURITÉ DES CENTRES DE DONNÉES ET DU WEB > Configuration de la sécurité.
3. Ouvrez la configuration de sécurité (et la version appropriée) pour laquelle vous souhaitez collecter des données SIEM.
4. Cliquez sur Paramètres avancés, puis développez Collecte de données pour les intégrations SIEM.
5. Cliquez sur Activé pour activer le SIEM.

6. Choisissez les règles de sécurité pour lesquelles vous souhaitez exporter des données :

   • Toutes les règles de sécurité : envoie les données SIEM pour les événements qui enfreignent tout ou partie des règles de sécurité dans la configuration de sécurité.
   • Règles de sécurité spécifiques : sélectionnez une ou plusieurs règles de sécurité spécifiques dans la liste déroulante.

7. Facultatif : Si vous utilisez Account Protector et que vous souhaitez inclure le nom d'utilisateur non chiffré, cochez la case Inclure le nom d'utilisateur.

   Remarque : Lorsque vous incluez username, toute personne ayant accès à votre sortie SIEM peut potentiellement voir cette valeur et son score de risque associé.

8. Facultatif : Si vous souhaitez exclure des événements appartenant à un type de protection et à une action spécifiques, cliquez sur Ajouter une exception, puis sélectionnez la protection et les actions associées que vous ne souhaitez pas que le SIEM collecte.

9. Cliquez sur Enregistrer.

10. Copiez et enregistrez l'ID de configuration de sécurité (configId) de la section "Intégration SIEM". Vous en aurez besoin pour la configuration Lambda.

Créer des identifiants d'API Akamai pour l'intégration SIEM

1. Connectez-vous à Akamai Control Center.
2. Accédez à ADMINISTRATEUR DE COMPTE> Identité et accès> Clients API.
3. Cliquez sur Créer un client API.

4. Fournissez les informations de configuration suivantes :

   • Nom du client API : saisissez un nom descriptif (par exemple, Google SecOps Poller).
   • Service d'API : sélectionnez SIEM et définissez le niveau d'accès sur LECTURE ET ÉCRITURE.

5. Cliquez sur Créer un client API.

6. Copiez et enregistrez les identifiants suivants de manière sécurisée :

   • Jeton Client
   • Code secret du client
   • Jeton d'accès
   • Hôte (par exemple, example.luna.akamaiapis.net)

Configurer un bucket AWS S3 et IAM pour Google SecOps

1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, akamai-siem-logs).
3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
4. Sélectionnez l'utilisateur créé.
5. Sélectionnez l'onglet Informations d'identification de sécurité.
6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
7. Sélectionnez Service tiers comme Cas d'utilisation.
8. Cliquez sur Suivant.
9. Facultatif : Ajoutez une balise de description.
10. Cliquez sur Créer une clé d'accès.
11. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
12. Cliquez sur OK.
13. Sélectionnez l'onglet Autorisations.
14. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
15. Sélectionnez Ajouter des autorisations.
16. Sélectionnez Joindre directement des règles.
17. Recherchez la règle AmazonS3FullAccess.
18. Sélectionnez la règle.
19. Cliquez sur Suivant.
20. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

1. Dans la console AWS, accédez à IAM > Stratégies > Créer une stratégie > onglet JSON.

2. Copiez et collez la règle suivante, puis remplacez akamai-siem-logs par le nom de votre bucket :

   Règle 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. Cliquez sur Suivant.

4. Saisissez le nom de la règle AkamaiSIEMtoS3Policy, puis cliquez sur Créer une règle.

5. Accédez à IAM > Rôles > Créer un rôle.

6. Sélectionnez Service AWS.

7. Sélectionnez Lambda comme cas d'utilisation.

8. Cliquez sur Suivant.

9. Recherchez et sélectionnez la règle AkamaiSIEMtoS3Policy que vous venez de créer.

10. Cliquez sur Suivant.

11. Saisissez le nom du rôle AkamaiSIEMtoS3Role, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
2. Cliquez sur Créer à partir de zéro.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	AkamaiSIEMtoS3Function
   Runtime (durée d'exécution)	Python 3.13
   Architecture	x86_64
   Rôle d'exécution	Utiliser un rôle existant
   Rôle existant	AkamaiSIEMtoS3Role

4. Cliquez sur Créer une fonction.

5. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et collez le code suivant :

   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. Cliquez sur Déployer pour enregistrer le code.

7. Accédez à Configuration > Variables d'environnement.

8. Cliquez sur Modifier.

9. Cliquez sur Ajouter une variable d'environnement pour chacun des éléments suivants :

   Variables d'environnement

   Clé	Exemple de valeur
   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. Cliquez sur Enregistrer.

11. Accédez à Configuration > Configuration générale.

12. Cliquez sur Modifier.

13. Définissez Délai avant expiration sur 5 minutes (300 secondes).

14. Cliquez sur Enregistrer.

    Remarque : Le délai d'expiration est une limite supérieure stricte. Si la fonction est toujours en cours d'exécution lorsque le minuteur atteint cinq minutes, AWS Lambda l'arrête. Vous n'êtes facturé que pour la durée d'exécution réelle.

Créer une programmation EventBridge

1. Accédez à Amazon EventBridge> Scheduler> Create schedule (Créer une programmation).

2. Fournissez les informations de configuration suivantes :

   • Nom de la programmation : saisissez AkamaiSIEMtoS3-5min.
   • Schéma de programmation : sélectionnez Programmation récurrente.
   • Type de programmation : sélectionnez Programmation basée sur le taux.
   • Expression du taux : saisissez 5, puis sélectionnez Minutes.

3. Cliquez sur Suivant.

4. Fournissez les informations de configuration suivantes :

   • Cible : sélectionnez Appel AWS Lambda.
   • Fonction Lambda : sélectionnez AkamaiSIEMtoS3Function.

5. Cliquez sur Suivant.

6. Cliquez sur Suivant (ignorez les paramètres facultatifs).

7. Vérifiez, puis cliquez sur Créer une programmation.

Configurer un flux dans Google SecOps pour ingérer les journaux du connecteur Akamai SIEM

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur + Ajouter un flux.
3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Akamai SIEM Connector).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez Connecteur SIEM Akamai comme Type de journal.
6. Cliquez sur Suivant.

7. Spécifiez les valeurs des paramètres d'entrée suivants :

   • URI S3 : s3://akamai-siem-logs/akamai-siem/
   • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
   • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
   • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
   • Espace de noms de l'élément : espace de noms de l'élément.
   • Libellés d'ingestion : libellé appliqué aux événements de ce flux.

8. Cliquez sur Suivant.

9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.