Recopila registros del conector de SIEM de Akamai

Se admite en los siguientes sistemas operativos:

Google SecOps SIEM

Nota: Esta función está sujeta a las Condiciones de las Ofertas de Fase Previa a la DG de las Condiciones Específicas de Google Security Operations. Las características de la fase previa a la DG pueden tener asistencia limitada, y es posible que los cambios que se les realicen no sean compatibles con otras versiones de la fase previa a la DG. Para obtener más información, consulta los Lineamientos de los Servicios de Asistencia Técnica de Google SecOps y las Condiciones Específicas del Servicio de Google SecOps.

En este documento, se explica cómo transferir registros del conector de SIEM de Akamai a Google Security Operations con Amazon S3. La integración de SIEM de Akamai proporciona eventos de seguridad de la plataforma de Akamai en formato JSON a través de la API de integración de SIEM. Esta integración usa AWS Lambda para recuperar eventos de la API de Akamai de forma periódica y almacenarlos en S3, donde Google SecOps los ingiere.

Antes de comenzar

• Una instancia de Google SecOps
• Acceso privilegiado a Akamai Control Center con el rol de usuario Manage SIEM
• Credenciales de la API de Akamai con el servicio de la API de SIEM habilitado (nivel de acceso de LECTURA Y ESCRITURA)
• Acceso con privilegios a AWS (S3, IAM, Lambda, EventBridge)

Habilita la integración del SIEM en Akamai Control Center

1. Accede a Akamai Control Center.
2. Ve a SEGURIDAD DE LA WEB Y DEL CENTRO DE DATOS > Configuración de seguridad.
3. Abre la Configuración de seguridad (y la versión adecuada) para la que deseas recopilar datos del SIEM.
4. Haz clic en Configuración avanzada y expande Recopilación de datos para las integraciones de SIEM.
5. Haz clic en Activado para habilitar el SIEM.

6. Elige las políticas de seguridad para las que deseas exportar datos:

   • Todas las políticas de seguridad: Envía datos del SIEM para los eventos que incumplen cualquiera de las políticas de seguridad o todas ellas dentro de la configuración de seguridad.
   • Políticas de seguridad específicas: Selecciona una o más políticas de seguridad específicas de la lista desplegable.

7. Opcional: Si usas Account Protector y quieres incluir el Nombre de usuario sin encriptar, activa la casilla de verificación Incluir nombre de usuario.

   Nota: Cuando incluyes username, cualquier persona que tenga acceso al resultado de tu SIEM puede ver este valor y su puntuación de riesgo asociada.

8. Opcional: Si deseas excluir eventos que pertenecen a un tipo y una acción de protección específicos, haz clic en Agregar excepción, selecciona la protección y las acciones asociadas que no deseas que recopile el SIEM.

9. Haz clic en Guardar.

10. Copia y guarda el ID de configuración de seguridad (configId) de la sección Integración del SIEM. Lo necesitarás para la configuración de Lambda.

Crea credenciales de la API de Akamai para la integración de SIEM

1. Accede a Akamai Control Center.
2. Ve a ADMINISTRADOR DE LA CUENTA > Identidad y acceso > Clientes de API.
3. Haz clic en Crear cliente de API.

4. Proporciona los siguientes detalles de configuración:

   • Nombre del cliente de API: Ingresa un nombre descriptivo (por ejemplo, Google SecOps Poller).
   • Servicio de API: Selecciona SIEM y establece el nivel de acceso en LECTURA Y ESCRITURA.

5. Haz clic en Crear cliente de API.

6. Copia y guarda las siguientes credenciales de forma segura:

   • Token cliente
   • Client Secret (Secreto del cliente)
   • Token de acceso (Access Token)
   • Host (por ejemplo, example.luna.akamaiapis.net)

Configura el bucket de AWS S3 y el IAM para Google SecOps

1. Crea un bucket de Amazon S3 siguiendo esta guía del usuario: Crea un bucket
2. Guarda el Nombre y la Región del bucket para futuras referencias (por ejemplo, akamai-siem-logs).
3. Crea un usuario siguiendo esta guía del usuario: Cómo crear un usuario de IAM.
4. Selecciona el usuario creado.
5. Selecciona la pestaña Credenciales de seguridad.
6. Haz clic en Crear clave de acceso en la sección Claves de acceso.
7. Selecciona Servicio de terceros como Caso de uso.
8. Haz clic en Siguiente.
9. Opcional: Agrega una etiqueta de descripción.
10. Haz clic en Crear clave de acceso.
11. Haz clic en Descargar archivo .csv para guardar la clave de acceso y la clave de acceso secreta para consultarlas en el futuro.
12. Haz clic en Listo.
13. Selecciona la pestaña Permisos.
14. Haz clic en Agregar permisos en la sección Políticas de permisos.
15. Selecciona Agregar permisos.
16. Selecciona Adjuntar políticas directamente.
17. Busca la política AmazonS3FullAccess.
18. Selecciona la política.
19. Haz clic en Siguiente.
20. Haz clic en Agregar permisos.

