Collecter les journaux CrowdStrike FileVantage

Compatible avec :

Google SecOps SIEM

Remarque : Cette fonctionnalité est couverte par les Conditions des offres avant disponibilité générale des conditions spécifiques au service Google Security Operations. Les fonctionnalités pré-DG (avant disponibilité générale) sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les instructions relatives aux services d'assistance technique Google SecOps et les Conditions spécifiques du service Google SecOps.

Ce document explique comment ingérer des journaux CrowdStrike FileVantage dans Google Security Operations à l'aide d'Amazon S3.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps.
• Accès privilégié à la console CrowdStrike Falcon.
• Accès privilégié à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Recueillir les conditions préalables de CrowdStrike FileVantage (identifiants API)

1. Connectez-vous à la console CrowdStrike Falcon.
2. Accédez à Assistance et ressources > Clients et clés API.
3. Cliquez sur Ajouter un client API.
4. Fournissez les informations de configuration suivantes :
   • Nom du client : saisissez un nom descriptif (par exemple, Google SecOps FileVantage Integration).
   • Description : saisissez une brève description de l'objectif de l'intégration.
   • Niveaux d'accès à l'API : sélectionnez Falcon FileVantage:read.
5. Cliquez sur Add (Ajouter) pour terminer le processus.
6. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
   • ID client
   • Code secret du client
   • URL de base (détermine votre région cloud)

Configurer un bucket AWS S3 et IAM pour Google SecOps

1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
2. Enregistrez le Nom et la Région du bucket pour référence ultérieure (par exemple, crowdstrike-filevantage-logs).
3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
4. Sélectionnez l'utilisateur créé.
5. Sélectionnez l'onglet Informations d'identification de sécurité.
6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
7. Sélectionnez Service tiers comme Cas d'utilisation.
8. Cliquez sur Suivant.
9. Facultatif : Ajoutez un tag de description.
10. Cliquez sur Créer une clé d'accès.
11. Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
12. Cliquez sur OK.
13. Sélectionnez l'onglet Autorisations.
14. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
15. Sélectionnez Ajouter des autorisations.
16. Sélectionnez Joindre directement des règles.
17. Recherchez la règle AmazonS3FullAccess.
18. Sélectionnez la règle.
19. Cliquez sur Suivant.
20. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

1. Dans la console AWS, accédez à IAM > Stratégies.
2. Cliquez sur Créer une règle > onglet JSON.
3. Copiez et collez le règlement suivant.

4. JSON de la règle (remplacez crowdstrike-filevantage-logs si vous avez saisi un autre nom de bucket) :

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::crowdstrike-filevantage-logs/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::crowdstrike-filevantage-logs/filevantage/state.json"
       }
     ]
   }
   

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

6. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

7. Associez la règle que vous venez de créer.

8. Nommez le rôle CrowdStrikeFileVantageRole, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
2. Cliquez sur Créer à partir de zéro.

3. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Nom	crowdstrike-filevantage-logs
   Durée d'exécution	Python 3.13
   Architecture	x86_64
   Rôle d'exécution	CrowdStrikeFileVantageRole

4. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et collez le code suivant (crowdstrike-filevantage-logs.py).

   import os
   import json
   import boto3
   import urllib3
   from datetime import datetime, timezone
   from urllib.parse import urlencode
   
   def lambda_handler(event, context):
       """
       Lambda function to fetch CrowdStrike FileVantage logs and store them in S3
       """
   
       # Environment variables
       s3_bucket = os.environ['S3_BUCKET']
       s3_prefix = os.environ['S3_PREFIX']
       state_key = os.environ['STATE_KEY']
       client_id = os.environ['FALCON_CLIENT_ID']
       client_secret = os.environ['FALCON_CLIENT_SECRET']
       base_url = os.environ['FALCON_BASE_URL']
   
       # Initialize clients
       s3_client = boto3.client('s3')
       http = urllib3.PoolManager()
   
       try:
           # Get OAuth token
           token_url = f"{base_url}/oauth2/token"
           token_headers = {
               'Content-Type': 'application/x-www-form-urlencoded',
               'Accept': 'application/json'
           }
           token_data = urlencode({
               'client_id': client_id,
               'client_secret': client_secret,
               'grant_type': 'client_credentials'
           })
   
           token_response = http.request('POST', token_url, body=token_data, headers=token_headers)
   
           if token_response.status != 200:
               print(f"Failed to get OAuth token: {token_response.status}")
               return {'statusCode': 500, 'body': 'Authentication failed'}
   
           token_data = json.loads(token_response.data.decode('utf-8'))
           access_token = token_data['access_token']
   
           # Get last checkpoint
           last_timestamp = get_last_checkpoint(s3_client, s3_bucket, state_key)
   
           # Fetch file changes
           changes_url = f"{base_url}/filevantage/queries/changes/v1"
           headers = {
               'Authorization': f'Bearer {access_token}',
               'Accept': 'application/json'
           }
   
           # Build query parameters
           params = {
               'limit': 500,
               'sort': 'action_timestamp.asc'
           }
   
           if last_timestamp:
               params['filter'] = f"action_timestamp:>'{last_timestamp}'"
   
           query_url = f"{changes_url}?{urlencode(params)}"
           response = http.request('GET', query_url, headers=headers)
   
           if response.status != 200:
               print(f"Failed to query changes: {response.status}")
               return {'statusCode': 500, 'body': 'Failed to fetch changes'}
   
           response_data = json.loads(response.data.decode('utf-8'))
           change_ids = response_data.get('resources', [])
   
           if not change_ids:
               print("No new changes found")
               return {'statusCode': 200, 'body': 'No new changes'}
   
           # Get detailed change information
           details_url = f"{base_url}/filevantage/entities/changes/v1"
           batch_size = 100
           all_changes = []
           latest_timestamp = last_timestamp
   
           for i in range(0, len(change_ids), batch_size):
               batch_ids = change_ids[i:i + batch_size]
               details_params = {'ids': batch_ids}
               details_query_url = f"{details_url}?{urlencode(details_params, doseq=True)}"
   
               details_response = http.request('GET', details_query_url, headers=headers)
   
               if details_response.status == 200:
                   details_data = json.loads(details_response.data.decode('utf-8'))
                   changes = details_data.get('resources', [])
                   all_changes.extend(changes)
   
                   # Track latest timestamp
                   for change in changes:
                       change_time = change.get('action_timestamp')
                       if change_time and (not latest_timestamp or change_time > latest_timestamp):
                           latest_timestamp = change_time
   
           if all_changes:
               # Store logs in S3
               timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
               s3_key = f"{s3_prefix}filevantage_changes_{timestamp}.json"
   
               s3_client.put_object(
                   Bucket=s3_bucket,
                   Key=s3_key,
                   Body='\n'.join(json.dumps(change) for change in all_changes),
                   ContentType='application/json'
               )
   
               # Update checkpoint
               save_checkpoint(s3_client, s3_bucket, state_key, latest_timestamp)
   
               print(f"Stored {len(all_changes)} changes in S3: {s3_key}")
   
           return {
               'statusCode': 200,
               'body': f'Processed {len(all_changes)} changes'
           }
   
       except Exception as e:
           print(f"Error: {str(e)}")
           return {'statusCode': 500, 'body': f'Error: {str(e)}'}
   
   def get_last_checkpoint(s3_client, bucket, key):
       """Get the last processed timestamp from S3 state file"""
       try:
           response = s3_client.get_object(Bucket=bucket, Key=key)
           state = json.loads(response['Body'].read().decode('utf-8'))
           return state.get('last_timestamp')
       except s3_client.exceptions.NoSuchKey:
           return None
       except Exception as e:
           print(f"Error reading checkpoint: {e}")
           return None
   
   def save_checkpoint(s3_client, bucket, key, timestamp):
       """Save the last processed timestamp to S3 state file"""
       try:
           state = {
               'last_timestamp': timestamp,
               'updated_at': datetime.now(timezone.utc).isoformat()
           }
           s3_client.put_object(
               Bucket=bucket,
               Key=key,
               Body=json.dumps(state),
               ContentType='application/json'
           )
       except Exception as e:
           print(f"Error saving checkpoint: {e}")
   

