Collecter les journaux Citrix Analytics

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 Citrix Analytics dans Google Security Operations à l'aide d'Amazon S3.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Instance Google SecOps
• Accès privilégié au locataire Citrix Analytics for Performance
• Accès privilégié à AWS (S3, IAM, Lambda, EventBridge)

Collecter les conditions préalables de Citrix Analytics

1. Connectez-vous à la console Citrix Cloud.
2. Accédez à Identity and Access Management> Accès à l'API.
3. Cliquez sur Créer un client.
4. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
   • ID client
   • Code secret du client
   • ID client (situé dans l'URL Citrix Cloud ou sur la page IAM)
   • URL de base de l'API : https://api.cloud.com/casodata

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, citrix-analytics-logs).
3. Créez un utilisateur en suivant ce guide : 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 une utilisation ultérieure.
12. Cliquez sur OK.
13. Sélectionnez l'onglet Autorisations.
14. Cliquez sur Ajouter des autorisations dans la section Règles d'autorisation.
15. Sélectionnez Ajouter des autorisations.
16. Sélectionnez Joindre directement des règles.
17. Recherchez et sélectionnez la règle AmazonS3FullAccess.
18. Cliquez sur Suivant.
19. 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 > Créer une stratégie > Onglet JSON.

2. Saisissez la règle suivante :

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

   • Remplacez citrix-analytics-logs si vous avez saisi un autre nom de bucket.

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

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

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

6. Nommez le rôle CitrixAnalyticsLambdaRole, 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	CitrixAnalyticsCollector
   Durée d'exécution	Python 3.13
   Architecture	x86_64
   Rôle d'exécution	CitrixAnalyticsLambdaRole

4. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant (CitrixAnalyticsCollector.py) :

   import os
   import json
   import uuid
   import datetime
   import urllib.parse
   import urllib.request
   import boto3
   import botocore
   
   CITRIX_TOKEN_URL_TMPL = "https://api.cloud.com/cctrustoauth2/{customerid}/tokens/clients"
   DEFAULT_API_BASE = "https://api.cloud.com/casodata"
   
   s3 = boto3.client("s3")
   
   def _http_post_form(url, data_dict):
       """POST form data to get authentication token."""
       data = urllib.parse.urlencode(data_dict).encode("utf-8")
       req = urllib.request.Request(url, data=data, headers={
           "Accept": "application/json",
           "Content-Type": "application/x-www-form-urlencoded",
       })
       with urllib.request.urlopen(req, timeout=30) as response:
           return json.loads(response.read().decode("utf-8"))
   
   def _http_get_json(url, headers):
       """GET JSON data from API endpoint."""
       req = urllib.request.Request(url, headers=headers)
       with urllib.request.urlopen(req, timeout=60) as response:
           return json.loads(response.read().decode("utf-8"))
   
   def get_citrix_token(customer_id, client_id, client_secret):
       """Get Citrix Cloud authentication token."""
       url = CITRIX_TOKEN_URL_TMPL.format(customerid=customer_id)
       payload = {
           "grant_type": "client_credentials",
           "client_id": client_id,
           "client_secret": client_secret,
       }
       token_response = _http_post_form(url, payload)
       return token_response["access_token"]
   
   def fetch_odata_entity(entity, when_utc, top, headers, api_base):
       """Fetch data from Citrix Analytics OData API with pagination."""
       year = when_utc.year
       month = when_utc.month
       day = when_utc.day
       hour = when_utc.hour
   
       base_url = f"{api_base.rstrip('/')}/{entity}?year={year:04d}&month={month:02d}&day={day:02d}&hour={hour:02d}"
       skip = 0
   
       while True:
           url = f"{base_url}&$top={top}&$skip={skip}"
           data = _http_get_json(url, headers)
           items = data.get("value", [])
   
           if not items:
               break
   
           for item in items:
               yield item
   
           if len(items) < top:
               break
   
           skip += top
   
   def read_state_file(bucket, state_key):
       """Read the last processed timestamp from S3 state file."""
       try:
           obj = s3.get_object(Bucket=bucket, Key=state_key)
           content = obj["Body"].read().decode("utf-8")
           state = json.loads(content)
           timestamp_str = state.get("last_hour_utc")
           if timestamp_str:
               return datetime.datetime.fromisoformat(timestamp_str.replace("Z", "+00:00")).replace(tzinfo=None)
       except botocore.exceptions.ClientError as e:
           if e.response["Error"]["Code"] == "NoSuchKey":
               return None
           raise
       return None
   
   def write_state_file(bucket, state_key, dt_utc):
       """Write the current processed timestamp to S3 state file."""
       state_data = {"last_hour_utc": dt_utc.isoformat() + "Z"}
       s3.put_object(
           Bucket=bucket, 
           Key=state_key,
           Body=json.dumps(state_data, separators=(",", ":")),
           ContentType="application/json"
       )
   
   def write_ndjson_to_s3(bucket, key, records):
       """Write records as NDJSON to S3."""
       body_lines = []
       for record in records:
           json_line = json.dumps(record, separators=(",", ":"), ensure_ascii=False)
           body_lines.append(json_line)
   
       body = ("n".join(body_lines) + "n").encode("utf-8")
       s3.put_object(
           Bucket=bucket, 
           Key=key, 
           Body=body, 
           ContentType="application/x-ndjson"
       )
   
   def lambda_handler(event, context):
       """Main Lambda handler function."""
   
       # Environment variables
       bucket = os.environ["S3_BUCKET"]
       prefix = os.environ.get("S3_PREFIX", "").strip("/")
       state_key = os.environ.get("STATE_KEY") or f"{prefix}/state.json"
       customer_id = os.environ["CITRIX_CUSTOMER_ID"]
       client_id = os.environ["CITRIX_CLIENT_ID"]
       client_secret = os.environ["CITRIX_CLIENT_SECRET"]
       api_base = os.environ.get("API_BASE", DEFAULT_API_BASE)
       entities = [e.strip() for e in os.environ.get("ENTITIES", "sessions,machines,users").split(",") if e.strip()]
       top_n = int(os.environ.get("TOP_N", "1000"))
       lookback_minutes = int(os.environ.get("LOOKBACK_MINUTES", "75"))
   
       # Determine target hour to collect
       now = datetime.datetime.utcnow()
       fallback_target = (now - datetime.timedelta(minutes=lookback_minutes)).replace(minute=0, second=0, microsecond=0)
   
       last_processed = read_state_file(bucket, state_key)
       if last_processed:
           target_hour = last_processed + datetime.timedelta(hours=1)
       else:
           target_hour = fallback_target
   
       # Get authentication token
       token = get_citrix_token(customer_id, client_id, client_secret)
       headers = {
           "Authorization": f"CwsAuth bearer={token}",
           "Citrix-CustomerId": customer_id,
           "Accept": "application/json",
           "Content-Type": "application/json",
       }
   
       total_records = 0
   
       # Process each entity type
       for entity in entities:
           records = []
   
           for row in fetch_odata_entity(entity, target_hour, top_n, headers, api_base):
               enriched_record = {
                   "citrix_entity": entity,
                   "citrix_hour_utc": target_hour.isoformat() + "Z",
                   "collection_timestamp": datetime.datetime.utcnow().isoformat() + "Z",
                   "raw": row
               }
               records.append(enriched_record)
   
               # Write in batches to avoid memory issues
               if len(records) >= 1000:
                   s3_key = f"{prefix}/{entity}/year={target_hour.year:04d}/month={target_hour.month:02d}/day={target_hour.day:02d}/hour={target_hour.hour:02d}/part-{uuid.uuid4().hex}.ndjson"
                   write_ndjson_to_s3(bucket, s3_key, records)
                   total_records += len(records)
                   records = []
   
           # Write remaining records
           if records:
               s3_key = f"{prefix}/{entity}/year={target_hour.year:04d}/month={target_hour.month:02d}/day={target_hour.day:02d}/hour={target_hour.hour:02d}/part-{uuid.uuid4().hex}.ndjson"
               write_ndjson_to_s3(bucket, s3_key, records)
               total_records += len(records)
   
       # Update state file
       write_state_file(bucket, state_key, target_hour)
   
       return {
           "statusCode": 200,
           "body": json.dumps({
               "success": True,
               "hour_collected": target_hour.isoformat() + "Z",
               "records_written": total_records,
               "entities_processed": entities
           })
       }
   

5. Accédez à Configuration> Variables d'environnement> Modifier> Ajouter une variable d'environnement.

6. Saisissez les variables d'environnement suivantes en remplaçant les valeurs par les vôtres :

   Clé	Exemple de valeur
   S3_BUCKET	citrix-analytics-logs
   S3_PREFIX	citrix_analytics
   STATE_KEY	citrix_analytics/state.json
   CITRIX_CLIENT_ID	your-client-id
   CITRIX_CLIENT_SECRET	your-client-secret
   API_BASE	https://api.cloud.com/casodata
   CITRIX_CUSTOMER_ID	your-customer-id
   ENTITIES	sessions,machines,users
   TOP_N	1000
   LOOKBACK_MINUTES	75

7. Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Functions > CitrixAnalyticsCollector).

8. Accédez à l'onglet Configuration.

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

10. 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 :
   • Calendrier récurrent : Taux (1 hour)
   • Cible : votre fonction Lambda CitrixAnalyticsCollector
   • Nom : CitrixAnalyticsCollector-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. Dans la console AWS, accédez à IAM > Utilisateurs > Ajouter des utilisateurs.
2. Cliquez sur Add users (Ajouter des utilisateurs).
3. Fournissez les informations de configuration suivantes :
   • Utilisateur : secops-reader
   • Type d'accès : 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. Dans l'éditeur JSON, saisissez la stratégie suivante :

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

7. Définissez le nom sur secops-reader-policy.

8. Accédez à Créer une règle > recherchez/sélectionnez > Suivant > Ajouter des autorisations.

9. Accédez à Identifiants de sécurité > Clés d'accès > Créer une clé d'accès.

10. Téléchargez le CSV (ces valeurs sont saisies dans le flux).

Configurer un flux dans Google SecOps pour ingérer les journaux Citrix Analytics

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, Citrix Analytics Performance logs).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez Citrix Analytics comme Type de journal.
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : s3://citrix-analytics-logs/citrix_analytics/
   • 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. 180 jours par défaut.
   • 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.