Coletar registros do WAF da Akamai

Compatível com:

Google SecOps SIEM

Este documento explica como ingerir registros do WAF da Akamai no Google Security Operations usando o conector CEF da Akamai e o Bindplane.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

Uma instância do Google SecOps
Um host Windows 2016 ou mais recente ou Linux com systemd para instalação do agente do Bindplane
Um servidor Linux (recomendado CentOS/RHEL/Ubuntu) com pelo menos 2 núcleos de CPU, 6 GB de RAM e 2 GB de espaço livre em disco para o conector CEF da Akamai
Java 8 (JRE 1.8) ou mais recente instalado no host do conector CEF
Se você estiver executando atrás de um proxy, verifique se as portas do firewall estão abertas de acordo com os requisitos do agente Bindplane e se as listas de permissões do proxy *.cloudsecurity.akamaiapis.net e *.luna.akamaiapis.net
Acesso privilegiado ao Akamai Control Center
Uma configuração de segurança da Akamai com o App & API Protector, o Kona Site Defender, o Web Application Protector, o Bot Manager ou o Account Protector ativado

Receber o arquivo de autenticação de ingestão do Google SecOps

Faça login no console do Google SecOps.
Acesse Configurações do SIEM > Agentes de coleta.
Baixe o arquivo de autenticação de ingestão. Salve o arquivo de forma segura no sistema em que o Bindplane será instalado.

Receber o ID de cliente do Google SecOps

Faça login no console do Google SecOps.
Acesse Configurações do SIEM > Perfil.
Copie e salve o ID do cliente na seção Detalhes da organização.

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

Faça login na Akamai Control Center.
Em SEGURANÇA DA WEB E DO DATA CENTER, clique em Configuração de segurança.
Abra a configuração de segurança e a versão apropriada para coletar dados do SIEM.
Clique em Configurações avançadas e expanda Coleta de dados para integrações de SIEM.
Clique em Ativado para ativar o SIEM.
Escolha as políticas de segurança para as quais você quer exportar dados:
- Todas as políticas de segurança: selecione essa opção para enviar dados do SIEM sobre eventos que violam qualquer política de segurança ou todas elas na configuração de segurança.
- Políticas de segurança específicas: selecione essa opção para enviar dados sobre uma ou mais políticas de segurança específicas. Selecione as políticas adequadas na lista suspensa.
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.
Opcional: se você quiser receber informações de impressão digital JA4 em eventos do SIEM, marque a caixa de seleção Incluir a impressão digital TLS do cliente JA4.
Opcional: se você quiser excluir eventos de um tipo e ação de proteção específicos, clique em Adicionar exceção. Selecione a proteção e as ações associadas que você não quer que o SIEM colete. Clique em Salvar.
Copie o valor no campo ID da configuração de segurança da Web. Salve esse ID para uso posterior.
Clique em Ativar para enviar as mudanças na configuração de segurança à rede de produção. Em Rede, clique em Produção e em Ativar.

Configurar um usuário para gerenciar o SIEM no Akamai Control Center

No Akamai Control Center, em ADMINISTRADOR DA CONTA, clique em Identidade e acesso.
Na guia Usuários e clientes de API, encontre o usuário a quem você quer atribuir a função ou clique no botão Criar usuário.
Para atribuir a função do SIEM a um usuário atual:
- Abra a conta do usuário e clique na guia Editar funções.
- Encontre o grupo adequado, clique no menu Funções e selecione a função Gerenciar SIEM.
- Clique em Enviar.
Para atribuir a função do SIEM a um novo usuário:
- Clique em Criar usuário.
- Insira as informações básicas do usuário e acesse a seção Atribuir funções.
- Encontre o grupo adequado, clique no menu Funções e selecione a função Gerenciar SIEM.
- Clique em Salvar.

Provisionar credenciais da API SIEM na Central de controle da Akamai

Acesse a página Criar credenciais de autenticação na documentação da Akamai.
Siga as etapas para provisionar a API SIEM para o usuário que você atribuiu para gerenciar o SIEM.
Copie e salve as seguintes credenciais com segurança:
- Access Token
- Token do cliente
- Client Secret
- URL de base

Instalar o conector CEF da Akamai

