Collecter les journaux d'analyse des données de sécurité personnalisés

Version de l'analyseur : 6.0

Compatible avec :

Ce document explique comment ingérer des données d'analyse de sécurité personnalisées dans Google Security Operations à l'aide de plusieurs méthodes d'ingestion. Ce guide s'adresse aux sources de données de sécurité personnalisées qui ne disposent pas d'un analyseur ou d'un type de journal prédéfinis.

L'analyse des données de sécurité personnalisées englobe la télémétrie de sécurité propriétaire, les journaux d'application personnalisés, les outils de sécurité internes ou toute donnée pertinente pour la sécurité provenant de sources sans intégration native à Google SecOps. Vous pouvez ingérer ces données en tant que journaux non structurés et, si vous le souhaitez, les normaliser à l'aide d'analyseurs personnalisés.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Source de données de sécurité personnalisée capable d'exporter des journaux au format JSON, CSV, SYSLOG ou dans d'autres formats structurés
  • Accès à l'un des éléments suivants :
    • Google Cloud Console (pour la création de clés API et GCS)
    • Console AWS (pour S3 ou Firehose)
    • Portail Azure (pour Azure Blob Storage)
    • Client ou application HTTP capable d'envoyer des requêtes de webhook
  • Autorisations de créer et de gérer des flux dans Google SecOps

Choisir votre méthode d'ingestion

Google SecOps est compatible avec plusieurs méthodes d'ingestion pour les données de sécurité personnalisées. Sélectionnez la méthode qui correspond le mieux aux capacités de votre source de données :

Méthode d'ingestion Cas d'utilisation Latence Complexité de configuration
Webhook Push en temps réel depuis les applications Secondes Faible
Amazon S3 V2 Exportation par lot vers un bucket S3 Minutes à heures Moyenne
Google Cloud Storage V2 Exportation par lot vers un bucket GCS Minutes à heures Moyenne
Azure Blob Storage V2 Exporter par lot vers Azure Storage Minutes à heures Moyenne
Amazon Data Firehose Streaming en temps réel depuis AWS Secondes Élevée

Option 1 : Ingestion par webhook (push en temps réel)

Utilisez cette méthode lorsque votre application de sécurité personnalisée peut envoyer des requêtes HTTP POST à un point de terminaison externe.

Créer un flux de webhook dans Google SecOps

Créer le flux

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Sur la page suivante, cliquez sur Configurer un seul flux.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, custom-security-analytics-webhook).
  5. Sélectionnez Webhook comme type de source.
  6. Sélectionnez Analyse personnalisée des données de sécurité comme Type de journal.
  7. Cliquez sur Suivant.
  8. Spécifiez les valeurs des paramètres d'entrée suivants :
    • Délimiteur de division : facultatif. Saisissez un délimiteur pour diviser les événements multilignes. Valeurs courantes :
      • \n : délimiteur de saut de ligne (le plus courant pour NDJSON)
      • Laissez ce champ vide si chaque requête contient un seul événement.
    • Espace de noms de l'élément : espace de noms de l'élément
    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux
  9. Cliquez sur Suivant.
  10. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Générer et enregistrer une clé secrète

Après avoir créé le flux, vous devez générer une clé secrète pour l'authentification :

  1. Sur la page d'informations du flux, cliquez sur Générer une clé secrète.
  2. Une boîte de dialogue affiche la clé secrète.

  3. Copiez et enregistrez la clé secrète de manière sécurisée.

Obtenir l'URL du point de terminaison du flux

  1. Accédez à l'onglet Détails du flux.
  2. Dans la section Informations sur le point de terminaison, copiez l'URL du point de terminaison du flux.

  3. Le format d'URL est le suivant :

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import

    Où {region} est la région de votre instance Google SecOps (par exemple, us, europe ou asia-southeast1) et {parent} est le chemin d'accès à la ressource au format projects/<PROJECT_ID>/locations/<LOCATION>/instances/<INSTANCE_ID>/logTypes/<LOG_TYPE>.

  4. Enregistrez cette URL pour les étapes suivantes.

  5. Cliquez sur OK.

Créer une clé API Google Cloud

Google SecOps nécessite une clé API pour l'authentification. Créez une clé API restreinte dans la Google Cloud Console.

Créer la clé API

  1. Accédez à la page Identifiants de la console Google Cloud.
  2. Sélectionnez votre projet (celui associé à votre instance Chronicle).
  3. Cliquez sur Créer des identifiants> Clé API.
  4. Une clé API est créée et affichée dans une boîte de dialogue.
  5. Cliquez sur Modifier la clé API pour restreindre la clé.

