Collecter les journaux Symantec Web Security Service (WSS)

Compatible avec :

Ce document explique comment ingérer les journaux Symantec Web Security Service (WSS) dans Google Security Operations à l'aide de Google Cloud Storage. L'analyseur tente d'abord d'analyser le message de journal en tant que JSON. Si cela échoue, il utilise une série de modèles grok de plus en plus spécifiques pour extraire les champs du texte brut, en mappant finalement les données extraites au modèle de données unifié (UDM). Symantec Web Security Service (WSS) est une solution de sécurité Web basée dans le cloud qui offre une protection en temps réel contre les menaces sur le Web, y compris les logiciels malveillants, l'hameçonnage et la perte de données.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations pour créer et gérer des buckets GCS
  • Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des tâches 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 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 API.
  4. Le portail affiche la boîte de dialogue Ajouter un identifiant API avec un nom d'utilisateur et un mot de passe générés automatiquement.

  5. Copiez et enregistrez le nom d'utilisateur et le mot de passe en lieu sûr.

  6. 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).

  7. Pour l'option Accès, sélectionnez Journaux d'accès aux rapports.

  8. 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 pouvez voir les identifiants d'API que vous avez créés avec Accès défini 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 Accès aux journaux de 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"

# Test API access (note: sync endpoint requires time parameters)
curl -v -H "X-APIUsername: ${WSS_USERNAME}" \
  -H "X-APIPassword: ${WSS_PASSWORD}" \
  "${WSS_SYNC_URL}?startDate=0&endDate=1000&token=none"

Réponse attendue : HTTP 200 avec des données de journaux ou réponse vide si aucun journal n'est disponible dans la plage de temps.

