Raccogli i log di Symantec Web Security Service (WSS)

Supportata in:

Questo documento spiega come importare i log di Symantec Web Security Service (WSS) in Google Security Operations utilizzando Cloud Storage. Il parser tenta innanzitutto di analizzare il messaggio di log come JSON. Se l'operazione non riesce, 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 su 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 Google Cloud con l'API Cloud Storage abilitata
  • Autorizzazioni per creare e gestire i bucket Cloud Storage
  • Autorizzazioni per gestire le policy di Identity and Access Management (IAM) sui bucket Cloud Storage
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Accesso con privilegi 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 l'URL specifico della tua 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 di Symantec Web Security Service come amministratore.
  2. Vai ad Account > Credenziali API.
  3. Fai clic su Aggiungi credenziali API. Il portale visualizza la finestra di dialogo Aggiungi credenziale API con Nome utente e Password generati automaticamente.

  4. Copia e salva in modo sicuro il Nome utente e la Password.

  5. Seleziona l'opzione Scadenza API:

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

  6. Per l'opzione Accesso, seleziona Accesso ai log dei report.

  7. 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 ad Account > Credenziali API.
  3. Se riesci a visualizzare le credenziali API che hai creato con l'opzione Accesso impostata su Log di accesso ai report, disponi delle autorizzazioni necessarie.
  4. Se non riesci a visualizzare questa opzione, contatta l'amministratore per concedere l'autorizzazione Reporting Access Logs.

Testa l'accesso all'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"

# startDate must be within the last 7 days. This requests logs from the start of the current hour.
START_MS=$(( $(date +%s) / 3600 * 3600 * 1000 ))

curl -sS -o wss-test.zip -w "HTTP %{http_code}\n" \
  -H "X-APIUsername: ${WSS_USERNAME}" \
  -H "X-APIPassword: ${WSS_PASSWORD}" \
  "${WSS_SYNC_URL}?token=none&startDate=${START_MS}&maxmb=10"

# The sync status is appended to the end of the response, after the ZIP data
tail -c 300 wss-test.zip | strings | grep -i "X-sync"

# List the log files in the archive
unzip -l wss-test.zip

Risultato previsto:

  • HTTP 200.
  • Due linee X-sync-token: ... e X-sync-status: done (o more).
  • Un elenco di file .log.gz, ad esempio cloud_<tenant_ID>_<timestamp>.log.gz. L'elenco è vuoto se non sono ancora presenti log per l'ora corrente.