Restreindre la clé API

  1. Sur la page des paramètres de la clé API :
    • Nom : saisissez un nom descriptif (par exemple, Chronicle Webhook API Key).
  2. Sous Restrictions relatives aux API :
    1. Sélectionnez Restreindre la clé.
    2. Dans le menu déroulant Sélectionner des API, recherchez et sélectionnez API Google SecOps (ou API Chronicle).
  3. Cliquez sur Enregistrer.
  4. Copiez la valeur de la clé API dans le champ Clé API en haut de la page.

  5. Enregistrez la clé API de manière sécurisée.

Configurer votre application personnalisée pour envoyer des données

Configurez votre application ou script de sécurité personnalisé pour envoyer des requêtes HTTP POST au point de terminaison du webhook Chronicle.

Créez l'URL de webhook :

  • Combinez l'URL du point de terminaison Chronicle et la clé API :

    <ENDPOINT_URL>?key=<API_KEY>

    Exemple :

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=AIzaSyD...

Format de la requête HTTP :

  • Méthode : POST

  • URL :

    <ENDPOINT_URL>?key=<API_KEY>

  • En-têtes :

    Content-Type: application/json
x-chronicle-auth: <SECRET_KEY>

  • Corps (événement unique) :

    {
    "timestamp": "2025-01-15T10:30:00Z",
    "event_type": "authentication",
    "user": "john.doe@example.com",
    "action": "login",
    "result": "success",
    "source_ip": "203.0.113.45",
    "custom_field_1": "value1",
    "custom_field_2": "value2"
}

  • Corps (plusieurs événements avec un délimiteur de nouvelle ligne) :

    {"timestamp": "2025-01-15T10:30:00Z", "event_type": "authentication", "action": "login"}
{"timestamp": "2025-01-15T10:30:05Z", "event_type": "file_access", "action": "read"}
{"timestamp": "2025-01-15T10:30:10Z", "event_type": "authentication", "action": "logout"}

Exemples :

  • Exemple : script Python :

    import requests
import json
from datetime import datetime

# Configuration
ENDPOINT_URL = "https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import"
API_KEY = "your-api-key-here"
SECRET_KEY = "your-secret-key-here"

# Construct full URL
url = f"{ENDPOINT_URL}?key={API_KEY}"

# Headers
headers = {
    "Content-Type": "application/json",
    "x-chronicle-auth": SECRET_KEY
}

# Sample event
event = {
    "timestamp": datetime.utcnow().isoformat() + "Z",
    "event_type": "custom_security_event",
    "severity": "high",
    "source": "custom_security_tool",
    "message": "Suspicious activity detected",
    "user": "admin@example.com",
    "ip_address": "192.168.1.100"
}

# Send request
response = requests.post(url, headers=headers, data=json.dumps(event))

if response.status_code == 200:
    print("Event sent successfully")
else:
    print(f"Error: {response.status_code} - {response.text}")

  • Exemple de commande cURL :

    curl -X POST \
    "https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -H "x-chronicle-auth: YOUR_SECRET_KEY" \
    -d '{
        "timestamp": "2025-01-15T10:30:00Z",
        "event_type": "security_alert",
        "severity": "critical",
        "source": "custom_tool",
        "message": "Threat detected"
    }'

Référence des méthodes d'authentification

Les flux de webhook Google SecOps sont compatibles avec plusieurs méthodes d'authentification. Choisissez la méthode compatible avec votre application.

Si votre application est compatible avec les en-têtes HTTP personnalisés, utilisez cette méthode pour une meilleure sécurité.

  • Format de la demande :

    POST <ENDPOINT_URL> HTTP/1.1
Content-Type: application/json
x-goog-chronicle-auth: <API_KEY>
x-chronicle-auth: <SECRET_KEY>

{
  "event": "data",
  "timestamp": "2025-01-15T10:30:00Z"
}

  • Avantages :

    • La clé API et le code secret ne sont pas visibles dans l'URL.
    • Plus sécurisé, car les en-têtes ne sont pas enregistrés dans les journaux d'accès du serveur Web.
    • Méthode recommandée lorsque l'application est compatible.

Méthode 2 : Paramètres de requête

