Collecter les journaux CyberArk EPM

Ce document explique comment ingérer des journaux CyberArk EPM dans Google Security Operations à l'aide d'AWS S3. L'analyseur transforme les données de journaux CyberArk EPM en un modèle de données unifié (UDM). Il parcourt chaque événement du journal, mappe les champs pertinents à leurs champs UDM correspondants, gère les structures de données spécifiques telles que exposedUsers et enrichit la sortie avec des informations statiques sur le fournisseur et le produit.

Avant de commencer

• Assurez-vous de disposer d'une instance Google Security Operations.
• Assurez-vous de disposer d'un accès privilégié à AWS.
• Assurez-vous de disposer d'un accès privilégié à la console de gestion du serveur EPM.

Configurer AWS IAM pour l'ingestion Google SecOps

1. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
2. Sélectionnez l'utilisateur créé.
3. Sélectionnez l'onglet Informations d'identification de sécurité.
4. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
5. Sélectionnez Service tiers comme Cas d'utilisation.
6. Cliquez sur Suivant.
7. Facultatif : Ajoutez un tag de description.
8. Cliquez sur Créer une clé d'accès.
9. 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.
10. Cliquez sur OK.
11. Sélectionnez l'onglet Autorisations.
12. Cliquez sur Ajouter des autorisations dans la section Règles d'autorisation .
13. Sélectionnez Ajouter des autorisations.
14. Sélectionnez Joindre directement des règles.
15. Recherchez et sélectionnez la règle AmazonS3FullAccess.
16. Cliquez sur Suivant.
17. Cliquez sur Ajouter des autorisations.

Configurer CyberArk EPM pour l'accès à l'API

1. Connectez-vous à la console Web CyberArk EPM en tant qu'administrateur.
2. Accédez à Administration > Gestion du compte.
3. Cliquez sur + Ajouter un utilisateur.
4. Spécifiez les informations suivantes :
   • Nom d'utilisateur : epm_api_user
   • Mot de passe : secret sécurisé
   • Adresse e-mail/Nom complet : facultatif
5. Sous Autorisations, accordez l'autorisation ViewOnlySetAdmin à chaque ensemble de journaux extraits.
6. Cliquez sur Enregistrer.
7. Facultatif : Prolonger le délai avant expiration de la session :
   • Accédez à Administration > Configuration du compte.
   • Définissez Délai avant expiration pour une session inactive sur 60 minutes.
   • Cliquez sur Enregistrer.
8. Accédez à Règles et ensembles> sélectionnez votre ensemble > Propriétés.
9. Copiez et enregistrez l'ID de l'ensemble (un GUID). Vous l'utiliserez dans le script sous la forme EPM_SET_ID.

Créer un bucket AWS S3

1. Connectez-vous à l'AWS Management Console.
2. Accédez à la console AWS> Services > S3 > Créer un bucket.
3. Fournissez les informations de configuration suivantes :
   • Nom du bucket : my-cyberark-epm-logs
   • Région : votre choix > Créer

Créer un rôle IAM pour EC2

1. Connectez-vous à l'AWS Management Console.
2. Accédez à Services.
3. Dans la barre de recherche, saisissez IAM et sélectionnez-le.
4. Dans le tableau de bord IAM, cliquez sur Rôles.
5. Cliquez sur Créer un rôle.
6. Fournissez les informations de configuration suivantes :
   • Entité de confiance : Service AWS > EC2 > Suivant.
   • Associez l'autorisation AmazonS3FullAccess (ou une stratégie limitée à votre bucket) > Suivant.
   • Nom du rôle : EC2-S3-EPM-Writer > Créer un rôle.

Facultatif : Lancez et configurez votre VM de collecte EC2