Crea un bucket Cloud Storage

  1. Vai alla consoleGoogle 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 globalmente univoco (ad esempio symantec-wss-logs)
    Tipo di località Scegli in base alle tue esigenze (Regione, a due regioni, multiregionale)
    Località Seleziona la località (ad esempio us-central1)
    Classe di archiviazione Standard (consigliato per i log ad accesso 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 ha bisogno di un account di servizio con le autorizzazioni per scrivere nel bucket Cloud Storage ed essere richiamata da Pub/Sub.

Crea il account di servizio

  1. Nella consoleGoogle Cloud , vai a IAM e amministrazione > Account di servizio.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome service account: inserisci symantec-wss-collector-sa.
    • Descrizione 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 obbligatori per:

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

Concedi le autorizzazioni IAM sul bucket Cloud Storage

Concedi al account di servizio le autorizzazioni in scrittura sul bucket Cloud Storage:

  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'indirizzo 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 un argomento Pub/Sub

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

  1. Nella consoleGoogle 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 verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API Symantec WSS Sync e scriverli in Cloud Storage.

L'API Sync restituisce un file ZIP di file di log compressi con gzip. La funzione estrae l'archivio e scrive ogni file .log.gz nel bucket come oggetto separato, perché il feed non può leggere i file di log all'interno di un file ZIP. La funzione archivia il token di sincronizzazione restituito dall'API in un file di stato, in modo che ogni esecuzione continui esattamente dal punto in cui si era interrotta l'esecuzione precedente.

  1. Nella console Google Cloud , vai a Cloud Run.
  2. Fai clic su Scrivi una funzione.

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

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

  4. Nella sezione Trigger, fai clic su Aggiungi trigger e seleziona Trigger Pub/Sub.

  5. Nel riquadro Trigger Eventarc, fornisci i seguenti dettagli di configurazione:

    • Nome trigger: mantieni il nome generato o inserisci un nome per il trigger.
    • Tipo di trigger: seleziona Origini Google.
    • Provider di eventi: seleziona Pub/Sub.
    • Tipo di evento: seleziona google.cloud.pubsub.topic.v1.messagePublished.
    • Seleziona un argomento Cloud Pub/Sub: scegli l'argomento symantec-wss-trigger.
    • Regione: seleziona la stessa regione della funzione.
    • Service account: seleziona il account di servizio symantec-wss-collector-sa.

  6. Fai clic su Salva trigger.

  7. Nella sezione Autenticazione:

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

  8. Vai a Container, networking, sicurezza ed espandi la sezione.

  9. Vai alla scheda Sicurezza:

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

  10. 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 dello stato, al di fuori del prefisso del log
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync Endpoint API WSS Sync
    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
    INITIAL_LOOKBACK_HOURS 1 Ore di log da raccogliere alla prima esecuzione (massimo 167, perché l'API Sync restituisce al massimo gli ultimi 7 giorni)
    WSS_MAX_MB 100 Dimensione massima approssimativa di una risposta dell'API Sync in MB (da 1 a 2560)
    HTTP_TIMEOUT 120 Timeout di lettura HTTP in secondi
    MAX_RETRIES 3 Numero massimo di tentativi di ripetizione per errori di rete e risposte HTTP 5xx
    RUN_BUDGET_SECONDS 480 Tempo dopo il quale la funzione interrompe la richiesta di nuove pagine; mantienilo al di sotto del timeout della richiesta
    USER_AGENT symantec-wss-to-gcs/2.0 Stringa dello user agent

  11. Nella sezione Variabili e secret, vai a Richieste:

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

  12. Vai alla scheda Impostazioni:

    • Nella sezione Risorse:
      • Memoria: seleziona 1 GiB o un valore superiore. La funzione conserva in memoria una risposta dell'API Sync (fino a WSS_MAX_MB) durante l'estrazione.
      • CPU: seleziona 1.

  13. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0.
    • Numero massimo di istanze: inserisci 1. L'API Sync consente un client per token di sincronizzazione, pertanto le esecuzioni non devono sovrapporsi.

  14. Fai clic su Crea.

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

  16. Dopo aver creato il servizio, l'editor di codice incorporato si aprirà automaticamente.

Aggiungi il 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.api_core import exceptions as gcs_exceptions
from google.cloud import storage
import io
import json
import os
import re
import time
import uuid
import zipfile
from datetime import datetime, timedelta, timezone
from urllib.parse import urlencode
import urllib3

http = urllib3.PoolManager(retries=False)
storage_client = storage.Client()

# The Sync API returns a ZIP archive of gzipped ELFF files followed by a
# plain-text footer with the X-sync-token and X-sync-status lines.
ZIP_SIGNATURES = (b'PK\x03\x04', b'PK\x05\x06')  # archive with files, empty archive
FOOTER_SCAN_BYTES = 4096
TOKEN_RE = re.compile(rb'X-sync-token:\s*(\S+)', re.IGNORECASE)
STATUS_RE = re.compile(rb'X-sync-status:\s*(\S+)', re.IGNORECASE)
MAX_LOOKBACK = timedelta(days=7)
THROTTLE_WAIT_SECONDS = 60
MIN_SECONDS_PER_REQUEST = 120

class SyncApiError(Exception):
    """The Sync API returned a response that must not be processed."""

class TokenExpired(Exception):
    """The Sync API rejected the saved token (HTTP 410)."""

@functions_framework.cloud_event
def main(cloud_event):
    """Fetch Symantec WSS access logs from the Sync API and write them to GCS."""
    bucket_name = os.environ['GCS_BUCKET']
    prefix = os.environ.get('GCS_PREFIX', 'symantec/wss/')
    state_key = os.environ.get('STATE_KEY', 'symantec-wss-state.json')
    sync_url = os.environ.get('WSS_SYNC_URL', 'https://portal.threatpulse.com/reportpod/logs/sync')
    username = os.environ['WSS_API_USERNAME']
    password = os.environ['WSS_API_PASSWORD']
    lookback_hours = int(os.environ.get('INITIAL_LOOKBACK_HOURS', '1'))
    max_mb = int(os.environ.get('WSS_MAX_MB', '100'))
    http_timeout = int(os.environ.get('HTTP_TIMEOUT', '120'))
    max_retries = int(os.environ.get('MAX_RETRIES', '3'))
    run_budget = int(os.environ.get('RUN_BUDGET_SECONDS', '480'))
    user_agent = os.environ.get('USER_AGENT', 'symantec-wss-to-gcs/2.0')

    bucket = storage_client.bucket(bucket_name)
    state, generation = load_state(bucket, state_key)
    deadline = time.monotonic() + run_budget

    while time.monotonic() + MIN_SECONDS_PER_REQUEST <= deadline:
        token = state.get('token') or 'none'
        params = {'token': token, 'maxmb': max_mb}
        if token == 'none':
            params['startDate'] = initial_start_ms(state, lookback_hours)
        requested_at = datetime.now(timezone.utc)

        try:
            body = fetch_page(sync_url, params, username, password, user_agent,
                              http_timeout, max_retries, deadline)
        except TokenExpired:
            # Restart the sync from the hour of the last successful page.
            # Events from that hour can be ingested again.
            print('Sync token expired (HTTP 410). Restarting with token=none.')
            state['token'] = None
            generation = save_state(bucket, state_key, state, generation)
            continue
        if body is None:
            print('Sync API is throttling requests. The next run continues from the saved token.')
            return

        archive, next_token, status = split_footer(body)
        if status not in ('more', 'done'):
            raise SyncApiError(
                f'X-sync-status is {status!r}. The data was discarded; the next run retries token {token!r}.')

        written = write_archive(bucket, prefix, archive)
        state.update({
            'token': next_token,
            'last_status': status,
            'last_success': requested_at.isoformat(),
        })
        # resume_ms is where a restart after an expired token begins: the
        # startDate of a new sync, then the hour of the last fully synced point.
        if token == 'none':
            state['resume_ms'] = params['startDate']
        if status == 'done':
            state['resume_ms'] = hour_floor_ms(requested_at)
        generation = save_state(bucket, state_key, state, generation)
        print(f'Wrote {len(written)} log files ({len(archive)} bytes), X-sync-status: {status}')

        if status == 'done':
            # The API expects at least 60 seconds before the next request.
            print('Sync is up to date.')
            return
        time.sleep(1)

    print('Run time budget reached. The next run continues from the saved token.')

def initial_start_ms(state, lookback_hours):
    """startDate for a token=none request: within the last 7 days, at an hour boundary."""
    now = datetime.now(timezone.utc)
    oldest_ms = hour_floor_ms(now - MAX_LOOKBACK) + 3600 * 1000
    start_ms = state.get('resume_ms') or hour_floor_ms(now - timedelta(hours=lookback_hours))
    return max(start_ms, oldest_ms)

def hour_floor_ms(dt):
    return int(dt.replace(minute=0, second=0, microsecond=0).timestamp() * 1000)

def fetch_page(sync_url, params, username, password, user_agent, timeout, max_retries, deadline):
    """Return the response body, None when throttled past the deadline, or raise."""
    url = f'{sync_url}?{urlencode(params)}'
    headers = {
        'User-Agent': user_agent,
        'X-APIUsername': username,
        'X-APIPassword': password,
    }
    failures = 0
    while True:
        try:
            response = http.request('GET', url, headers=headers,
                                    timeout=urllib3.Timeout(connect=10.0, read=timeout))
        except urllib3.exceptions.HTTPError as e:
            failures += 1
            if failures > max_retries:
                raise
            print(f'Request failed ({e}), retry {failures}/{max_retries}')
            time.sleep(min(30, 2 ** failures))
            continue

        if response.status == 200:
            return response.data
        if response.status == 410:
            raise TokenExpired()
        if response.status in (423, 429):
            # 423: another request with this token is in progress. 429: throttled.
            wait = retry_after_seconds(response)
            if time.monotonic() + wait + MIN_SECONDS_PER_REQUEST > deadline:
                return None
            print(f'HTTP {response.status}, waiting {wait}s')
            time.sleep(wait)
            continue
        if response.status >= 500:
            failures += 1
            if failures <= max_retries:
                print(f'HTTP {response.status}, retry {failures}/{max_retries} with the same token')
                time.sleep(min(30, 2 ** failures))
                continue
        detail = response.data[:500].decode('utf-8', errors='replace')
        raise SyncApiError(f'HTTP {response.status}: {detail}')

def retry_after_seconds(response):
    value = response.headers.get('Retry-After', '')
    return int(value) if value.isdigit() else THROTTLE_WAIT_SECONDS

def split_footer(body):
    """Split the response into the ZIP archive bytes, X-sync-token and X-sync-status."""
    tail_start = max(0, len(body) - FOOTER_SCAN_BYTES)
    tail = body[tail_start:]
    token_match = TOKEN_RE.search(tail)
    status_match = STATUS_RE.search(tail)
    if not token_match or not status_match:
        raise SyncApiError(
            f'Response of {len(body)} bytes has no X-sync-token/X-sync-status footer (incomplete download).')
    footer_start = tail_start + min(token_match.start(), status_match.start())
    token = token_match.group(1).decode('ascii')
    status = status_match.group(1).decode('ascii').lower()
    return body[:footer_start], token, status

def write_archive(bucket, prefix, archive):
    """Upload every file in the ZIP archive to GCS as a separate object."""
    if not archive:
        return []
    if not archive.startswith(ZIP_SIGNATURES):
        raise SyncApiError(f'Expected a ZIP archive, got bytes starting with {archive[:8]!r}')

    date_path = datetime.now(timezone.utc).strftime('%Y/%m/%d')
    batch_id = f'{int(time.time())}_{uuid.uuid4().hex[:8]}'
    written = []
    with zipfile.ZipFile(io.BytesIO(archive)) as zf:
        for member in zf.infolist():
            if member.is_dir():
                continue
            file_name = os.path.basename(member.filename)
            blob_name = f'{prefix}{date_path}/{batch_id}_{file_name}'
            content_type = 'application/gzip' if file_name.endswith('.gz') else 'text/plain'
            # if_generation_match=0 creates the object only if it does not exist,
            # which also makes the upload safe to retry.
            bucket.blob(blob_name).upload_from_string(
                zf.read(member), content_type=content_type, if_generation_match=0)
            written.append(blob_name)
    return written

def load_state(bucket, key):
    """Return the saved state and its object generation (0 if there is no state yet)."""
    blob = bucket.get_blob(key)
    if blob is None:
        return {}, 0
    return json.loads(blob.download_as_text()), blob.generation

def save_state(bucket, key, state, generation):
    """Save the state only if no other run changed it since it was loaded."""
    blob = bucket.blob(key)
    try:
        blob.upload_from_string(json.dumps(state), content_type='application/json',
                                if_generation_match=generation)
    except gcs_exceptions.PreconditionFailed:
        raise RuntimeError(f'{key} was changed by another run; stopping to avoid a token conflict.')
    return blob.generation

    • 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 un job Cloud Scheduler

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

  1. Nella consoleGoogle 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 (consigliato UTC)
    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 * * * Basso volume, elaborazione batch
Ogni giorno 0 0 * * * Raccolta dei dati storici

Testa 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:

    Wrote N log files (X bytes), X-sync-status: done
Sync is up to date.

    Se l'API Sync ha più dati di quelli che possono essere contenuti in una risposta, il log mostra diverse righe Wrote N log files con X-sync-status: more prima della riga done finale.

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic sul nome del bucket.

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

  11. Verifica che siano stati creati nuovi file .log.gz, ad esempio symantec/wss/YYYY/MM/DD/<run_ID>_cloud_<tenant_ID>_<timestamp>.log.gz. L'esecuzione non crea file se Symantec WSS non ha nuovi log.

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 "Reporting Access Logs" (Log di accesso ai report) abilitata nel portale WSS.
  • HTTP 400: la prima richiesta di una sincronizzazione ha utilizzato una data di inizio precedente a 7 giorni. Finale INITIAL_LOOKBACK_HOURS.
  • HTTP 409: troppe richieste hanno avviato una nuova sincronizzazione con token=none. Attendi 90 minuti prima della prossima corsa.
  • HTTP 423 o 429: un'altra richiesta è in corso o l'API Sync sta limitando le richieste. La funzione attende e riprova. Se l'attesa non rientra nel tempo di esecuzione, l'esecuzione successiva continua dal token salvato.
  • Token di sincronizzazione scaduto (HTTP 410): la funzione riavvia la sincronizzazione dall'ora dell'ultima sincronizzazione completata. Alcuni eventi di quell'ora possono essere importati di nuovo.
  • X-sync-status è "abort" o nessun piè di pagina X-sync-token/X-sync-status: la risposta era incompleta ed è stata ignorata. L'esecuzione successiva riprova con lo stesso token.
  • È previsto un file ZIP: l'API Sync ha restituito un elemento diverso da un archivio di log. Controlla la risposta con il test in Testa l'accesso all'API.
  • Modificato da un'altra esecuzione: due esecuzioni si sono sovrapposte. Imposta Numero massimo di istanze su 1.
  • KeyError per un nome di variabile: verifica che tutte le variabili di ambiente richieste siano impostate nella configurazione della funzione Cloud Run.

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 es. 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. Verrà visualizzato un indirizzo email univoco del account di servizio, ad esempio:

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

  8. Copia l'indirizzo email. Lo utilizzerai nel prossimo passaggio.

  9. Fai clic su Avanti.

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

    • URL bucket di archiviazione: inserisci l'URI del bucket Cloud Storage con il percorso del prefisso:
    gs://symantec-wss-logs/symantec/wss/

    • Sostituisci:

    • symantec-wss-logs: il nome del tuo bucket Cloud Storage.

    • symantec/wss/: prefisso o percorso della cartella facoltativo in cui sono archiviati i log (lascia vuoto per la directory principale).

    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:

      • Non eliminare mai i file: non eliminare mai i file dall'origine (opzione consigliata per i test).
      • Elimina i file trasferiti e le directory vuote: elimina i file e le directory vuote dall'origine dopo il completamento di un recupero riuscito.

    • Età massima del file: includi i file modificati negli ultimi 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.

  11. Fai clic su Avanti.

  12. Controlla la nuova configurazione del feed di notizie nella schermata Finalizza, quindi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps richiede due ruoli nel bucket Cloud Storage: Storage Object Viewer per leggere gli oggetti di log e un ruolo a livello di bucket per leggere i metadati del bucket.

  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'indirizzo email del account di servizio Google SecOps.
    • Assegna ruoli: seleziona entrambe le seguenti opzioni:
    • Storage Object Viewer: legge gli oggetti di log.
    • Storage Legacy Bucket Reader: legge i metadati del bucket. Se hai selezionato l'opzione di eliminazione Elimina i file trasferiti e le directory vuote, seleziona Storage Legacy Bucket Writer, che concede anche l'autorizzazione di eliminazione.

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
content_type_label additional.fields Unita
cs_uri_extension_label additional.fields Unita
cs_uri_path_label additional.fields Unita
hostname_categories_label additional.fields Unita
_intermediary intermediary Unita
msg_desc metadata.description Mappatura diretta
s_action metadata.description Mappatura diretta
device_time metadata.event_timestamp Analizzato come ISO8601
log_time metadata.event_timestamp Analizzato come UNIX_MS
timestamp metadata.event_timestamp Analizzato come UNIX
when metadata.event_timestamp Analizzato come MMM dd HH:mm:ss
has_principal metadata.event_type Mappatura: true → NETWORK_CONNECTION, true → STATUS_UPDATE
s-action metadata.product_event_type Mappatura diretta
product_data.x-bluecoat-transaction-uuid metadata.product_log_id Mappatura diretta
ref_uid metadata.product_log_id Mappatura diretta
uuid metadata.product_log_id Mappatura diretta
x-bluecoat-transaction-uuid metadata.product_log_id Mappatura diretta
product_name metadata.product_name Mappatura diretta
product_ver metadata.product_version Mappatura diretta
connection.url.scheme network.application_protocol Mappatura diretta
cs-uri-scheme network.application_protocol Mappatura: (?i)https → HTTPS
uri_scheme network.application_protocol Mappatura diretta
cs-version network.application_protocol_version Mappatura diretta
connection.url.method network.http.method Mappatura diretta
cs-method network.http.method Mappatura diretta
method network.http.method Mappatura diretta
cs_referer network.http.referral_url Mappatura diretta
connection.http_status network.http.response_code Rinominato/mappato
status network.http.response_code Mappatura diretta
connection.http_user_agent network.http.user_agent Mappatura diretta
cs(user-agent) network.http.user_agent Mappatura diretta
http_user_agent network.http.user_agent Mappatura diretta
connection.url.scheme network.ip_protocol Mappatura diretta
uri_scheme network.ip_protocol Mappatura diretta
connection.bytes_download network.received_bytes Rinominato/mappato
received_bytes network.received_bytes Rinominato/mappato
connection.bytes_upload network.sent_bytes Rinominato/mappato
sent_bytes network.sent_bytes Rinominato/mappato
time_taken network.session_duration.seconds Mappatura diretta
session_id network.session_id Mappatura diretta
cs_connection_negotiated_cipher network.tls.cipher Mappatura diretta
product_data.x-cs-connection-negotiated-cipher network.tls.cipher Mappatura diretta
x-cs-connection-negotiated-cipher network.tls.cipher Mappatura diretta
certificate_hostname network.tls.client.server_name Mappatura diretta
product_data.x-rs-certificate-hostname network.tls.client.server_name Mappatura diretta
x-rs-certificate-hostname network.tls.client.server_name Mappatura diretta
product_data.x-rs-certificate-observed-errors network.tls.server.certificate.issuer Mappatura diretta
x-rs-certificate-observed-errors network.tls.server.certificate.issuer Mappatura diretta
certificate_validate network.tls.server.certificate.subject Mappatura diretta
product_data.x-rs-certificate-validate-status network.tls.server.certificate.subject Mappatura diretta
x-rs-certificate-validate-status network.tls.server.certificate.subject Mappatura diretta
connection.tls.version network.tls.version_protocol Mappatura diretta
cs_ssl_version network.tls.version_protocol Mappatura diretta
product_data.x-cs-connection-negotiated-ssl-version network.tls.version_protocol Mappatura diretta
x-cs-connection-negotiated-ssl-version network.tls.version_protocol Mappatura diretta
agent_type observer.application Mappatura diretta
product_data.x-client-agent-type observer.application Mappatura diretta
x-client-agent-type observer.application Mappatura diretta
os_version observer.platform_version Mappatura diretta
product_data.x-client-agent-sw observer.platform_version Mappatura diretta
x-client-agent-sw observer.platform_version Mappatura diretta
user_domain principal.administrative_domain Mappatura diretta
hostname principal.asset.hostname Mappatura diretta
c-ip principal.asset.ip Unita
c_ip principal.asset.ip Unita
collector_device_ip principal.asset.ip Unita
connection.src_ip principal.asset.ip Unita
src_ip principal.asset.ip Unita
x-sr-vpop-ip principal.asset.ip Unita
x-client-os principal.asset.platform_software.platform Mappatura: Windows → WINDOWS
hostname principal.hostname Mappatura diretta
c-ip principal.ip Unita
c_ip principal.ip Unita
collector_device_ip principal.ip Unita
connection.src_ip principal.ip Unita
src_ip principal.ip Unita
x-sr-vpop-ip principal.ip Unita
product_data.r-supplier-country principal.location.country_or_region Mappatura diretta
r-supplier-country principal.location.country_or_region Mappatura diretta
supplier_country principal.location.country_or_region Mappatura diretta
src_port principal.port Rinominato/mappato
x-client-device-id principal.resource.product_object_id Mappatura diretta
user.name principal.user.user_display_name Mappatura diretta
user_name principal.user.user_display_name Mappatura diretta
cs-userdn principal.user.userid Mappatura diretta
security_result_action security_result.action Unita
filter_result security_result.action_details Mappatura diretta
result security_result.action_details Mappatura diretta
rs_icap_status security_result.action_details Mappatura diretta
category_details security_result.category_details Unita
cs-categories security_result.category_details Unita
cs-icap-status security_result.description Mappatura diretta
cs_icap_status security_result.description Mappatura diretta
product_data.cs-icap-status security_result.description Mappatura diretta
additional_x_tenant_id security_result.detection_fields Unita
architecture_label security_result.detection_fields Unita
content_type_label security_result.detection_fields Unita
risk_groups_label security_result.detection_fields Unita
rs_negotiated_cipher_size_label security_result.detection_fields Unita
verdict_label security_result.detection_fields Unita
x_bluecoat_access_type_label security_result.detection_fields Unita
x_bluecoat_application_operation_label security_result.detection_fields Unita
x_cs_connection_negotiated_cipher_size_label security_result.detection_fields Unita
x_data_leak_detected security_result.detection_fields Unita
x_rs_certificate_hostname_threat_risk_label security_result.detection_fields Unita
x_rs_connection_negotiated_cipher_label security_result.detection_fields Unita
x_rs_connection_negotiated_cipher_size_label security_result.detection_fields Unita
x_rs_connection_negotiated_ssl_version_label security_result.detection_fields Unita
x_rs_ocsp_error_label security_result.detection_fields Unita
x_x_virus_id_label security_result.detection_fields Unita
rule_name1 security_result.rule_name Mappatura diretta
severity_id security_result.severity Mapped: 1 , 2 → LOW, 3 , 4 → MEDIUM, 5 , 6 → HIGH
product_data.x-exception-id security_result.summary Mappatura diretta
device_name src.asset.hostname Mappatura diretta
product_data.x-client-device-name src.asset.hostname Mappatura diretta
x-client-device-name src.asset.hostname Mappatura diretta
connection.src_ip src.asset.ip Unita
device_name src.hostname Mappatura diretta
product_data.x-client-device-name src.hostname Mappatura diretta
x-client-device-name src.hostname Mappatura diretta
connection.src_ip src.ip Unita
product_data.x_bluecoat_application_name target.application Mappatura diretta
target_application target.application Mappatura diretta
x_bluecoat_application_name target.application Mappatura diretta
connection.dst_name target.asset.hostname Mappatura diretta
connection.url.host target.asset.hostname Mappatura diretta
cs-host target.asset.hostname Mappatura diretta
device_name target.asset.hostname Mappatura diretta
connection.dst_ip target.asset.ip Unita
s-ip target.asset.ip Unita
target_ip target.asset.ip Unita
os_name target.asset.platform_software.platform Mappatura: Windows → WINDOWS, macOS → MAC
os_ver target.asset.platform_software.platform_version Mappatura diretta
connection.dst_name target.hostname Mappatura diretta
connection.url.host target.hostname Mappatura diretta
cs-host target.hostname Mappatura diretta
device_name target.hostname Mappatura diretta
connection.dst_ip target.ip Unita
s-ip target.ip Unita
target_ip target.ip Unita
ip_geo_artifact_entry target.ip_geo_artifact Unita
client_country target.location.country_or_region Mappatura diretta
connection.dst_location.country target.location.country_or_region Mappatura diretta
product_data.x-cs-client-ip-country target.location.country_or_region Mappatura diretta
x-cs-client-ip-country target.location.country_or_region Mappatura diretta
connection.dst_port target.port Rinominato/mappato
cs-uri-port target.port Rinominato/mappato
device_id target.resource.id Mappatura diretta
product_data.x-client-device-id target.resource.id Mappatura diretta
device_id target.resource.product_object_id Mappatura diretta
product_data.x-client-device-id target.resource.product_object_id Mappatura diretta
x_bluecoat_location_id target.resource.product_object_id Mappatura diretta
connection.url.path target.url Mappatura diretta
connection.url.text target.url Mappatura diretta
target_url target.url Mappatura diretta
uri_query target.url Mappatura diretta
N/D metadata.event_type Costante: NETWORK_UNCATEGORIZED
N/D metadata.product_event_type Costante: Security
N/D metadata.vendor_name Costante: SYMANTEC
N/D network.http.parsed_user_agent Costante: cs(user-agent)}
N/D principal.asset.platform_software.platform Costante: WINDOWS
N/D security_result.severity Costante: LOW
N/D target.asset.platform_software.platform Costante: WINDOWS
N/D target.resource.type Costante: DEVICE

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.