5. Accédez à Configuration > Variables d'environnement.

6. Cliquez sur Modifier > Ajouter une variable d'environnement.

7. Saisissez les variables d'environnement fournies dans le tableau suivant, en remplaçant les exemples de valeurs par les vôtres.

   Variables d'environnement

   Clé	Exemple de valeur
   S3_BUCKET	crowdstrike-filevantage-logs
   S3_PREFIX	filevantage/
   STATE_KEY	filevantage/state.json
   FALCON_CLIENT_ID	<your-client-id>
   FALCON_CLIENT_SECRET	<your-client-secret>
   FALCON_BASE_URL	https://api.crowdstrike.com (US-1) / https://api.us-2.crowdstrike.com (US-2) / https://api.eu-1.crowdstrike.com (EU-1)

8. Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Fonctions > votre-fonction).

9. Accédez à l'onglet Configuration.

10. Dans le panneau Configuration générale, cliquez sur Modifier.

11. Définissez le délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

    Remarque : Le délai d'expiration est une limite supérieure stricte. Cela signifie que si la fonction est toujours en cours d'exécution lorsque le minuteur atteint cinq minutes, AWS Lambda l'arrête. Toute exécution plus courte se termine normalement. Vous n'êtes facturé que pour la durée d'exécution réelle.

Créer une programmation EventBridge

1. Accédez à Amazon EventBridge> Scheduler> Create schedule.
2. Fournissez les informations de configuration suivantes :
   • Planning récurrent : Tarif (1 hour).
   • Cible : votre fonction Lambda crowdstrike-filevantage-logs.
   • Nom : crowdstrike-filevantage-logs-1h.
3. Cliquez sur Créer la programmation.

(Facultatif) Créez un utilisateur et des clés IAM en lecture seule pour Google SecOps

1. Accédez à Console AWS > IAM > Utilisateurs.
2. Cliquez sur Add users (Ajouter des utilisateurs).
3. Fournissez les informations de configuration suivantes :
   • Utilisateur : saisissez secops-reader.
   • Type d'accès : sélectionnez Clé d'accès – Accès programmatique.
4. Cliquez sur Créer un utilisateur.
5. Associez une stratégie de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des stratégies directement > Créer une stratégie.

6. JSON :

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["s3:GetObject"],
         "Resource": "arn:aws:s3:::crowdstrike-filevantage-logs/*"
       },
       {
         "Effect": "Allow",
         "Action": ["s3:ListBucket"],
         "Resource": "arn:aws:s3:::crowdstrike-filevantage-logs"
       }
     ]
   }
   

7. Nom = secops-reader-policy.

8. Cliquez sur Créer une règle> recherchez/sélectionnez > Suivant> Ajouter des autorisations.

9. Créez une clé d'accès pour secops-reader : Identifiants de sécurité > Clés d'accès.

10. Cliquez sur Créer une clé d'accès.

11. Téléchargez le fichier .CSV. (Vous collerez ces valeurs dans le flux.)

Configurer un flux dans Google SecOps pour ingérer les journaux CrowdStrike FileVantage

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur + Ajouter un flux.
3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, CrowdStrike FileVantage logs).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez CrowdStrike Filevantage comme Type de journal.
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : s3://crowdstrike-filevantage-logs/filevantage/
   • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
   • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
   • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
   • Espace de noms de l'élément : espace de noms de l'élément.
   • Libellés d'ingestion : libellé appliqué aux événements de ce flux.
8. Cliquez sur Suivant.
9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

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