Collecter les journaux FortiCNAPP (anciennement Lacework)
Ce document explique comment ingérer des journaux FortiCNAPP (anciennement Lacework) dans Google Security Operations à l'aide de Cloud Storage V2.
FortiCNAPP est une plate-forme de protection des applications cloud natives (CNAPP) qui fournit une gestion de la stratégie de sécurité cloud, une protection des charges de travail et une détection des menaces dans les environnements multicloud. Il génère des alertes, des résultats de conformité et des journaux d'audit qui peuvent être collectés via l'API REST Lacework.
Avant de commencer
Assurez-vous de remplir les conditions préalables suivantes :
- Une instance Google SecOps
- Un projet Google Cloud avec l'API Cloud Storage activée
- Autorisations de créer et de gérer des buckets Cloud Storage
- Autorisations de gérer les stratégies IAM (Identity and Access Management) sur les buckets Cloud Storage
- Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
- Accès privilégié à la console FortiCNAPP (anciennement Lacework) avec des autorisations d'administrateur
- Un compte Lacework avec accès par clé API activé
Créer un bucket Cloud Storage
- Accédez à la consoleGoogle Cloud .
- Sélectionnez votre projet ou créez-en un.
- Dans le menu de navigation, accédez à Cloud Storage > Buckets.
Cliquez sur Créer un bucket.
Fournissez les informations de configuration suivantes :
Paramètre Valeur Attribuez un nom au bucket Saisissez un nom unique (par exemple, lacework-logs).Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale). Emplacement Sélectionnez l'emplacement (par exemple, us-central1).Classe de stockage Standard (recommandé pour les journaux fréquemment consultés) Access control (Contrôle des accès) Uniforme (recommandé) Outils de protection Facultatif : Activez la gestion des versions d'objets ou la règle de conservation Cliquez sur Créer.
Collecter les identifiants de l'API FortiCNAPP (anciennement Lacework)
Générer une clé API
- Connectez-vous à votre console Lacework.
- Accédez à Settings > Configuration > API Keys (Paramètres > Configuration > Clés API).
- Cliquez sur + Ajouter.
- Saisissez un nom pour la clé API (par exemple,
Google SecOps Integration). - Si vous le souhaitez, saisissez une description.
Cliquez sur Enregistrer.
Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
- ID de clé : ID de la clé API générée
- Secret : code secret de l'API généré (affiché une seule fois)
Notez l'URL de votre compte Lacework dans la barre d'adresse du navigateur.
- Format :
https://<ACCOUNT>.lacework.net - Exemple : Si l'URL de votre console Lacework est
https://acme.lacework.net, le nom de votre compte estacme.
- Format :
Vérifier les autorisations
Pour vérifier que le compte dispose des autorisations requises :
- Connectez-vous à la console Lacework.
- Accédez à Settings > Configuration > API Keys (Paramètres > Configuration > Clés API).
- Si vous pouvez voir la page "Clés API" et créer des clés, vous disposez des autorisations requises.
- Si vous ne voyez pas cette option, contactez votre administrateur pour qu'il vous accorde un accès de niveau administrateur.
Tester l'accès à l'API
Testez vos identifiants avant de procéder à l'intégration :
# Replace with your actual credentials LW_ACCOUNT="your-account-name" LW_KEY_ID="your-api-key-id" LW_SECRET="your-api-secret" # Get a temporary access token TOKEN=$(curl -s -X POST "https://${LW_ACCOUNT}.lacework.net/api/v2/access/tokens" \ -H "X-LW-UAKS: ${LW_SECRET}" \ -H "Content-Type: application/json" \ -d "{\"keyId\": \"${LW_KEY_ID}\", \"expiryTime\": 3600}" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))") # Test API access - list alerts curl -v -H "Authorization: Bearer ${TOKEN}" \ "https://${LW_ACCOUNT}.lacework.net/api/v2/Alerts?startTime=$(date -u -v-1d +%Y-%m-%dT%H:%M:%SZ)&endTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)"
Créer un compte de service pour la fonction Cloud Run
La fonction Cloud Run a besoin d'un compte de service autorisé à écrire dans le bucket Cloud Storage et à être appelée par Pub/Sub.
Créer un compte de service
- Dans la console Google Cloud , accédez à IAM et administration > Comptes de service.
Cliquez sur Créer un compte de service.
Fournissez les informations de configuration suivantes :
- Nom du compte de service : saisissez
lacework-logs-collector-sa. - Description du compte de service : saisissez
Service account for Cloud Run function to collect FortiCNAPP (formerly Lacework) logs.
- Nom du compte de service : saisissez
Cliquez sur Créer et continuer.
Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
- Cliquez sur Sélectionner un rôle.
- Recherchez et sélectionnez Administrateur des objets Storage.
- Cliquez sur + Ajouter un autre rôle.
- Recherchez et sélectionnez Demandeur Cloud Run.
- Cliquez sur + Ajouter un autre rôle.
- Recherchez et sélectionnez Demandeur Cloud Functions.
Cliquez sur Continuer.
Cliquez sur OK.
Ces rôles sont requis pour :
- Administrateur des objets de l'espace de stockage : écrire des journaux dans le bucket Cloud Storage et gérer les fichiers d'état
- Demandeur Cloud Run : autorisez Pub/Sub à appeler la fonction.
- Demandeur Cloud Functions : autorise l'appel de fonctions.
Accorder des autorisations IAM sur le bucket Cloud Storage
Accordez au compte de service des autorisations d'écriture sur le bucket Cloud Storage :
- Accédez à Cloud Storage > Buckets.
- Cliquez sur le nom de votre bucket (par exemple,
lacework-logs). - Accédez à l'onglet Autorisations.
Cliquez sur Accorder l'accès.
Fournissez les informations de configuration suivantes :
- Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple,
lacework-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com). - Attribuer des rôles : sélectionnez Administrateur des objets Storage.
- Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple,
Cliquez sur Enregistrer.
Créer un sujet Pub/Sub
Créez un sujet Pub/Sub dans lequel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.
- Dans la console Google Cloud , accédez à Pub/Sub > Sujets.
Cliquez sur Créer un sujet.
Fournissez les informations de configuration suivantes :
- ID du sujet : saisissez
lacework-logs-trigger. - Conservez les valeurs par défaut des autres paramètres.
- ID du sujet : saisissez
Cliquez sur Créer.
Créer une fonction Cloud Run pour collecter les journaux
La fonction Cloud Run sera déclenchée par les messages Pub/Sub de Cloud Scheduler pour récupérer les journaux de l'API FortiCNAPP (anciennement Lacework) et les écrire dans Cloud Storage.
- Dans la console Google Cloud , accédez à Cloud Run.
- Cliquez sur Créer un service.
Sélectionnez Fonction (utilisez un éditeur de modification directe pour créer une fonction).
Dans la section Configurer, fournissez les informations de configuration suivantes :
Paramètre Valeur Nom du service lacework-logs-collectorRégion Sélectionnez la région correspondant à votre bucket Cloud Storage (par exemple, us-central1).Durée d'exécution Sélectionnez Python 3.12 ou une version ultérieure. Dans la section Déclencheur (facultatif) :
- Cliquez sur + Ajouter un déclencheur.
- Sélectionnez Cloud Pub/Sub.
- Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet
lacework-logs-trigger. - Cliquez sur Enregistrer.
Dans la section Authentification :
- Sélectionnez Exiger l'authentification.
- Vérifiez Identity and Access Management (IAM).
Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.
Accédez à l'onglet Sécurité :
- Compte de service : sélectionnez le compte de service
lacework-logs-collector-sa.
- Compte de service : sélectionnez le compte de service
Accédez à l'onglet Conteneurs :
- Cliquez sur Variables et secrets.
- Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
Nom de la variable Exemple de valeur Description GCS_BUCKETlacework-logsNom du bucket Cloud Storage GCS_PREFIXlaceworkPréfixe des fichiers journaux STATE_KEYlacework/state.jsonChemin d'accès au fichier d'état LW_ACCOUNTacmeNom du compte Lacework LW_KEY_IDyour-api-key-idID de clé API Lacework LW_SECRETyour-api-secretCode secret de l'API Lacework MAX_RECORDS5000Nombre maximal d'enregistrements par exécution PAGE_SIZE500Enregistrements par page LOOKBACK_HOURS24Période d'analyse initiale Dans la section Variables et secrets, faites défiler la page jusqu'à Requêtes :
- Délai avant expiration de la requête : saisissez
600secondes (10 minutes).
- Délai avant expiration de la requête : saisissez
Accédez à l'onglet Paramètres :
- Dans la section Ressources :
- Mémoire : sélectionnez 512 Mio ou plus.
- Processeur : sélectionnez 1.
- Dans la section Ressources :
Dans la section Scaling de révision :
- Nombre minimal d'instances : saisissez
0. - Nombre maximal d'instances : saisissez
100(ou ajustez en fonction de la charge attendue).
- Nombre minimal d'instances : saisissez
Cliquez sur Créer.
Attendez que le service soit créé (une à deux minutes).
Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.
Ajouter un code de fonction
- Saisissez main dans le champ Point d'entrée.
Dans l'éditeur de code intégré, créez deux fichiers :
main.py:
import functions_framework from google.cloud import storage import json import os import urllib3 from datetime import datetime, timezone, timedelta import time # Initialize HTTP client with timeouts http = urllib3.PoolManager( timeout=urllib3.Timeout(connect=5.0, read=30.0), retries=False, ) # Initialize Storage client storage_client = storage.Client() # Environment variables GCS_BUCKET = os.environ.get('GCS_BUCKET') GCS_PREFIX = os.environ.get('GCS_PREFIX', 'lacework') STATE_KEY = os.environ.get('STATE_KEY', 'lacework/state.json') LW_ACCOUNT = os.environ.get('LW_ACCOUNT') LW_KEY_ID = os.environ.get('LW_KEY_ID') LW_SECRET = os.environ.get('LW_SECRET') MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000')) PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '500')) LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24')) # Lacework API base URL API_BASE_TEMPLATE = 'https://{account}.lacework.net/api/v2' # Log endpoints to fetch ENDPOINTS = [ {'name': 'alerts', 'path': '/Alerts', 'time_field': 'startTime', 'results_key': 'data'}, {'name': 'audit_logs', 'path': '/AuditLogs', 'time_field': 'createdTime', 'results_key': 'data'}, ] def get_access_token(api_base: str, key_id: str, secret: str) -> str: """Get a temporary access token from Lacework API.""" token_url = f"{api_base}/access/tokens" body = json.dumps({ 'keyId': key_id, 'expiryTime': 3600 }).encode('utf-8') headers = { 'X-LW-UAKS': secret, 'Content-Type': 'application/json', } response = http.request('POST', token_url, body=body, headers=headers) if response.status != 201: raise Exception(f"Failed to get access token: HTTP {response.status} - {response.data.decode('utf-8')}") token_data = json.loads(response.data.decode('utf-8')) return token_data['token'] @functions_framework.cloud_event def main(cloud_event): """ Cloud Run function triggered by Pub/Sub to fetch FortiCNAPP (formerly Lacework) logs and write to GCS. Args: cloud_event: CloudEvent object containing Pub/Sub message """ if not all([GCS_BUCKET, LW_ACCOUNT, LW_KEY_ID, LW_SECRET]): print('Error: Missing required environment variables') return try: bucket = storage_client.bucket(GCS_BUCKET) api_base = API_BASE_TEMPLATE.format(account=LW_ACCOUNT) # Get access token token = get_access_token(api_base, LW_KEY_ID, LW_SECRET) print("Successfully obtained access token") # Load state state = load_state(bucket, STATE_KEY) # Determine time window now = datetime.now(timezone.utc) all_records = [] for endpoint in ENDPOINTS: ep_name = endpoint['name'] last_time_str = None if isinstance(state, dict) and state.get(f"last_{ep_name}_time"): try: last_time = parse_datetime(state[f"last_{ep_name}_time"]) # Overlap by 2 minutes to catch any delayed events last_time = last_time - timedelta(minutes=2) last_time_str = last_time.strftime('%Y-%m-%dT%H:%M:%SZ') except Exception as e: print(f"Warning: Could not parse last_{ep_name}_time: {e}") if last_time_str is None: last_time = now - timedelta(hours=LOOKBACK_HOURS) last_time_str = last_time.strftime('%Y-%m-%dT%H:%M:%SZ') end_time_str = now.strftime('%Y-%m-%dT%H:%M:%SZ') print(f"Fetching {ep_name} from {last_time_str} to {end_time_str}") records, newest_event_time = fetch_logs( api_base=api_base, token=token, endpoint=endpoint, start_time=last_time_str, end_time=end_time_str, page_size=PAGE_SIZE, max_records=MAX_RECORDS, ) # Tag records with endpoint type for record in records: record['_lw_log_type'] = ep_name all_records.extend(records) # Update state for this endpoint if newest_event_time: state[f"last_{ep_name}_time"] = newest_event_time else: state[f"last_{ep_name}_time"] = end_time_str print(f"Fetched {len(records)} {ep_name} records") if not all_records: print("No new log records found.") save_state(bucket, STATE_KEY, state) return # Write to GCS as NDJSON timestamp = now.strftime('%Y%m%d_%H%M%S') object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson" blob = bucket.blob(object_key) ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in all_records]) + '\n' blob.upload_from_string(ndjson, content_type='application/x-ndjson') print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}") # Save state save_state(bucket, STATE_KEY, state) print(f"Successfully processed {len(all_records)} records") except Exception as e: print(f'Error processing logs: {str(e)}') raise def parse_datetime(value: str) -> datetime: """Parse ISO datetime string to datetime object.""" if value.endswith("Z"): value = value[:-1] + "+00:00" return datetime.fromisoformat(value) def load_state(bucket, key): """Load state from GCS.""" try: blob = bucket.blob(key) if blob.exists(): state_data = blob.download_as_text() return json.loads(state_data) except Exception as e: print(f"Warning: Could not load state: {e}") return {} def save_state(bucket, key, state: dict): """Save the state to GCS state file.""" try: blob = bucket.blob(key) blob.upload_from_string( json.dumps(state, indent=2), content_type='application/json' ) print(f"Saved state: {json.dumps(state)}") except Exception as e: print(f"Warning: Could not save state: {e}") def fetch_logs(api_base: str, token: str, endpoint: dict, start_time: str, end_time: str, page_size: int, max_records: int): """ Fetch logs from Lacework API with pagination and rate limiting. Args: api_base: API base URL token: Bearer access token endpoint: Endpoint configuration dict start_time: Start time in ISO format end_time: End time in ISO format page_size: Number of records per page max_records: Maximum total records to fetch Returns: Tuple of (records list, newest_event_time ISO string) """ headers = { 'Authorization': f'Bearer {token}', 'Accept': 'application/json', 'Content-Type': 'application/json', 'User-Agent': 'GoogleSecOps-LaceworkCollector/1.0' } ep_path = endpoint['path'] time_field = endpoint['time_field'] results_key = endpoint['results_key'] records = [] newest_time = None page_num = 0 backoff = 1.0 next_page = None while True: page_num += 1 if len(records) >= max_records: print(f"Reached max_records limit ({max_records}) for {endpoint['name']}") break # Build request URL if next_page: url = next_page else: url = f"{api_base}{ep_path}?startTime={start_time}&endTime={end_time}" try: response = http.request('GET', url, headers=headers) # Handle rate limiting with exponential backoff if response.status == 429: retry_after = int(response.headers.get('Retry-After', str(int(backoff)))) print(f"Rate limited (429). Retrying after {retry_after}s...") time.sleep(retry_after) backoff = min(backoff * 2, 30.0) continue backoff = 1.0 if response.status != 200: print(f"HTTP Error: {response.status}") response_text = response.data.decode('utf-8') print(f"Response body: {response_text}") return [], None data = json.loads(response.data.decode('utf-8')) page_results = data.get(results_key, []) if not page_results: print(f"No more results (empty page) for {endpoint['name']}") break print(f"Page {page_num}: Retrieved {len(page_results)} {endpoint['name']} events") records.extend(page_results) # Track newest event time for event in page_results: try: event_time = event.get(time_field) if event_time: if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time): newest_time = event_time except Exception as e: print(f"Warning: Could not parse event time: {e}") # Check for next page via paging object paging = data.get('paging', {}) next_page_url = paging.get('urls', {}).get('nextPage') if not next_page_url: print(f"No more pages for {endpoint['name']}") break next_page = next_page_url except Exception as e: print(f"Error fetching {endpoint['name']} logs: {e}") return [], None print(f"Retrieved {len(records)} total {endpoint['name']} records from {page_num} pages") return records, newest_timerequirements.txt:
functions-framework==3.* google-cloud-storage==2.* urllib3>=2.0.0
Cliquez sur Déployer pour enregistrer et déployer la fonction.
Attendez la fin du déploiement (deux à trois minutes).
Créer une tâche Cloud Scheduler
Cloud Scheduler publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera la fonction Cloud Run.
- Dans la console Google Cloud , accédez à Cloud Scheduler.
Cliquez sur Créer une tâche.
Fournissez les informations de configuration suivantes :
Paramètre Valeur Nom lacework-logs-collector-hourlyRégion Sélectionnez la même région que la fonction Cloud Run. Fréquence 0 * * * *(toutes les heures, à l'heure pile)Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé) Type de cible Pub/Sub Sujet Sélectionnez le sujet lacework-logs-trigger.Corps du message {}(objet JSON vide)Cliquez sur Créer.
Options de fréquence de programmation
Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :
| Fréquence | Expression Cron | Cas d'utilisation |
|---|---|---|
| Toutes les 5 minutes | */5 * * * * |
Volume élevé, faible latence |
| Toutes les 15 minutes | */15 * * * * |
Volume moyen |
| Toutes les heures | 0 * * * * |
Standard (recommandé) |
| Toutes les 6 heures | 0 */6 * * * |
Traitement par lot de faible volume |
| Tous les jours | 0 0 * * * |
Collecte des données historiques |
Tester l'intégration
- Dans la console Cloud Scheduler, recherchez votre job.
- Cliquez sur Forcer l'exécution pour déclencher le job manuellement.
- Patientez pendant quelques secondes.
- Accédez à Cloud Run > Services.
- Cliquez sur
lacework-logs-collector. - Cliquez sur l'onglet Journaux.
Vérifiez que la fonction a bien été exécutée. Par exemple :
Successfully obtained access token Fetching alerts from YYYY-MM-DDTHH:MM:SSZ to YYYY-MM-DDTHH:MM:SSZ Page 1: Retrieved X alerts events Fetched X alerts records Fetching audit_logs from YYYY-MM-DDTHH:MM:SSZ to YYYY-MM-DDTHH:MM:SSZ Page 1: Retrieved X audit_logs events Fetched X audit_logs records Wrote X records to gs://lacework-logs/lacework/logs_YYYYMMDD_HHMMSS.ndjson Successfully processed X recordsAccédez à Cloud Storage > Buckets.
Cliquez sur le nom de votre bucket (
lacework-logs).Accédez au dossier
lacework/.Vérifiez qu'un nouveau fichier
.ndjsona été créé avec le code temporel actuel.
Si des erreurs s'affichent dans les journaux :
- HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement ou le jeton peut avoir expiré.
- HTTP 403 : vérifiez que la clé API dispose des autorisations requises dans la console Lacework.
- HTTP 429 : limitation du débit. La fonction effectue automatiquement une nouvelle tentative avec intervalle exponentiel entre les tentatives.
- Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.
Configurer un flux dans Google SecOps pour ingérer les journaux FortiCNAPP (anciennement Lacework)
- Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
- Cliquez sur Ajouter un flux d'actualités.
- Cliquez sur Configurer un flux unique.
- Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple,
Lacework Logs). - Sélectionnez Google Cloud Storage V2 comme Type de source.
- Sélectionnez Lacework Cloud Security comme type de journal.
Cliquez sur Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique s'affiche, par exemple :
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.comCopiez cette adresse e-mail.
Cliquez sur Suivant.
Spécifiez les valeurs des paramètres d'entrée suivants :
URL du bucket de stockage : saisissez l'URI du bucket Cloud Storage avec le chemin d'accès du préfixe :
gs://lacework-logs/lacework/- Remplacez :
lacework-logs: nom de votre bucket Cloud Storage.lacework: préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).
- Remplacez :
Option de suppression de la source : sélectionnez l'option de suppression de votre choix :
- Jamais : ne supprime jamais les fichiers après les transferts (recommandé pour les tests).
- Supprimer les fichiers transférés : supprime les fichiers une fois le transfert réussi.
Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides une fois le transfert réussi.
Âge maximal des fichiers : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).
Espace de noms de l'élément : espace de noms de l'élément
Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux
Cliquez sur Suivant.
Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.
Accorder des autorisations IAM au compte de service Google SecOps
Le compte de service Google SecOps doit disposer du rôle Lecteur des objets Storage sur votre bucket Cloud Storage.
- Accédez à Cloud Storage > Buckets.
- Cliquez sur le nom du bucket.
- Accédez à l'onglet Autorisations.
Cliquez sur Accorder l'accès.
Fournissez les informations de configuration suivantes :
- Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
- Attribuer des rôles : sélectionnez Lecteur d'objets Storage.
Cliquez sur Enregistrer.
Exemples de journaux Lacework Cloud Security compatibles
Informations sur l'agent ou la machine (inventaire des hôtes)
{ "AGENT_VERSION": "6.7.6-4ce73a7b", "CREATED_TIME": "Thu, 03 Nov 2022 02:09:36 -0700", "HOSTNAME": "host-agent-1", "IP_ADDR": "10.0.0.1", "LAST_UPDATE": "Wed, 18 Oct 2023 17:59:09 -0700", "MID": 6516601498285932156, "MODE": "ebpf", "OS": "Linux", "STATUS": "ACTIVE", "TAGS": { "Account": "999999999999", "AmiId": "ami-00000000000000000", "ExternalIp": "203.0.113.10", "Hostname": "internal-host-1.zone.compute.internal", "InstanceId": "i-00000000000000000", "InternalIp": "172.16.1.10", "LwTokenShort": "DUMMYTOKENABCD123456", "Name": "proxy-DMZ-app-1", "ResourceType": "proxy-machines", "SubnetId": "subnet-00000000000000000", "VmInstanceType": "t3.small", "VmProvider": "AWS", "VpcId": "vpc-00000000000000000", "Zone": "us-west-2a", "arch": "amd64", "falconx.io/application": "proxy-machines", "falconx.io/environment": "prod", "falconx.io/project": "edge", "falconx.io/team": "edge", "os": "linux" } }Métadonnées ou intégrité des fichiers
{ "CREATED_TIME": "Wed, 18 Oct 2023 17:02:01 -0700", "FILEDATA_HASH": "DUMMYHASH582C741AD91CA817B4718DEAA4E8A83C0B9D92E2", "FILE_PATH": "/usr/local/bin/secure_config", "MID": 7371220731851617371, "MTIME": "Fri, 25 Aug 2023 13:03:09 -0700", "SIZE": 8078 }Évaluation des failles de l'hôte
{ "CVE_PROPS": { "description": "DOCUMENTATION: The MITRE CVE dictionary describes this issue as: " "This CVE ID has been rejected or withdrawn by its CVE Numbering " "Authority for the following reason: This CVE ID has been rejected " "or withdrawn by its CVE Numbering Authority.", "link": "https://vendor.example.com/security/cve/CVE-2021-47472", "metadata": null }, "CVE_RISK_INFO": { "HOST_COUNT": 1249, "IMAGE_COUNT": 0, "PKG_COUNT": 0, "SEVERITY_LEVEL": 2, "score": 0.5154245281584533 }, "CVE_RISK_SCORE": 3.77, "END_TIME": "2024-09-04 07:00:00.000", "EVAL_CTX": { "collector_type": "Agent", "exception_props": [], "hostname": "vuln-host-1.example.net" }, "EVAL_GUID": "3dc61df780e3b722aa59b0ffcac85683", "FEATURE_KEY": { "name": "kernel-headers", "namespace": "centos:7", "package_active": 1, "package_path": "", "version_installed": "0:3.10.0-1160.119.1.el7.tuxcare.els2" }, "MACHINE_TAGS": { "Account": "999999999999", "AmiId": "ami-00000000000000000", "ExternalIp": "203.0.113.10", "Hostname": "ip-172-16-1-10.example-prod.aws.featurespace.net", "InternalIp": "10.0.0.1", "LwTokenShort": "DUMMYTOKENABCD123456", "VmProvider": "AWS", "VpcId": "vpc-00000000000000000", "os": "linux" }, "MID": 5746003737030963813, "PACKAGE_STATUS": "ACTIVE", "REGION": "eu-west-2", "RISK_SCORE": 10, "SEVERITY": "Low", "START_TIME": "2024-09-04 06:00:00.000", "STATUS": "Exception", "VULN_ID": "CVE-2021-47472" }Conformité de la configuration cloud (audit)
{ "ACCOUNT": { "AccountId": "999999999999", "Account_Alias": "" }, "EVAL_TYPE": "LW_SA", "ID": "lacework-global-87", "REASON": "Default security group does not restrict traffic", "RECOMMENDATION": "Ensure the default security group of every Virtual Private Cloud (VPC) restricts all traffic", "REGION": "eu-north-1", "REPORT_TIME": "2024-11-10 18:00:00.000", "RESOURCE_ID": "arn:aws:ec2:eu-west-1:999999999999:security-group/sg-00000000000000000", "SECTION": "", "SEVERITY": "High", "STATUS": "NonCompliant" }Requête ou résolution DNS
{ "CREATED_TIME": "2024-11-06 05:14:44.329", "DNS_SERVER_IP": "10.0.0.53", "FQDN": "data-service-prod-1234567890.s3.eu-west-2.amazonaws.com", "HOST_IP_ADDR": "172.16.1.20", "MID": 8843985456817096491, "TTL": 5 }Évaluation des failles dans les images
{ "CVE_PROPS": null, "EVAL_CTX": { "collector_type": "Agentless", "image_info": { "digest": "sha256:52d5cb782dad7a8a03c8bd1b285bbd32bdbfa8fcc435614bb1e6ceefcf26ae1d", "id": "sha256:31427c44cac7ab632d541181073bbd46a964e4ed38d087d8a47f60bb66eef4df", "registry": "999999999999.dkr.ecr.eu-west-1.amazonaws.com", "repo": "amazon/aws-network-policy-agent" } }, "EVAL_GUID": "3a17a74f0a65eed2bddd2d37bb02e6af", "FEATURE_KEY": { "name": "perl-threads", "namespace": "amzn:2", "version": "1.87-4.amzn2.0.2" }, "FIX_INFO": { "fix_available": 0, "fixed_version": "" }, "IMAGE_ID": "sha256:31427c44cac7ab632d541181073bbd46a964e4ed38d087d8a47f60bb66eef4df", "IMAGE_RISK_INFO": { "factors": [ "cve", "reachability" ], "factors_breakdown": { "cve_counts": { "Critical": 0, "High": 21, "Medium": 73 }, "internet_reachability": "Unknown" } }, "IMAGE_RISK_SCORE": 6.4, "PACKAGE_STATUS": "NO_AGENT_AVAILABLE", "RISK_SCORE": 6.4, "START_TIME": "2024-11-05 19:05:03.553", "STATUS": "GOOD" }Résumé du trafic réseau ou de la connexion
{ "DST_ENTITY_ID": { "hostname": "service-A.region.amazonaws.com", "ip_internal": 0, "port": 443, "protocol": "TCP" }, "DST_ENTITY_TYPE": "DnsSep", "DST_IN_BYTES": 0, "DST_OUT_BYTES": 0, "ENDPOINT_DETAILS": [ { "dst_ip_addr": "203.0.113.10", "dst_port": 443, "protocol": "TCP", "src_ip_addr": "192.168.1.10" }, { "dst_ip_addr": "198.51.100.5", "dst_port": 443, "protocol": "TCP", "src_ip_addr": "192.168.1.10" } ], "END_TIME": "2024-11-05 21:00:00.000", "NUM_CONNS": 4, "SRC_ENTITY_ID": { "mid": 2080882850610892909, "pid_hash": 744766973756676842 }, "SRC_ENTITY_TYPE": "Process", "SRC_IN_BYTES": 25028, "SRC_OUT_BYTES": 11962, "START_TIME": "2024-11-05 20:00:00.000" }Informations sur le package ou mise à jour
{ "ARCH": "x86_64", "CREATED_TIME": "2024-11-08 01:28:30.566", "MID": 4172267319977985370, "PACKAGE_NAME": "grub2", "VERSION": "2:2.02-0.87.0.2.el7.el7.centos.14.tuxcare.els2" }Activité des processus du conteneur
{ "CONTAINER_ID": "4853339865add970f72213ec5d76ff51d1308c61a7680cc23c8de20c38c0a8e1", "END_TIME": "2024-11-08 02:00:00.000", "FILE_PATH": "/app/grpc-health-probe", "MID": 3708952045169222383, "PID": 177267, "POD_NAME": "kubernetes-pod-abc", "PPID": 177257, "PROCESS_START_TIME": "2024-11-08 01:43:29.960", "START_TIME": "2024-11-08 01:00:00.000", "UID": 0, "USERNAME": "serviceuser" }Alerte ou événement général (CloudTrail)
{ "EVENT_ID": "413328", "EVENT_NAME": "Unauthorized API Call", "EVENT_TYPE": "CloudTrailDefaultAlert", "SUMMARY": " For account: 999999999999 (and 22 more) : event Unauthorized API Call from a username other " "than whitelisted ones. Replaces lacework-global-29 occurred 3772 times by user " "UDM-PRINCIPAL-ID:UDM-SERVICE-ROLE (and 167 more) ", "START_TIME": "07 Feb 2025 12:00 GMT", "EVENT_CATEGORY": "Aws", "LINK": "https://security.example.net/ui/alert/12345/details", "ACCOUNT": "UDM_ACCOUNT", "SOURCE": "CloudTrail", "subject": { "srcEvent": { "event": { "errorCode": "AccessDenied", "errorMessage": "User: arn:aws:sts::999999999999:assumed-role/UDM-SERVICE-ROLE-IngestionApiRole/UDM-SERVICE-PRINCIPAL " "is not authorized to perform: kinesis:ListShards on resource: " "arn:aws:kinesis:us-east-1:999999999999:stream/ingestion-qa-rel-fraud-review-Stream " "because no identity-based policy allows the kinesis:ListShards action", "eventName": "ListShards", "eventSource": "kinesis.amazonaws.com", "eventTime": "2025-02-07T12:00:24Z", "recipientAccountId": "999999999999", "sourceIPAddress": "firehose.amazonaws.com", "userIdentity": { "accessKeyId": "ACCESSKEYIDDUMMY", "accountId": "999999999999", "arn": "arn:aws:sts::999999999999:assumed-role/UDM-SERVICE-ROLE-IngestionApiRole/UDM-SERVICE-PRINCIPAL", "sessionContext": { "sessionIssuer": { "accountId": "999999999999", "arn": "arn:aws:iam::999999999999:role/UDM-SERVICE-ROLE-IngestionApiRole", "principalId": "PRINCIPALIDDUMMY", "userName": "UDM-SERVICE-ROLE-IngestionApiRole" } } }, "vpcEndpointId": "vpce-00000000000000000" }, "principalId": "PRINCIPALIDDUMMY:UDM-SERVICE-PRINCIPAL", "recipientAccountId": "999999999999", "sourceIPAddress": "firehose.amazonaws.com", "userIdentityName": "UDM-SERVICE-ROLE-IngestionApiRole" } } }
Table de mappage UDM
| Champ du journal | Mappage UDM | Logique |
|---|---|---|
| alertId | metadata.product_log_id | Valeur copiée directement |
| alertName | security_result.rule_name | Valeur copiée directement |
| de gravité, | security_result.severity | Mappé sur la gravité UDM |
| état | security_result.summary | Valeur copiée directement |
| alertType | security_result.category_details | Valeur copiée directement |
| startTime | metadata.event_timestamp | Analysé en tant que code temporel ISO 8601 |
| endTime | additional.fields | Stocké en tant qu'étiquette end_time |
| alertInfo.description | security_result.description | Valeur copiée directement |
| alertInfo.subject | metadata.description | Valeur copiée directement |
| entityMap.Machine.hostname | principal.hostname | Valeur copiée directement |
| entityMap.Machine.externalIp | principal.ip | Valeur copiée directement |
| entityMap.User.username | principal.user.userid | Valeur copiée directement |
| entityMap.Region.region | principal.location.name | Valeur copiée directement |
| entityMap.CT_User.accountId | principal.user.product_object_id | Valeur copiée directement |
event_title |
event.idm.read_only_udm.security_result.summary |
Mappé à partir du journal des modifications |
event_description |
event.idm.read_only_udm.security_result.description |
Mappé à partir du journal des modifications |
summary_details |
event.idm.read_only_udm.security_result.confidence_details |
Mappé à partir du journal des modifications |
target_user_id |
event.idm.read_only_udm.target.user.userid |
Mappé à partir du journal des modifications |
resource_product_id |
event.idm.read_only_udm.target.resource.product_object_id |
Mappé à partir du journal des modifications |
user_role |
event.idm.read_only_udm.target.user.role_name |
Mappé à partir du journal des modifications |
account_name |
event.idm.read_only_udm.target.resource.name |
Mappé à partir du journal des modifications |
application |
event.idm.read_only_udm.target.application |
Mappé à partir du journal des modifications |
event_id |
event.idm.read_only_udm.metadata.product_log_id |
Mappé à partir du journal des modifications |
event_type |
event.idm.read_only_udm.metadata.product_event_type |
Mappé à partir du journal des modifications |
event_severity |
event.idm.read_only_udm.security_result.severity_details |
Mappé à partir du journal des modifications |
lacework_account |
event.idm.read_only_udm.principal.user.userid |
Mappé à partir du journal des modifications |
event_link |
event.idm.read_only_udm.metadata.url_back_to_product |
Mappé à partir du journal des modifications |
starttimevalue |
event.idm.read_only_udm.additional.fields |
Mappé à partir du journal des modifications |
endtimevalue |
event.idm.read_only_udm.additional.fields |
Mappé à partir du journal des modifications |
intgGuid |
event.idm.read_only_udm.target.resource.attribute.labels |
Mappé à partir du journal des modifications |
rec_id |
event.idm.read_only_udm.target.resource.attribute.labels |
Mappé à partir du journal des modifications |
event_source |
event.idm.read_only_udm.metadata.product_name |
Mappé à partir du journal des modifications |
event_timestamp |
event.idm.read_only_udm.metadata.event_timestamp |
Mappé à partir du journal des modifications |
ACCOUNT", "EVENT_CATEGORY", "subject.srcEvent.recipientAccountAlias", "DERIVED_FIELDS.SOURCE", "subject.srcEvent.event.userIdentity.accessKeyId", "subject.srcEvent.event.userIdentity.arn", "subject.srcEvent.event.errorCode", "subject.srcEvent.event.errorMessage", "subject.srcEvent.event.eventID", "subject.srcEvent.event.eventSource", "subject.srcEvent.event.userIdentity.sessionContext.attributes.mfaAuthenticated", "subject.srcEvent.username", "subject.startTime", "subject.srcEvent.eventName", "DERIVED_FIELDS.CATEGORY", "DERIVED_FIELDS.SUBCATEGORY", "subject.dstEvent.gbm_version", "subject.dstEvent.is_visible", "subject.dstEvent.severity", "subject.dstEvent.recipientAccountAlias", "subject.srcEvent.api", "subject.srcEvent.calltype", "subject.srcEvent.gbm_version", "subject.srcEvent.is_visible", and "subject.srcEvent.severity |
additional.fields |
Mappé à partir du journal des modifications |
SUMMARY |
metadata.description |
Mappé à partir du journal des modifications |
EVENT_TYPE |
metadata.product_event_type |
Mappé à partir du journal des modifications |
EVENT_ID |
metadata.product_log_id |
Mappé à partir du journal des modifications |
LINK |
metadata.url_back_to_product |
Mappé à partir du journal des modifications |
subject.srcEvent.event.userAgent", "subject.srcEvent.source |
network.http.user_agent |
Mappé à partir du journal des modifications |
subject.srcEvent.recipientAccountId |
principal.user.groupid |
Mappé à partir du journal des modifications |
subject.srcEvent.principalId |
principal.user.userid |
Mappé à partir du journal des modifications |
subject.srcEvent.event.awsRegion |
security_result.about.asset.attribute.cloud.availability_zone |
Mappé à partir du journal des modifications |
subject.srcEvent.event.eventCategory |
security_result.about.asset.category |
Mappé à partir du journal des modifications |
EVENT_NAME |
security_result.category |
Mappé à partir du journal des modifications |
EVENT_NAME |
security_result.summary |
Mappé à partir du journal des modifications |
subject.srcType |
src.resource.resource_subtype |
Mappé à partir du journal des modifications |
subject.srcEvent.event.userIdentity.sessionContext.attributes.creationDate |
metadata.event_timestamp |
Mappé à partir du journal des modifications |
subject.srcEvent.accountcaller |
principal.resource.product_object_id |
Mappé à partir du journal des modifications |
subject.dstEvent.region |
target.asset.location.name |
Mappé à partir du journal des modifications |
subject.dstEvent.accountcaller |
target.resource.product_object_id |
Mappé à partir du journal des modifications |
subject.dstType |
target.resource.resource_subtype |
Mappé à partir du journal des modifications |
subject.dstEvent.service |
target.url |
Mappé à partir du journal des modifications |
subject.dstEvent.username |
target.user.userid |
Mappé à partir du journal des modifications |
Journal des modifications
Afficher le journal des modifications de cet analyseur
Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.