Si votre application n'accepte pas les en-têtes personnalisés, ajoutez les identifiants à l'URL.

  • Format de l'URL :

    <ENDPOINT_URL>?key=<API_KEY>&secret=<SECRET_KEY>

    Exemple :

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=AIzaSyD...&secret=abcd1234...

  • Format de la requête :

    POST <ENDPOINT_URL>?key=<API_KEY>&secret=<SECRET_KEY> HTTP/1.1
Content-Type: application/json

{
  "event": "data",
  "timestamp": "2025-01-15T10:30:00Z"
}

  • Inconvénients :

    • Les identifiants sont visibles dans l'URL.
    • Les identifiants peuvent être enregistrés dans les journaux d'accès du serveur Web.
    • Moins sécurisé que les en-têtes.

Méthode 3 : Hybride (URL + en-tête)

Certaines configurations utilisent une clé API dans l'URL et une clé secrète dans l'en-tête.

  • Format de la demande :

    POST <ENDPOINT_URL>?key=<API_KEY> HTTP/1.1
Content-Type: application/json
x-chronicle-auth: <SECRET_KEY>

{
    "event": "data",
    "timestamp": "2025-01-15T10:30:00Z"
}

Limites et bonnes pratiques concernant les webhooks

Limites de requêtes

Limite Valeur
Taille maximale des requêtes 4 Mo
RPS (requêtes par seconde) max. 15 000
Délai avant expiration de la requête 30 seconds
Comportement de nouvelle tentative Automatique avec intervalle exponentiel entre les tentatives

Bonnes pratiques

  • Événements par lot : envoyez plusieurs événements dans une seule requête au format JSON délimité par un retour à la ligne (NDJSON) pour réduire les frais généraux.
  • Incluez des codes temporels : incluez toujours un champ de code temporel au format ISO 8601 pour un classement précis des événements.
  • Utilisez des données structurées : envoyez des données au format JSON pour faciliter l'analyse et l'extraction des champs.
  • Implémentez une logique de nouvelle tentative : gérez les défaillances temporaires avec un intervalle exponentiel entre les tentatives.
  • Surveillez les codes de réponse : enregistrez les réponses autres que 200 et configurez des alertes pour celles-ci.

Option 2 : Ingestion Amazon S3 V2 (exportation par lot)

Utilisez cette méthode lorsque votre application de sécurité personnalisée peut exporter des journaux vers un bucket Amazon S3.

Créer un bucket Amazon S3

  1. Ouvrez la console Amazon S3.
  2. Cliquez sur Créer un bucket.
  3. Fournissez les informations de configuration suivantes :
    • Nom du bucket : saisissez un nom explicite pour le bucket (par exemple, custom-security-analytics-logs).
    • Région : sélectionnez la région AWS de votre choix (par exemple, us-east-1).
  4. Cliquez sur Créer.

Créer un utilisateur IAM avec un accès S3

  1. Ouvrez la console IAM.
  2. Cliquez sur Utilisateurs > Ajouter un utilisateur.
  3. Saisissez un nom d'utilisateur (par exemple, chronicle-s3-reader).
  4. Sélectionnez Accès programmatique.
  5. Cliquez sur Next: Permissions (Suivant : Autorisations).
  6. Choisissez Associer directement les stratégies existantes.
  7. Recherchez et sélectionnez AmazonS3FullAccess.
  8. Cliquez sur Next: Tags (Suivant : Tags).
  9. Cliquez sur Suivant : Relire.
  10. Cliquez sur Create User (Créer un utilisateur).
  11. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer l'ID de clé d'accès et la clé d'accès secrète.
  12. Cliquez sur Fermer.

Configurer votre application pour l'exportation vers S3

Configurez votre application de sécurité personnalisée pour écrire des fichiers journaux dans le bucket S3. L'application doit :

  • Écrivez les journaux dans un format structuré (JSON, CSV ou texte brut).
  • Utilisez une convention d'attribution de noms de fichiers cohérente.
  • Facultatif : Organisez les fichiers par date (par exemple, logs/2025/01/15/events.json).

  • Écrivez des fichiers complets (évitez les écritures partielles).

  • Exemple de structure de fichier :

    s3://custom-security-analytics-logs/
├── security-events/
│   ├── 2025/01/15/
│   │   ├── events-10-00.json
│   │   ├── events-11-00.json
│   │   └── events-12-00.json

  • Exemple de format de fichier journal (NDJSON) :

    {"timestamp": "2025-01-15T10:00:00Z", "event_type": "login", "user": "alice@example.com", "result": "success"}
{"timestamp": "2025-01-15T10:05:00Z", "event_type": "file_access", "user": "bob@example.com", "file": "/data/sensitive.txt"}
{"timestamp": "2025-01-15T10:10:00Z", "event_type": "logout", "user": "alice@example.com"}

