Symantec Web Security Service (WSS)-Logs erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Symantec Web Security Service (WSS)-Logs mit Cloud Storage in Google Security Operations aufnehmen. Der Parser versucht zuerst, die Logeinträge als JSON zu parsen. Wenn das fehlschlägt, werden eine Reihe von immer spezifischeren Grok-Mustern verwendet, um Felder aus dem Rohtext zu extrahieren. Die extrahierten Daten werden dann dem Unified Data Model (UDM) zugeordnet. Symantec Web Security Service (WSS) ist eine cloudbasierte Websicherheitslösung, die Echtzeitschutz vor webbasierten Bedrohungen wie Malware, Phishing und Datenverlust bietet.

Hinweis

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Eine Google SecOps-Instanz
  • Ein Google Cloud -Projekt mit aktivierter Cloud Storage API
  • Berechtigungen zum Erstellen und Verwalten von Cloud Storage-Buckets
  • Berechtigungen zum Verwalten von IAM-Richtlinien (Identity and Access Management) für Cloud Storage-Buckets
  • Berechtigungen zum Erstellen von Cloud Run-Diensten, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Privilegierter Zugriff auf das Symantec Web Security Service-Portal

Symantec WSS API-Anmeldedaten erfassen

Symantec WSS-Website-URL abrufen

  1. Melden Sie sich im Symantec Web Security Service-Portal an.
  2. Notieren Sie sich die Portal-URL aus der Adressleiste des Browsers.
    • Format: https://portal.threatpulse.com oder Ihre organisationsspezifische URL
    • Beispiel: Wenn Sie unter https://portal.threatpulse.com/reportpod auf WSS zugreifen, lautet die URL Ihrer Website https://portal.threatpulse.com.

API-Anmeldedaten erstellen

  1. Melden Sie sich als Administrator im Symantec Web Security Service Portal an.
  2. Gehen Sie zu Konto > API-Anmeldedaten.
  3. Klicken Sie auf API-Anmeldedaten hinzufügen. Im Portal wird das Dialogfeld API-Anmeldedaten hinzufügen mit automatisch generiertem Nutzernamen und Passwort angezeigt.
  4. Kopieren und speichern Sie den Nutzernamen und das Passwort an einem sicheren Ort.

  5. Wählen Sie die Option API-Ablauf aus:

    • Zeitbasiert: Legen Sie das Datum und die Uhrzeit fest, zu der dieses Token abläuft.
    • Läuft nie ab: Das Token bleibt unbegrenzt gültig (für die Produktion empfohlen).
  6. Wählen Sie für die Option Zugriff die Option Zugriffsprotokolle für Berichte aus.

  7. Klicken Sie auf Speichern.

Berechtigungen prüfen

So prüfen Sie, ob das Konto die erforderlichen Berechtigungen hat:

  1. Melden Sie sich im Symantec Web Security Service Portal an.
  2. Gehen Sie zu Konto > API-Anmeldedaten.
  3. Wenn Sie die von Ihnen erstellten API-Anmeldedaten sehen können und Zugriff auf Zugriffslogs für die Berichterstellung festgelegt ist, haben Sie die erforderlichen Berechtigungen.
  4. Wenn diese Option nicht angezeigt wird, wenden Sie sich an Ihren Administrator, um die Berechtigung Berichterstellung für Zugriffsprotokolle zu erhalten.

API-Zugriff testen

  • Testen Sie Ihre Anmeldedaten, bevor Sie mit der Integration fortfahren:

    # 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
    

Erwartetes Ergebnis:

  • HTTP 200.
  • Zwei Linien X-sync-token: ... und X-sync-status: done (oder more).
  • Eine Liste von .log.gz-Dateien, z. B. cloud_<tenant_ID>_<timestamp>.log.gz. Die Liste ist leer, wenn es für die aktuelle Stunde noch keine Logs gibt.

