Collecter les journaux Symantec Web Security Service (WSS)
Ce document explique comment ingérer des journaux Symantec Web Security Service (WSS) dans Google Security Operations à l'aide de Cloud Storage. L'analyseur tente d'abord d'analyser le message de journal au format JSON. En cas d'échec, il utilise une série de modèles grok de plus en plus spécifiques pour extraire les champs du texte brut, puis mappe les données extraites au modèle de données unifié (UDM). Symantec Web Security Service (WSS) est une solution de sécurité Web dans le cloud qui offre une protection en temps réel contre les menaces Web, y compris les logiciels malveillants, l'hameçonnage et la perte de données.
Avant de commencer
Assurez-vous de remplir les conditions 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é au portail Symantec Web Security Service
Collecter les identifiants de l'API Symantec WSS
Obtenir l'URL du site Symantec WSS
- Connectez-vous au portail Symantec Web Security Service.
- Notez l'URL de votre portail dans la barre d'adresse du navigateur.
- Format :
https://portal.threatpulse.comou l'URL spécifique à votre organisation - Exemple : Si vous accédez à WSS à l'adresse
https://portal.threatpulse.com/reportpod, l'URL de votre site esthttps://portal.threatpulse.com.
- Format :
Créer des identifiants d'API
- Connectez-vous au portail Symantec Web Security Service en tant qu'administrateur.
- Accédez à Compte > Identifiants de l'API.
- Cliquez sur Ajouter des identifiants d'API. Le portail affiche la boîte de dialogue Add API Credential (Ajouter un identifiant d'API) avec un nom d'utilisateur et un mot de passe générés automatiquement.
Copiez et enregistrez le nom d'utilisateur et le mot de passe de manière sécurisée.
Sélectionnez l'option Expiration de l'API :
- Basé sur le temps : définissez la date et l'heure d'expiration de ce jeton.
- N'expire jamais : le jeton reste valide indéfiniment (recommandé pour la production).
Pour l'option Accès, sélectionnez Journaux d'accès aux rapports.
Cliquez sur Enregistrer.
Vérifier les autorisations
Pour vérifier que le compte dispose des autorisations requises :
- Connectez-vous au portail Symantec Web Security Service.
- Accédez à Compte > Identifiants de l'API.
- Si vous voyez les identifiants d'API que vous avez créés avec l'option Accès définie sur Journaux d'accès aux rapports, vous disposez des autorisations requises.
- Si cette option ne s'affiche pas, contactez votre administrateur pour qu'il vous accorde l'autorisation Reporting Access Logs (Journaux d'accès aux rapports).
Tester l'accès à l'API
Testez vos identifiants avant de procéder à l'intégration :
# Replace with your actual credentials WSS_USERNAME="your-api-username" WSS_PASSWORD="your-api-password" WSS_SYNC_URL="https://portal.threatpulse.com/reportpod/logs/sync" # startDate must be within the last 7 days. This requests logs from the start of the current hour. START_MS=$(( $(date +%s) / 3600 * 3600 * 1000 )) curl -sS -o wss-test.zip -w "HTTP %{http_code}\n" \ -H "X-APIUsername: ${WSS_USERNAME}" \ -H "X-APIPassword: ${WSS_PASSWORD}" \ "${WSS_SYNC_URL}?token=none&startDate=${START_MS}&maxmb=10" # The sync status is appended to the end of the response, after the ZIP data tail -c 300 wss-test.zip | strings | grep -i "X-sync" # List the log files in the archive unzip -l wss-test.zip
Résultat attendu :
HTTP 200.- Deux lignes
X-sync-token: ...etX-sync-status: done(oumore). - Liste de fichiers
.log.gz, par exemplecloud_<tenant_ID>_<timestamp>.log.gz. La liste est vide s'il n'y a pas encore de journaux pour l'heure en cours.
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, symantec-wss-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.
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 le compte de service
- Dans la consoleGoogle 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
symantec-wss-collector-sa. - Description du compte de service : saisissez
Service account for Cloud Run function to collect Symantec WSS 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 : écrit des journaux dans le bucket Cloud Storage et gère les fichiers d'état.
- Demandeur Cloud Run : permet à Pub/Sub d'appeler la fonction.
- Demandeur Cloud Functions : permet d'appeler des 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.
- 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,
symantec-wss-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 consoleGoogle Cloud , accédez à Pub/Sub > Sujets.
- Cliquez sur Créer un sujet.
- Fournissez les informations de configuration suivantes :
- ID du sujet : saisissez
symantec-wss-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 des messages Pub/Sub provenant de Cloud Scheduler pour récupérer les journaux de l'API Symantec WSS Sync et les écrire dans Cloud Storage.
L'API Sync renvoie une archive ZIP de fichiers journaux compressés au format gzip. La fonction extrait l'archive et écrit chaque fichier .log.gz dans le bucket en tant qu'objet distinct, car le flux ne peut pas lire les fichiers journaux d'une archive ZIP. La fonction stocke le jeton de synchronisation renvoyé par l'API dans un fichier d'état. Ainsi, chaque exécution reprend exactement là où la précédente s'est arrêtée.
- Dans la consoleGoogle Cloud , accédez à Cloud Run.
- Cliquez sur Écrire une fonction.
Dans la section Configurer, fournissez les informations de configuration suivantes :
Paramètre Valeur Nom du service symantec-wss-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, cliquez sur Ajouter un déclencheur, puis sélectionnez Déclencheur Pub/Sub.
Dans le volet Déclencheur Eventarc, fournissez les informations de configuration suivantes :
- Nom du déclencheur : conservez le nom généré ou saisissez un nom pour le déclencheur.
- Type de déclencheur : sélectionnez Sources Google.
- Fournisseur d'événements : sélectionnez Pub/Sub.
- Type d'événement : sélectionnez google.cloud.pubsub.topic.v1.messagePublished.
- Sélectionner un sujet Cloud Pub/Sub : choisissez le sujet
symantec-wss-trigger. - Région : sélectionnez la même région que la fonction.
- Compte de service : sélectionnez le compte de service
symantec-wss-collector-sa.
Cliquez sur Enregistrer le déclencheur.
Dans la section Authentification :
- Sélectionnez Exiger l'authentification.
- Vérifiez Identity and Access Management (IAM).
Accédez à Conteneurs, mise en réseau, sécurité et développez cette section.
Accédez à l'onglet Sécurité :
- Compte de service : sélectionnez le compte de service (
symantec-wss-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_BUCKETsymantec-wss-logsNom du bucket GCS GCS_PREFIXsymantec/wss/Préfixe des fichiers journaux STATE_KEYsymantec-wss-state.jsonChemin d'état, en dehors du préfixe du journal WSS_SYNC_URLhttps://portal.threatpulse.com/reportpod/logs/syncPoint de terminaison de l'API WSS Sync WSS_API_USERNAMEyour-api-username(à partir des identifiants de l'API)Nom d'utilisateur de l'API WSS WSS_API_PASSWORDyour-api-password(à partir des identifiants de l'API)Mot de passe de l'API WSS INITIAL_LOOKBACK_HOURS1Nombre d'heures de journaux à collecter lors de la première exécution (maximum 167, car l'API Sync renvoie au maximum les sept derniers jours) WSS_MAX_MB100Taille maximale approximative d'une réponse de l'API Sync en Mo (1 à 2 560) HTTP_TIMEOUT120Délai avant expiration de la lecture HTTP en secondes MAX_RETRIES3Nombre maximal de nouvelles tentatives pour les erreurs réseau et les réponses HTTP 5xx RUN_BUDGET_SECONDS480Délai après lequel la fonction cesse de demander de nouvelles pages. Il doit être inférieur au délai avant expiration de la requête. USER_AGENTsymantec-wss-to-gcs/2.0Chaîne user-agent Dans la section Variables et secrets, accédez à 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 1 Gio ou plus. La fonction conserve une réponse de l'API Sync (jusqu'à
WSS_MAX_MB) en mémoire pendant qu'elle l'extrait. - Processeur : sélectionnez 1.
- Mémoire : sélectionnez 1 Gio ou plus. La fonction conserve une réponse de l'API Sync (jusqu'à
- Dans la section Ressources :
Dans la section Scaling de révision :
- Nombre minimal d'instances : saisissez
0. - Nombre maximal d'instances : saisissez
1. L'API Sync n'autorise qu'un seul client par jeton de synchronisation. Les exécutions ne doivent donc pas se chevaucher.
- 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 le code de la fonction
- Saisissez main dans Point d'entrée de la fonction.
Dans l'éditeur de code intégré, créez deux fichiers :
- Premier fichier : main.py:
import functions_framework from google.api_core import exceptions as gcs_exceptions from google.cloud import storage import io import json import os import re import time import uuid import zipfile from datetime import datetime, timedelta, timezone from urllib.parse import urlencode import urllib3 http = urllib3.PoolManager(retries=False) storage_client = storage.Client() # The Sync API returns a ZIP archive of gzipped ELFF files followed by a # plain-text footer with the X-sync-token and X-sync-status lines. ZIP_SIGNATURES = (b'PK\x03\x04', b'PK\x05\x06') # archive with files, empty archive FOOTER_SCAN_BYTES = 4096 TOKEN_RE = re.compile(rb'X-sync-token:\s*(\S+)', re.IGNORECASE) STATUS_RE = re.compile(rb'X-sync-status:\s*(\S+)', re.IGNORECASE) MAX_LOOKBACK = timedelta(days=7) THROTTLE_WAIT_SECONDS = 60 MIN_SECONDS_PER_REQUEST = 120 class SyncApiError(Exception): """The Sync API returned a response that must not be processed.""" class TokenExpired(Exception): """The Sync API rejected the saved token (HTTP 410).""" @functions_framework.cloud_event def main(cloud_event): """Fetch Symantec WSS access logs from the Sync API and write them to GCS.""" bucket_name = os.environ['GCS_BUCKET'] prefix = os.environ.get('GCS_PREFIX', 'symantec/wss/') state_key = os.environ.get('STATE_KEY', 'symantec-wss-state.json') sync_url = os.environ.get('WSS_SYNC_URL', 'https://portal.threatpulse.com/reportpod/logs/sync') username = os.environ['WSS_API_USERNAME'] password = os.environ['WSS_API_PASSWORD'] lookback_hours = int(os.environ.get('INITIAL_LOOKBACK_HOURS', '1')) max_mb = int(os.environ.get('WSS_MAX_MB', '100')) http_timeout = int(os.environ.get('HTTP_TIMEOUT', '120')) max_retries = int(os.environ.get('MAX_RETRIES', '3')) run_budget = int(os.environ.get('RUN_BUDGET_SECONDS', '480')) user_agent = os.environ.get('USER_AGENT', 'symantec-wss-to-gcs/2.0') bucket = storage_client.bucket(bucket_name) state, generation = load_state(bucket, state_key) deadline = time.monotonic() + run_budget while time.monotonic() + MIN_SECONDS_PER_REQUEST <= deadline: token = state.get('token') or 'none' params = {'token': token, 'maxmb': max_mb} if token == 'none': params['startDate'] = initial_start_ms(state, lookback_hours) requested_at = datetime.now(timezone.utc) try: body = fetch_page(sync_url, params, username, password, user_agent, http_timeout, max_retries, deadline) except TokenExpired: # Restart the sync from the hour of the last successful page. # Events from that hour can be ingested again. print('Sync token expired (HTTP 410). Restarting with token=none.') state['token'] = None generation = save_state(bucket, state_key, state, generation) continue if body is None: print('Sync API is throttling requests. The next run continues from the saved token.') return archive, next_token, status = split_footer(body) if status not in ('more', 'done'): raise SyncApiError( f'X-sync-status is {status!r}. The data was discarded; the next run retries token {token!r}.') written = write_archive(bucket, prefix, archive) state.update({ 'token': next_token, 'last_status': status, 'last_success': requested_at.isoformat(), }) # resume_ms is where a restart after an expired token begins: the # startDate of a new sync, then the hour of the last fully synced point. if token == 'none': state['resume_ms'] = params['startDate'] if status == 'done': state['resume_ms'] = hour_floor_ms(requested_at) generation = save_state(bucket, state_key, state, generation) print(f'Wrote {len(written)} log files ({len(archive)} bytes), X-sync-status: {status}') if status == 'done': # The API expects at least 60 seconds before the next request. print('Sync is up to date.') return time.sleep(1) print('Run time budget reached. The next run continues from the saved token.') def initial_start_ms(state, lookback_hours): """startDate for a token=none request: within the last 7 days, at an hour boundary.""" now = datetime.now(timezone.utc) oldest_ms = hour_floor_ms(now - MAX_LOOKBACK) + 3600 * 1000 start_ms = state.get('resume_ms') or hour_floor_ms(now - timedelta(hours=lookback_hours)) return max(start_ms, oldest_ms) def hour_floor_ms(dt): return int(dt.replace(minute=0, second=0, microsecond=0).timestamp() * 1000) def fetch_page(sync_url, params, username, password, user_agent, timeout, max_retries, deadline): """Return the response body, None when throttled past the deadline, or raise.""" url = f'{sync_url}?{urlencode(params)}' headers = { 'User-Agent': user_agent, 'X-APIUsername': username, 'X-APIPassword': password, } failures = 0 while True: try: response = http.request('GET', url, headers=headers, timeout=urllib3.Timeout(connect=10.0, read=timeout)) except urllib3.exceptions.HTTPError as e: failures += 1 if failures > max_retries: raise print(f'Request failed ({e}), retry {failures}/{max_retries}') time.sleep(min(30, 2 ** failures)) continue if response.status == 200: return response.data if response.status == 410: raise TokenExpired() if response.status in (423, 429): # 423: another request with this token is in progress. 429: throttled. wait = retry_after_seconds(response) if time.monotonic() + wait + MIN_SECONDS_PER_REQUEST > deadline: return None print(f'HTTP {response.status}, waiting {wait}s') time.sleep(wait) continue if response.status >= 500: failures += 1 if failures <= max_retries: print(f'HTTP {response.status}, retry {failures}/{max_retries} with the same token') time.sleep(min(30, 2 ** failures)) continue detail = response.data[:500].decode('utf-8', errors='replace') raise SyncApiError(f'HTTP {response.status}: {detail}') def retry_after_seconds(response): value = response.headers.get('Retry-After', '') return int(value) if value.isdigit() else THROTTLE_WAIT_SECONDS def split_footer(body): """Split the response into the ZIP archive bytes, X-sync-token and X-sync-status.""" tail_start = max(0, len(body) - FOOTER_SCAN_BYTES) tail = body[tail_start:] token_match = TOKEN_RE.search(tail) status_match = STATUS_RE.search(tail) if not token_match or not status_match: raise SyncApiError( f'Response of {len(body)} bytes has no X-sync-token/X-sync-status footer (incomplete download).') footer_start = tail_start + min(token_match.start(), status_match.start()) token = token_match.group(1).decode('ascii') status = status_match.group(1).decode('ascii').lower() return body[:footer_start], token, status def write_archive(bucket, prefix, archive): """Upload every file in the ZIP archive to GCS as a separate object.""" if not archive: return [] if not archive.startswith(ZIP_SIGNATURES): raise SyncApiError(f'Expected a ZIP archive, got bytes starting with {archive[:8]!r}') date_path = datetime.now(timezone.utc).strftime('%Y/%m/%d') batch_id = f'{int(time.time())}_{uuid.uuid4().hex[:8]}' written = [] with zipfile.ZipFile(io.BytesIO(archive)) as zf: for member in zf.infolist(): if member.is_dir(): continue file_name = os.path.basename(member.filename) blob_name = f'{prefix}{date_path}/{batch_id}_{file_name}' content_type = 'application/gzip' if file_name.endswith('.gz') else 'text/plain' # if_generation_match=0 creates the object only if it does not exist, # which also makes the upload safe to retry. bucket.blob(blob_name).upload_from_string( zf.read(member), content_type=content_type, if_generation_match=0) written.append(blob_name) return written def load_state(bucket, key): """Return the saved state and its object generation (0 if there is no state yet).""" blob = bucket.get_blob(key) if blob is None: return {}, 0 return json.loads(blob.download_as_text()), blob.generation def save_state(bucket, key, state, generation): """Save the state only if no other run changed it since it was loaded.""" blob = bucket.blob(key) try: blob.upload_from_string(json.dumps(state), content_type='application/json', if_generation_match=generation) except gcs_exceptions.PreconditionFailed: raise RuntimeError(f'{key} was changed by another run; stopping to avoid a token conflict.') return blob.generation- Deuxième fichier : requirements.txt: :
functions-framework==3.* google-cloud-storage==2.* urllib3>=2.0.0Cliquez 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 consoleGoogle Cloud , accédez à Cloud Scheduler.
- Cliquez sur Créer une tâche.
Fournissez les informations de configuration suivantes :
Paramètre Valeur Nom symantec-wss-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 Pub/Sub ( symantec-wss-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 le nom de votre fonction (
symantec-wss-collector). - Cliquez sur l'onglet Journaux.
Vérifiez que la fonction a bien été exécutée. Par exemple :
Wrote N log files (X bytes), X-sync-status: done Sync is up to date.Si l'API Sync contient plus de données que ce qui peut tenir dans une seule réponse, le journal affiche plusieurs lignes
Wrote N log filesavecX-sync-status: moreavant la lignedonefinale.Accédez à Cloud Storage > Buckets.
Cliquez sur le nom de votre bucket.
Accédez au dossier du préfixe (
symantec/wss/).Vérifiez que de nouveaux fichiers
.log.gzont été créés, par exemplesymantec/wss/YYYY/MM/DD/<run_ID>_cloud_<tenant_ID>_<timestamp>.log.gz. L'exécution ne crée pas de fichiers si Symantec WSS ne contient pas de nouveaux journaux.
Si des erreurs s'affichent dans les journaux :
- HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement. Vérifiez que le nom d'utilisateur et le mot de passe sont corrects.
- HTTP 403 : vérifiez que l'autorisation "Reporting Access Logs" (Journaux d'accès aux rapports) est activée pour les identifiants de l'API dans le portail WSS.
- HTTP 400 : la première requête d'une synchronisation a utilisé une date de début antérieure à sept jours.
INITIAL_LOOKBACK_HOURSbas. - HTTP 409 : trop de requêtes ont lancé une nouvelle synchronisation avec
token=none. Attendez 90 minutes avant la prochaine exécution. - HTTP 423 ou 429 : une autre requête est en cours ou l'API Sync limite les requêtes. La fonction attend et réessaie. Si l'attente ne correspond pas à l'environnement d'exécution, l'exécution suivante se poursuit à partir du jeton enregistré.
- Jeton de synchronisation expiré (HTTP 410) : la fonction redémarre la synchronisation à partir de l'heure de la dernière synchronisation terminée. Certains événements de cette heure peuvent être ingérés à nouveau.
- X-sync-status est "abort" ou pas de pied de page X-sync-token/X-sync-status : la réponse était incomplète et a été supprimée. L'exécution suivante réessaie avec le même jeton.
- Expected a ZIP archive (Archive ZIP attendue) : l'API Sync a renvoyé un élément autre qu'une archive de journaux. Vérifiez la réponse avec le test dans Tester l'accès à l'API.
- Modifié par une autre exécution : deux exécutions se sont chevauchées. Définissez le paramètre Nombre maximal d'instances sur
1. - KeyError pour un nom de variable : vérifiez que toutes les variables d'environnement requises sont définies dans la configuration de la fonction Cloud Run.
Configurer un flux dans Google SecOps pour ingérer les journaux Symantec WSS
- Accédez à Paramètres SIEM > 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,
Symantec WSS logs). - Sélectionnez Google Cloud Storage V2 comme Type de source.
- Sélectionnez Symantec WSS 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. Vous en aurez besoin lors de la tâche suivante.
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://symantec-wss-logs/symantec/wss/Remplacez :
symantec-wss-logs: nom de votre bucket Cloud Storage.symantec/wss/: préfixe ou chemin d'accès au dossier facultatif où les journaux sont stockés (laissez ce champ vide pour la racine).
Exemples : - Bucket racine :
gs://company-logs/- Avec préfixe :gs://company-logs/symantec-wss/- Avec sous-dossier :gs://company-logs/symantec/wss/Option de suppression de la source : sélectionnez l'option de suppression de votre choix :
- Ne jamais supprimer les fichiers : ne supprime jamais les fichiers de la source (recommandé pour les tests).
- Supprimer les fichiers transférés et les répertoires vides : supprimez les fichiers et les répertoires vides de la source une fois la récupération terminée.
Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours. La valeur par défaut est de 180 jours.
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 d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.
Accorder des autorisations IAM au compte de service Google SecOps
Le compte de service Google SecOps a besoin de deux rôles sur votre bucket Cloud Storage : Lecteur des objets Storage pour lire les objets de journal et un rôle au niveau du bucket pour lire les métadonnées du bucket.
- Accédez à Cloud Storage > Buckets.
- Cliquez sur le nom de votre 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 les deux options suivantes :
- Lecteur des objets de l'espace de stockage : lit les objets de journal.
- Lecteur des anciens buckets Storage : lit les métadonnées du bucket. Si vous avez sélectionné l'option de suppression Supprimer les fichiers transférés et les répertoires vides, sélectionnez plutôt Rédacteur d'ancien bucket Storage, qui accorde également l'autorisation de suppression.
Cliquez sur Enregistrer.
Table de mappage UDM
| Champ du journal | Mappage UDM | Logique |
|---|---|---|
content_type_label |
additional.fields |
Fusionné |
cs_uri_extension_label |
additional.fields |
Fusionné |
cs_uri_path_label |
additional.fields |
Fusionné |
hostname_categories_label |
additional.fields |
Fusionné |
_intermediary |
intermediary |
Fusionné |
msg_desc |
metadata.description |
Mappage direct |
s_action |
metadata.description |
Mappage direct |
device_time |
metadata.event_timestamp |
Analysé en tant que ISO8601 |
log_time |
metadata.event_timestamp |
Analysé en tant que UNIX_MS |
timestamp |
metadata.event_timestamp |
Analysé en tant que UNIX |
when |
metadata.event_timestamp |
Analysé en tant que MMM dd HH:mm:ss |
has_principal |
metadata.event_type |
Mappé : true → NETWORK_CONNECTION, true → STATUS_UPDATE |
s-action |
metadata.product_event_type |
Mappage direct |
product_data.x-bluecoat-transaction-uuid |
metadata.product_log_id |
Mappage direct |
ref_uid |
metadata.product_log_id |
Mappage direct |
uuid |
metadata.product_log_id |
Mappage direct |
x-bluecoat-transaction-uuid |
metadata.product_log_id |
Mappage direct |
product_name |
metadata.product_name |
Mappage direct |
product_ver |
metadata.product_version |
Mappage direct |
connection.url.scheme |
network.application_protocol |
Mappage direct |
cs-uri-scheme |
network.application_protocol |
Mappé : (?i)https → HTTPS |
uri_scheme |
network.application_protocol |
Mappage direct |
cs-version |
network.application_protocol_version |
Mappage direct |
connection.url.method |
network.http.method |
Mappage direct |
cs-method |
network.http.method |
Mappage direct |
method |
network.http.method |
Mappage direct |
cs_referer |
network.http.referral_url |
Mappage direct |
connection.http_status |
network.http.response_code |
Renommé/Mappé |
status |
network.http.response_code |
Mappage direct |
connection.http_user_agent |
network.http.user_agent |
Mappage direct |
cs(user-agent) |
network.http.user_agent |
Mappage direct |
http_user_agent |
network.http.user_agent |
Mappage direct |
connection.url.scheme |
network.ip_protocol |
Mappage direct |
uri_scheme |
network.ip_protocol |
Mappage direct |
connection.bytes_download |
network.received_bytes |
Renommé/Mappé |
received_bytes |
network.received_bytes |
Renommé/Mappé |
connection.bytes_upload |
network.sent_bytes |
Renommé/Mappé |
sent_bytes |
network.sent_bytes |
Renommé/Mappé |
time_taken |
network.session_duration.seconds |
Mappage direct |
session_id |
network.session_id |
Mappage direct |
cs_connection_negotiated_cipher |
network.tls.cipher |
Mappage direct |
product_data.x-cs-connection-negotiated-cipher |
network.tls.cipher |
Mappage direct |
x-cs-connection-negotiated-cipher |
network.tls.cipher |
Mappage direct |
certificate_hostname |
network.tls.client.server_name |
Mappage direct |
product_data.x-rs-certificate-hostname |
network.tls.client.server_name |
Mappage direct |
x-rs-certificate-hostname |
network.tls.client.server_name |
Mappage direct |
product_data.x-rs-certificate-observed-errors |
network.tls.server.certificate.issuer |
Mappage direct |
x-rs-certificate-observed-errors |
network.tls.server.certificate.issuer |
Mappage direct |
certificate_validate |
network.tls.server.certificate.subject |
Mappage direct |
product_data.x-rs-certificate-validate-status |
network.tls.server.certificate.subject |
Mappage direct |
x-rs-certificate-validate-status |
network.tls.server.certificate.subject |
Mappage direct |
connection.tls.version |
network.tls.version_protocol |
Mappage direct |
cs_ssl_version |
network.tls.version_protocol |
Mappage direct |
product_data.x-cs-connection-negotiated-ssl-version |
network.tls.version_protocol |
Mappage direct |
x-cs-connection-negotiated-ssl-version |
network.tls.version_protocol |
Mappage direct |
agent_type |
observer.application |
Mappage direct |
product_data.x-client-agent-type |
observer.application |
Mappage direct |
x-client-agent-type |
observer.application |
Mappage direct |
os_version |
observer.platform_version |
Mappage direct |
product_data.x-client-agent-sw |
observer.platform_version |
Mappage direct |
x-client-agent-sw |
observer.platform_version |
Mappage direct |
user_domain |
principal.administrative_domain |
Mappage direct |
hostname |
principal.asset.hostname |
Mappage direct |
c-ip |
principal.asset.ip |
Fusionné |
c_ip |
principal.asset.ip |
Fusionné |
collector_device_ip |
principal.asset.ip |
Fusionné |
connection.src_ip |
principal.asset.ip |
Fusionné |
src_ip |
principal.asset.ip |
Fusionné |
x-sr-vpop-ip |
principal.asset.ip |
Fusionné |
x-client-os |
principal.asset.platform_software.platform |
Mappé : Windows → WINDOWS |
hostname |
principal.hostname |
Mappage direct |
c-ip |
principal.ip |
Fusionné |
c_ip |
principal.ip |
Fusionné |
collector_device_ip |
principal.ip |
Fusionné |
connection.src_ip |
principal.ip |
Fusionné |
src_ip |
principal.ip |
Fusionné |
x-sr-vpop-ip |
principal.ip |
Fusionné |
product_data.r-supplier-country |
principal.location.country_or_region |
Mappage direct |
r-supplier-country |
principal.location.country_or_region |
Mappage direct |
supplier_country |
principal.location.country_or_region |
Mappage direct |
src_port |
principal.port |
Renommé/Mappé |
x-client-device-id |
principal.resource.product_object_id |
Mappage direct |
user.name |
principal.user.user_display_name |
Mappage direct |
user_name |
principal.user.user_display_name |
Mappage direct |
cs-userdn |
principal.user.userid |
Mappage direct |
security_result_action |
security_result.action |
Fusionné |
filter_result |
security_result.action_details |
Mappage direct |
result |
security_result.action_details |
Mappage direct |
rs_icap_status |
security_result.action_details |
Mappage direct |
category_details |
security_result.category_details |
Fusionné |
cs-categories |
security_result.category_details |
Fusionné |
cs-icap-status |
security_result.description |
Mappage direct |
cs_icap_status |
security_result.description |
Mappage direct |
product_data.cs-icap-status |
security_result.description |
Mappage direct |
additional_x_tenant_id |
security_result.detection_fields |
Fusionné |
architecture_label |
security_result.detection_fields |
Fusionné |
content_type_label |
security_result.detection_fields |
Fusionné |
risk_groups_label |
security_result.detection_fields |
Fusionné |
rs_negotiated_cipher_size_label |
security_result.detection_fields |
Fusionné |
verdict_label |
security_result.detection_fields |
Fusionné |
x_bluecoat_access_type_label |
security_result.detection_fields |
Fusionné |
x_bluecoat_application_operation_label |
security_result.detection_fields |
Fusionné |
x_cs_connection_negotiated_cipher_size_label |
security_result.detection_fields |
Fusionné |
x_data_leak_detected |
security_result.detection_fields |
Fusionné |
x_rs_certificate_hostname_threat_risk_label |
security_result.detection_fields |
Fusionné |
x_rs_connection_negotiated_cipher_label |
security_result.detection_fields |
Fusionné |
x_rs_connection_negotiated_cipher_size_label |
security_result.detection_fields |
Fusionné |
x_rs_connection_negotiated_ssl_version_label |
security_result.detection_fields |
Fusionné |
x_rs_ocsp_error_label |
security_result.detection_fields |
Fusionné |
x_x_virus_id_label |
security_result.detection_fields |
Fusionné |
rule_name1 |
security_result.rule_name |
Mappage direct |
severity_id |
security_result.severity |
Mappé : 1 , 2 → LOW, 3 , 4 → MEDIUM, 5 , 6 → HIGH |
product_data.x-exception-id |
security_result.summary |
Mappage direct |
device_name |
src.asset.hostname |
Mappage direct |
product_data.x-client-device-name |
src.asset.hostname |
Mappage direct |
x-client-device-name |
src.asset.hostname |
Mappage direct |
connection.src_ip |
src.asset.ip |
Fusionné |
device_name |
src.hostname |
Mappage direct |
product_data.x-client-device-name |
src.hostname |
Mappage direct |
x-client-device-name |
src.hostname |
Mappage direct |
connection.src_ip |
src.ip |
Fusionné |
product_data.x_bluecoat_application_name |
target.application |
Mappage direct |
target_application |
target.application |
Mappage direct |
x_bluecoat_application_name |
target.application |
Mappage direct |
connection.dst_name |
target.asset.hostname |
Mappage direct |
connection.url.host |
target.asset.hostname |
Mappage direct |
cs-host |
target.asset.hostname |
Mappage direct |
device_name |
target.asset.hostname |
Mappage direct |
connection.dst_ip |
target.asset.ip |
Fusionné |
s-ip |
target.asset.ip |
Fusionné |
target_ip |
target.asset.ip |
Fusionné |
os_name |
target.asset.platform_software.platform |
Mappé : Windows → WINDOWS, macOS → MAC |
os_ver |
target.asset.platform_software.platform_version |
Mappage direct |
connection.dst_name |
target.hostname |
Mappage direct |
connection.url.host |
target.hostname |
Mappage direct |
cs-host |
target.hostname |
Mappage direct |
device_name |
target.hostname |
Mappage direct |
connection.dst_ip |
target.ip |
Fusionné |
s-ip |
target.ip |
Fusionné |
target_ip |
target.ip |
Fusionné |
ip_geo_artifact_entry |
target.ip_geo_artifact |
Fusionné |
client_country |
target.location.country_or_region |
Mappage direct |
connection.dst_location.country |
target.location.country_or_region |
Mappage direct |
product_data.x-cs-client-ip-country |
target.location.country_or_region |
Mappage direct |
x-cs-client-ip-country |
target.location.country_or_region |
Mappage direct |
connection.dst_port |
target.port |
Renommé/Mappé |
cs-uri-port |
target.port |
Renommé/Mappé |
device_id |
target.resource.id |
Mappage direct |
product_data.x-client-device-id |
target.resource.id |
Mappage direct |
device_id |
target.resource.product_object_id |
Mappage direct |
product_data.x-client-device-id |
target.resource.product_object_id |
Mappage direct |
x_bluecoat_location_id |
target.resource.product_object_id |
Mappage direct |
connection.url.path |
target.url |
Mappage direct |
connection.url.text |
target.url |
Mappage direct |
target_url |
target.url |
Mappage direct |
uri_query |
target.url |
Mappage direct |
| N/A | metadata.event_type |
Constante : NETWORK_UNCATEGORIZED |
| N/A | metadata.product_event_type |
Constante : Security |
| N/A | metadata.vendor_name |
Constante : SYMANTEC |
| N/A | network.http.parsed_user_agent |
Constante : cs(user-agent)} |
| N/A | principal.asset.platform_software.platform |
Constante : WINDOWS |
| N/A | security_result.severity |
Constante : LOW |
| N/A | target.asset.platform_software.platform |
Constante : WINDOWS |
| N/A | target.resource.type |
Constante : DEVICE |
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.