Configurer le flux Google SecOps pour S3

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Sur la page suivante, cliquez sur Configurer un seul flux.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, custom-security-analytics-s3).
  5. Sélectionnez Amazon S3 V2 comme Type de source.
  6. Sélectionnez Analyse personnalisée des données de sécurité comme Type de journal.
  7. Cliquez sur Suivant.

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

    • URI S3 : URI du bucket au format s3://custom-security-analytics-logs/security-events/.

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers une fois le transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • ID de la clé d'accès : saisissez la clé d'accès de l'utilisateur IAM.

    • Clé d'accès secrète : saisissez la clé secrète de l'utilisateur IAM.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

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

Option 3 : Ingestion Google Cloud Storage V2 (exportation par lot)

Utilisez cette méthode lorsque votre application de sécurité personnalisée peut exporter des journaux vers un bucket Google Cloud Storage.

Créer un bucket GCS

  1. Accédez à la console Google Cloud.
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, custom-security-analytics-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion, multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions d'objets ou la règle de conservation

  6. Cliquez sur Créer.

Configurer votre application pour exporter vers GCS

Configurez votre application de sécurité personnalisée pour qu'elle écrive des fichiers journaux dans le bucket GCS à l'aide de l'une des méthodes suivantes :

  • Google Cloud SDK : utilisez gsutil ou des bibliothèques clientes.
  • Compte de service : créez un compte de service avec le rôle "Créateur d'objets de l'espace de stockage".

  • URL signées : générez des URL signées pour un accès en écriture temporaire.

  • Exemple avec gsutil :

    gsutil cp /path/to/logs/events.json gs://custom-security-analytics-logs/security-events/

  • Exemple utilisant la bibliothèque cliente Python :

    from google.cloud import storage
import json

# Initialize client
client = storage.Client()
bucket = client.bucket('custom-security-analytics-logs')

# Upload log file
blob = bucket.blob('security-events/2025/01/15/events.json')

# Write NDJSON data
events = [
    {"timestamp": "2025-01-15T10:00:00Z", "event_type": "login"},
    {"timestamp": "2025-01-15T10:05:00Z", "event_type": "logout"}
]

ndjson_data = '\n'.join([json.dumps(event) for event in events]) + '\n'
blob.upload_from_string(ndjson_data, content_type='application/x-ndjson')

Obtenir un compte de service Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, custom-security-analytics-gcs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Analyse personnalisée des données de sécurité comme Type de journal.
  7. Cliquez sur Get Service Account (Obtenir un compte de service).

  8. Une adresse e-mail de compte de service unique s'affiche, par exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  9. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

Accorder des autorisations IAM

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom du bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  6. Cliquez sur Enregistrer.

Configurer le flux Google SecOps pour GCS

  1. Continuez sur la page de création du flux (ou accédez à Paramètres du SIEM> Flux> Ajouter un flux).
  2. Cliquez sur Suivant.

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

    • URL du bucket de stockage : saisissez l'URI du bucket GCS avec le chemin d'accès au préfixe :

      gs://custom-security-analytics-logs/security-events/

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers une fois le transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  4. Cliquez sur Suivant.

  5. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Option 4 : Ingestion Azure Blob Storage V2 (exportation par lot)

Utilisez cette méthode lorsque votre application de sécurité personnalisée peut exporter des journaux vers Azure Blob Storage.

Créer un compte de stockage Azure

  1. Dans le portail Azure, recherchez Comptes de stockage.
  2. Cliquez sur + Créer.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Abonnement Sélectionnez votre abonnement Azure.
    Groupe de ressources Sélectionner un élément existant ou en créer un
    Nom du compte de stockage Saisissez un nom unique (par exemple, customsecuritylogs).
    Région Sélectionnez la région (par exemple, East US).
    Performances Standard (recommandé)
    Redondance GRS (stockage géoredondant) ou LRS (stockage localement redondant)

  4. Cliquez sur Examiner et créer.

  5. Examinez l'aperçu du compte, puis cliquez sur Créer.

  6. Attendez la fin du déploiement.

