Raccogliere i log del servizio di monitoraggio Citrix

Supportato in:

Google SecOps SIEM

Nota: questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini specifici del servizio Google Security Operations. Le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le linee guida per il servizio di assistenza tecnica di Google SecOps e i Termini di servizio specifici di Google SecOps.

Questo documento spiega come importare i log del servizio Citrix Monitor in Google Security Operations utilizzando Amazon S3. Il parser trasforma i log non elaborati in formato JSON in un formato strutturato conforme a UDM di Google SecOps. Estrae i campi pertinenti dal log non elaborato, li mappa ai campi UDM corrispondenti e arricchisce i dati con un contesto aggiuntivo, come informazioni sull'utente, dettagli del computer e attività di rete.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

• Istanza Google SecOps
• Accesso con privilegi al tenant Citrix Cloud
• Accesso con privilegi ad AWS (S3, IAM, Lambda, EventBridge)

Raccogliere i prerequisiti del servizio Citrix Monitor (ID, chiavi API, ID organizzazione, token)

1. Accedi alla console Citrix Cloud.
2. Vai a Identity and Access Management > Accesso API.
3. Fai clic su Crea cliente.
4. Copia e salva in una posizione sicura i seguenti dettagli:
   • ID client
   • Client secret
   • ID cliente (visibile nella console Citrix Cloud)
   • URL di base dell'API:
     • Globale: https://api.cloud.com
     • Giappone: https://api.citrixcloud.jp

Configura il bucket AWS S3 e IAM per Google SecOps

1. Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket
2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, citrix-monitor-logs).
3. Crea un utente seguendo questa guida: Creazione di un utente IAM.
4. Seleziona l'utente creato.
5. Seleziona la scheda Credenziali di sicurezza.
6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
7. Seleziona Servizio di terze parti come Caso d'uso.
8. Fai clic su Avanti.
9. (Facoltativo) Aggiungi un tag di descrizione.
10. Fai clic su Crea chiave di accesso.
11. Fai clic su Scarica file CSV per salvare la chiave di accesso e la chiave di accesso segreta per un utilizzo successivo.
12. Fai clic su Fine.
13. Seleziona la scheda Autorizzazioni.
14. Fai clic su Aggiungi autorizzazioni nella sezione Criteri per le autorizzazioni.
15. Seleziona Aggiungi autorizzazioni.
16. Seleziona Allega direttamente i criteri.
17. Cerca e seleziona il criterio AmazonS3FullAccess.
18. Fai clic su Avanti.
19. Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

1. Nella console AWS, vai a IAM > Policy > Crea policy > scheda JSON.

2. Inserisci la seguente policy:

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

   • Sostituisci citrix-monitor-logs se hai inserito un nome bucket diverso.

3. Fai clic su Avanti > Crea criterio.

4. Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.

5. Collega il criterio appena creato e il criterio gestito AWSLambdaBasicExecutionRole.

6. Assegna al ruolo il nome CitrixMonitorLambdaRole e fai clic su Crea ruolo.

Crea la funzione Lambda

1. Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
2. Fai clic su Crea autore da zero.

3. Fornisci i seguenti dettagli di configurazione:

   Impostazione	Valore
   Nome	CitrixMonitorCollector
   Tempo di esecuzione	Python 3.13
   Architettura	x86_64
   Ruolo di esecuzione	CitrixMonitorLambdaRole

4. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e inserisci il seguente codice (CitrixMonitorCollector.py):

   import os
   import json
   import uuid
   import datetime
   import urllib.parse
   import urllib.request
   import urllib.error
   import boto3
   import botocore
   
   # Citrix Cloud OAuth2 endpoint template
   TOKEN_URL_TMPL = "{api_base}/cctrustoauth2/{customerid}/tokens/clients"
   DEFAULT_API_BASE = "https://api.cloud.com"
   MONITOR_BASE_PATH = "/monitorodata"
   
   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=45) as resp:
           return json.loads(resp.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=90) as resp:
           return json.loads(resp.read().decode("utf-8"))
   
   def get_citrix_token(api_base, customer_id, client_id, client_secret):
       """Get Citrix Cloud authentication token."""
       url = TOKEN_URL_TMPL.format(api_base=api_base.rstrip("/"), customerid=customer_id)
       payload = {
           "grant_type": "client_credentials",
           "client_id": client_id,
           "client_secret": client_secret,
       }
       response = http_post_form(url, payload)
       return response["access_token"]
   
   def build_entity_url(api_base, entity, filter_query=None, top=None):
       """Build OData URL with optional filter and pagination."""
       base = api_base.rstrip("/") + MONITOR_BASE_PATH + "/" + entity
       params = []
       if filter_query:
           params.append("$filter=" + urllib.parse.quote(filter_query, safe="()= ':-TZ0123456789"))
       if top:
           params.append("$top=" + str(top))
       return base + ("?" + "&".join(params) if params else "")
   
   def fetch_entity_rows(entity, start_iso=None, end_iso=None, page_size=1000, headers=None, api_base=DEFAULT_API_BASE):
       """Fetch entity data with optional time filtering and pagination."""
       # Try ModifiedDate filter if timestamps are provided
       first_url = None
       if start_iso and end_iso:
           filter_query = f"(ModifiedDate ge {start_iso} and ModifiedDate lt {end_iso})"
           first_url = build_entity_url(api_base, entity, filter_query, page_size)
       else:
           first_url = build_entity_url(api_base, entity, None, page_size)
   
       url = first_url
       while url:
           try:
               data = http_get_json(url, headers)
               items = data.get("value", [])
               for item in items:
                   yield item
               url = data.get("@odata.nextLink")
           except urllib.error.HTTPError as e:
               # If ModifiedDate filtering fails, fall back to unfiltered query
               if e.code == 400 and start_iso and end_iso:
                   print(f"ModifiedDate filter not supported for {entity}, falling back to unfiltered query")
                   url = build_entity_url(api_base, entity, None, page_size)
                   continue
               else:
                   raise
   
   def read_state_file(bucket, key):
       """Read the last processed timestamp from S3 state file."""
       try:
           obj = s3.get_object(Bucket=bucket, Key=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, key, dt_utc):
       """Write the current processed timestamp to S3 state file."""
       state = {"last_hour_utc": dt_utc.isoformat() + "Z"}
       s3.put_object(
           Bucket=bucket, 
           Key=key, 
           Body=json.dumps(state, separators=(",", ":")), 
           ContentType="application/json"
       )
   
   def write_ndjson_to_s3(bucket, key, rows):
       """Write rows as NDJSON to S3."""
       body_lines = []
       for row in rows:
           json_line = json.dumps(row, 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", "citrix_monitor").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", "Machines,Sessions,Connections,Applications,Users").split(",") if e.strip()]
       page_size = int(os.environ.get("PAGE_SIZE", "1000"))
       lookback_minutes = int(os.environ.get("LOOKBACK_MINUTES", "75"))
       use_time_filter = os.environ.get("USE_TIME_FILTER", "true").lower() == "true"
   
       # Time window calculation
       now = datetime.datetime.utcnow()
       fallback_hour = (now - datetime.timedelta(minutes=lookback_minutes)).replace(minute=0, second=0, microsecond=0)
   
       last_processed = read_state_file(bucket, state_key)
       target_hour = (last_processed + datetime.timedelta(hours=1)) if last_processed else fallback_hour
       start_iso = target_hour.isoformat() + "Z"
       end_iso = (target_hour + datetime.timedelta(hours=1)).isoformat() + "Z"
   
       # Authentication
       token = get_citrix_token(api_base, customer_id, client_id, client_secret)
       headers = {
           "Authorization": f"CWSAuth bearer={token}",
           "Citrix-CustomerId": customer_id,
           "Accept": "application/json",
           "Accept-Encoding": "gzip, deflate, br",
           "User-Agent": "citrix-monitor-s3-collector/1.0"
       }
   
       total_records = 0
   
       # Process each entity type
       for entity in entities:
           rows_batch = []
           try:
               entity_generator = fetch_entity_rows(
                   entity=entity,
                   start_iso=start_iso if use_time_filter else None,
                   end_iso=end_iso if use_time_filter else None,
                   page_size=page_size,
                   headers=headers,
                   api_base=api_base
               )
   
               for row in entity_generator:
                   # Store raw Citrix data directly for proper parser recognition
                   rows_batch.append(row)
   
                   # Write in batches to avoid memory issues
                   if len(rows_batch) >= 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, rows_batch)
                       total_records += len(rows_batch)
                       rows_batch = []
   
           except Exception as ex:
               print(f"Error processing entity {entity}: {str(ex)}")
               continue
   
           # Write remaining records
           if rows_batch:
               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, rows_batch)
               total_records += len(rows_batch)
   
       # Update state file
       write_state_file(bucket, state_key, target_hour)
   
       return {
           "statusCode": 200,
           "body": json.dumps({
               "success": True, 
               "hour_collected": start_iso, 
               "records_written": total_records, 
               "entities_processed": entities
           })
       }
   

