Coletar registros do conector SIEM da Akamai

Compatível com:

Google SecOps SIEM

Observação: esse recurso é coberto pelos Termos de produtos pré-GA dos Termos específicos de serviço do Google Security Operations. Os recursos pré-GA podem ter suporte limitado, e as mudanças realizadas podem não ser compatíveis com outras versões pré-GA. Para mais informações, consulte as diretrizes do serviço de suporte técnico do Google SecOps e os Termos específicos de serviço do Google SecOps.

Este documento explica como ingerir registros do conector SIEM da Akamai no Google Security Operations usando o Amazon S3. A integração do SIEM da Akamai fornece eventos de segurança da plataforma Akamai no formato JSON pela API de integração do SIEM. Essa integração usa o AWS Lambda para buscar eventos periodicamente da API Akamai e armazená-los no S3, onde o Google SecOps os ingere.

Antes de começar

• Uma instância do Google SecOps
• Acesso privilegiado ao Akamai Control Center com a função de usuário Gerenciar SIEM
• Credenciais da API Akamai com o serviço API SIEM ativado (nível de acesso de leitura e gravação)
• Acesso privilegiado à AWS (S3, IAM, Lambda, EventBridge)

Ativar a integração do SIEM no Akamai Control Center

1. Faça login na Akamai Control Center.
2. Acesse SEGURANÇA DE WEB E DATA CENTER > Configuração de segurança.
3. Abra a Configuração de segurança (e a versão adequada) para coletar dados do SIEM.
4. Clique em Configurações avançadas e expanda Coleta de dados para integrações de SIEM.
5. Clique em Ativado para ativar o SIEM.

6. Escolha as políticas de segurança para as quais você quer exportar dados:

   • Todas as políticas de segurança: envie dados do SIEM para eventos que violam todas ou qualquer uma das políticas de segurança na configuração de segurança.
   • Políticas de segurança específicas: selecione uma ou mais políticas de segurança específicas na lista suspensa.

7. Opcional: se você usa o Account Protector e quer incluir o Nome de usuário não criptografado, marque a caixa de seleção Incluir nome de usuário.

   Observação: quando você inclui username, qualquer pessoa com acesso à saída do SIEM pode ver esse valor e a pontuação de risco associada.

8. Opcional: se você quiser excluir eventos de um tipo e ação de proteção específicos, clique em Adicionar exceção e selecione a proteção e as ações associadas que você não quer que o SIEM colete.

9. Clique em Salvar.

10. Copie e salve o ID da configuração de segurança (configId) na seção "Integração do SIEM". Você vai precisar disso para a configuração do Lambda.

Criar credenciais da API Akamai para integração do SIEM

1. Faça login na Akamai Control Center.
2. Acesse ADMINISTRADOR DA CONTA > Identidade e acesso > Clientes de API.
3. Clique em Criar cliente de API.

4. Informe os seguintes detalhes de configuração:

   • Nome do cliente da API: insira um nome descritivo (por exemplo, Google SecOps Poller).
   • Serviço de API: selecione SIEM e defina o nível de acesso como LEITURA-GRAVAÇÃO.

5. Clique em Criar cliente de API.

6. Copie e salve as seguintes credenciais com segurança:

   • Token do cliente
   • Client Secret
   • Access Token
   • Host (por exemplo, example.luna.akamaiapis.net)

Configurar o bucket do AWS S3 e o IAM para o Google SecOps

1. Crie um bucket do Amazon S3 seguindo este guia do usuário: Como criar um bucket
2. Salve o Nome e a Região do bucket para referência futura (por exemplo, akamai-siem-logs).
3. Crie um usuário seguindo este guia: Como criar um usuário do IAM.
4. Selecione o usuário criado.
5. Selecione a guia Credenciais de segurança.
6. Clique em Criar chave de acesso na seção Chaves de acesso.
7. Selecione Serviço de terceiros como Caso de uso.
8. Clique em Próxima.
9. Opcional: adicione uma tag de descrição.
10. Clique em Criar chave de acesso.
11. Clique em Baixar arquivo .csv para salvar a chave de acesso e a chave de acesso secreta para referência futura.
12. Clique em Concluído.
13. Selecione a guia Permissões.
14. Clique em Adicionar permissões na seção Políticas de permissões.
15. Selecione Adicionar permissões.
16. Selecione Anexar políticas diretamente.
17. Pesquise a política AmazonS3FullAccess.
18. Selecione a política.
19. Clique em Próxima.
20. Clique em Adicionar permissões

