Netwrix Auditor-Logs erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Netwrix Auditor-Logs mit Google Cloud Storage V2 in Google Security Operations aufnehmen.

Netwrix Auditor ist eine Plattform zur Analyse des Nutzerverhaltens und zur Risikominderung, die die Kontrolle über Änderungen, Konfigurationen und den Zugriff in hybriden IT-Umgebungen ermöglicht. Die Plattform bietet Sicherheitsanalysen, mit denen Anomalien im Nutzerverhalten erkannt und Bedrohungsmuster untersucht werden können, bevor es zu einem Datenleck kommt. Die Plattform bietet mit einer RESTful Integration API einheitliche Transparenz und Kontrolle über alle Ihre lokalen oder cloudbasierten IT-Systeme.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Ein GCP-Projekt, in dem die Cloud Storage, Cloud Run, Pub/Sub und Cloud Scheduler APIs aktiviert sind
  • Berechtigungen zum Erstellen und Verwalten von GCS-Buckets
  • Berechtigungen zum Verwalten von IAM-Richtlinien für GCS-Buckets
  • Berechtigungen zum Erstellen von Cloud Run-Diensten, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Administratorzugriff auf den Netwrix Auditor-Server
  • Ein Windows-Domänenkonto mit den entsprechenden Berechtigungen für den API-Zugriff
  • Netwrix Auditor-Server mit aktivierter Integration API (standardmäßig aktiviert)
  • Audit-Datenbank in Netwrix Auditor konfiguriert
  • Netzwerkverbindung von der Cloud Run-Funktion zum Netwrix Auditor-Server auf Port 9699 (Standard)

Netwrix Auditor-API-Zugriff konfigurieren

Damit die Cloud Run-Funktion Aktivitätsdatensätze abrufen kann, müssen Sie prüfen, ob die Integration API aktiviert ist, und ein Windows-Domänenkonto mit der entsprechenden Rolle in Netwrix Auditor erstellen.

Prüfen, ob die Integration API aktiviert ist

  1. Starten Sie Netwrix Auditor auf dem Computer, auf dem Netwrix Auditor Server installiert ist.
  2. Gehen Sie zu Einstellungen > Integrationen.
  3. Prüfen Sie, ob die Option Leverage Integration API (Integrations-API nutzen) aktiviert ist.
  4. Notieren Sie sich die Portnummer (Standard ist 9699).

  5. So ändern Sie den Port:

    1. Klicken Sie im Abschnitt API-Einstellungen auf Ändern.
    2. Geben Sie eine neue Portnummer ein.
    3. Klicken Sie auf OK.

Dienstkonto für API-Zugriff erstellen

  1. Öffnen Sie auf Ihrem Windows-Domaincontroller Active Directory-Nutzer und -Computer.
  2. Rufen Sie die Organisationseinheit auf, in der Sie das Dienstkonto erstellen möchten.
  3. Klicken Sie mit der rechten Maustaste auf die Organisationseinheit > Neu > Nutzer.
  4. Geben Sie im Feld Vorname Chronicle Integration ein.
  5. Geben Sie im Feld Nutzeranmeldename chronicle-api (oder Ihren bevorzugten Nutzernamen) ein.
  6. Klicken Sie auf Weiter.
  7. Geben Sie ein starkes Passwort ein und konfigurieren Sie die Passworteinstellungen gemäß der Richtlinie Ihrer Organisation.
  8. Entfernen Sie das Häkchen bei Benutzer muss Kennwort bei der nächsten Anmeldung ändern.
  9. Wählen Sie Kennwort läuft nie ab aus (empfohlen für Dienstkonten).
  10. Klicken Sie auf Weiter > Fertigstellen.

Rolle „Global reviewer“ zuweisen

  1. Rufen Sie im Hauptfenster von Netwrix Auditor Monitoring Plans (Überwachungspläne) auf.
  2. Wählen Sie in der Baumstruktur der Monitoring-Pläne Alle Monitoring-Pläne (den Stammordner) aus.
  3. Klicken Sie auf Bevollmächtigen.
  4. Klicken Sie im Dialogfeld Delegation auf Nutzer hinzufügen.
  5. Gehen Sie im Dialogfeld Nutzer oder Gruppe auswählen so vor:
    1. Klicken Sie auf Durchsuchen.
    2. Geben Sie im Feld Auszuwählenden Objektnamen eingeben den Nutzernamen chronicle-api ein.
    3. Klicken Sie auf Namen überprüfen, um das Konto zu bestätigen.
    4. Klicken Sie auf OK.
  6. Wählen Sie im Drop-down-Menü Rolle die Option Globaler Prüfer aus.
  7. Klicken Sie auf OK.

  8. Klicken Sie auf Speichern.

