Raccogli i log di Symantec Web Security Service (WSS)

Supportato in:

Questo documento spiega come importare i log di Symantec Web Security Service (WSS) in Google Security Operations utilizzando Google Cloud Storage. Il parser tenta innanzitutto di analizzare il messaggio di log come JSON. In caso contrario, utilizza una serie di pattern grok sempre più specifici per estrarre i campi dal testo non elaborato, mappando infine i dati estratti al modello Unified Data Model (UDM). Symantec Web Security Service (WSS) è una soluzione di sicurezza web basata sul cloud che fornisce protezione in tempo reale contro le minacce basate sul web, tra cui malware, phishing e perdita di dati.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto GCP con l'API Cloud Storage abilitata
  • Autorizzazioni per creare e gestire bucket GCS
  • Autorizzazioni per gestire le policy IAM nei bucket GCS
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Accesso privilegiato al portale Symantec Web Security Service

Raccogli le credenziali API di Symantec WSS

Ottieni l'URL del sito Symantec WSS

  1. Accedi al portale Symantec Web Security Service.
  2. Prendi nota dell'URL del portale dalla barra degli indirizzi del browser.
    • Formato: https://portal.threatpulse.com o URL specifico dell'organizzazione
    • Esempio: se accedi a WSS all'indirizzo https://portal.threatpulse.com/reportpod, l'URL del tuo sito è https://portal.threatpulse.com

Crea credenziali API

  1. Accedi al portale Symantec Web Security Service come amministratore.
  2. Vai a Account > Credenziali API.
  3. Fai clic su Aggiungi credenziali API.
  4. Il portale mostra la finestra di dialogo Aggiungi credenziali API con Nome utente e Password generati automaticamente.

  5. Copia e salva in modo sicuro il nome utente e la password.

  6. Seleziona l'opzione Scadenza API:

    • Basato sul tempo: definisci la data e l'ora di scadenza di questo token.
    • Non scade mai: il token rimane valido a tempo indeterminato (opzione consigliata per la produzione).

  7. Per l'opzione Accesso, seleziona Log di accesso ai report.

  8. Fai clic su Salva.

Verifica le autorizzazioni

Per verificare che l'account disponga delle autorizzazioni richieste:

  1. Accedi al portale Symantec Web Security Service.
  2. Vai a Account > Credenziali API.
  3. Se riesci a visualizzare le credenziali API che hai creato con Accesso impostato su Report sui log di accesso, disponi delle autorizzazioni richieste.
  4. Se non riesci a visualizzare questa opzione, contatta l'amministratore per concedere l'autorizzazione Accesso ai log dei report.

Testare l'accesso API

  • Testa le tue credenziali prima di procedere con l'integrazione:

    # 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"

Risposta prevista: HTTP 200 con dati di log o risposta vuota se non sono presenti log nell'intervallo di tempo.

Crea un bucket Google Cloud Storage

  1. Vai alla console Google Cloud.
  2. Seleziona il tuo progetto o creane uno nuovo.
  3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
  4. Fai clic su Crea bucket.

  5. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Assegna un nome al bucket Inserisci un nome univoco globale (ad esempio symantec-wss-logs).
    Tipo di località Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
    Località Seleziona la posizione (ad esempio, us-central1).
    Classe di archiviazione Standard (consigliato per i log a cui si accede di frequente)
    Controllo degli accessi Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione

  6. Fai clic su Crea.

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni di scrittura nel bucket GCS e di invocazione da parte di Pub/Sub.

Crea service account

  1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome service account: inserisci symantec-wss-collector-sa.
    • Descrizione del service account: inserisci Service account for Cloud Run function to collect Symantec WSS logs.
  4. Fai clic su Crea e continua.
  5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
    1. Fai clic su Seleziona un ruolo.
    2. Cerca e seleziona Storage Object Admin.
    3. Fai clic su + Aggiungi un altro ruolo.
    4. Cerca e seleziona Cloud Run Invoker.
    5. Fai clic su + Aggiungi un altro ruolo.
    6. Cerca e seleziona Cloud Functions Invoker.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono necessari per:

  • Storage Object Admin: scrive i log nel bucket GCS e gestisce i file di stato
  • Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
  • Cloud Functions Invoker: consente la chiamata di funzioni