Obtenir les identifiants du compte de stockage

  1. Accédez au compte de stockage que vous venez de créer.
  2. Dans le menu de navigation de gauche, sélectionnez Clés d'accès sous Sécurité et mise en réseau.
  3. Cliquez sur Afficher les clés.
  4. Copiez et enregistrez les éléments suivants pour les utiliser ultérieurement :
    • Nom du compte de stockage : customsecuritylogs
    • Touche 1 ou Touche 2 : clé d'accès partagée

Créer un conteneur d'objets blob

  1. Dans le même compte de stockage, sélectionnez Containers (Conteneurs) dans le menu de navigation de gauche.
  2. Cliquez sur + Conteneur.
  3. Fournissez les informations de configuration suivantes :
    • Nom : saisissez un nom de conteneur (par exemple, security-events).
    • Niveau d'accès public : sélectionnez Privé (pas d'accès anonyme).
  4. Cliquez sur Créer.

Configurer votre application pour l'exportation vers Azure Blob

Configurez votre application de sécurité personnalisée pour qu'elle écrive des fichiers journaux dans le conteneur d'objets blob Azure à l'aide de l'une des méthodes suivantes :

  • CLI Azure : utilisez az storage blob upload.
  • SDK Azure : utilisez des bibliothèques clientes pour votre langage de programmation.
  • AzCopy : utilisez l'outil de ligne de commande AzCopy.

Exemples :

  • Exemple avec Azure CLI :

    az storage blob upload \
    --account-name customsecuritylogs \
    --container-name security-events \
    --name logs/2025/01/15/events.json \
    --file /path/to/events.json \
    --account-key <YOUR_ACCESS_KEY>

  • Exemple avec le SDK Python :

    from azure.storage.blob import BlobServiceClient
import json

# Initialize client
connection_string = "DefaultEndpointsProtocol=https;AccountName=customsecuritylogs;AccountKey=<YOUR_KEY>;EndpointSuffix=core.windows.net"
blob_service_client = BlobServiceClient.from_connection_string(connection_string)

# Get container client
container_client = blob_service_client.get_container_client("security-events")

# Upload log file
blob_client = container_client.get_blob_client("logs/2025/01/15/events.json")

# Write NDJSON data
events = [
    {"timestamp": "2025-01-15T10:00:00Z", "event_type": "login"},
    {"timestamp": "2025-01-15T10:05:00Z", "event_type": "logout"}
]

ndjson_data = '\n'.join([json.dumps(event) for event in events]) + '\n'
blob_client.upload_blob(ndjson_data, overwrite=True)

Configurer le flux Google SecOps pour Azure Blob

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Sur la page suivante, cliquez sur Configurer un seul flux.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, custom-security-analytics-azure).
  5. Sélectionnez Microsoft Azure Blob Storage V2 comme Type de source.
  6. Sélectionnez Custom Security Data Analytics comme type de journal.
  7. Cliquez sur Suivant.

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

    • URI Azure : saisissez l'URL du point de terminaison du service Blob avec le chemin d'accès au conteneur :

      https://customsecuritylogs.blob.core.windows.net/security-events/

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts.
      • Supprimer les fichiers transférés : supprime les fichiers une fois le transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • Clé partagée : saisissez la valeur de la clé partagée (clé d'accès) du compte de stockage.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Option 5 : Ingestion Amazon Data Firehose (streaming en temps réel)

Utilisez cette méthode lorsque votre application de sécurité personnalisée écrit des journaux dans Amazon CloudWatch Logs et que vous avez besoin d'un streaming en temps réel vers Google SecOps.

Créer un flux Firehose Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, custom-security-analytics-firehose).
  4. Sélectionnez Amazon Data Firehose comme type de source.
  5. Sélectionnez Analyse personnalisée des données de sécurité comme Type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • Délimiteur de division (facultatif) : saisissez \n pour diviser les journaux délimités par un saut de ligne.
    • Espace de noms de l'élément : espace de noms de l'élément.
    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.
  8. Cliquez sur Suivant.
  9. Vérifiez la configuration du flux, puis cliquez sur Envoyer.
  10. Cliquez sur Générer une clé secrète pour générer une clé secrète permettant d'authentifier ce flux.
  11. Copiez et enregistrez la clé secrète, car vous ne pourrez plus l'afficher.
  12. Accédez à l'onglet Détails.
  13. Copiez l'URL du point de terminaison du flux à partir du champ Informations sur le point de terminaison.
  14. Cliquez sur OK.