1. Connectez-vous à l'AWS Management Console.
2. Accédez à Services.
3. Dans la barre de recherche, saisissez "EC2" et sélectionnez-le.
4. Dans le tableau de bord EC2, cliquez sur Instances.
5. Cliquez sur Lancer des instances.
6. Fournissez les informations de configuration suivantes :
   • Nom : saisissez EPM-Log-Collector.
   • AMI : sélectionnez Ubuntu Server 22.04 LTS.
   • Type d'instance : sélectionnez t3.micro (ou une taille supérieure), puis cliquez sur Suivant.
   • Réseau : assurez-vous que le paramètre "Réseau" est défini sur votre VPC par défaut.
   • Rôle IAM : sélectionnez le rôle IAM EC2-S3-EPM-Writer dans le menu.
   • Attribuer automatiquement une adresse IP publique : définissez cette option sur Activer. Si vous vous connectez via un VPN, vous pouvez laisser cette option désactivée.
   • Ajouter du stockage : conservez la configuration de stockage par défaut (8 Gio), puis cliquez sur Suivant.
   • Sélectionnez Créer un groupe de sécurité.
   • Règle entrante : cliquez sur Ajouter une règle.
   • Type : sélectionnez SSH.
   • Port : 22
   • Source : votre adresse IP
   • Cliquez sur Vérifier et lancer.
   • Sélectionnez ou créez une paire de clés.
   • Cliquez sur Download Key Pair (Télécharger la paire de clés).
   • Enregistrez le fichier PEM téléchargé. Vous aurez besoin de ce fichier pour vous connecter à votre instance via SSH.

7. Connectez-vous à votre machine virtuelle (VM) à l'aide de SSH :

   chmod 400 ~/Downloads/your-key.pem
   ssh -i ~/Downloads/your-key.pem ubuntu@<EC2_PUBLIC_IP>
   

Installer les prérequis du collecteur

1. Mettez à jour le système d'exploitation :

   # Update OS
   sudo apt update && sudo apt upgrade -y
   
   # Install Python, Git
   sudo apt install -y python3 python3-venv python3-pip git
   
   # Create & activate virtualenv
   python3 -m venv ~/epm-venv
   source ~/epm-venv/bin/activate
   
   # Install libraries
   pip install requests boto3
   

2. Créez le répertoire et le fichier d'état :

   sudo mkdir -p /var/lib/epm-collector
   sudo touch /var/lib/epm-collector/last_run.txt
   sudo chown ubuntu:ubuntu /var/lib/epm-collector/last_run.txt
   

3. Initialisez-le (par exemple, sur "il y a une heure") :

   echo "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)" > /var/lib/epm-collector/last_run.txt
   

Déployer le script du collecteur

1. Créez un dossier pour le projet :

   mkdir ~/epm-collector && cd ~/epm-collector
   

2. Définissez les variables d'environnement (par exemple, dans ~/.bashrc) :

   export EPM_URL="https://epm.mycompany.com"
   export EPM_USER="epm_api_user"
   export EPM_PASS="YourPasswordHere"
   export EPM_SET_ID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
   export S3_BUCKET="my-cyberark-epm-logs"
   export S3_PREFIX="epm/"
   

