Cette page a été traduite par l'API Cloud Translation.

Collecter les journaux Akamai WAF

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des journaux Akamai WAF dans Google Security Operations à l'aide du connecteur Akamai CEF et de Bindplane.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Une instance Google SecOps
Un hôte Windows 2016 ou version ultérieure, ou Linux avec systemd pour l'installation de l'agent Bindplane
Un serveur Linux (CentOS/RHEL/Ubuntu recommandé) avec au moins deux cœurs de processeur, 6 Go de RAM et 2 Go d'espace disque libre pour le connecteur Akamai CEF
Java 8 (JRE 1.8) ou version ultérieure installé sur l'hôte du connecteur CEF
Si vous exécutez l'agent derrière un proxy, assurez-vous que les ports du pare-feu sont ouverts conformément aux exigences de l'agent Bindplane et que les listes d'autorisation du proxy *.cloudsecurity.akamaiapis.net et *.luna.akamaiapis.net
Accès privilégié à Akamai Control Center
Une configuration de sécurité Akamai avec App & API Protector, Kona Site Defender, Web Application Protector, Bot Manager ou Account Protector activé

Obtenir le fichier d'authentification d'ingestion Google SecOps

Connectez-vous à la console Google SecOps.
Accédez à Paramètres du SIEM > Agents de collecte.
Téléchargez le fichier d'authentification d'ingestion. Enregistrez le fichier de manière sécurisée sur le système sur lequel Bindplane sera installé.

Obtenir l'ID client Google SecOps

Connectez-vous à la console Google SecOps.
Accédez à Paramètres SIEM> Profil.
Copiez et enregistrez le numéro client de la section Informations sur l'organisation.

Activer l'intégration SIEM dans Akamai Control Center

Connectez-vous à Akamai Control Center.
Sous SÉCURITÉ DU CENTRE DE DONNÉES ET DU WEB, cliquez sur Configuration de la sécurité.
Ouvrez la configuration de sécurité et la version appropriée pour lesquelles vous souhaitez collecter des données SIEM.
Cliquez sur Paramètres avancés, puis développez Collecte de données pour les intégrations SIEM.
Cliquez sur Activé pour activer le SIEM.
Choisissez les règles de sécurité pour lesquelles vous souhaitez exporter des données :
- Toutes les règles de sécurité : sélectionnez cette option pour envoyer les données SIEM pour les événements qui enfreignent une ou plusieurs règles de sécurité dans la configuration de sécurité.
- Règles de sécurité spécifiques : sélectionnez cette option pour envoyer des données concernant une ou plusieurs règles de sécurité spécifiques. Sélectionnez les règles appropriées dans la liste déroulante.
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.
(Facultatif) Si vous souhaitez recevoir des informations sur l'empreinte JA4 dans les événements SIEM, cochez la case Inclure l'empreinte TLS du client JA4.
Facultatif : Si vous souhaitez exclure des événements appartenant à un type de protection et à une action spécifiques, cliquez sur Ajouter une exception. Sélectionnez la protection et les actions associées que vous ne souhaitez pas que le SIEM collecte. Cliquez sur Enregistrer.
Copiez la valeur du champ ID de configuration de la sécurité Web. Enregistrez cet ID pour une utilisation ultérieure.
Cliquez sur Activer pour appliquer les modifications de configuration de la sécurité au réseau de production. Sous Réseau, cliquez sur Production, puis sur Activer.

Configurer un utilisateur pour gérer le SIEM dans Akamai Control Center

Dans Akamai Control Center, sous ACCOUNT ADMIN (ADMINISTRATEUR DE COMPTE), cliquez sur Identity & access (Identité et accès).
Dans l'onglet Utilisateurs et clients API, recherchez l'utilisateur auquel vous souhaitez attribuer le rôle ou cliquez sur le bouton Créer un utilisateur.
Pour attribuer le rôle SIEM à un utilisateur existant :
- Ouvrez le compte de l'utilisateur, puis cliquez sur l'onglet Modifier les rôles.
- Recherchez le groupe approprié, cliquez sur le menu Rôles, puis sélectionnez le rôle Gérer le SIEM.
- Cliquez sur Envoyer.
Pour attribuer le rôle SIEM à un nouvel utilisateur :
- Cliquez sur Créer un utilisateur.
- Saisissez les informations de base de l'utilisateur, puis accédez à la section Attribuer des rôles.
- Recherchez le groupe approprié, cliquez sur le menu Rôles, puis sélectionnez le rôle Gérer le SIEM.
- Cliquez sur Enregistrer.

Provisionner les identifiants de l'API SIEM dans Akamai Control Center

Consultez la page Créer des identifiants d'authentification dans la documentation Akamai.
Suivez la procédure pour provisionner l'API SIEM pour l'utilisateur que vous avez désigné pour gérer le SIEM.
Copiez et enregistrez les identifiants suivants de manière sécurisée :
- Jeton d'accès
- Jeton Client
- Code secret du client
- URL de base