Créer une clé API Google Cloud

  1. Accédez à la page Identifiants de la console Google Cloud à l'adresse https://console.cloud.google.com/apis/credentials.
  2. Cliquez sur Créer des identifiants, puis sélectionnez Clé API.
  3. Cliquez sur Modifier la clé API pour restreindre la clé.
  4. Sous API restrictions (Restrictions liées à l'API), sélectionnez Restrict key (Restreindre la clé).
  5. Recherchez et sélectionnez API Google SecOps.
  6. Cliquez sur Enregistrer.
  7. Copiez et enregistrez la clé API.

Créer l'URL du point de terminaison

  1. Ajoutez la clé API à l'URL du point de terminaison du flux au format suivant :

    <FEED_ENDPOINT_URL>?key=<API_KEY>

    Exemple :

    https://{region}-chronicle.googleapis.com/v1/{parent}/logs:import?key=AIzaSyD...

  2. Enregistrez cette URL complète pour l'étape suivante.

Créer une stratégie IAM pour Firehose

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

  2. Collez le code JSON de la règle suivant :

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "firehose:PutRecord",
                "firehose:PutRecordBatch"
            ],
            "Resource": "arn:aws:firehose:<REGION>:<ACCOUNT_ID>:deliverystream/CustomSecurityToChronicle"
        }
    ]
}

  3. Remplacez les éléments suivants :

    • <REGION> : votre région AWS (par exemple, us-east-1).
    • <ACCOUNT_ID> : ID de votre compte AWS (numéro à 12 chiffres).

  4. Nommez la règle CloudWatchLogsToFirehosePolicy.

  5. Cliquez sur Créer une règle.

Créer un rôle IAM pour CloudWatch Logs

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

  2. Sélectionnez Stratégie de confiance personnalisée, puis collez :

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.<REGION>.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

  3. Remplacez <REGION> par votre région AWS.

  4. Cliquez sur Suivant.

  5. Recherchez et sélectionnez la règle CloudWatchLogsToFirehosePolicy que vous avez créée à l'étape précédente.

  6. Cliquez sur Suivant.

  7. Nommez le rôle CloudWatchLogsToFirehoseRole.

  8. Cliquez sur Créer un rôle.

Créer un flux de diffusion Kinesis Data Firehose

  1. Dans la console AWS, accédez à Kinesis > Data Firehose > Create delivery stream (Créer un flux de diffusion).

  2. Fournissez les informations de configuration suivantes :

    • Source et destination :

      • Source : sélectionnez PUT direct ou autres sources.
      • Destination : sélectionnez Point de terminaison HTTP.

    • Nom du flux de diffusion :

      • Nom du flux de diffusion : saisissez CustomSecurityToChronicle.

    • Destination du point de terminaison HTTP :

      • URL du point de terminaison HTTP : saisissez l'URL complète du point de terminaison que vous avez créée précédemment (point de terminaison du flux + clé API).
      • Encodage du contenu : sélectionnez GZIP (recommandé pour économiser de la bande passante).

    • En-têtes HTTP personnalisés :

      • Cliquez sur Ajouter un en-tête HTTP personnalisé.
      • Nom de l'en-tête : saisissez X-Goog-Chronicle-Auth.
      • Valeur de l'en-tête : saisissez la clé secrète que vous avez enregistrée à l'étape précédente.

    • Paramètres de sauvegarde :

      • Sauvegarde des enregistrements sources dans Amazon S3 : sélectionnez Données ayant échoué uniquement (recommandé).
      • Bucket S3 : sélectionnez un bucket existant ou créez-en un pour les enregistrements ayant échoué.

    • Conseils concernant la mémoire tampon :

      • Taille de la mémoire tampon : saisissez 1 Mio (minimum pour les points de terminaison HTTP).
      • Intervalle de mise en mémoire tampon : saisissez 60 secondes.

    • Durée de la nouvelle tentative :

      • Durée de la nouvelle tentative : saisissez 300 secondes (5 minutes).

  3. Cliquez sur Créer un flux de diffusion.

  4. Attendez que l'état du flux de diffusion passe à Actif (1 à 2 minutes).

