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 für die Analyse des Nutzerverhaltens und die Risikominderung, die die Kontrolle über Änderungen, Konfigurationen und Zugriffe 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 einer Datenpanne kommt. Dank einer RESTful-Integrations-API bietet die Plattform eine einheitliche Übersicht 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 mit aktivierten Cloud Storage, Cloud Run, Pub/Sub und Cloud Scheduler APIs
  • 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-Domainkonto 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 über 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 auf dem Computer, auf dem Netwrix Auditor Server installiert ist, Netwrix Auditor.
  2. Gehen Sie zu den Einstellungen > Integrationen.
  3. Prüfen Sie, ob die Option Leverage Integration API (Integrations-API nutzen) aktiviert ist.
  4. Notieren Sie sich die Port-Nummer (Standard ist 9699).

  5. So ändern Sie den Port:

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

Dienstkonto für den API-Zugriff erstellen

  1. Öffnen Sie auf Ihrem Windows-Domaincontroller Active Directory-Benutzer und ‑Computer.
  2. Rufen Sie die Organisationseinheit auf, in der Sie das Dienstkonto erstellen möchten.
  3. Rechtsklicken Sie auf die Organisationseinheit > Neu > Nutzer.
  4. Geben Sie im Feld Vorname Chronicle Integration ein.
  5. Geben Sie im Feld User logon name (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 aus dem Kästchen Nutzer muss Kennwort bei der nächsten Anmeldung ändern.
  9. Wählen Sie Passwort 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 (Monitoring-Pläne) auf.
  2. Wählen Sie im Baum der Monitoring-Pläne Alle Monitoring-Pläne (den Stammordner) aus.
  3. Klicken Sie auf Bevollmächtigen.
  4. Klicken Sie im Dialogfeld Delegierung auf Nutzer hinzufügen.
  5. Führen Sie im Dialogfeld Nutzer oder Gruppe auswählen die folgenden Schritte aus:
    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 für Cloud Run Functions zu konfigurieren:

  • Nutzername: Das Domainkonto im Format DOMAIN\username (z. B. ENTERPRISE\chronicle-api)
  • Password: Das Passwort für das Dienstkonto.
  • Hostname: Der vollständig qualifizierte Domainname (Fully Qualified Domain Name, 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 (Standardeinstellung: 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 Delegieren.
  4. Prüfen Sie, ob das Konto chronicle-api mit der Rolle Globaler Prüfer angezeigt wird.
  5. Wenn das Konto nicht angezeigt wird, folgen Sie der Anleitung unter Globale Prüferrolle zuweisen oben.

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"

Eine erfolgreiche Antwort gibt ein JSON-Objekt zurück, das ein Array von Aktivitätseinträgen und ein ContinuationMark für die Paginierung enthält.

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 die Option aus, 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)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutztools Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

Dienstkonto für die Cloud Run-Funktion erstellen

  1. Wechseln Sie in der GCP Console zu IAM und 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 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 diese Option aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

IAM-Berechtigungen für GCS-Bucket gewähren

  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 Object Admin 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.
    • Ü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 Aktivitätsdatensätze von der Netwrix Auditor Integration API abzurufen und in GCS zu schreiben.

  1. Rufen Sie in der GCP Console die Option 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. Weitere Informationen finden Sie unter Identity and Access Management (IAM).

  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 Logdateien
    STATE_KEY netwrix-audit/state.json Pfad der Statusdatei
    NETWRIX_HOST auditor.enterprise.local FQDN oder IP-Adresse des Netwrix Auditor-Servers
    NETWRIX_PORT 9699 Integrations-API-Port
    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 Anfänglicher 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. Gehen Sie zum Tab Einstellungen:

    • 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, bis der Dienst erstellt wurde (1–2 Minuten).

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

Funktionscode hinzufügen

  1. Geben Sie main in das Feld Einstiegspunkt ein.

  2. Erstellen Sie im Inline-Code-Editor 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–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 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 netwrix-audit-trigger auswählen
    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 * * * 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 Ausführung erzwingen, um den Job manuell auszulösen.
  3. Warte 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 in den Logs Fehler angezeigt werden:

  • HTTP 401: Prüfen Sie, ob die Umgebungsvariablen NETWRIX_USER und NETWRIX_PASS korrekt sind und das Format DOMAIN\username haben.
  • 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.
  • Verbindungszeitüberschreitung: Prüfen Sie die Netzwerkverbindung von Cloud Run zum Netwrix Auditor-Server über 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 Nachrichten-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 Protokolltyp 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, um sie im nächsten Schritt zu verwenden.

  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 Löschoption aus:
      • Nie: Löscht nach Übertragungen nie Dateien (empfohlen für Tests).
      • Übertragene Dateien löschen: Dateien werden nach erfolgreicher Übertragung gelöscht.
      • Übertragene Dateien und leere Verzeichnisse löschen: Löscht Dateien und leere Verzeichnisse nach der erfolgreichen Übertragung.
    • Höchstalter der Datei: Dateien einbeziehen, die in den letzten Tagen geändert wurden (Standardwert: 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 Nachrichten-Feed-Konfiguration 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 Object Viewer 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 Hauptkonto verknüpft ist
Wo principal.asset.hostname
Workstation principal.asset.hostname
device_name principal.asset.hostname
Workstation principal.hostname Hostname des Hauptkontos
device_name principal.hostname
ProcessID principal.process.pid Prozess-ID des Principals
Name principal.resource.name Name der Ressource, die mit dem Hauptkonto verknüpft ist
Wer principal.user.user_display_name Anzeigename des Nutzers
SourceName security_result.about.resource.attribute.labels Labels für Ressourcenattribute im Sicherheitsergebnis „Über“
Aktion security_result.action Ergriffene Maßnahme im Sicherheitsergebnis
action_details security_result.action_details Details zur 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

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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