Configura la política y el rol de IAM para las cargas de S3

1. En la consola de AWS, ve a IAM > Políticas > Crear política > pestaña JSON.

2. Copia y pega la siguiente política, y reemplaza akamai-siem-logs por el nombre de tu bucket:

   JSON de la política:

   {
     "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. Haz clic en Siguiente.

4. Ingresa el nombre de la política AkamaiSIEMtoS3Policy y haz clic en Crear política.

5. Ve a IAM > Roles > Crear rol.

6. Selecciona Servicio de AWS.

7. Selecciona Lambda como el caso de uso.

8. Haz clic en Siguiente.

9. Busca y selecciona la política AkamaiSIEMtoS3Policy que acabas de crear.

10. Haz clic en Siguiente.

11. Ingresa el nombre del rol AkamaiSIEMtoS3Role y haz clic en Crear rol.

Crea la función Lambda

1. En la consola de AWS, ve a Lambda > Functions > Create function.
2. Haz clic en Crear desde cero.

3. Proporciona los siguientes detalles de configuración:

   Configuración	Valor
   Nombre	AkamaiSIEMtoS3Function
   Tiempo de ejecución	Python 3.13
   Arquitectura	x86_64
   Rol de ejecución	Cómo usar un rol existente
   Rol existente	AkamaiSIEMtoS3Role

4. Haz clic en Crear función.

5. Después de crear la función, abre la pestaña Código, borra el código auxiliar y pega el siguiente código:

   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. Haz clic en Implementar para guardar el código.

7. Ve a Configuration > Environment variables.

8. Haz clic en Editar.

9. Haz clic en Agregar variable de entorno para cada una de las siguientes opciones:

   Variables de entorno

   Clave	Valor de ejemplo
   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. Haz clic en Guardar.

11. Ve a Configuración > Configuración general.

12. Haz clic en Editar.

13. Cambia Tiempo de espera a 5 minutos (300 segundos).

14. Haz clic en Guardar.

    Nota: El tiempo de espera es un límite superior estricto. Si la función sigue en ejecución cuando el temporizador llega a los 5 minutos, AWS Lambda la finalizará. Solo se te factura el tiempo de ejecución real.

Crea una programación de EventBridge

1. Ve a Amazon EventBridge > Scheduler > Create schedule.

2. Proporciona los siguientes detalles de configuración:

   • Nombre de la programación: Ingresa AkamaiSIEMtoS3-5min.
   • Patrón de programación: Selecciona Programación recurrente.
   • Tipo de programa: Selecciona Programa basado en tarifas.
   • Expresión de la tarifa: Ingresa 5 y selecciona Minutos.

3. Haz clic en Siguiente.

4. Proporciona los siguientes detalles de configuración:

   • Target: Selecciona AWS Lambda Invoke.
   • Función Lambda: Selecciona AkamaiSIEMtoS3Function.

5. Haz clic en Siguiente.

6. Haz clic en Siguiente (omite la configuración opcional).

7. Revisa la programación y haz clic en Crear programación.

Configura un feed en Google SecOps para transferir registros del conector de Akamai SIEM

1. Ve a Configuración de SIEM > Feeds.
2. Haz clic en + Agregar feed nuevo.
3. En el campo Nombre del feed, ingresa un nombre para el feed (por ejemplo, Akamai SIEM Connector).
4. Selecciona Amazon S3 V2 como el Tipo de fuente.
5. Selecciona Akamai SIEM Connector como el Tipo de registro.
6. Haz clic en Siguiente.

7. Especifica valores para los siguientes parámetros de entrada:

   • URI de S3: s3://akamai-siem-logs/akamai-siem/
   • Opciones de borrado de la fuente: Selecciona la opción de borrado según tu preferencia.
   • Antigüedad máxima del archivo: Incluye los archivos modificados en la cantidad de días especificada. El valor predeterminado es de 180 días.
   • ID de clave de acceso: Clave de acceso del usuario con acceso al bucket de S3.
   • Clave de acceso secreta: Clave secreta del usuario con acceso al bucket de S3.
   • Espacio de nombres del recurso: Es el espacio de nombres del recurso.
   • Etiquetas de transmisión: Es la etiqueta que se aplica a los eventos de este feed.

8. Haz clic en Siguiente.

9. Revisa la nueva configuración del feed en la pantalla Finalizar y, luego, haz clic en Enviar.

¿Necesitas más ayuda? Obtén respuestas de miembros de la comunidad y profesionales de Google SecOps.