Collecter les journaux Symantec Web Security Service (WSS)

Compatible avec :

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

  1. Connectez-vous au portail Symantec Web Security Service.
  2. Notez l'URL de votre portail dans la barre d'adresse du navigateur.
    • Format : https://portal.threatpulse.com ou l'URL spécifique à votre organisation
    • Exemple : Si vous accédez à WSS à l'adresse https://portal.threatpulse.com/reportpod, l'URL de votre site est https://portal.threatpulse.com.

Créer des identifiants d'API

  1. Connectez-vous au portail Symantec Web Security Service en tant qu'administrateur.
  2. Accédez à Compte > Identifiants de l'API.
  3. 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.
  4. Copiez et enregistrez le nom d'utilisateur et le mot de passe de manière sécurisée.

  5. 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).
  6. Pour l'option Accès, sélectionnez Journaux d'accès aux rapports.

  7. Cliquez sur Enregistrer.

Vérifier les autorisations

Pour vérifier que le compte dispose des autorisations requises :

  1. Connectez-vous au portail Symantec Web Security Service.
  2. Accédez à Compte > Identifiants de l'API.
  3. 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.
  4. 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: ... et X-sync-status: done (ou more).
  • Liste de fichiers .log.gz, par exemple cloud_<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

  1. Accédez à la consoleGoogle Cloud .
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
  4. Cliquez sur Créer un bucket.
  5. 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.
  6. 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

  1. Dans la consoleGoogle Cloud , accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. 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.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets Storage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. 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 :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. 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.
  6. 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.

  1. Dans la consoleGoogle Cloud , accédez à Pub/Sub > Sujets.
  2. Cliquez sur Créer un sujet.
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez symantec-wss-trigger.
    • Conservez les valeurs par défaut des autres paramètres.
  4. 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.

  1. Dans la consoleGoogle Cloud , accédez à Cloud Run.
  2. Cliquez sur Écrire une fonction.
  3. Dans la section Configurer, fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom du service symantec-wss-collector
    Ré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.
  4. Dans la section Déclencheur, cliquez sur Ajouter un déclencheur, puis sélectionnez Déclencheur Pub/Sub.

  5. 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.
  6. Cliquez sur Enregistrer le déclencheur.

  7. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Vérifiez Identity and Access Management (IAM).
  8. Accédez à Conteneurs, mise en réseau, sécurité et développez cette section.

  9. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service (symantec-wss-collector-sa).
  10. Accédez à l'onglet Conteneurs :

    1. Cliquez sur Variables et secrets.
    2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
    Nom de la variable Exemple de valeur Description
    GCS_BUCKET symantec-wss-logs Nom du bucket GCS
    GCS_PREFIX symantec/wss/ Préfixe des fichiers journaux
    STATE_KEY symantec-wss-state.json Chemin d'état, en dehors du préfixe du journal
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync Point de terminaison de l'API WSS Sync
    WSS_API_USERNAME your-api-username (à partir des identifiants de l'API) Nom d'utilisateur de l'API WSS
    WSS_API_PASSWORD your-api-password (à partir des identifiants de l'API) Mot de passe de l'API WSS
    INITIAL_LOOKBACK_HOURS 1 Nombre 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_MB 100 Taille maximale approximative d'une réponse de l'API Sync en Mo (1 à 2 560)
    HTTP_TIMEOUT 120 Délai avant expiration de la lecture HTTP en secondes
    MAX_RETRIES 3 Nombre maximal de nouvelles tentatives pour les erreurs réseau et les réponses HTTP 5xx
    RUN_BUDGET_SECONDS 480 Dé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_AGENT symantec-wss-to-gcs/2.0 Chaîne user-agent
  11. Dans la section Variables et secrets, accédez à Requêtes :

    • Délai avant expiration de la requête : saisissez 600 secondes (10 minutes).
  12. 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.
  13. 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.
  14. Cliquez sur Créer.

  15. Attendez que le service soit créé (une à deux minutes).

  16. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter le code de la fonction

  1. Saisissez main dans Point d'entrée de la fonction.
  2. 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.0
    
  3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

  4. 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.

  1. Dans la consoleGoogle Cloud , accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.
  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom symantec-wss-collector-hourly
    Ré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)
  4. 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

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Forcer l'exécution pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de votre fonction (symantec-wss-collector).
  6. Cliquez sur l'onglet Journaux.
  7. 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 files avec X-sync-status: more avant la ligne done finale.

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

  10. Accédez au dossier du préfixe (symantec/wss/).

  11. Vérifiez que de nouveaux fichiers .log.gz ont été créés, par exemple symantec/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_HOURS bas.
  • 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

  1. Accédez à Paramètres SIEM > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Symantec WSS logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Symantec WSS comme Type de journal.
  7. 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.com
    
  8. Copiez cette adresse e-mail. Vous en aurez besoin lors de la tâche suivante.

  9. Cliquez sur Suivant.

  10. 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.

  11. Cliquez sur Suivant.

  12. 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.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. 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.
  6. 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.