Configurar a política e o papel do IAM para uploads do S3

1. No console da AWS, acesse IAM > Políticas > Criar política > guia JSON.

2. Copie e cole a política a seguir e substitua akamai-siem-logs pelo nome do bucket:

   JSON de 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. Clique em Próxima.

4. Digite o nome da política AkamaiSIEMtoS3Policy e clique em Criar política.

5. Acesse IAM > Papéis > Criar papel.

6. Selecione Serviço da AWS.

7. Selecione Lambda como o caso de uso.

8. Clique em Próxima.

9. Pesquise e selecione a política AkamaiSIEMtoS3Policy que você acabou de criar.

10. Clique em Próxima.

11. Digite o nome da função AkamaiSIEMtoS3Role e clique em Criar função.

Criar a função Lambda

1. No console da AWS, acesse Lambda > Functions > Create function.
2. Clique em Criar do zero.

3. Informe os seguintes detalhes de configuração:

   Configuração	Valor
   Nome	AkamaiSIEMtoS3Function
   Ambiente de execução	Python 3.13
   Arquitetura	x86_64
   Função de execução	Usar uma função
   Função atual	AkamaiSIEMtoS3Role

4. Clique em Criar função.

5. Depois que a função for criada, abra a guia Código, exclua o stub e cole o seguinte 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. Clique em Implantar para salvar o código.

7. Acesse Configuração > Variáveis de ambiente.

8. Clique em Editar.

9. Clique em Adicionar variável de ambiente para cada uma das seguintes opções:

   Variáveis de ambiente

   Chave	Valor de exemplo
   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. Clique em Salvar.

11. Acesse Configuração > Configuração geral.

12. Clique em Editar.

13. Mude Tempo limite para 5 minutos (300 segundos).

14. Clique em Salvar.

    Observação: o tempo limite é um limite superior rígido. Se a função ainda estiver em execução quando o timer atingir 5 minutos, o AWS Lambda vai encerrá-la. Você só recebe cobranças pelo tempo de execução real.

Criar uma programação do EventBridge

1. Acesse Amazon EventBridge > Scheduler > Criar programação.

2. Informe os seguintes detalhes de configuração:

   • Nome da programação: insira AkamaiSIEMtoS3-5min.
   • Padrão de programação: selecione Programação recorrente.
   • Tipo de programação: selecione Programação com base em taxa.
   • Expressão de taxa: insira 5 e selecione Minutos.

3. Clique em Próxima.

4. Informe os seguintes detalhes de configuração:

   • Destino: selecione Invocar AWS Lambda.
   • Função Lambda: selecione AkamaiSIEMtoS3Function.

5. Clique em Próxima.

6. Clique em Próxima (pule as configurações opcionais).

7. Revise e clique em Criar programação.

Configurar um feed no Google SecOps para ingerir registros do conector SIEM da Akamai

1. Acesse Configurações do SIEM > Feeds.
2. Clique em + Adicionar novo feed.
3. No campo Nome do feed, insira um nome para o feed (por exemplo, Akamai SIEM Connector).
4. Selecione Amazon S3 V2 como o Tipo de origem.
5. Selecione Conector do SIEM da Akamai como o Tipo de registro.
6. Clique em Próxima.

7. Especifique valores para os seguintes parâmetros de entrada:

   • URI do S3: s3://akamai-siem-logs/akamai-siem/
   • Opções de exclusão da fonte: selecione a opção de exclusão de acordo com sua preferência.
   • Idade máxima do arquivo: inclui arquivos modificados no último número de dias. O padrão é de 180 dias.
   • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3.
   • Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3.
   • Namespace do recurso: o namespace do recurso.
   • Rótulos de ingestão: o rótulo aplicado aos eventos deste feed.

8. Clique em Próxima.

9. Revise a nova configuração do feed na tela Finalizar e clique em Enviar.

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais do Google SecOps.