Cloud Storage-Bucket erstellen

  1. Rufen Sie die Google Cloud Console auf.
  2. Wählen Sie Ihr Projekt aus oder erstellen Sie ein neues.
  3. Rufen Sie im Navigationsmenü Cloud Storage > Buckets auf.
  4. Klicken Sie auf Bucket erstellen.
  5. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Bucket benennen Geben Sie einen global eindeutigen Namen ein (z. B. symantec-wss-logs).
    Standorttyp Wählen Sie die Option, die am besten zu Ihren Anforderungen passt (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Standort aus (z. B. us-central1).
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffssteuerung Einheitlich (empfohlen)
    Schutztools Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren
  6. Klicken Sie auf Erstellen.

Dienstkonto für die Cloud Run-Funktion erstellen

Die Cloud Run-Funktion benötigt ein Dienstkonto mit Berechtigungen zum Schreiben in den Cloud Storage-Bucket und zum Aufrufen durch Pub/Sub.

Erstellen Sie das Dienstkonto:

  1. Rufen Sie in der Google Cloud Console die Seite IAM & Verwaltung > Dienstkonten auf.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Dienstkontoname: Geben Sie symantec-wss-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect Symantec WSS logs ein.
  4. Klicken Sie auf Erstellen und fortfahren.
  5. Fügen Sie im Abschnitt Diesem Dienstkonto Zugriff auf das Projekt erteilen die folgenden Rollen hinzu:
    1. Klicken Sie auf Rolle auswählen.
    2. Suchen Sie nach Storage Object Admin und wählen Sie die Rolle aus.
    3. Klicken Sie auf + Weitere Rolle hinzufügen.
    4. Suchen Sie nach Cloud Run Invoker und wählen Sie die Rolle aus.
    5. Klicken Sie auf + Weitere Rolle hinzufügen.
    6. Suchen Sie nach Cloud Functions-Aufrufer und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

Diese Rollen sind erforderlich für:

  • Storage-Objekt-Administrator: Schreibt Logs in den Cloud Storage-Bucket und verwaltet Statusdateien.
  • Cloud Run-Aufrufer: Ermöglicht Pub/Sub, die Funktion aufzurufen.
  • Cloud Functions-Invoker: Ermöglicht den Funktionsaufruf

IAM-Berechtigungen für den Cloud Storage-Bucket gewähren

Gewähren Sie dem Dienstkonto Schreibberechtigungen für den Cloud Storage-Bucket:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Geben Sie die E-Mail-Adresse des Dienstkontos ein (z. B. symantec-wss-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage Object Admin aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, in dem Cloud Scheduler Nachrichten veröffentlicht und das die Cloud Run-Funktion abonniert.

  1. Rufen Sie in der Google Cloud Console die Option Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie symantec-wss-trigger ein.
    • Übernehmen Sie die anderen Einstellungen.
  4. Klicken Sie auf Erstellen.

Cloud Run-Funktion zum Erfassen von Logs erstellen

Die Cloud Run-Funktion wird durch Pub/Sub-Nachrichten von Cloud Scheduler ausgelöst, um Logs von der Symantec WSS Sync API abzurufen und in Cloud Storage zu schreiben.

Die Sync API gibt ein ZIP-Archiv mit gzip-komprimierten Logdateien zurück. Die Funktion extrahiert das Archiv und schreibt jede .log.gz-Datei als separates Objekt in den Bucket, da der Feed keine Logdateien in einem ZIP-Archiv lesen kann. Die Funktion speichert das von der API zurückgegebene Synchronisierungstoken in einer Statusdatei, sodass jeder Durchlauf genau dort fortgesetzt wird, wo der vorherige Durchlauf beendet wurde.

  1. Rufen Sie in der Google Cloud Console Cloud Run auf.
  2. Klicken Sie auf Funktion schreiben.
  3. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname symantec-wss-collector
    Region Wählen Sie die Region aus, die Ihrem Cloud Storage-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.
  4. Klicken Sie im Bereich Trigger auf Trigger hinzufügen und wählen Sie Pub/Sub-Trigger aus.

  5. Geben Sie im Bereich Eventarc-Trigger die folgenden Konfigurationsdetails an:

    • Triggername: Behalten Sie den generierten Namen bei oder geben Sie einen Namen für den Trigger ein.
    • Triggertyp: Wählen Sie Google-Quellen aus.
    • Ereignisanbieter: Wählen Sie Pub/Sub aus.
    • Ereignistyp: Wählen Sie google.cloud.pubsub.topic.v1.messagePublished aus.
    • Cloud Pub/Sub-Thema auswählen: Wählen Sie das Thema symantec-wss-trigger aus.
    • Region: Wählen Sie dieselbe Region wie für die Funktion aus.
    • Dienstkonto: Wählen Sie das Dienstkonto symantec-wss-collector-sa aus.
  6. Klicken Sie auf Trigger speichern.

  7. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Prüfen Sie Identity and Access Management (IAM).
  8. Rufen Sie Container, Netzwerk, Sicherheit auf und maximieren Sie den Bereich.

  9. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie das Dienstkonto (symantec-wss-collector-sa) aus.
  10. Rufen Sie den Tab Container auf:

    1. Klicken Sie auf Variablen und Secrets.
    2. Klicken Sie für jede Umgebungsvariable auf + Variable hinzufügen:
    Variablenname Beispielwert Beschreibung
    GCS_BUCKET symantec-wss-logs Name des GCS-Buckets
    GCS_PREFIX symantec/wss/ Präfix für Logdateien
    STATE_KEY symantec-wss-state.json Zustandspfad, außerhalb des Logpräfixes
    WSS_SYNC_URL https://portal.threatpulse.com/reportpod/logs/sync WSS-Sync-API-Endpunkt
    WSS_API_USERNAME your-api-username (aus API-Anmeldedaten) WSS API-Nutzername
    WSS_API_PASSWORD your-api-password (aus API-Anmeldedaten) WSS-API-Passwort
    INITIAL_LOOKBACK_HOURS 1 Anzahl der Stunden, für die beim ersten Durchlauf Protokolle erfasst werden sollen (maximal 167, da die Sync API maximal die letzten 7 Tage zurückgibt)
    WSS_MAX_MB 100 Ungefähre maximale Größe einer Sync API-Antwort in MB (1 bis 2.560)
    HTTP_TIMEOUT 120 HTTP-Lesezeitlimit in Sekunden
    MAX_RETRIES 3 Maximale Anzahl von Wiederholungsversuchen bei Netzwerkfehlern und HTTP-5xx-Antworten
    RUN_BUDGET_SECONDS 480 Zeit, nach der die Funktion keine neuen Seiten mehr anfordert; sollte unter dem Zeitlimit für Anfragen liegen
    USER_AGENT symantec-wss-to-gcs/2.0 User-Agent-String
  11. Gehen Sie im Bereich Variablen und Secrets zu Anfragen:

    • Zeitüberschreitung bei Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.
  12. Rufen Sie den Tab Einstellungen auf:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 1 GiB oder höher aus. Die Funktion speichert eine Sync API-Antwort (bis zu WSS_MAX_MB) im Arbeitsspeicher, während sie sie extrahiert.
      • CPU: Wählen Sie 1 aus.
  13. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 1 ein. Die Sync API lässt nur einen Client pro Synchronisierungstoken zu. Die Ausführungen dürfen sich also nicht überschneiden.
  14. Klicken Sie auf Erstellen.

  15. Warten Sie ein bis zwei Minuten, bis der Dienst erstellt wurde.

  16. Nachdem der Dienst erstellt wurde, wird der Inline-Code-Editor automatisch geöffnet.

Funktionscode hinzufügen

  1. Geben Sie unter Funktionseinstiegspunkt den Wert main ein.
  2. Erstellen Sie im Inline-Code-Editor zwei Dateien:

    • Erste Datei: 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
    

    • Zweite Datei: requirements.txt:
    functions-framework==3.*
    google-cloud-storage==2.*
    urllib3>=2.0.0
    
  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema und löst so die Cloud Run-Funktion aus.

  1. Rufen Sie in der Google Cloud Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name symantec-wss-collector-hourly
    Region Wählen Sie dieselbe Region wie für die Cloud Run-Funktion aus.
    Frequenz 0 * * * * (stündlich zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema Wählen Sie das Pub/Sub-Thema (symantec-wss-trigger) aus.
    Inhalt der Nachricht {} (leeres JSON-Objekt)
  4. Klicken Sie auf Erstellen.

Optionen für die Häufigkeit des Zeitplans

Wählen Sie die Häufigkeit basierend auf dem Logvolumen und den Latenzanforderungen aus:

Häufigkeit Cron-Ausdruck Anwendungsfall
Alle 5 Minuten */5 * * * * Hohes Volumen, niedrige Latenz
Alle 15 Minuten */15 * * * * Mittleres Suchvolumen
Stündlich 0 * * * * Standard (empfohlen)
Alle 6 Stunden 0 */6 * * * Batchverarbeitung mit geringem Volumen
Täglich 0 0 * * * Erhebung von Verlaufsdaten

Integration testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job.
  2. Klicken Sie auf Ausführung erzwingen, um den Job manuell auszulösen.
  3. Warte einige Sekunden.
  4. Rufen Sie Cloud Run > Dienste auf.
  5. Klicken Sie auf den Namen Ihrer Funktion (symantec-wss-collector).
  6. Klicken Sie auf den Tab Logs.
  7. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde. Achte dabei auf Folgendes:

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

    Wenn die Sync API mehr Daten enthält, als in eine Antwort passen, werden im Protokoll mehrere Wrote N log files-Zeilen mit X-sync-status: more vor dem letzten done angezeigt.

  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf den Namen Ihres Buckets.

  10. Rufen Sie den Präfixordner (symantec/wss/) auf.

  11. Prüfen Sie, ob neue .log.gz-Dateien erstellt wurden, z. B. symantec/wss/YYYY/MM/DD/<run_ID>_cloud_<tenant_ID>_<timestamp>.log.gz. Wenn Symantec WSS keine neuen Logs enthält, werden bei der Ausführung keine Dateien erstellt.

Wenn Sie Fehler in den Logs sehen:

  • HTTP 401: Prüfen Sie die API-Anmeldedaten in den Umgebungsvariablen. Prüfen Sie, ob Nutzername und Passwort korrekt sind.
  • HTTP 403: Prüfen Sie, ob für die API-Anmeldedaten im WSS-Portal die Berechtigung „Reporting Access Logs“ aktiviert ist.
  • HTTP 400: Für die erste Anfrage einer Synchronisierung wurde ein Startdatum verwendet, das älter als 7 Tage ist. INITIAL_LOOKBACK_HOURS niedriger.
  • HTTP 409: Zu viele Anfragen haben eine neue Synchronisierung mit token=none gestartet. Warten Sie 90 Minuten, bevor Sie den nächsten Lauf starten.
  • HTTP 423 oder 429: Eine andere Anfrage wird gerade verarbeitet oder die Sync API drosselt Anfragen. Die Funktion wartet und versucht es noch einmal. Wenn die Wartezeit nicht in die Laufzeit passt, wird die nächste Ausführung ab dem gespeicherten Token fortgesetzt.
  • Synchronisierungstoken abgelaufen (HTTP 410): Die Funktion startet die Synchronisierung ab der Stunde der letzten abgeschlossenen Synchronisierung neu. Einige Ereignisse aus dieser Stunde können noch einmal aufgenommen werden.
  • X-sync-status ist „abort“ oder keine Fußzeile „X-sync-token“/„X-sync-status“: Die Antwort war unvollständig und wurde verworfen. Bei der nächsten Ausführung wird es mit demselben Token noch einmal versucht.
  • ZIP-Archiv erwartet: Die Sync API hat etwas anderes als ein Protokollarchiv zurückgegeben. Prüfen Sie die Antwort mit dem Test unter API-Zugriff testen.
  • Durch eine andere Ausführung geändert: Zwei Ausführungen haben sich überschnitten. Setzen Sie die Maximale Anzahl von Instanzen auf 1.
  • KeyError für einen Variablennamen: Prüfen Sie, ob alle erforderlichen Umgebungsvariablen in der Cloud Run-Funktionskonfiguration festgelegt sind.

Feed in Google SecOps konfigurieren, um Symantec WSS-Logs aufzunehmen

  1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Symantec WSS logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Symantec WSS als Logtyp aus.
  7. Klicken Sie auf Dienstkonto abrufen. Eine eindeutige E-Mail-Adresse für das Dienstkonto wird angezeigt, z. B.:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. Kopieren Sie diese E-Mail-Adresse. Sie verwenden es in der nächsten Aufgabe.

  9. Klicken Sie auf Weiter.

  10. Geben Sie Werte für die folgenden Eingabeparameter an:

    • Storage-Bucket-URL: Geben Sie den Cloud Storage-Bucket-URI mit dem Präfixpfad ein:
    gs://symantec-wss-logs/symantec/wss/
    
    • Ersetzen Sie:

    • symantec-wss-logs: Name Ihres Cloud Storage-Bucket.

    • symantec/wss/: Optionales Präfix oder Ordnerpfad, in dem Logs gespeichert werden (leer lassen für Stammverzeichnis).

    Beispiele: – Stamm-Bucket: gs://company-logs/ – Mit Präfix: gs://company-logs/symantec-wss/ – Mit Unterordner: gs://company-logs/symantec/wss/

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption aus:

      • Dateien nie löschen: Dateien werden nie aus der Quelle gelöscht (empfohlen für Tests).
      • Übertragene Dateien und leere Verzeichnisse löschen: Dateien und leere Verzeichnisse werden nach einem erfolgreichen Abruf aus der Quelle gelöscht.
    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden. Der Standardwert ist 180 Tage.

    • Asset-Namespace: Der Asset-Namespace.

    • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.

  11. Klicken Sie auf Weiter.

  12. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt zwei Rollen für Ihren Cloud Storage-Bucket: Storage-Objekt-Betrachter zum Lesen der Logobjekte und eine Rolle auf Bucket-Ebene zum Lesen der Bucket-Metadaten.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Fügen Sie die E‑Mail-Adresse des Google SecOps-Dienstkontos ein.
    • Rollen zuweisen: Wählen Sie die beiden folgenden Rollen aus:
    • Storage-Objekt-Betrachter: Liest die Logobjekte.
    • Storage Legacy Bucket Reader: Liest die Bucket-Metadaten. Wenn Sie die Löschoption Übertragene Dateien und leere Verzeichnisse löschen ausgewählt haben, wählen Sie stattdessen Storage Legacy Bucket Writer aus. Dadurch wird auch die Löschberechtigung gewährt.
  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

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

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten