Collecter des journaux de données analytiques de sécurité personnalisées

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 ni d'un type de journal prédéfinis.

L'analyse personnalisée des données de sécurité 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 Google SecOps native. Vous pouvez ingérer ces données sous forme de 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 webhook
  • Autorisations pour créer et 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 la configuration
Webhook Notifications push en temps réel provenant des applications Secondes Faible
Amazon S3 V2 Exportation par lot vers un bucket S3 Minutes à heures Moyenne
Google Cloud Storage V2 Exporter par lot vers un bucket GCS Minutes à heures Moyenne
Azure Blob Storage V2 Exportation par lot vers Azure Storage Minutes à heures Moyenne
Amazon Data Firehose Streaming en temps réel depuis AWS Secondes Élevée

Option 1 : Ingestion de webhook (envoi 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 Add New Feed (Ajouter un flux).
  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 Données d'analyse de sécurité personnalisées comme Type de journal.
  7. Cliquez sur Suivant.
  8. Spécifiez les valeurs des paramètres d'entrée suivants :
    • Séparateur de fractionnement : facultatif. Saisissez un séparateur pour fractionner les événements multilignes. Valeurs courantes :
      • \n : délimiteur de retour à la 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 sur le 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 Endpoint Information (Informations sur le point de terminaison), copiez l'URL du point de terminaison du flux.

  3. Le format d'URL est le suivant :

    https://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate

    ou

    https://<REGION>-malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate

  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 la restreindre.

Restreindre la clé API

  1. Sur la page des paramètres 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 depuis 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 de webhook Chronicle.

Créez l'URL du webhook :

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

    <ENDPOINT_URL>?key=<API_KEY>

    Exemple :

    https://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate?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 saut de 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://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate"
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://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate?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 consignés dans les journaux d'accès au serveur Web.
    • Méthode à privilégier lorsque l'application la prend en charge.

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://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate?key=AIzaSyD...&secret=abcd1234...

  • Format de la demande :

    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 consignés dans les journaux d'accès au 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 de la requête 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 la surcharge.
  • Incluez des codes temporels : incluez toujours un champ de code temporel au format ISO 8601 pour que les événements soient classés avec précision.
  • 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 échecs temporaires avec un intervalle exponentiel entre les tentatives.
  • Surveiller les codes de réponse : enregistrez les réponses autres que 200 et définissez des alertes.

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 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. Sélectionnez Attach existing policies directly (Joindre directement des règles existantes).
  7. Recherchez et sélectionnez AmazonS3FullAccess.
  8. Cliquez sur Next: Tags (Suivant : Tags).
  9. Cliquez sur Suivant : Relire.
  10. Cliquez sur 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 qu'elle écrive 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 Add New Feed (Ajouter un flux).
  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 Données d'analyse de sécurité personnalisées 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 après un 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 des fichiers : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

    • ID de 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.

    • 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.

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 à Google Cloud Console.
  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
    Nommer votre bucket Saisissez un nom unique (par exemple, custom-security-analytics-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou 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 : Activer la gestion des versions des objets ou la règle de conservation

  6. Cliquez sur Créer.

Configurer votre application pour l'exportation 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 des objets de l'espace de stockage".

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

  • Exemple d'utilisation de gsutil :

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

  • Exemple d'utilisation de 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 Add New Feed (Ajouter un flux).
  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 Données d'analyse de sécurité personnalisées comme Type de journal.
  7. Cliquez sur Obtenir un compte de service.

  8. Une adresse e-mail unique pour le compte de service 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 des objets de l'espace de stockage.

  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 après un 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 des fichiers : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

    • 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.

  4. Cliquez sur Suivant.

  5. Vérifiez la configuration de votre nouveau flux 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 une base de données existante ou en créer une
    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 local 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 volet 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 une utilisation ultérieure :
    • 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 Conteneurs dans le panneau de navigation de gauche.
  2. Cliquez sur + Conteneur.
  3. Fournissez les informations de configuration suivantes :
    • Name (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 écrire des fichiers journaux dans le conteneur Azure Blob à l'aide de l'une des méthodes suivantes :

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

Exemples :

  • Exemple d'utilisation de la CLI Azure :

    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 d'utilisation du 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 Add New Feed (Ajouter un flux).
  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 Données d'analyse de sécurité personnalisées 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 après un 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 des fichiers : incluez les fichiers modifiés au cours des derniers 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.

    • 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.

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 flux en temps réel vers Google SecOps.

Créer un flux Firehose Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  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 Données d'analyse de sécurité personnalisées comme Type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • Délimiteur de fractionnement : facultatif. Saisissez \n pour fractionner les journaux délimités par un retour à la ligne.
    • 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.
  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 la restreindre.
  4. Sous Restrictions relatives aux API, sélectionnez Restreindre la clé.
  5. Recherchez et sélectionnez l'API Google SecOps.
  6. Cliquez sur Enregistrer.
  7. Copiez et enregistrez la clé API.

Construire 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://malachiteingestion-pa.googleapis.com/v2/unstructuredlogentries:batchCreate?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 Règle 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.

  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 livraison : 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 lors d'une é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 le 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).

S'abonner à un groupe de journaux CloudWatch pour 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 du 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 certains événements.
  6. Cliquez sur Démarrer le streaming.
  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é lorsque :

  • 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 sur les 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 du 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 journaux 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 de l'analyseur : 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

Une fois votre flux configuré, 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)
    • Suspendu : le flux est suspendu.

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 des 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 API Chronicle est sélectionné sous "Restrictions d'API".

  • Problème : Requête incorrecte HTTP 400

    • 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 code 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 de fin et que le compte de service dispose du rôle Lecteur des objets de l'espace de stockage.

  • 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 : Accorder le rôle "Administrateur des objets de l'espace de stockage" au lieu de "Lecteur des objets de l'espace de stockage"

  • Problème : anciens fichiers non ingérés

    • Cause : le paramètre "Âge maximal des fichiers" 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 distribution affiche des erreurs

    • Cause : URL de point de terminaison ou authentification non valides
    • 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 requises
    • 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 des données de sécurité personnalisées sont ingérés en tant que données non structurées. Pour activer le mappage des 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 la configuration de votre analyseur. 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.

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