Abonner le groupe de journaux CloudWatch à Firehose

  1. Dans la console AWS, accédez à CloudWatch > Journaux > Groupes de journaux.
  2. Sélectionnez le groupe de journaux cible contenant vos journaux d'analyse de sécurité personnalisés.
  3. Cliquez sur l'onglet Filtres d'abonnement.
  4. Cliquez sur Créer > Créer un filtre d'abonnement Amazon Kinesis Data Firehose.
  5. Fournissez les informations de configuration suivantes :
    • Destination : sélectionnez le flux de diffusion CustomSecurityToChronicle.
    • Accorder l'autorisation : sélectionnez le rôle CloudWatchLogsToFirehoseRole.
    • Nom du filtre d'abonnement : saisissez CustomSecurityToChronicle.
    • Format de journal : sélectionnez Autre (Google SecOps gère l'analyse).
    • Modèle de filtre d'abonnement : laissez ce champ vide pour envoyer tous les événements, ou saisissez un modèle de filtre pour n'envoyer que des événements spécifiques.
  6. Cliquez sur Démarrer la diffusion.
  7. Les journaux seront désormais diffusés en temps réel vers Google SecOps via Firehose.

Créer un analyseur personnalisé (facultatif)

Après avoir ingéré des données de sécurité personnalisées sous forme de journaux non structurés, vous pouvez créer un analyseur personnalisé pour normaliser les données au format UDM afin d'améliorer la recherche et la détection.

Quand créer un analyseur personnalisé ?

Créez un analyseur personnalisé dans les cas suivants :

  • Vous devez extraire des champs spécifiques de votre format de journal personnalisé.
  • Vous souhaitez activer la recherche UDM sur vos données personnalisées.
  • Vous devez mapper les champs personnalisés aux champs UDM standards pour les règles de détection
  • Vous souhaitez améliorer les performances de recherche en indexant des champs spécifiques.

Créer un type de journal personnalisé

  1. Accédez à Paramètres SIEM> Types de journaux disponibles.
  2. Cliquez sur Demander un type de journal.
  3. Dans la section Créer un type de journal personnalisé ou demander un type de journal prédéfini, sélectionnez Créer un type de journal personnalisé.
  4. Fournissez les informations suivantes :
    • Nom du type de journal : saisissez un nom descriptif (par exemple, CUSTOM_SECURITY_ANALYTICS).
    • Description : saisissez une description du type de journal.
    • Exemples de journaux : collez 5 à 10 exemples d'entrées de journal au format brut.
  5. Cliquez sur Envoyer.
  6. Le type de journal personnalisé sera disponible dans environ 10 minutes.

Créer un analyseur personnalisé

  1. Accédez à Paramètres SIEM> Analyseurs.
  2. Cliquez sur Créer un analyseur.
  3. Sélectionnez Analyseur personnalisé.
  4. Fournissez les informations suivantes :
    • Nom du parseur : saisissez un nom descriptif.
    • Type de journal : sélectionnez votre type de journal personnalisé (par exemple, CUSTOM_SECURITY_ANALYTICS).
    • Code de l'analyseur : saisissez la configuration de votre analyseur à l'aide du langage de configuration de l'analyseur de Google SecOps.
  5. Testez l'analyseur avec des exemples de journaux.
  6. Cliquez sur Envoyer pour activer l'analyseur.

Exemple de configuration de l'analyseur

  • Pour un format de journal JSON personnalisé :

    {
    "timestamp": "2025-01-15T10:30:00Z",
    "event_type": "authentication",
    "user": "john.doe@example.com",
    "action": "login",
    "result": "success",
    "source_ip": "203.0.113.45"
}

    Exemple de configuration de l'analyseur :

    filter {
    json {
        fields {
            timestamp: timestamp
            event_type: event_type
            user: user
            action: action
            result: result
            source_ip: source_ip
        }
    }
}

event {
    $e.metadata.event_timestamp.seconds = parseTimestamp(timestamp, "yyyy-MM-dd'T'HH:mm:ss'Z'")
    $e.metadata.event_type = "USER_LOGIN"
    $e.principal.user.email_addresses = user
    $e.target.ip = source_ip
    $e.security_result.action = if(result == "success", "ALLOW", "BLOCK")
}

    Pour en savoir plus sur la création d'analyseurs personnalisés, consultez Gérer les analyseurs prédéfinis et personnalisés.

Vérifier l'ingestion des données

Après avoir configuré votre flux, vérifiez que les données sont bien ingérées.

Vérifier l'état du flux

  1. Accédez à Paramètres SIEM> Flux.
  2. Recherchez votre flux dans la liste.
  3. Vérifiez la colonne État :
    • Actif : le flux est en cours d'exécution et ingère des données.
    • Erreur : Une erreur s'est produite dans le flux (cliquez pour en savoir plus)
    • Mis en veille : le flux est mis en veille.

Rechercher des journaux ingérés

  1. Accédez à Recherche > Analyse des journaux bruts.

  2. Saisissez une requête de recherche pour trouver vos journaux personnalisés :

    metadata.log_type = "CUSTOM_SECURITY_DATA_ANALYTICS"

  3. Ajustez la période si nécessaire.

  4. Cliquez sur Rechercher.

  5. Vérifiez que vos journaux apparaissent dans les résultats.

Surveiller les métriques du flux

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur le nom de votre flux.
  3. Accédez à l'onglet Métriques.
  4. Examinez les métriques suivantes :
    • Événements ingérés : nombre total d'événements ingérés
    • Octets ingérés : volume total de données ingérées
    • Taux d'ingestion : événements par seconde
    • Erreurs : nombre d'erreurs d'ingestion

Dépannage

Problèmes d'ingestion de webhook

  • Problème : HTTP 401 Non autorisé

    • Cause : clé API ou clé secrète non valide
    • Solution : Vérifiez que la clé API et la clé secrète sont correctes et n'ont pas expiré.

  • Problème : HTTP 403 Forbidden

    • Cause : la clé API ne dispose pas des autorisations de l'API Chronicle.
    • Solution : modifiez la clé API et assurez-vous que l'API Chronicle est sélectionnée sous "Restrictions d'API".

  • Problème : requête HTTP 400 incorrecte

    • Cause : format ou charge utile de la requête non valides
    • Solution : Vérifiez que l'en-tête Content-Type est défini sur application/json et que la charge utile est un fichier JSON valide.

Problèmes d'ingestion S3/GCS/Azure Blob

  • Problème : aucune donnée ingérée

    • Cause : URI de bucket incorrect ou autorisations manquantes
    • Solution : vérifiez que l'URI du bucket inclut la barre oblique finale et que le compte de service dispose du rôle "Lecteur des objets Storage".

  • Problème : Les fichiers ne sont pas supprimés après l'ingestion

    • Cause : Le compte de service ne dispose pas des autorisations de suppression
    • Solution : attribuez le rôle Administrateur des objets Storage au lieu du rôle Lecteur des objets Storage

  • Problème : les anciens fichiers ne sont pas ingérés

    • Cause : Le paramètre "Âge maximal du fichier" exclut les anciens fichiers
    • Solution : augmentez la valeur "Âge maximal du fichier" dans la configuration du flux.

Problèmes d'ingestion Firehose

  • Problème : le flux de diffusion affiche des erreurs

    • Cause : URL de point de terminaison ou authentification non valide
    • Solution : Vérifiez que l'URL du point de terminaison inclut le paramètre de clé API et que l'en-tête X-Goog-Chronicle-Auth contient la clé secrète appropriée.

  • Problème : métrique de fraîcheur des données élevée

    • Cause : Firehose est limité ou rencontre des échecs de diffusion
    • Solution : Vérifiez les métriques CloudWatch pour les taux ThrottledRecords et DeliveryToHTTP.Success.

  • Problème : aucun journal n'est diffusé depuis CloudWatch

    • Cause : le filtre d'abonnement n'est pas configuré ou le rôle IAM ne dispose pas des autorisations nécessaires
    • Solution : Vérifiez que le filtre d'abonnement est actif et que le rôle IAM dispose des autorisations firehose:PutRecord.

Table de mappage UDM

Les journaux d'analyse de données de sécurité personnalisés sont ingérés en tant que données non structurées. Pour activer le mappage de champs UDM, créez un analyseur personnalisé comme décrit dans la section "Créer un analyseur personnalisé" ci-dessus.

Une fois que vous avez créé un analyseur personnalisé, les champs UDM sont renseignés en fonction de sa configuration. Voici quelques exemples de champs UDM courants pour les données d'analyse de la sécurité :

Champ UDM Description
metadata.event_timestamp Code temporel de l'événement
metadata.event_type Type d'événement (par exemple, USER_LOGIN, FILE_ACCESS)
principal.user.email_addresses Adresse e-mail de l'utilisateur
principal.ip Adresse IP source
target.resource.name Nom de la ressource cible
security_result.action Action de sécurité (AUTORISER, BLOQUER, etc.)
security_result.severity Gravité de l'événement

Pour obtenir la liste complète des champs UDM, consultez la documentation de référence sur les champs UDM.

Journal des modifications

Afficher le journal des modifications de cet analyseur

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