API-Anmeldedaten aufzeichnen

Notieren Sie sich die folgenden Informationen, um die Umgebungsvariablen der Cloud Run-Funktion zu konfigurieren:

  • Nutzername: Das Domainkonto im Format DOMAIN\username (z. B. ENTERPRISE\chronicle-api)
  • Passwort: Das Passwort für das Dienstkonto
  • Hostname: Der vollqualifizierte Domainname (FQDN) oder die IP-Adresse des Netwrix Auditor-Servers (z. B. auditor.enterprise.local oder 172.28.6.15)

  • Port: Der Port der Integration API (Standardwert: 9699)

Berechtigungen prüfen

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

  1. Rufen Sie in Netwrix Auditor Monitoring Plans auf.
  2. Wählen Sie Alle Monitoring-Pläne aus.
  3. Klicken Sie auf Bevollmächtigen.
  4. Prüfen Sie, ob das chronicle-api-Konto mit der Rolle Globaler Prüfer angezeigt wird.
  5. Wenn das Konto nicht angezeigt wird, folgen Sie der Anleitung oben unter Globale Prüferrolle zuweisen.

API-Zugriff testen

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

    # Replace with your actual values
NETWRIX_HOST="auditor.enterprise.local"
NETWRIX_PORT="9699"
NETWRIX_USER="ENTERPRISE\\chronicle-api"
NETWRIX_PASS="your-password"

# Test API access (retrieve first batch of activity records)
curl -k --ntlm -u "${NETWRIX_USER}:${NETWRIX_PASS}" \
    "https://${NETWRIX_HOST}:${NETWRIX_PORT}/netwrix/api/v1/activity_records/enum" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

Bei einer erfolgreichen Antwort wird ein JSON-Objekt mit einem Array von Aktivitätsdatensätzen und einem ContinuationMark für die Paginierung zurückgegeben.