5. Vai a Configurazione > Variabili di ambiente.

6. Fai clic su Modifica > Aggiungi nuova variabile di ambiente.

7. Inserisci le seguenti variabili di ambiente, sostituendole con i tuoi valori:

   Chiave	Valore di esempio
   S3_BUCKET	citrix-monitor-logs
   S3_PREFIX	citrix_monitor
   STATE_KEY	citrix_monitor/state.json
   CITRIX_CLIENT_ID	your-client-id
   CITRIX_CLIENT_SECRET	your-client-secret
   CITRIX_CUSTOMER_ID	your-customer-id
   API_BASE	https://api.cloud.com
   ENTITIES	Machines,Sessions,Connections,Applications,Users
   PAGE_SIZE	1000
   LOOKBACK_MINUTES	75
   USE_TIME_FILTER	true

8. Dopo aver creato la funzione, rimani sulla relativa pagina (o apri Lambda > Funzioni > CitrixMonitorCollector).

9. Seleziona la scheda Configurazione.

10. Nel riquadro Configurazione generale, fai clic su Modifica.

11. Modifica Timeout impostando 5 minuti (300 secondi) e fai clic su Salva.

    Nota: il timeout è un limite superiore rigido, il che significa che se la funzione è ancora in esecuzione quando il timer raggiunge i 5 minuti, AWS Lambda la terminerà. Qualsiasi esecuzione più breve termina normalmente e ti viene addebitato solo il tempo di esecuzione effettivo.

Creare una pianificazione EventBridge

1. Vai a Amazon EventBridge > Scheduler > Crea pianificazione.
2. Fornisci i seguenti dettagli di configurazione:
   • Programma ricorrente: Tariffa (1 hour)
   • Target: la tua funzione Lambda CitrixMonitorCollector
   • Nome: CitrixMonitorCollector-1h
3. Fai clic su Crea pianificazione.

(Facoltativo) Crea chiavi e utenti IAM di sola lettura per Google SecOps

1. Nella console AWS, vai a IAM > Utenti > Aggiungi utenti.
2. Fai clic su Add users (Aggiungi utenti).
3. Fornisci i seguenti dettagli di configurazione:
   • Utente: secops-reader
   • Tipo di accesso: Chiave di accesso - Accesso programmatico
4. Fai clic su Crea utente.
5. Collega la criterio per la lettura minima (personalizzata): Utenti > secops-reader > Autorizzazioni > Aggiungi autorizzazioni > Collega le norme direttamente > Crea norma.

6. Nell'editor JSON, inserisci la seguente policy:

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

7. Imposta il nome su secops-reader-policy.

8. Vai a Crea criterio > cerca/seleziona > Avanti > Aggiungi autorizzazioni.

9. Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.

10. Scarica il file CSV (questi valori vengono inseriti nel feed).

Configura un feed in Google SecOps per importare i log del servizio Citrix Monitor

1. Vai a Impostazioni SIEM > Feed.
2. Fai clic su + Aggiungi nuovo feed.
3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Citrix Monitor Service logs).
4. Seleziona Amazon S3 V2 come Tipo di origine.
5. Seleziona Citrix Monitor come Tipo di log.
6. Fai clic su Avanti.
7. Specifica i valori per i seguenti parametri di input:
   • URI S3: s3://citrix-monitor-logs/citrix_monitor/
   • Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
   • Età massima del file: includi i file modificati nell'ultimo numero di giorni. Valore predefinito 180 giorni.
   • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3.
   • Chiave di accesso segreta: chiave segreta dell'utente con accesso al bucket S3.
   • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
   • Etichette di importazione: l'etichetta applicata agli eventi di questo feed.
8. Fai clic su Avanti.
9. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.