Raccogliere i log di Symantec Web Security Service (WSS)

Supportato in:

Google secops SIEM

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. Se l'operazione non va a buon fine, 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 offre protezione in tempo reale contro le minacce basate sul web, tra cui malware, phishing e perdita di dati.

Prima di iniziare

Assicurati di disporre dei 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

Raccogliere le credenziali API di Symantec WSS

Recuperare l'URL del sito Symantec WSS

Accedi al portale Symantec Web Security Service.
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

Accedi al portale Symantec Web Security Service come amministratore.
Vai ad Account > Credenziali API.
Fai clic su Aggiungi credenziali API.
Il portale mostra la finestra di dialogo Aggiungi credenziale API con Nome utente e Password generati automaticamente.
Copia e salva in modo sicuro il nome utente e la password.

Nota: queste credenziali vengono visualizzate una sola volta. Se le perdi, dovrai generarne di nuove.
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).
Per l'opzione Accesso, seleziona Log di accesso ai report.
Fai clic su Salva.

Verifica le autorizzazioni

Per verificare che l'account disponga delle autorizzazioni richieste:

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

Testare l'accesso API

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

Creazione di un bucket Google Cloud Storage

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

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, doppia regione, più regioni)
Località	Seleziona la posizione (ad esempio, `us-central1`).
Classe di archiviazione	Standard (consigliato per i log a cui si accede di frequente)
Controllo dell'accesso	Uniforme (consigliato)
Strumenti di protezione	(Facoltativo) Attiva il controllo delle versioni degli oggetti o la policy di conservazione

Fai clic su Crea.

Crea un service account per la funzione Cloud Run

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

Crea service account

Nella console Google Cloud, vai a IAM e amministrazione > Service Accounts.
Fai clic su Crea service account.
Fornisci i seguenti dettagli di configurazione:
- Nome del service account: inserisci symantec-wss-collector-sa.
- Descrizione service account: inserisci Service account for Cloud Run function to collect Symantec WSS logs.
Fai clic su Crea e continua.
Nella sezione Concedi a questo service account l'accesso al progetto, aggiungi i seguenti ruoli:
1. Fai clic su Seleziona un ruolo.
2. Cerca e seleziona Amministratore oggetti di archiviazione.
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 Invoker di Cloud Functions.
Fai clic su Continua.
Fai clic su Fine.

Questi ruoli sono necessari per:

Amministratore oggetti Storage: 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 service account le autorizzazioni di scrittura sul bucket GCS:

Vai a Cloud Storage > Bucket.
Fai clic sul nome del bucket.
Vai alla scheda Autorizzazioni.
Fai clic su Concedi l'accesso.
Fornisci i seguenti dettagli di configurazione:
- Aggiungi entità: inserisci l'email del service account (ad es. symantec-wss-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Assegna i ruoli: seleziona Storage Object Admin.
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à.

Nella console GCP, vai a Pub/Sub > Argomenti.
Fai clic su Crea argomento.
Fornisci i seguenti dettagli di configurazione:
- ID argomento: inserisci symantec-wss-trigger.
- Lascia le altre impostazioni sui valori predefiniti.
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.

Nella console GCP, vai a Cloud Run.
Fai clic su Crea servizio.
Seleziona Funzione (usa un editor in linea per creare una funzione).

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`)
Runtime	Seleziona Python 3.12 o versioni successive

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.
Nella sezione Autenticazione:
1. Seleziona Richiedi autenticazione.
2. Controlla Identity and Access Management (IAM).
Nota: Pub/Sub gestisce automaticamente l'autenticazione quando richiama la funzione.
Scorri verso il basso ed espandi Container, networking, sicurezza.
Vai alla scheda Sicurezza:
- Service account: seleziona il service account (symantec-wss-collector-sa).

Vai alla scheda Container:

Fai clic su Variabili e secret.
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 richiesta HTTP in secondi
`MAX_RETRIES`	`3`	Numero massimo di nuovi tentativi
`USER_AGENT`	`symantec-wss-to-gcs/1.0`	Stringa 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 di sincronizzazione

Nella sezione Variabili e secret, scorri fino a Richieste:
- Timeout richiesta: inserisci 600 secondi (10 minuti).
Vai alla scheda Impostazioni:
- Nella sezione Risorse:
  - Memoria: seleziona 512 MiB o un valore superiore.
  - CPU: seleziona 1.
Nella sezione Scalabilità della revisione:
- Numero minimo di istanze: inserisci 0.
- Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).
Fai clic su Crea.
Attendi la creazione del servizio (1-2 minuti).
Dopo aver creato il servizio, si apre automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

Inserisci main in Entry point della funzione

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

Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.
Attendi il completamento del deployment (2-3 minuti).

Nota :la configurazione del trigger Pub/Sub crea automaticamente le sottoscrizioni e le autorizzazioni necessarie.

Crea job Cloud Scheduler

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

Nella console di GCP, vai a Cloud Scheduler.
Fai clic su Crea job.

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, all'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)

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

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

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]

Vai a Cloud Storage > Bucket.
Fai clic sul nome del bucket.
Vai alla cartella del prefisso (symantec/wss/).
Verifica che sia stato creato un nuovo file con il timestamp corrente.

Se visualizzi errori nei log:

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 eseguirà automaticamente un nuovo tentativo con backoff.
Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione della funzione Cloud Run.

Recuperare il service account Google SecOps

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

Recuperare l'email del service account

Vai a Impostazioni SIEM > Feed.
Fai clic su Aggiungi nuovo feed.
Fai clic su Configura un singolo feed.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Symantec WSS logs).
Seleziona Google Cloud Storage V2 come Tipo di origine.
Seleziona Symantec WSS come tipo di log.
Fai clic su Ottieni service account. Viene visualizzata un'email del service account univoca, ad esempio:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

Nota: ogni istanza di Google SecOps ha un service account univoco. Non utilizzare service account di altre documentazioni o esempi.

Concedi le autorizzazioni IAM al service account Google SecOps

Il service account Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel bucket GCS.

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

Nota: se prevedi di utilizzare l'opzione di eliminazione "Elimina i file trasferiti" o "Elimina i file trasferiti e le directory vuote", assegna il ruolo Storage Object Admin anziché Storage Object Viewer.

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

Vai a Impostazioni SIEM > Feed.
Fai clic su Aggiungi nuovo feed.
Fai clic su Configura un singolo feed.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Symantec WSS logs).
Seleziona Google Cloud Storage V2 come Tipo di origine.
Seleziona Symantec WSS come tipo di log.
Fai clic su Avanti.
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/
    Nota: includi sempre la barra finale (/) alla fine dell'URI.
- 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.
    
    Nota :se selezioni un'opzione di eliminazione, il service account deve disporre del ruolo Storage Object Admin anziché di Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.
- Età massima del 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.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Funzione 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	Valore del campo 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
user.name	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 convertito in timestamp
read_only_udm.metadata.event_type		Impostato su NETWORK_UNCATEGORIZED se il nome host è vuoto e connection.dst_ip non è vuoto. Impostato su SCAN_NETWORK se il nome host non è vuoto. Impostato 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

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