Google Cloud Storage-Bucket erstellen

  1. Gehen Sie zur Google Cloud Console.
  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. netwrix-auditor-logs.
    Standorttyp Wählen Sie je nach Bedarf aus (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Ort aus, z. B. us-central1.
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutzmaßnahmen Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Dienstkonto für Cloud Run-Funktion erstellen

  1. Wechseln Sie in der GCP Console zu IAM & Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie netwrix-audit-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect Netwrix Auditor 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-Objekt-Administrator 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 Invoker und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

IAM-Berechtigungen für GCS-Bucket erteilen

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets (netwrix-auditor-logs).
  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 (netwrix-audit-collector-sa@PROJECT_ID.iam.gserviceaccount.com) ein.
    • Rollen zuweisen: Wählen Sie Storage-Objekt-Administrator aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

  1. Rufen Sie in der GCP Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie netwrix-audit-trigger ein.
    • Andere Einstellungen als Standardeinstellungen beibehalten
  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 Aktivitätsdatensätze aus der Netwrix Auditor Integration API abzurufen und in GCS zu schreiben.

  1. Rufen Sie in der GCP Console Cloud Run auf.
  2. Klicken Sie auf Dienst erstellen.
  3. Wählen Sie Funktion aus, um eine Funktion mit einem Inline-Editor zu erstellen.

  4. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname netwrix-audit-collector
    Region Wählen Sie die Region aus, die Ihrem GCS-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.

  5. Im Abschnitt Trigger (optional):

    1. Klicken Sie auf + Trigger hinzufügen.
    2. Wählen Sie Cloud Pub/Sub aus.
    3. Wählen Sie unter Cloud Pub/Sub-Thema auswählen die Option netwrix-audit-trigger aus.
    4. Klicken Sie auf Speichern.

  6. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Identitäts- und Zugriffsverwaltung

  7. Scrollen Sie nach unten und maximieren Sie Container, Netzwerk, Sicherheit.

  8. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie netwrix-audit-collector-sa aus.

  9. 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 netwrix-auditor-logs Name des GCS-Buckets
    GCS_PREFIX netwrix-audit Präfix für Protokolldateien
    STATE_KEY netwrix-audit/state.json Statusdateipfad
    NETWRIX_HOST auditor.enterprise.local FQDN oder IP-Adresse des Netwrix Auditor-Servers
    NETWRIX_PORT 9699 Port für die Integration API
    NETWRIX_USER ENTERPRISE\chronicle-api Domainkonto im Format DOMAIN\Nutzername
    NETWRIX_PASS your-password Dienstkontopasswort
    MAX_RECORDS 10000 Maximale Anzahl von Datensätzen pro Ausführung
    LOOKBACK_HOURS 24 Erster Rückschauzeitraum

  10. Scrollen Sie im Bereich Variablen und Secrets nach unten zu Anfragen:

    • Zeitüberschreitung bei Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.

  11. Rufen Sie den Tab Einstellungen auf:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 512 MiB oder höher aus.
      • CPU: Wählen Sie 1 aus.

  12. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 100 ein.

  13. Klicken Sie auf Erstellen.

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

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

Funktionscode hinzufügen

  1. Geben Sie main in das Feld Einstiegspunkt ein.

  2. Erstellen Sie im Inline-Codeeditor zwei Dateien:

    • main.py:
    import functions_framework
from google.cloud import storage
import json
import os
import requests
from requests_ntlm import HttpNtlmAuth
from datetime import datetime, timezone, timedelta
import time
import urllib3

# Suppress insecure HTTPS warnings for self-signed certificates
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'netwrix-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'netwrix-audit/state.json')
NETWRIX_HOST = os.environ.get('NETWRIX_HOST')
NETWRIX_PORT = os.environ.get('NETWRIX_PORT', '9699')
NETWRIX_USER = os.environ.get('NETWRIX_USER')
NETWRIX_PASS = os.environ.get('NETWRIX_PASS')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

def parse_datetime(value):
  """Parse ISO datetime string to datetime object."""
  if value.endswith("Z"):
    value = value[:-1] + "+00:00"
  return datetime.fromisoformat(value)

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch Netwrix Auditor
  activity records and write to GCS.

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

  if not all([GCS_BUCKET, NETWRIX_HOST, NETWRIX_USER, NETWRIX_PASS]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)
    state = load_state(bucket)
    now = datetime.now(timezone.utc)

    if isinstance(state, dict) and state.get('last_event_time'):
      try:
        last_time = parse_datetime(state['last_event_time'])
        last_time = last_time - timedelta(minutes=2)
      except Exception as e:
        print(f"Warning: Could not parse last_event_time: {e}")
        last_time = now - timedelta(hours=LOOKBACK_HOURS)
    else:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

    print(f"Fetching activity records from {last_time.isoformat()} "
        f"to {now.isoformat()}")

    records, newest_event_time = fetch_activity_records(
      last_time, now
    )

    if not records:
      print("No new activity records found.")
      save_state(bucket, now.isoformat())
      return

    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = (
      f"{GCS_PREFIX}/netwrix_audit_{timestamp}.ndjson"
    )
    blob = bucket.blob(object_key)

    ndjson = '\n'.join(
      [json.dumps(r, ensure_ascii=False, default=str)
      for r in records]
    ) + '\n'
    blob.upload_from_string(
      ndjson, content_type='application/x-ndjson'
    )

    print(f"Wrote {len(records)} records to "
        f"gs://{GCS_BUCKET}/{object_key}")

    if newest_event_time:
      save_state(bucket, newest_event_time)
    else:
      save_state(bucket, now.isoformat())

    print(f"Successfully processed {len(records)} records")

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

def load_state(bucket):
  """Load state from GCS."""
  try:
    blob = bucket.blob(STATE_KEY)
    if blob.exists():
      return json.loads(blob.download_as_text())
  except Exception as e:
    print(f"Warning: Could not load state: {e}")
  return {}

def save_state(bucket, last_event_time_iso):
  """Save the last event timestamp to GCS state file."""
  try:
    state = {
      'last_event_time': last_event_time_iso,
      'last_run': datetime.now(timezone.utc).isoformat()
    }
    blob = bucket.blob(STATE_KEY)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json'
    )
    print(f"Saved state: last_event_time={last_event_time_iso}")
  except Exception as e:
    print(f"Warning: Could not save state: {e}")

