Collecter les données de renseignements sur les menaces Team Cymru Scout

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 données Team Cymru Scout Threat Intelligence 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é au locataire Team Cymru Scout
• Accès privilégié à AWS (S3, IAM, Lambda, EventBridge)

Obtenir les prérequis de Team Cymru Scout

1. Connectez-vous à la plate-forme Team Cymru Scout.
2. Accédez à la page Web Clés API.
3. Cliquez sur le bouton Créer.
4. Si nécessaire, saisissez la description de la clé.
5. Cliquez sur le bouton Créer une clé pour générer la clé API.
6. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
   • SCOUT_API_KEY : clé d'accès à l'API
   • SCOUT_BASE_URL : URL de base de l'API Scout

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, team-cymru-scout-ti).
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. Saisissez la règle suivante :

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

   • Remplacez team-cymru-scout-ti si vous avez saisi un autre nom de bucket.

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

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

6. Associez la règle nouvellement créée.

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

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

   ```python
   #!/usr/bin/env python3
   # Lambda: Pull Team Cymru Scout Threat Intelligence exports to S3 (no transform)
   
   import os, json, time
   from urllib.request import Request, urlopen
   from urllib.error import HTTPError, URLError
   import boto3
   
   S3_BUCKET    = os.environ["S3_BUCKET"]
   S3_PREFIX    = os.environ.get("S3_PREFIX", "team-cymru/scout-ti/")
   STATE_KEY    = os.environ.get("STATE_KEY", "team-cymru/scout-ti/state.json")
   WINDOW_SEC   = int(os.environ.get("WINDOW_SECONDS", "3600"))
   HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
   HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
   MODE         = os.environ.get("MODE", "GET").upper()
   API_HEADERS  = json.loads(os.environ.get("API_HEADERS", "{}"))
   MAX_PAGES    = int(os.environ.get("MAX_PAGES", "10"))
   
   # GET mode
   DOWNLOAD_URL_TEMPLATE = os.environ.get("DOWNLOAD_URL_TEMPLATE", "")
   # POST_JSON mode
   API_URL            = os.environ.get("API_URL", "")
   JSON_BODY_TEMPLATE = os.environ.get("JSON_BODY_TEMPLATE", "")
   
   # Team Cymru Scout specific
   SCOUT_BASE_URL = os.environ.get("SCOUT_BASE_URL", "https://api.scout.cymru.com")
   SCOUT_API_KEY  = os.environ.get("SCOUT_API_KEY", "")
   
   s3 = boto3.client("s3")
   
   def _iso(ts: float) -> str:
       return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))
   
   def _get_state() -> dict:
       try:
           obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
           b = obj["Body"].read()
           return json.loads(b) if b else {}
       except Exception:
           return {}
   
   def _put_state(st: dict):
       s3.put_object(
           Bucket=S3_BUCKET, Key=STATE_KEY,
           Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
   
   def _http(url: str, method: str = "GET", body: bytes | None = None) -> tuple[bytes, str]:
       attempt = 0
       while True:
           try:
               req = Request(url, method=method)
               # Add headers
               headers = API_HEADERS.copy()
               if SCOUT_API_KEY and "Authorization" not in headers:
                   headers["Authorization"] = f"Bearer {SCOUT_API_KEY}"
               headers.setdefault("Accept", "application/json")
   
               for k, v in headers.items():
                   req.add_header(k, v)
   
               if body is not None:
                   req.add_header("Content-Type", "application/json")
   
               with urlopen(req, data=body, timeout=HTTP_TIMEOUT) as r:
                   return r.read(), r.headers.get("Content-Type", "application/json")
           except HTTPError as e:
               if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                   delay = 1 + attempt
                   try:
                       delay = int(e.headers.get("Retry-After", delay))
                   except Exception:
                       pass
                   time.sleep(max(1, delay))
                   attempt += 1
                   continue
               raise
           except URLError:
               if attempt < HTTP_RETRIES:
                   time.sleep(1 + attempt)
                   attempt += 1
                   continue
               raise
   
   def _write(blob: bytes, ctype: str, from_ts: float, to_ts: float, page: int) -> str:
       date_path = time.strftime("%Y/%m/%d", time.gmtime(to_ts))
       key = f"{S3_PREFIX}/{date_path}/scout_ti_{int(from_ts)}_{int(to_ts)}_p{page:03d}.json"
       s3.put_object(Bucket=S3_BUCKET, Key=key, Body=blob, ContentType=ctype or "application/json")
       return key
   
   def _next_cursor(obj: dict) -> str | None:
       if not isinstance(obj, dict):
           return None
   
       for container in (obj, obj.get("meta", {}) or {}, obj.get("metadata", {}) or {}):
           for k in ("next", "next_cursor", "nextCursor", "nextPageToken", "continuation", "cursor", "pagedResultsCookie"):
               v = container.get(k)
               if v:
                   return str(v)
       return None
   
   def _loop(from_ts: float, to_ts: float) -> dict:
       cursor, page, written = None, 0, 0
   
       while page < MAX_PAGES:
           if MODE == "GET":
               if DOWNLOAD_URL_TEMPLATE:
                   url = (DOWNLOAD_URL_TEMPLATE
                       .replace("{FROM}", _iso(from_ts))
                       .replace("{TO}", _iso(to_ts))
                       .replace("{CURSOR}", cursor or ""))
               else:
                   # Default Scout API endpoint (adjust based on actual API)
                   url = f"{SCOUT_BASE_URL}/v1/threat-intelligence?start={_iso(from_ts)}&end={_iso(to_ts)}"
                   if cursor:
                       url += f"&cursor={cursor}"
               blob, ctype = _http(url, method="GET")
           else:
               assert API_URL and JSON_BODY_TEMPLATE, "API_URL and JSON_BODY_TEMPLATE required for MODE=POST_JSON"
               body = (JSON_BODY_TEMPLATE
                       .replace("{FROM}", _iso(from_ts))
                       .replace("{TO}", _iso(to_ts))
                       .replace("{CURSOR}", cursor or "")).encode("utf-8")
               blob, ctype = _http(API_URL, method="POST", body=body)
   
           # Normalize to JSON bytes for storage
           try:
               parsed = json.loads(blob.decode("utf-8"))
               normalized = json.dumps(parsed, separators=(",", ":")).encode("utf-8")
               ctype_out = "application/json"
           except Exception:
               normalized = blob
               ctype_out = ctype or "application/octet-stream"
   
           _ = _write(normalized, ctype_out, from_ts, to_ts, page)
           written += 1
           page += 1
   
           # Follow cursor if JSON and cursor exists
           try:
               if parsed and isinstance(parsed, dict):
                   cursor = _next_cursor(parsed)
               if not cursor:
                   break
           except Exception:
               break
   
       return {"pages": page, "objects": written}
   
   def lambda_handler(event=None, context=None):
       st = _get_state()
       now = time.time()
       from_ts = st.get("last_to_ts") or (now - WINDOW_SEC)
       to_ts = now
       res = _loop(from_ts, to_ts)
       st["last_to_ts"] = to_ts
       _put_state(st)
       return {"ok": True, "window": {"from": _iso(from_ts), "to": _iso(to_ts)}, **res}
   
   if __name__ == "__main__":
       print(lambda_handler())
   ```
   

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

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