No servidor Linux, faça o download do pacote de distribuição mais recente do conector CEF no repositório do GitHub da Akamai.
Transfira o pacote para seu servidor usando wget ou SFTP.
Verifique o hash SHA256 do arquivo baixado para garantir a integridade.
Extraia o pacote de distribuição:
```
unzip CEFConnector-<version>.zip
```
Navegue até o diretório extraído:
```
cd CEFConnector-<version>
```

Para instalar o serviço, crie um link simbólico para o script de inicialização:

sudo ln -s /path/to/CEFConnector-<version>/bin/AkamaiCEFConnector.sh /etc/init.d/AkamaiCEFConnector

Configurar o conector CEF da Akamai

Navegue até o diretório config na instalação do conector CEF:
```
cd config
```
Abra o arquivo CEFConnector.properties usando um editor de texto (por exemplo, nano, vi):
```
sudo nano CEFConnector.properties
```

Configure os seguintes parâmetros obrigatórios:

# Akamai API Configuration
akamai.data.requesturlhost=https://cloudsecurity.akamaiapis.net
akamai.data.configs=<YOUR_SECURITY_CONFIG_ID>
akamai.data.timebased=false
akamai.data.limit=200000

# API Credentials (from Step: Provision SIEM API credentials)
akamai.data.accesstoken=<YOUR_ACCESS_TOKEN>
akamai.data.clienttoken=<YOUR_CLIENT_TOKEN>
akamai.data.clientsecret=<YOUR_CLIENT_SECRET>
akamai.data.baseurl=<YOUR_BASE_URL>

# CEF Format Configuration
akamai.cefformatheader=CEF:0|Akamai|akamai_siem|1.0|eventClassId()|name()|severity()

akamai.cefformatextension=act=appliedAction() app=${httpMessage.protocol} c6a2=ipv6src() c6a2Label="Source IPv6 Address" cs1=${attackData.rules} cs1Label="Rules" cs2=${attackData.ruleMessages} cs2Label="Rule Messages" cs3=${attackData.ruleData} cs3Label="Rule Data" cs4=${attackData.ruleSelectors} cs4Label="Rule Selectors" cs5=${attackData.clientReputation} cs5Label="Client Reputation" cs6=${attackData.apiId} cs6Label="API ID" devicePayloadId=${httpMessage.requestId} dhost=${httpMessage.host} dpt=${httpMessage.port} flexString1=${attackData.configId} flexString1Label="Security Config ID" flexString2=${attackData.policyId} flexString2Label="Firewall Policy Id" out=${httpMessage.bytes} request=requestURL() requestMethod=${httpMessage.method} src=${attackData.clientIP} start=${httpMessage.start} AkamaiSiemSlowPostAction=${attackData.slowPostAction} AkamaiSiemSlowPostRate=${attackData.slowPostRate} AkamaiSiemRuleVersions=${attackData.ruleVersions} AkamaiSiemRuleTags=${attackData.ruleTags} AkamaiSiemJA4=${identity.ja4} AkamaiSiemRuleActions=${attackData.ruleActions}

# Connector Pull Configuration
connector.refresh.period=60
connector.consumer.count=3
connector.retry=5

# Proxy Configuration (if applicable)
# connector.proxy.host=
# connector.proxy.port=

Substitua os seguintes marcadores pelos seus valores reais:
- <YOUR_SECURITY_CONFIG_ID>: o ID da configuração de segurança da Web que você copiou anteriormente. Para várias configurações, separe os IDs com pontos e vírgulas (por exemplo, 12345;67890).
- <YOUR_ACCESS_TOKEN>: o token de acesso das credenciais da API Akamai.
- <YOUR_CLIENT_TOKEN>: o token do cliente das credenciais da API Akamai.
- <YOUR_CLIENT_SECRET>: a chave secreta do cliente das credenciais da API Akamai
- <YOUR_BASE_URL>: o URL base das credenciais da API Akamai.
Salve e feche o arquivo.

Configurar a geração de registros do conector CEF

Navegue até o diretório config na instalação do conector CEF.
Abra o arquivo log4j2.xml usando um editor de texto:
```
sudo nano log4j2.xml
```

Configure os seguintes parâmetros para a saída do syslog no Bindplane:

<!-- Syslog Appender Configuration -->
<Syslog name="SyslogAppender" 
        host="<BINDPLANE_IP_ADDRESS>" 
        port="<BINDPLANE_PORT>" 
        protocol="<PROTOCOL>" 
        facility="LOCAL0"
        format="RFC5424">
    <PatternLayout pattern="%m%n"/>
</Syslog>