def fetch_activity_records(start_time, end_time):
  """
  Fetch activity records from Netwrix Auditor Integration API
  using the enum endpoint with continuation mark pagination.

  The API returns up to 1000 records per request. Subsequent
  requests include the ContinuationMark from the previous
  response to retrieve the next batch.

  Args:
    start_time: Start time for filtering records
    end_time: End time for filtering records

  Returns:
    Tuple of (records list, newest_event_time ISO string)
  """
  base_url = (
    f"https://{NETWRIX_HOST}:{NETWRIX_PORT}"
    f"/netwrix/api/v1/activity_records/enum"
  )
  auth = HttpNtlmAuth(NETWRIX_USER, NETWRIX_PASS)
  session = requests.Session()
  session.auth = auth
  session.verify = False
  session.headers.update({
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'User-Agent': 'GoogleSecOps-NetwrixCollector/1.0'
  })

  all_records = []
  newest_time = None
  continuation_mark = None
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

    if len(all_records) >= MAX_RECORDS:
      print(f"Reached max_records limit ({MAX_RECORDS})")
      break

    try:
      if continuation_mark:
        response = session.post(
          base_url,
          json={"ContinuationMark": continuation_mark},
          timeout=(10, 60)
        )
      else:
        response = session.get(
          base_url,
          timeout=(10, 60)
        )

      if response.status_code == 429:
        retry_after = int(
          response.headers.get(
            'Retry-After', str(int(backoff))
          )
        )
        print(f"Rate limited (429). Retrying after "
            f"{retry_after}s...")
        time.sleep(retry_after)
        backoff = min(backoff * 2, 30.0)
        continue

      backoff = 1.0

      if response.status_code != 200:
        print(f"HTTP Error: {response.status_code}")
        print(f"Response body: {response.text}")
        return all_records, newest_time

      data = response.json()

      page_results = data.get('ActivityRecordList', [])
      continuation_mark = data.get('ContinuationMark')

      if not page_results:
        print("No more activity records (empty page)")
        break

      # Filter records by time window
      filtered = []
      for record in page_results:
        when = record.get('When')
        if when:
          try:
            record_time = parse_datetime(when)
            if start_time <= record_time <= end_time:
              filtered.append(record)
            if (newest_time is None or
                record_time >
                parse_datetime(newest_time)):
              newest_time = when
          except Exception as e:
            print(f"Warning: Could not parse "
                f"record time: {e}")
            filtered.append(record)
        else:
          filtered.append(record)

      print(f"Page {page_num}: Retrieved "
          f"{len(page_results)} records, "
          f"{len(filtered)} within time window")
      all_records.extend(filtered)

      if not continuation_mark:
        print("No more pages (no ContinuationMark)")
        break

    except requests.exceptions.Timeout:
      print(f"Request timeout on page {page_num}")
      return all_records, newest_time
    except Exception as e:
      print(f"Error fetching activity records: {e}")
      return all_records, newest_time

  print(f"Retrieved {len(all_records)} total records "
      f"from {page_num} pages")
  return all_records, newest_time
    • requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
requests>=2.31.0
requests-ntlm>=1.2.0

  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

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