Installer le connecteur Akamai CEF

Sur votre serveur Linux, téléchargez le dernier package de distribution du connecteur CEF à partir du dépôt GitHub Akamai.
Transférez le package sur votre serveur à l'aide de wget ou de SFTP.
Vérifiez le hachage SHA256 du fichier téléchargé pour vous assurer de son intégrité.
Extrayez le package de distribution :
```
unzip CEFConnector-<version>.zip
```
Accédez au répertoire extrait :
```
cd CEFConnector-<version>
```

Pour installer le service, créez un lien symbolique vers le script de démarrage :

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

Configurer le connecteur Akamai CEF

Accédez au répertoire config dans l'installation du connecteur CEF :
```
cd config
```
Ouvrez le fichier CEFConnector.properties à l'aide d'un éditeur de texte (par exemple, nano, vi) :
```
sudo nano CEFConnector.properties
```

Configurez les paramètres obligatoires suivants :

# 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=

Remplacez les espaces réservés suivants par vos valeurs réelles :
- <YOUR_SECURITY_CONFIG_ID> : ID de la configuration de sécurité Web que vous avez copié précédemment. Pour plusieurs configurations, séparez les ID par des points-virgules (par exemple, 12345;67890).
- <YOUR_ACCESS_TOKEN> : jeton d'accès provenant des identifiants de l'API Akamai
- <YOUR_CLIENT_TOKEN> : jeton client issu des identifiants de l'API Akamai
- <YOUR_CLIENT_SECRET> : code secret du client provenant des identifiants de l'API Akamai
- <YOUR_BASE_URL> : URL de base des identifiants de l'API Akamai
Enregistrez et fermez le fichier.

Configurer la journalisation du connecteur CEF

Accédez au répertoire config dans l'installation du connecteur CEF.
Ouvrez le fichier log4j2.xml à l'aide d'un éditeur de texte :
```
sudo nano log4j2.xml
```

Configurez les paramètres suivants pour la sortie syslog vers 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>

Remplacez les espaces réservés suivants :
- <BINDPLANE_IP_ADDRESS> : adresse IP du serveur sur lequel l'agent Bindplane est installé
- <BINDPLANE_PORT> : numéro de port sur lequel l'agent Bindplane écoute (par exemple, 514 pour UDP ou 601 pour TCP)
- <PROTOCOL> : sélectionnez UDP ou TCP.
Assurez-vous que le connecteur CEF envoie les journaux au serveur syslog distant (BindPpane) en configurant les paramètres spécifiques à CEF :
```
# In CEFConnector.properties, ensure these are set:
# Note: These settings are typically in log4j2.xml but referenced here for clarity
```
Enregistrez et fermez le fichier.

Démarrer le connecteur Akamai CEF

Démarrez le service CEF Connector :

sudo /etc/init.d/AkamaiCEFConnector start

Vérifiez que le service est en cours d'exécution :
```
sudo /etc/init.d/AkamaiCEFConnector status
```
Surveillez les journaux pour vous assurer que le connecteur extrait les événements d'Akamai et les envoie à Bindplane :
```
tail -f /path/to/CEFConnector-<version>/bin/logs/cefconnector.log
```

Installer l'agent Bindplane

Installez l'agent Bindplane sur votre système d'exploitation Windows ou Linux en suivant les instructions ci-dessous.

Installation de fenêtres

Ouvrez l'invite de commandes ou PowerShell en tant qu'administrateur.

Exécutez la commande suivante :

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

Installation de Linux

Ouvrez un terminal avec les droits root ou sudo.

Exécutez la commande suivante :

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

Autres ressources d'installation

Pour plus d'options d'installation, consultez ce guide d'installation.

Configurer l'agent Bindplane pour ingérer Syslog et l'envoyer à Google SecOps

Accédez au fichier de configuration :
1. Recherchez le fichier config.yaml. Il se trouve généralement dans le répertoire /etc/bindplane-agent/ sous Linux ou dans le répertoire d'installation sous Windows.
2. Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou le Bloc-notes).

Modifiez le fichier config.yaml comme suit :

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

Redémarrez l'agent Bindplane pour appliquer les modifications.

Pour redémarrer l'agent Bindplane sous Linux, exécutez la commande suivante :
```
sudo systemctl restart bindplane-agent
```
Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :
```
net stop BindPlaneAgent && net start BindPlaneAgent
```

Vérifier l'ingestion des journaux

Connectez-vous à la console Google SecOps.
Accédez à Recherche ou Analyse des journaux bruts.
Recherchez les journaux Akamai WAF récents à l'aide du libellé d'ingestion :
```
metadata.log_type = "AKAMAI_WAF"
```
Vérifiez que les journaux s'affichent avec les champs et les codes temporels attendus.
Vérifiez que les champs au format CEF sont correctement analysés et mappés à l'UDM.