Créer un bucket Google Cloud Storage

  1. Accédez à la console Google 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
    Nommer votre bucket Saisissez un nom unique (par exemple, symantec-wss-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions des 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 disposant des autorisations nécessaires pour écrire dans le bucket GCS et être appelée par Pub/Sub.

Créer un compte de service

  1. Dans la console GCP, 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 de l'espace de stockage.
    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 Storage : écrire des journaux dans le bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction
  • Demandeur Cloud Functions : autorise l'appel de fonctions

Accorder des autorisations IAM sur un bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

  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 auquel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Create topic (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 est déclenchée par les messages Pub/Sub de Cloud Scheduler pour extraire les journaux de l'API Symantec WSS Sync et les écrire dans GCS.

  1. Dans la console GCP, accédez à Cloud Run.
  2. Cliquez sur Créer un service.
  3. Sélectionnez Fonction (utilisez un éditeur intégré pour créer une fonction).

  4. 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 GCS (par exemple, us-central1).
    Runtime (durée d'exécution) Sélectionnez Python 3.12 ou version ultérieure.

  5. Dans la section Déclencheur (facultatif) :

    1. Cliquez sur + Ajouter un déclencheur.
    2. Sélectionnez Cloud Pub/Sub.
    3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet Pub/Sub (symantec-wss-trigger).
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

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

    • Compte de service : sélectionnez le compte de service (symantec-wss-collector-sa).

  9. 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'accès au fichier d'état
    WINDOW_SECONDS 3600 Période (en secondes) (1 heure)
    HTTP_TIMEOUT 60 Délai avant expiration de la requête HTTP (en secondes)
    MAX_RETRIES 3 Nombre maximal de nouvelles tentatives
    USER_AGENT symantec-wss-to-gcs/1.0 Chaîne user-agent
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync Point de terminaison de l'API de synchronisation WSS
    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
    WSS_TOKEN_PARAM none Paramètre de jeton pour l'API de synchronisation

  10. Dans la section Variables et secrets, faites défiler la page jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 600 secondes (10 minutes).

  11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.

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

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (1 à 2 minutes).

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

Ajouter un code de 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.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone
import uuid
import time

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=5.0, read=60.0),
    retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch logs from Symantec WSS Sync API and write to GCS.

    Args:
        cloud_event: CloudEvent object containing Pub/Sub message
    """

    # Get environment variables
    bucket_name = os.environ.get('GCS_BUCKET')
    prefix = os.environ.get('GCS_PREFIX', 'symantec/wss/')
    state_key = os.environ.get('STATE_KEY', 'symantec/wss/state.json')
    window_sec = int(os.environ.get('WINDOW_SECONDS', '3600'))
    http_timeout = int(os.environ.get('HTTP_TIMEOUT', '60'))
    max_retries = int(os.environ.get('MAX_RETRIES', '3'))
    user_agent = os.environ.get('USER_AGENT', 'symantec-wss-to-gcs/1.0')
    wss_sync_url = os.environ.get('WSS_SYNC_URL', 'https://portal.threatpulse.com/reportpod/logs/sync')
    api_username = os.environ.get('WSS_API_USERNAME')
    api_password = os.environ.get('WSS_API_PASSWORD')
    token_param = os.environ.get('WSS_TOKEN_PARAM', 'none')

    if not all([bucket_name, api_username, api_password]):
        print('Error: Missing required environment variables')
        return

    try:
        # Get GCS bucket
        bucket = storage_client.bucket(bucket_name)

        # Load state (last processed timestamp)
        state = load_state(bucket, state_key)
        now = datetime.now(timezone.utc).timestamp()
        from_ts = float(state.get('last_to_ts', now - window_sec))
        to_ts = now

        # Convert to milliseconds for WSS API
        start_ms = int(from_ts * 1000)
        end_ms = int(to_ts * 1000)

        print(f'Fetching Symantec WSS logs from {start_ms} to {end_ms}')

        # Fetch logs from WSS Sync API
        blob_data, content_type, content_encoding = fetch_wss_logs(
            wss_sync_url, api_username, api_password, token_param,
            start_ms, end_ms, user_agent, http_timeout, max_retries
        )

        print(f'Retrieved {len(blob_data)} bytes with content-type: {content_type}')
        if content_encoding:
            print(f'Content encoding: {content_encoding}')

        # Write to GCS
        if blob_data:
            blob_name = write_wss_data(
                bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts
            )
            print(f'Wrote logs to {blob_name}')

        # Update state
        save_state(bucket, state_key, {
            'last_to_ts': to_ts,
            'last_successful_run': now
        })

        print(f'Successfully processed logs up to {to_ts}')

    except Exception as e:
        print(f'Error processing logs: {str(e)}')
        raise

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: {str(e)}')
    return {}

def save_state(bucket, key, state):
    """Save state to GCS."""
    try:
        blob = bucket.blob(key)
        blob.upload_from_string(
            json.dumps(state, separators=(',', ':')),
            content_type='application/json'
        )
    except Exception as e:
        print(f'Warning: Could not save state: {str(e)}')

def fetch_wss_logs(sync_url, username, password, token, start_ms, end_ms, user_agent, timeout, max_retries):
    """Fetch logs from WSS Sync API with retry logic using custom HTTP headers."""
    params = f"startDate={start_ms}&endDate={end_ms}&token={token}"
    url = f"{sync_url}?{params}"

    attempt = 0
    backoff = 1.0

    while True:
        try:
            headers = {
                'User-Agent': user_agent,
                'X-APIUsername': username,
                'X-APIPassword': password
            }

            response = http.request('GET', url, headers=headers, timeout=timeout)

            # 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:
                content_type = response.headers.get('Content-Type', 'application/octet-stream')
                content_encoding = response.headers.get('Content-Encoding', '')
                return response.data, content_type, content_encoding
            else:
                raise Exception(f'HTTP {response.status}: {response.data.decode("utf-8", errors="ignore")}')

        except Exception as e:
            attempt += 1
            print(f'HTTP error on attempt {attempt}: {e}')
            if attempt > max_retries:
                raise
            # Exponential backoff with jitter
            time.sleep(min(60, 2 ** attempt) + (time.time() % 1))

def determine_extension(content_type, content_encoding):
    """Determine file extension based on content type and encoding."""
    if 'zip' in content_type.lower():
        return '.zip'
    if 'gzip' in content_type.lower() or content_encoding.lower() == 'gzip':
        return '.gz'
    if 'json' in content_type.lower():
        return '.json'
    if 'csv' in content_type.lower():
        return '.csv'
    return '.bin'

def write_wss_data(bucket, prefix, blob_data, content_type, content_encoding, from_ts, to_ts):
    """Write WSS data to GCS with unique key."""
    ts_path = datetime.fromtimestamp(to_ts, tz=timezone.utc).strftime('%Y/%m/%d')
    uniq = f"{int(time.time() * 1e6)}_{uuid.uuid4().hex[:8]}"
    ext = determine_extension(content_type, content_encoding)
    blob_name = f"{prefix}{ts_path}/symantec_wss_{int(from_ts)}_{int(to_ts)}_{uniq}{ext}"

    blob = bucket.blob(blob_name)
    blob.upload_from_string(
        blob_data,
        content_type=content_type
    )

    # Set metadata
    blob.metadata = {
        'source': 'symantec-wss',
        'from_timestamp': str(int(from_ts)),
        'to_timestamp': str(int(to_ts)),
        'content_encoding': content_encoding
    }
    blob.patch()

    return blob_name
    • 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 publie des messages sur le sujet Pub/Sub à intervalles réguliers, ce qui déclenche la fonction Cloud Run.

  1. Dans la console GCP, 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)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Topic 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 planification

  • 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 à faible volume
    Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Exécuter de force 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 s'est exécutée correctement. Recherchez les éléments suivants :

    Fetching Symantec WSS logs from [start_ms] to [end_ms]
Retrieved X bytes with content-type: [type]
Wrote logs to symantec/wss/YYYY/MM/DD/symantec_wss_[timestamps].[ext]
Successfully processed logs up to [timestamp]

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

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

  11. Vérifiez qu'un fichier a été créé avec le code temporel actuel.

Si vous constatez des erreurs 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 les identifiants de l'API disposent de l'autorisation "Reporting Access Logs" (Journaux d'accès aux rapports) dans le portail WSS.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un intervalle de temps.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  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 Obtenir un compte de service. Une adresse e-mail unique pour le compte de service s'affiche, par exemple :

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin du rôle Lecteur des objets Storage sur votre bucket GCS.

  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.
    • Attribuez des rôles : sélectionnez Lecteur des objets de l'espace de stockage.

  6. Cliquez sur Enregistrer.

Configurer un flux dans Google SecOps pour ingérer les journaux Symantec WSS

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  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 Suivant.

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

    • URL du bucket Storage : saisissez l'URI du bucket GCS avec le préfixe du chemin d'accès :

      gs://symantec-wss-logs/symantec/wss/

      • Remplacez :

        • symantec-wss-logs : nom de votre bucket GCS.
        • symantec/wss/ : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).

      • Exemples :

        • Bucket racine : gs://company-logs/
        • Avec préfixe : gs://company-logs/symantec-wss/
        • Avec un sous-dossier : gs://company-logs/symantec/wss/

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.

      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.

    • Espace de noms de l'élément : espace de noms de l'élément.

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ du journal Mappage UDM Logique
category_id read_only_udm.metadata.product_event_type Si category_id est défini sur 1, read_only_udm.metadata.product_event_type est défini sur "Security". Si category_id est défini sur 5, read_only_udm.metadata.product_event_type est défini sur "Policy" (Règlement).
collector_device_ip read_only_udm.principal.ip, read_only_udm.principal.asset.ip Valeur du champ collector_device_ip
connection.bytes_download read_only_udm.network.received_bytes Valeur du champ "connection.bytes_download" convertie en entier
connection.bytes_upload read_only_udm.network.sent_bytes Valeur du champ "connection.bytes_upload" convertie en entier
connection.dst_ip read_only_udm.target.ip Valeur du champ "connection.dst_ip"
connection.dst_location.country read_only_udm.target.location.country_or_region Valeur du champ connection.dst_location.country
connection.dst_name read_only_udm.target.hostname Valeur du champ "connection.dst_name"
connection.dst_port read_only_udm.target.port Valeur du champ connection.dst_port convertie en entier
connection.http_status read_only_udm.network.http.response_code Valeur du champ connection.http_status convertie en entier
connection.http_user_agent read_only_udm.network.http.user_agent Valeur du champ connection.http_user_agent
connection.src_ip read_only_udm.principal.ip, read_only_udm.src.ip Valeur du champ "connection.src_ip". Si src_ip ou collector_device_ip n'est pas vide, il est mappé sur read_only_udm.src.ip.
connection.tls.version read_only_udm.network.tls.version_protocol Valeur du champ "connection.tls.version"
connection.url.host read_only_udm.target.hostname Valeur du champ connection.url.host
connection.url.method read_only_udm.network.http.method Valeur du champ connection.url.method
connection.url.path read_only_udm.target.url Valeur du champ "connection.url.path"
connection.url.text read_only_udm.target.url Valeur du champ "connection.url.text"
cs_connection_negotiated_cipher read_only_udm.network.tls.cipher Valeur du champ cs_connection_negotiated_cipher
cs_icap_status read_only_udm.security_result.description Valeur du champ cs_icap_status
device_id read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id Valeur du champ device_id
device_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valeur du champ "device_ip"
device_time read_only_udm.metadata.collected_timestamp, read_only_udm.metadata.event_timestamp Valeur du champ device_time convertie en chaîne. Si "when" est vide, il est mappé sur read_only_udm.metadata.event_timestamp.
nom d'hôte read_only_udm.principal.hostname, read_only_udm.principal.asset.hostname Valeur du champ "Nom d'hôte"
log_time read_only_udm.metadata.event_timestamp La valeur du champ "log_time" a été convertie en code temporel. Si les champs "when" et "device_time" sont vides, ils sont mappés sur read_only_udm.metadata.event_timestamp.
msg_desc read_only_udm.metadata.description Valeur du champ msg_desc
os_details read_only_udm.target.asset.platform_software.platform, read_only_udm.target.asset.platform_software.platform_version Valeur du champ "os_details". Si os_details n'est pas vide, il est analysé pour extraire os_name et os_ver. Si os_name contient Windows, read_only_udm.target.asset.platform_software.platform est défini sur WINDOWS. os_ver est mappé sur read_only_udm.target.asset.platform_software.platform_version.
product_data.cs(Referer) read_only_udm.network.http.referral_url Valeur du champ product_data.cs(Referer)
product_data.r-supplier-country read_only_udm.principal.location.country_or_region Valeur du champ product_data.r-supplier-country
product_data.s-supplier-ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valeur du champ product_data.s-supplier-ip
product_data.x-bluecoat-application-name read_only_udm.target.application Valeur du champ product_data.x-bluecoat-application-name
product_data.x-bluecoat-transaction-uuid read_only_udm.metadata.product_log_id Valeur du champ product_data.x-bluecoat-transaction-uuid
product_data.x-client-agent-sw read_only_udm.observer.platform_version Valeur du champ product_data.x-client-agent-sw
product_data.x-client-agent-type read_only_udm.observer.application Valeur du champ product_data.x-client-agent-type
product_data.x-client-device-id read_only_udm.target.resource.type, read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id Si elle n'est pas vide, read_only_udm.target.resource.type est défini sur DEVICE. La valeur du champ product_data.x-client-device-id est mappée sur read_only_udm.target.resource.id et read_only_udm.target.resource.product_object_id.
product_data.x-client-device-name read_only_udm.src.hostname, read_only_udm.src.asset.hostname Valeur du champ product_data.x-client-device-name
product_data.x-cs-client-ip-country read_only_udm.target.location.country_or_region Valeur du champ product_data.x-cs-client-ip-country
product_data.x-cs-connection-negotiated-cipher read_only_udm.network.tls.cipher Valeur du champ product_data.x-cs-connection-negotiated-cipher
product_data.x-cs-connection-negotiated-ssl-version read_only_udm.network.tls.version_protocol Valeur du champ product_data.x-cs-connection-negotiated-ssl-version
product_data.x-exception-id read_only_udm.security_result.summary Valeur du champ product_data.x-exception-id
product_data.x-rs-certificate-hostname read_only_udm.network.tls.client.server_name Valeur du champ product_data.x-rs-certificate-hostname
product_data.x-rs-certificate-hostname-categories read_only_udm.security_result.category_details Valeur du champ product_data.x-rs-certificate-hostname-categories
product_data.x-rs-certificate-observed-errors read_only_udm.network.tls.server.certificate.issuer Valeur du champ product_data.x-rs-certificate-observed-errors
product_data.x-rs-certificate-validate-status read_only_udm.network.tls.server.certificate.subject Valeur du champ product_data.x-rs-certificate-validate-status
product_name read_only_udm.metadata.product_name Valeur du champ product_name
product_ver read_only_udm.metadata.product_version Valeur du champ product_ver
proxy_connection.src_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valeur du champ proxy_connection.src_ip
received_bytes read_only_udm.network.received_bytes Valeur du champ "received_bytes" convertie en entier
ref_uid read_only_udm.metadata.product_log_id Valeur du champ ref_uid
s_action read_only_udm.metadata.description Valeur du champ s_action
sent_bytes read_only_udm.network.sent_bytes Valeur du champ "sent_bytes" convertie en entier
severity_id read_only_udm.security_result.severity Si severity_id est défini sur 1 ou 2, read_only_udm.security_result.severity est défini sur "LOW". Si severity_id est défini sur 3 ou 4, read_only_udm.security_result.severity est défini sur "MEDIUM". Si severity_id est défini sur 5 ou 6, read_only_udm.security_result.severity est défini sur HIGH.
supplier_country read_only_udm.principal.location.country_or_region Valeur du champ "supplier_country"
target_ip read_only_udm.target.ip, read_only_udm.target.asset.ip Valeur du champ "target_ip"
user.full_name read_only_udm.principal.user.user_display_name Valeur du champ user.full_name
user.name read_only_udm.principal.user.user_display_name Valeur du champ "user.name"
user_name read_only_udm.principal.user.user_display_name Valeur du champ "user_name"
uuid read_only_udm.metadata.product_log_id Valeur du champ "uuid"
when read_only_udm.metadata.event_timestamp Valeur du champ "when" convertie en code temporel
read_only_udm.metadata.event_type Définissez sur NETWORK_UNCATEGORIZED si le nom d'hôte est vide et que connection.dst_ip n'est pas vide. Définissez sur SCAN_NETWORK si le nom d'hôte n'est pas vide. Définissez sur NETWORK_CONNECTION si has_principal et has_target sont définis sur "true". Définissez-le sur STATUS_UPDATE si has_principal est défini sur "true" et has_target sur "false". Définissez sur GENERIC_EVENT si has_principal et has_target sont définis sur "false".
read_only_udm.metadata.log_type Toujours défini sur SYMANTEC_WSS
read_only_udm.metadata.vendor_name Toujours défini sur SYMANTEC
read_only_udm.security_result.action Définissez sur ALLOW si product_data.sc-filter_result est défini sur OBSERVED ou PROXIED. Définissez sur BLOCK si product_data.sc-filter_result est défini sur DENIED.
read_only_udm.security_result.action_details Valeur du champ product_data.sc-filter_result
read_only_udm.target.resource.type Définissez sur DEVICE si product_data.x-client-device-id n'est pas vide.

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