Cloud Scheduler-Job erstellen

  1. Rufen Sie in der GCP Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name netwrix-audit-collector-hourly
    Region Dieselbe Region wie die Cloud Run-Funktion auswählen
    Frequenz 0 * * * * (jede Stunde, zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema netwrix-audit-trigger auswählen
    Nachrichtentext {} (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 * * * Geringes Volumen, Batchverarbeitung
Täglich 0 0 * * * Erhebung von Verlaufsdaten

Integration testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job (netwrix-audit-collector-hourly).
  2. Klicken Sie auf Force run (Ausführung erzwingen), um den Job manuell auszulösen.
  3. Warten Sie einige Sekunden.
  4. Rufen Sie Cloud Run > Dienste auf.
  5. Klicken Sie auf netwrix-audit-collector.
  6. Klicken Sie auf den Tab Logs.

  7. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde. Darauf sollten Sie achten:

    Fetching activity records from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X records, X within time window
Wrote X records to gs://netwrix-auditor-logs/netwrix-audit/netwrix_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf netwrix-auditor-logs.

  10. Rufen Sie den Ordner netwrix-audit/ auf.

  11. Prüfen Sie, ob eine neue .ndjson-Datei mit dem aktuellen Zeitstempel erstellt wurde.

Wenn Sie Fehler in den Logs sehen:

  • HTTP 401: Prüfen Sie, ob die Umgebungsvariablen NETWRIX_USER und NETWRIX_PASS korrekt sind und das Format DOMAIN\username verwendet wird.
  • HTTP 403: Prüfen Sie, ob das Dienstkonto in Netwrix Auditor die Rolle Global reviewer hat.
  • HTTP 429: Ratenbegrenzung – die Funktion wird automatisch mit exponentiellem Backoff wiederholt.
  • Zeitüberschreitung bei der Verbindung: Prüfen Sie die Netzwerkverbindung von Cloud Run zum Netwrix Auditor-Server auf Port 9691. VPC-Connector oder Cloud VPN konfigurieren, wenn sich der Server lokal befindet
  • Fehlende Umgebungsvariablen: Prüfen Sie, ob alle erforderlichen Variablen in der Konfiguration der Cloud Run-Funktion festgelegt sind.

Google SecOps-Dienstkonto abrufen

  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. Netwrix Auditor Activity Records.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Netwrix als Logtyp aus.
  7. Klicken Sie auf Dienstkonto abrufen.

  8. Eine eindeutige E-Mail-Adresse für das Dienstkonto wird angezeigt. Beispiel:

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

  9. Kopieren Sie diese E-Mail-Adresse für den nächsten Schritt.

  10. Klicken Sie auf Weiter.

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

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI mit dem Präfixpfad ein:

      gs://netwrix-auditor-logs/netwrix-audit/
    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus:
      • Nie: Es werden niemals Dateien nach Übertragungen gelöscht (empfohlen für Tests).
      • Übertragene Dateien löschen: Löscht Dateien nach der erfolgreichen Übertragung.
      • Übertragene Dateien und leere Verzeichnisse löschen: Dateien und leere Verzeichnisse werden nach der erfolgreichen Übertragung gelöscht.
    • Höchstalter für Dateien: Dateien einschließen, die in den letzten Tagen geändert wurden (Standard: 180 Tage)
    • Asset-Namespace: Der Asset-Namespace
    • Labels für Datenaufnahme: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll

  12. Klicken Sie auf Weiter.

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

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf netwrix-auditor-logs.
  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 Storage-Objekt-Betrachter aus.

  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
Opcode about.labels Mit den Informationen „Über mich“ verknüpfte Labels
Caption about.resource.attribute.labels Attributlabels für die Ressource im Bereich „Über“
Aufgabe additional.fields Zusätzliche Felder mit zusätzlichen Informationen zum Ereignis
Was additional.fields
Hinweis additional.fields
Beschreibung additional.fields
Hinzugefügt additional.fields
Entfernt additional.fields
service_type additional.fields
Details additional.fields
extensions.auth.type extensions.auth.type Verwendeter Authentifizierungstyp
EventReceivedTime metadata.collected_timestamp Zeitstempel, der angibt, wann das Ereignis vom System erfasst wurde
Nachricht metadata.description Eine Beschreibung des Ereignisses
event_type metadata.event_type Ereignistyp
EventType metadata.product_event_type Produktspezifischer Ereignistyp
EventID metadata.product_log_id Produktspezifische Log-Kennzeichnung
SourceModuleType observer.application Anwendung, die das Ereignis beobachtet hat
Hostname principal.asset.hostname Hostname des Assets, das mit dem Rechtssubjekt verknüpft ist
Wo principal.asset.hostname
Workstation principal.asset.hostname
device_name principal.asset.hostname
Workstation principal.hostname Hostname des Prinzipal
device_name principal.hostname
ProcessID principal.process.pid Prozess-ID des Prinzipal
Name principal.resource.name Name der Ressource, die dem Prinzipal zugeordnet ist
Wer principal.user.user_display_name Anzeigename des Nutzers
SourceName security_result.about.resource.attribute.labels Ressourcenattributlabels für den Abschnitt „Informationen“ im Sicherheitsergebnis
Aktion security_result.action Im Sicherheitsergebnis ergriffene Maßnahme
action_details security_result.action_details Details der Aktion im Sicherheitsergebnis
backup_name security_result.description Beschreibung des Sicherheitsergebnisses
service_failed security_result.description
Keywords security_result.detection_fields Felder, die für die Erkennung im Sicherheitsergebnis verwendet werden
RecordNumber security_result.detection_fields
session_ID security_result.detection_fields
allow_connection_with_desktop security_result.detection_fields
service_account security_result.detection_fields
Schweregrad security_result.severity Schweregrad des Sicherheitsergebnisses
SeverityValue security_result.severity
Zusammenfassung security_result.summary Zusammenfassung des Sicherheitsergebnisses
application_name target.application Anwendung auf das Ziel
Hostname target.asset.hostname Hostname des mit dem Ziel verknüpften Assets
Wo target.asset.hostname
file_path target.file.full_path Vollständiger Pfad der Zieldatei
Größe target.file.size Größe der Zieldatei
Hostname target.hostname Hostname des Ziels
Wo target.hostname
Typ target.resource.attribute.labels Attributlabels für die Zielressource
SourceModuleName target.resource.name Name der Zielressource
DataSource metadata.product_name Name des Produkts, das das Ereignis generiert hat
metadata.vendor_name metadata.vendor_name Name des Anbieters

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