Substitua os seguintes marcadores de posição:
- <BINDPLANE_IP_ADDRESS>: o endereço IP do servidor em que o agente do Bindplane está instalado
- <BINDPLANE_PORT>: o número da porta em que o agente do Bindplane escuta. Por exemplo, 514 para UDP ou 601 para TCP.
- <PROTOCOL>: selecione UDP ou TCP

Verifique se o conector CEF envia registros ao servidor syslog remoto (BindPpane) configurando as definições específicas do CEF:

# In CEFConnector.properties, ensure these are set:
# Note: These settings are typically in log4j2.xml but referenced here for clarity

Salve e feche o arquivo.

Iniciar o conector CEF da Akamai

Inicie o serviço do conector CEF:

sudo /etc/init.d/AkamaiCEFConnector start

Verifique se o serviço está em execução:

sudo /etc/init.d/AkamaiCEFConnector status

Monitore os registros para garantir que o conector esteja extraindo eventos do Akamai e enviando-os para o Bindplane:
```
tail -f /path/to/CEFConnector-<version>/bin/logs/cefconnector.log
```

Instalar o agente do Bindplane

Instale o agente do Bindplane no seu sistema operacional Windows ou Linux de acordo com as instruções a seguir.

Instalação do Windows

Abra o Prompt de Comando ou o PowerShell como administrador.

Execute este comando:

msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet

Instalação do Linux

Abra um terminal com privilégios de root ou sudo.

Execute este comando:

sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh

Outros recursos de instalação

Para mais opções de instalação, consulte este guia de instalação.

Configurar o agente do Bindplane para ingerir o Syslog e enviar ao Google SecOps

Acesse o arquivo de configuração:
1. Localize o arquivo config.yaml. Normalmente, ele fica no diretório /etc/bindplane-agent/ no Linux ou no diretório de instalação no Windows.
2. Abra o arquivo usando um editor de texto (por exemplo, nano, vi ou Bloco de Notas).

Edite o arquivo config.yaml da seguinte forma:

receivers:
    udplog:
      # Replace the port and IP address as required
      listen_address: "0.0.0.0:514"
    tcplog:
      # Alternative TCP receiver if using TCP protocol
      listen_address: "0.0.0.0:601"

exporters:
  chronicle/chronicle_w_labels:
    compression: gzip
    # Adjust the path to the credentials file you downloaded in the Get ingestion authentication file section
    creds_file_path: '/path/to/ingestion-authentication-file.json'
    # Replace with your actual customer ID from the Get customer ID section
    customer_id: <YOUR_CUSTOMER_ID>
    # Select the appropriate regional endpoint based on where your Google SecOps instance is provisioned
    # For regional endpoints, see: https://cloud.google.com/chronicle/docs/reference/ingestion-api#regional_endpoints
    endpoint: malachiteingestion-pa.googleapis.com
    # Set the log_type to ensure the correct parser is applied
    log_type: 'AKAMAI_WAF'
    raw_log_field: body
    # Add optional ingestion labels for better organization
    ingestion_labels:

service:
  pipelines:
    logs/source0__chronicle_w_labels-0:
      receivers:
        - udplog
        # - tcplog  # Uncomment if using TCP
      exporters:
        - chronicle/chronicle_w_labels

Reinicie o agente do Bindplane para aplicar as mudanças

Para reiniciar o agente do Bindplane no Linux, execute o seguinte comando:
```
sudo systemctl restart bindplane-agent
```
Para reiniciar o agente do Bindplane no Windows, use o console Serviços ou insira o seguinte comando:
```
net stop BindPlaneAgent && net start BindPlaneAgent
```

Verificar a ingestão de registros

Faça login no console do Google SecOps.
Acesse Pesquisa ou Verificação de registros brutos.
Pesquise registros recentes do WAF da Akamai usando o rótulo de ingestão:
```
metadata.log_type = "AKAMAI_WAF"
```
Verifique se os registros estão aparecendo com os campos e carimbos de data/hora esperados.
Verifique se os campos de formato CEF estão sendo analisados e mapeados corretamente para UDM.

Solução de problemas

Problemas com o conector CEF

Nenhum evento sendo extraído: verifique se há erros no arquivo cefconnector.log. Verifique se as credenciais da API do Akamai estão corretas e se os IDs de configuração de segurança são válidos.
Erros de conexão: verifique se as configurações de proxy (se aplicável) estão configuradas corretamente e se os domínios necessários estão na lista de permissões.
Redefinição do banco de dados: se você precisar redefinir o rastreamento de posição, execute:
```
sudo /etc/init.d/AkamaiCEFConnector resetdb
```