Concedi autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni di scrittura sul bucket GCS:

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket.
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: inserisci l'email del account di servizio (ad esempio, symantec-wss-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Assegna i ruoli: seleziona Storage Object Admin.
  6. Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci symantec-wss-trigger.
    • Lascia invariate le altre impostazioni predefinite.
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run viene attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API Symantec WSS Sync e li scrive in GCS.

  1. Nella console Google Cloud, vai a Cloud Run.
  2. Fai clic su Crea servizio.
  3. Seleziona Funzione (utilizza un editor in linea per creare una funzione).

  4. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome servizio symantec-wss-collector
    Regione Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)
    Tempo di esecuzione Seleziona Python 3.12 o versioni successive.

  5. Nella sezione Trigger (facoltativo):

    1. Fai clic su + Aggiungi trigger.
    2. Seleziona Cloud Pub/Sub.
    3. In Seleziona un argomento Cloud Pub/Sub, scegli l'argomento Pub/Sub (symantec-wss-trigger).
    4. Fai clic su Salva.

  6. Nella sezione Autenticazione:

    1. Seleziona Richiedi autenticazione.
    2. Controlla Identity and Access Management (IAM).

  7. Scorri verso il basso ed espandi Container, networking, sicurezza.

  8. Vai alla scheda Sicurezza:

    • Service account: seleziona il account di servizio (symantec-wss-collector-sa).

  9. Vai alla scheda Container:

    1. Fai clic su Variabili e secret.
    2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:
    Nome variabile Valore di esempio Descrizione
    GCS_BUCKET symantec-wss-logs Nome bucket GCS
    GCS_PREFIX symantec/wss/ Prefisso per i file di log
    STATE_KEY symantec/wss/state.json Percorso file di stato
    WINDOW_SECONDS 3600 Finestra temporale in secondi (1 ora)
    HTTP_TIMEOUT 60 Timeout della richiesta HTTP in secondi
    MAX_RETRIES 3 Numero massimo di nuovi tentativi
    USER_AGENT symantec-wss-to-gcs/1.0 Stringa dello user agent
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync Endpoint API di sincronizzazione WSS
    WSS_API_USERNAME your-api-username (dalle credenziali API) Nome utente API WSS
    WSS_API_PASSWORD your-api-password (dalle credenziali API) Password API WSS
    WSS_TOKEN_PARAM none Parametro token per l'API Sync

  10. Nella sezione Variabili e secret, scorri fino a Richieste:

    • Timeout richiesta: inserisci 600 secondi (10 minuti).

  11. Vai alla scheda Impostazioni:

    • Nella sezione Risorse:
      • Memoria: seleziona 512 MiB o un valore superiore.
      • CPU: seleziona 1.

  12. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0.
    • Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).

  13. Fai clic su Crea.

  14. Attendi la creazione del servizio (1-2 minuti).

  15. Dopo aver creato il servizio, si apre automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

  1. Inserisci main in Entry point della funzione

  2. Nell'editor di codice incorporato, crea due file:

    • Primo file: 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
    • Secondo file: requirements.txt::
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

  4. Attendi il completamento del deployment (2-3 minuti).

Crea job Cloud Scheduler