3. Créez collector.py et collez-y le code suivant :

   #!/usr/bin/env python3
   import os
   import sys
   import json
   import boto3
   import requests
   from datetime import datetime, timezone, timedelta
   
   # ── LOAD CONFIG FROM ENV ───────────────────────────────────────────────────────
   def must_env(var):
       v = os.getenv(var)
       if not v:
           print(f"ERROR: environment variable {var} is required", file=sys.stderr)
           sys.exit(1)
       return v
   
   EPM_URL    = must_env("EPM_URL")        # for example, https://epm.mycompany.com
   USERNAME   = must_env("EPM_USER")       # API username
   PASSWORD   = must_env("EPM_PASS")       # API password
   SET_ID     = must_env("EPM_SET_ID")     # GUID of the Set to pull
   S3_BUCKET  = must_env("S3_BUCKET")      # for example, my-cyberark-epm-logs
   S3_PREFIX  = os.getenv("S3_PREFIX", "") # optional, for example "epm/"
   STATE_FILE = os.getenv("STATE_FILE", "/var/lib/epm-collector/last_run.txt")
   PAGE_SIZE  = int(os.getenv("PAGE_SIZE", "100"))
   # ── END CONFIG ────────────────────────────────────────────────────────────────
   
   def read_last_run():
       try:
           ts = open(STATE_FILE).read().strip()
           return datetime.fromisoformat(ts.replace("Z","+00:00"))
       except:
           # default to 1 hour ago
           return datetime.now(timezone.utc) - timedelta(hours=1)
   
   def write_last_run(dt):
       with open(STATE_FILE, "w") as f:
           f.write(dt.strftime("%Y-%m-%dT%H:%M:%SZ"))
   
   def logon():
       r = requests.post(
           f"{EPM_URL}/REST/EPMService.svc/Logon",
           json={"username": USERNAME, "password": PASSWORD},
           headers={"Content-Type": "application/json"}
       )
       r.raise_for_status()
       return r.json().get("SessionToken")
   
   def logoff(token):
       requests.post(
           f"{EPM_URL}/REST/EPMService.svc/Logoff",
           headers={"Authorization": f"Bearer {token}"}
       )
   
   def fetch_raw_events(token, start, end):
       headers = {"Authorization": f"Bearer {token}"}
       page = 1
       while True:
           params = {
               "setId":     SET_ID,
               "startDate": start,
               "endDate":   end,
               "pageSize":  PAGE_SIZE,
               "pageNumber": page
           }
           resp = requests.get(
               f"{EPM_URL}/REST/EPMService.svc/GetRawEvents",
               headers=headers, params=params
           )
           resp.raise_for_status()
           events = resp.json().get("RawEvents", [])
           if not events:
               break
           yield from events
           page += 1
   
   def upload_to_s3(obj, key):
       boto3.client("s3").put_object(
           Bucket=S3_BUCKET,
           Key=key,
           Body=json.dumps(obj).encode("utf-8")
       )
   
   def main():
       # determine time window
       start_dt = read_last_run()
       end_dt   = datetime.now(timezone.utc)
       START = start_dt.strftime("%Y-%m-%dT%H:%M:%SZ")
       END   = end_dt.strftime("%Y-%m-%dT%H:%M:%SZ")
   
       token = logon()
       try:
           for idx, raw_evt in enumerate(fetch_raw_events(token, START, END), start=1):
               key = f"{S3_PREFIX}{end_dt.strftime('%Y/%m/%d')}/raw_{int(end_dt.timestamp())}_{idx}.json"
               upload_to_s3(raw_evt, key)
               print(f"Uploaded raw event to {key}")
       finally:
           logoff(token)
   
       # persist for next run
       write_last_run(end_dt)
   
   if __name__ == "__main__":
       main()
   

4. Rendez le script exécutable :

   chmod +x collector.py
   

Automatiser avec Cron

1. Ouvrez crontab :

   crontab -e
   

2. Ajoutez le job quotidien :

   0 0 * * * cd ~/epm-collector && source ~/epm-venv/bin/activate && python collector.py >> ~/epm-collector/epm.log 2>&1
   

Configurer un flux dans Google SecOps pour ingérer les journaux Cyberark EPM

1. Accédez à Paramètres SIEM> Flux.
2. Cliquez sur Ajouter.
3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Cyberark EPM Logs).
4. Sélectionnez Amazon S3 comme Type de source.
5. Sélectionnez Cyberark EPM comme Type de journal.
6. Cliquez sur Suivant.

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

   • Région : région dans laquelle se trouve le bucket Amazon S3.
   • URI S3 : URI du bucket (au format s3://your-log-bucket-name/). Remplacez les éléments suivants :
     • your-log-bucket-name : nom du bucket.
   • L'URI est : sélectionnez Répertoire ou Répertoire incluant des sous-répertoires.
   • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • 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é à appliquer 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.

Table de mappage UDM

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