Problemas com o agente do Bindplane

Os registros não chegam ao Bindplane: verifique se o conector CEF está configurado para enviar syslog ao endereço IP e à porta corretos do Bindplane. Verifique as regras de firewall entre o conector CEF e o agente do Bindplane.
Os registros não estão chegando ao Google SecOps: verifique o arquivo de configuração do Bindplane, o ID do cliente e o caminho de autenticação de ingestão. Verifique se há erros nos registros do Bindplane:
```
sudo journalctl -u observiq-otel-collector -f
```

Rede e conectividade

Verifique se o conector CEF pode acessar os endpoints da API SIEM da Akamai.
Verifique se o agente do Bindplane pode acessar o endpoint de ingestão do Google SecOps (malachiteingestion-pa.googleapis.com).
Verifique se todas as portas de firewall necessárias estão abertas.

Recuperar eventos de segurança anteriores

O conector CEF da Akamai opera em dois modos:

Baseado em deslocamento (recomendado): o conector registra automaticamente os eventos de segurança à medida que são coletados quase em tempo real. Esse é o modo padrão quando akamai.data.timebased está definido como false.
Com base no tempo: permite recuperar eventos que ocorreram em um período específico (até 12 horas atrás).

Para recuperar eventos de segurança ausentes ou passados:

Abra o arquivo de configuração do conector:

sudo nano /path/to/CEFConnector-<version>/config/CEFConnector.properties

Mude a configuração com base no tempo:
```
akamai.data.timebased=true
akamai.data.timebased.from=<EPOCH_START_TIME>
akamai.data.timebased.to=<EPOCH_END_TIME>
```
- Substitua <EPOCH_START_TIME> pela hora de início no formato de época (nas últimas 12 horas).
- Substitua <EPOCH_END_TIME> pelo horário de término no formato de época (opcional; se deixado em branco, extrai eventos até o presente).

Reinicie o conector CEF:

sudo /etc/init.d/AkamaiCEFConnector restart

Depois que os dados históricos forem recuperados, volte ao modo de ajuste:
```
akamai.data.timebased=false
```
Reinicie o conector CEF novamente.

Tabela de mapeamento do UDM

Campo de registro	Mapeamento do UDM	Lógica
`src` (attackData.clientIP)	`principal.ip`	Endereço IP de origem do cliente que faz a solicitação
`c6a2` (ipv6src)	`principal.ip`	Endereço IPv6 de origem se attackData.clientIP estiver no formato IPv6
`dhost` (httpMessage.host)	`target.hostname`	Nome do host do cabeçalho HTTP HOST
`dpt` (httpMessage.port)	`target.port`	Número da porta usada pela solicitação de entrada.
`requestMethod` (httpMessage.method)	`network.http.method`	Método HTTP da solicitação recebida (GET, POST etc.)
`request` (requestURL)	`target.url`	Calcula o URL completo com base nos campos httpMessage.
`cs1` (attackData.rules)	`security_result.rule_id`	IDs das regras acionadas para esta solicitação
`cs2` (attackData.ruleMessages)	`security_result.rule_name`	Mensagens das regras que foram acionadas
`act` (appliedAction)	`security_result.action`	Ação realizada (alerta, negação, cancelamento etc.)
`severity`	`security_result.severity`	Gravidade calculada (5 para detectar, 10 para mitigar)
`cs5` (attackData.clientReputation)	`security_result.threat_name`	Pontuações de IP do cliente para reputação do cliente
`cs6` (attackData.apiId)	`security_result.detection_fields`	ID da API para proteção de APIs
`start` (httpMessage.start)	`metadata.event_timestamp`	Hora em que o servidor de borda iniciou a conexão (formato de época)
`devicePayloadId` (httpMessage.requestId)	`metadata.product_log_id`	ID globalmente exclusivo da mensagem.
`flexString1` (attackData.configId)	`security_result.detection_fields`	ID da configuração de segurança aplicada a esta solicitação.
`flexString2` (attackData.policyId)	`security_result.detection_fields`	ID da política de firewall aplicada a esta solicitação.
`AkamaiSiemJA4` (identity.ja4)	`network.tls.client.ja3`	Impressão digital TLS do cliente JA4

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