Dépannage

Problèmes liés au connecteur CEF

Aucun événement n'est extrait : vérifiez si le fichier cefconnector.log contient des erreurs. Vérifiez que les identifiants de l'API Akamai sont corrects et que les ID de configuration de sécurité sont valides.
Erreurs de connexion : assurez-vous que les paramètres de proxy (le cas échéant) sont correctement configurés et que les domaines requis sont ajoutés à la liste d'autorisation.
Réinitialisation de la base de données : si vous devez réinitialiser le suivi du décalage, exécutez la commande suivante :
```
sudo /etc/init.d/AkamaiCEFConnector resetdb
```

Problèmes liés à l'agent Bindplane

Les journaux n'atteignent pas Bindplane : vérifiez que le connecteur CEF est configuré pour envoyer syslog à l'adresse IP et au port Bindplane corrects. Vérifiez les règles de pare-feu entre le connecteur CEF et l'agent Bindplane.
Les journaux n'atteignent pas Google SecOps : vérifiez le fichier de configuration Bindplane, le numéro client et le chemin d'authentification de l'ingestion. Recherchez les erreurs dans les journaux Bindplane :
```
sudo journalctl -u observiq-otel-collector -f
```

Réseau et connectivité

Vérifiez que le connecteur CEF peut accéder aux points de terminaison de l'API Akamai SIEM.
Vérifiez que l'agent Bindplane peut accéder au point de terminaison d'ingestion Google SecOps (malachiteingestion-pa.googleapis.com).
Vérifiez que tous les ports de pare-feu requis sont ouverts.

Récupérer les événements de sécurité passés

Le connecteur Akamai CEF fonctionne dans deux modes :

Basé sur le décalage (recommandé) : le connecteur enregistre automatiquement les événements de sécurité à mesure qu'ils sont collectés en temps quasi réel. Il s'agit du mode par défaut lorsque akamai.data.timebased est défini sur false.
Basé sur le temps : vous permet de récupérer les événements qui se sont produits au cours d'une période spécifique (jusqu'à 12 heures dans le passé).

Pour récupérer des événements de sécurité manquants ou passés :

Ouvrez le fichier de configuration du connecteur :

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

Modifiez la configuration basée sur le temps :
```
akamai.data.timebased=true
akamai.data.timebased.from=<EPOCH_START_TIME>
akamai.data.timebased.to=<EPOCH_END_TIME>
```
- Remplacez <EPOCH_START_TIME> par l'heure de début au format epoch (au cours des 12 dernières heures).
- Remplacez <EPOCH_END_TIME> par l'heure de fin au format epoch (facultatif ; si vous le laissez vide, les événements sont extraits jusqu'à présent).

Redémarrez le connecteur CEF :

sudo /etc/init.d/AkamaiCEFConnector restart

Une fois les données historiques récupérées, revenez au mode décalage :
```
akamai.data.timebased=false
```
Redémarrez à nouveau le connecteur CEF.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
`src` (attackData.clientIP)	`principal.ip`	Adresse IP source du client qui envoie la requête
`c6a2` (ipv6src)	`principal.ip`	Adresse IPv6 source si attackData.clientIP est au format IPv6
`dhost` (httpMessage.host)	`target.hostname`	Nom d'hôte de l'en-tête HTTP HOST
`dpt` (httpMessage.port)	`target.port`	Numéro de port utilisé par la requête entrante
`requestMethod` (httpMessage.method)	`network.http.method`	Méthode HTTP de la requête entrante (GET, POST, etc.)
`request` (requestURL)	`target.url`	URL complète calculée à partir des champs httpMessage
`cs1` (attackData.rules)	`security_result.rule_id`	ID des règles déclenchées pour cette demande
`cs2` (attackData.ruleMessages)	`security_result.rule_name`	Messages des règles déclenchées
`act` (appliedAction)	`security_result.action`	Action effectuée (alerte, refus, abandon, etc.)
`severity`	`security_result.severity`	Gravité calculée (5 pour "Détecter", 10 pour "Atténuer")
`cs5` (attackData.clientReputation)	`security_result.threat_name`	Scores d'adresses IP de clients pour la réputation des clients
`cs6` (attackData.apiId)	`security_result.detection_fields`	ID d'API pour la protection des API
`start` (httpMessage.start)	`metadata.event_timestamp`	Heure à laquelle le serveur Edge a initié la connexion (format epoch)
`devicePayloadId` (httpMessage.requestId)	`metadata.product_log_id`	ID unique mondial du message
`flexString1` (attackData.configId)	`security_result.detection_fields`	ID de la configuration de sécurité appliquée à cette requête
`flexString2` (attackData.policyId)	`security_result.detection_fields`	ID de la règle de pare-feu appliquée à cette requête
`AkamaiSiemJA4` (identity.ja4)	`network.tls.client.ja3`	Empreinte TLS du client JA4

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