7. Saisissez les variables d'environnement fournies, en remplaçant par vos valeurs.

   Clé	Exemple de valeur
   S3_BUCKET	team-cymru-scout-ti
   S3_PREFIX	team-cymru/scout-ti/
   STATE_KEY	team-cymru/scout-ti/state.json
   SCOUT_BASE_URL	https://api.scout.cymru.com
   SCOUT_API_KEY	your-scout-api-key
   WINDOW_SECONDS	3600
   HTTP_TIMEOUT	60
   HTTP_RETRIES	3
   MODE	GET ou POST_JSON
   API_HEADERS	{"Authorization":"Bearer <token>","Accept":"application/json"}
   DOWNLOAD_URL_TEMPLATE	(Mode GET) Modèle d'URL personnalisé avec {FROM}, {TO}, {CURSOR}
   API_URL	URL du point de terminaison de l'API (mode POST_JSON)
   JSON_BODY_TEMPLATE	(Mode POST_JSON) Corps JSON avec {FROM}, {TO}, {CURSOR}
   MAX_PAGES	10

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 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 :
   • Planification récurrente : Tarif (1 hour).
   • Cible : votre fonction Lambda team_cymru_scout_ti_to_s3.
   • Nom : team-cymru-scout-ti-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 à la console AWS> IAM> Utilisateurs> Ajouter des 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. Dans l'éditeur JSON, saisissez la stratégie suivante :

   {
   "Version": "2012-10-17",
   "Statement": [
       {
       "Effect": "Allow",
       "Action": ["s3:GetObject"],
       "Resource": "arn:aws:s3:::team-cymru-scout-ti/*"
       },
       {
       "Effect": "Allow",
       "Action": ["s3:ListBucket"],
       "Resource": "arn:aws:s3:::team-cymru-scout-ti"
       }
   ]
   }
   

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 informations sur les menaces Team Cymru Scout

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, Team Cymru Scout Threat Intelligence).
4. Sélectionnez Amazon S3 V2 comme type de source.
5. Sélectionnez Team Cymru Scout Threat Intelligence comme Type de journal.
6. Cliquez sur Suivant.
7. Spécifiez les valeurs des paramètres d'entrée suivants :
   • URI S3 : s3://team-cymru-scout-ti/team-cymru/scout-ti/
   • 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.

Formats de journaux Team Cymru Scout Threat Intelligence acceptés

L'analyseur Team Cymru Scout Threat Intelligence est compatible avec les journaux aux formats KV (LEEF) et CSV.

Exemples de journaux Team Cymru Scout Threat Intelligence acceptés

• JSON

  {
    "account_name": "dummy_secops_user",
    "account_type": "basic_auth",
    "used_queries": 1414,
    "remaining_queries": 48586,
    "used_queries_percentage": 2.828,
    "query_limit": 50000,
    "used_foundation_queries": 4224,
    "remaining_foundation_queries": 5776,
    "foundation_query_limit": 10000,
    "used_foundation_queries_percentage": 42.24,
    "event_type": "account_usage"
  }
  

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