Cloud Scheduler pubblica messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console Google Cloud, vai a Cloud Scheduler.
  2. Fai clic su Crea job.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome symantec-wss-collector-hourly
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza 0 * * * * (ogni ora, allo scoccare dell'ora)
    Fuso orario Seleziona il fuso orario (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona l'argomento Pub/Sub (symantec-wss-trigger).
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Opzioni di frequenza di pianificazione

  • Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

    Frequenza Espressione cron Caso d'uso
    Ogni 5 minuti */5 * * * * Volume elevato, bassa latenza
    Ogni 15 minuti */15 * * * * Volume medio
    Ogni ora 0 * * * * Standard (consigliato)
    Ogni 6 ore 0 */6 * * * Volume basso, elaborazione batch
    Ogni giorno 0 0 * * * Raccolta dei dati storici

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il tuo job.
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi alcuni secondi.
  4. Vai a Cloud Run > Servizi.
  5. Fai clic sul nome della funzione (symantec-wss-collector).
  6. Fai clic sulla scheda Log.

  7. Verifica che la funzione sia stata eseguita correttamente. Cerca quanto segue:

    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. Vai a Cloud Storage > Bucket.

  9. Fai clic sul nome del bucket.

  10. Vai alla cartella del prefisso (symantec/wss/).

  11. Verifica che sia stato creato un nuovo file con il timestamp attuale.

Se nei log vengono visualizzati errori:

  • HTTP 401: controlla le credenziali API nelle variabili di ambiente. Verifica che il nome utente e la password siano corretti.
  • HTTP 403: verifica che le credenziali API abbiano l'autorizzazione "Registri di accesso ai report" abilitata nel portale WSS.
  • HTTP 429: limitazione della frequenza: la funzione verrà ritentata automaticamente con backoff.
  • Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione della funzione Cloud Run.

Recuperare il account di servizio Google SecOps

Google SecOps utilizza un account di servizio univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo account di servizio l'accesso al tuo bucket.

Recupera l'email del account di servizio

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Symantec WSS logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Symantec WSS come Tipo di log.

  7. Fai clic su Ottieni service account. Viene visualizzata un'email del account di servizio univoca, ad esempio:

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

  8. Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel tuo bucket GCS.

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket.
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: incolla l'email del account di servizio Google SecOps.
    • Assegna ruoli: seleziona Visualizzatore oggetti Storage.

  6. Fai clic su Salva.

Configura un feed in Google SecOps per importare i log di Symantec WSS

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Symantec WSS logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Symantec WSS come Tipo di log.
  7. Fai clic su Avanti.

  8. Specifica i valori per i seguenti parametri di input:

    • URL del bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

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

      • Sostituisci:

        • symantec-wss-logs: il nome del bucket GCS.
        • symantec/wss/: (Facoltativo) prefisso/percorso della cartella in cui vengono archiviati i log (lascia vuoto per la radice).

      • Esempi:

        • Bucket radice: gs://company-logs/
        • Con prefisso: gs://company-logs/symantec-wss/
        • Con sottocartella: gs://company-logs/symantec/wss/

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
      • Elimina file trasferiti: elimina i file dopo il trasferimento riuscito.

      • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

  9. Fai clic su Avanti.

  10. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log mappatura UDM Logica
category_id read_only_udm.metadata.product_event_type Se category_id è 1, read_only_udm.metadata.product_event_type è impostato su Security. Se category_id è 5, read_only_udm.metadata.product_event_type è impostato su Policy
collector_device_ip read_only_udm.principal.ip, read_only_udm.principal.asset.ip Valore del campo collector_device_ip
connection.bytes_download read_only_udm.network.received_bytes Valore del campo connection.bytes_download convertito in numero intero
connection.bytes_upload read_only_udm.network.sent_bytes Valore del campo connection.bytes_upload convertito in numero intero
connection.dst_ip read_only_udm.target.ip Valore del campo connection.dst_ip
connection.dst_location.country read_only_udm.target.location.country_or_region Valore del campo connection.dst_location.country
connection.dst_name read_only_udm.target.hostname Valore del campo connection.dst_name
connection.dst_port read_only_udm.target.port Valore del campo connection.dst_port convertito in numero intero
connection.http_status read_only_udm.network.http.response_code Valore del campo connection.http_status convertito in numero intero
connection.http_user_agent read_only_udm.network.http.user_agent Campo Value of connection.http_user_agent
connection.src_ip read_only_udm.principal.ip, read_only_udm.src.ip Valore del campo connection.src_ip. Se src_ip o collector_device_ip non è vuoto, viene mappato a read_only_udm.src.ip
connection.tls.version read_only_udm.network.tls.version_protocol Valore del campo connection.tls.version
connection.url.host read_only_udm.target.hostname Valore del campo connection.url.host
connection.url.method read_only_udm.network.http.method Valore del campo connection.url.method
connection.url.path read_only_udm.target.url Valore del campo connection.url.path
connection.url.text read_only_udm.target.url Valore del campo connection.url.text
cs_connection_negotiated_cipher read_only_udm.network.tls.cipher Valore del campo cs_connection_negotiated_cipher
cs_icap_status read_only_udm.security_result.description Valore del campo cs_icap_status
device_id read_only_udm.target.resource.id, read_only_udm.target.resource.product_object_id Valore del campo device_id
device_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valore del campo device_ip
device_time read_only_udm.metadata.collected_timestamp, read_only_udm.metadata.event_timestamp Valore del campo device_time convertito in stringa. Se when è vuoto, viene mappato a read_only_udm.metadata.event_timestamp
nome host read_only_udm.principal.hostname, read_only_udm.principal.asset.hostname Valore del campo nome host
log_time read_only_udm.metadata.event_timestamp Valore del campo log_time convertito in timestamp. Se when e device_time sono vuoti, viene mappato a read_only_udm.metadata.event_timestamp
msg_desc read_only_udm.metadata.description Valore del campo msg_desc
os_details read_only_udm.target.asset.platform_software.platform, read_only_udm.target.asset.platform_software.platform_version Valore del campo os_details. Se os_details non è vuoto, viene analizzato per estrarre os_name e os_ver. Se os_name contiene Windows, read_only_udm.target.asset.platform_software.platform è impostato su WINDOWS. os_ver è mappato a read_only_udm.target.asset.platform_software.platform_version
product_data.cs(Referer) read_only_udm.network.http.referral_url Valore del campo product_data.cs(Referer)
product_data.r-supplier-country read_only_udm.principal.location.country_or_region Valore del campo product_data.r-supplier-country
product_data.s-supplier-ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valore del campo product_data.s-supplier-ip
product_data.x-bluecoat-application-name read_only_udm.target.application Valore del campo product_data.x-bluecoat-application-name
product_data.x-bluecoat-transaction-uuid read_only_udm.metadata.product_log_id Valore del campo product_data.x-bluecoat-transaction-uuid
product_data.x-client-agent-sw read_only_udm.observer.platform_version Valore del campo product_data.x-client-agent-sw
product_data.x-client-agent-type read_only_udm.observer.application Valore del campo 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 Se non è vuoto, read_only_udm.target.resource.type è impostato su DEVICE. Il valore del campo product_data.x-client-device-id viene mappato a read_only_udm.target.resource.id e 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 Valore del campo product_data.x-client-device-name
product_data.x-cs-client-ip-country read_only_udm.target.location.country_or_region Valore del campo product_data.x-cs-client-ip-country
product_data.x-cs-connection-negotiated-cipher read_only_udm.network.tls.cipher Valore del campo product_data.x-cs-connection-negotiated-cipher
product_data.x-cs-connection-negotiated-ssl-version read_only_udm.network.tls.version_protocol Valore del campo product_data.x-cs-connection-negotiated-ssl-version
product_data.x-exception-id read_only_udm.security_result.summary Valore del campo product_data.x-exception-id
product_data.x-rs-certificate-hostname read_only_udm.network.tls.client.server_name Valore del campo product_data.x-rs-certificate-hostname
product_data.x-rs-certificate-hostname-categories read_only_udm.security_result.category_details Valore del campo product_data.x-rs-certificate-hostname-categories
product_data.x-rs-certificate-observed-errors read_only_udm.network.tls.server.certificate.issuer Valore del campo product_data.x-rs-certificate-observed-errors
product_data.x-rs-certificate-validate-status read_only_udm.network.tls.server.certificate.subject Valore del campo product_data.x-rs-certificate-validate-status
product_name read_only_udm.metadata.product_name Valore del campo product_name
product_ver read_only_udm.metadata.product_version Valore del campo product_ver
proxy_connection.src_ip read_only_udm.intermediary.ip, read_only_udm.intermediary.asset.ip Valore del campo proxy_connection.src_ip
received_bytes read_only_udm.network.received_bytes Valore del campo received_bytes convertito in numero intero
ref_uid read_only_udm.metadata.product_log_id Valore del campo ref_uid
s_action read_only_udm.metadata.description Valore del campo s_action
sent_bytes read_only_udm.network.sent_bytes Valore del campo sent_bytes convertito in numero intero
severity_id read_only_udm.security_result.severity Se severity_id è 1 o 2, read_only_udm.security_result.severity è impostato su LOW. Se severity_id è 3 o 4, read_only_udm.security_result.severity è impostato su MEDIUM. Se severity_id è 5 o 6, read_only_udm.security_result.severity è impostato su HIGH
supplier_country read_only_udm.principal.location.country_or_region Valore del campo supplier_country
target_ip read_only_udm.target.ip, read_only_udm.target.asset.ip Valore del campo target_ip
user.full_name read_only_udm.principal.user.user_display_name Valore del campo user.full_name
nome.utente read_only_udm.principal.user.user_display_name Valore del campo user.name
user_name read_only_udm.principal.user.user_display_name Valore del campo user_name
uuid read_only_udm.metadata.product_log_id Valore del campo uuid
quando read_only_udm.metadata.event_timestamp Valore del campo Quando convertito in timestamp
read_only_udm.metadata.event_type Impostato su NETWORK_UNCATEGORIZED se hostname è vuoto e connection.dst_ip non è vuoto. Imposta SCAN_NETWORK se il nome host non è vuoto. Imposta su NETWORK_CONNECTION se has_principal e has_target sono true. Impostato su STATUS_UPDATE se has_principal è true e has_target è false. Impostato su GENERIC_EVENT se has_principal e has_target sono false
read_only_udm.metadata.log_type Impostato sempre su SYMANTEC_WSS
read_only_udm.metadata.vendor_name Impostato sempre su SYMANTEC
read_only_udm.security_result.action Imposta su ALLOW se product_data.sc-filter_result è OBSERVED o PROXIED. Imposta su BLOCK se product_data.sc-filter_result è DENIED
read_only_udm.security_result.action_details Valore del campo product_data.sc-filter_result
read_only_udm.target.resource.type Impostato su DEVICE se product_data.x-client-device-id non è vuoto
application_name" from "cs_uri_path target.application Mappato dal log delle modifiche
device_time" and "log_time metadata.event_timestamp Mappato dal log delle modifiche
device_name target.hostname Mappato dal log delle modifiche
product_data.x-client-device-id" and "device_id target.resource.product_object_id Mappato dal log delle modifiche
connection.protocol_version tls.version Mappato dal log delle modifiche

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.