1Password-Protokolle erfassen

Parserversion: 5.0

Unterstützt in:

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

1Password ist eine Plattform zur Passwortverwaltung, mit der Teams Anmeldedaten, Secrets und vertrauliche Informationen sicher speichern, freigeben und verwalten können. Die 1Password Events API bietet Zugriff auf Anmeldeversuche und Daten zur Verwendung von Elementen aus Ihrem 1Password Business-Konto.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Ein GCP-Projekt mit aktivierter Cloud Storage API
  • 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
  • Ein 1Password Business-Konto
  • Eine Inhaber- oder Administratorrolle in Ihrem 1Password-Konto

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. onepassword-secops-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)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutztools Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren

  6. Klicken Sie auf Erstellen.

1Password-Anmeldedaten abrufen

Integration für Ereignisberichte einrichten

  1. Melden Sie sich auf 1Password.com in Ihrem Konto an.
  2. Wählen Sie in der Seitenleiste Integrationen aus.
  3. Wenn Sie bereits andere Integrationen eingerichtet haben, wählen Sie auf der Seite Integrationen die Option Verzeichnis aus.
  4. Wählen Sie im Bereich Ereignisberichte die Option Sonstiges aus.
  5. Geben Sie im Feld Name einen Namen für die Integration ein, z. B. Google SecOps Integration.
  6. Klicken Sie auf Integration hinzufügen.

Inhabertoken erstellen

  1. Klicken Sie auf der Detailseite der Integration auf Inhabertoken hinzufügen.
  2. Geben Sie die folgenden Konfigurationsdetails an:
    • Tokenname: Geben Sie einen aussagekräftigen Namen ein (z. B. SecOps GCS Collector - SignIn and ItemUsage).
    • Läuft nach: Wählen Sie den Ablaufzeitraum nach Bedarf aus. Wählen Sie Nie für ein Token ohne Ablaufdatum oder 30 Tage, 90 Tage oder 180 Tage aus.
    • Zu meldende Ereignisse: Aktivieren Sie die folgenden Kästchen:
      • Anmeldeversuche
      • Ereignisse zur Artikelnutzung
  3. Klicken Sie auf Issue Token (Token ausstellen).

  4. Klicken Sie auf der Seite Token speichern auf In 1Password speichern oder kopieren Sie das Token und speichern Sie es an einem sicheren Ort.

  5. Klicken Sie auf Integrationsdetails ansehen, um zu bestätigen, dass die Integration aktiv ist.

Basis-URL der Events API ermitteln

Die Basis-URL hängt vom Server ab, auf dem Ihr 1Password-Konto gehostet wird:

Wenn Ihr Konto auf Die Basis-URL für die Events API lautet
1password.com https://events.1password.com
ent.1password.com https://events.ent.1password.com
1password.ca https://events.1password.ca
1password.eu https://events.1password.eu

API-Zugriff testen

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

    # Replace with your actual bearer token and base URL
BEARER_TOKEN="<your-bearer-token>"
API_BASE="https://events.1password.com"

# Test API access using the introspect endpoint
curl -v \
    -H "Authorization: Bearer $BEARER_TOKEN" \
    "$API_BASE/api/v2/auth/introspect"

Bei einer erfolgreichen Antwort wird ein JSON-Objekt mit dem Feld features zurückgegeben, in dem die Ereignistypen aufgeführt sind, auf die mit Ihrem Token zugegriffen werden kann (z. B. ["signinattempts", "itemusages"]).

Dienstkonto für die Cloud Run-Funktion erstellen

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

Dienstkonto 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:
    • Dienstkontoname: Geben Sie onepassword-logs-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect 1Password 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.

Diese Rollen sind erforderlich für:

  • Storage-Objekt-Administrator: Logs in den GCS-Bucket schreiben und Zustandsdateien verwalten
  • Cloud Run-Aufrufer: Pub/Sub erlauben, die Funktion aufzurufen
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

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

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

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf Ihren Bucket (onepassword-secops-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 onepassword-logs-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

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

  1. Wechseln Sie in der GCP Console zu Pub/Sub > Themen.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie onepassword-logs-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 Anmeldeversuchs- und Artikelnutzungslogs von der 1Password Events 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 onepassword-logs-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 onepassword-logs-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 onepassword-logs-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 onepassword-secops-logs Name des GCS-Buckets
      GCS_PREFIX onepassword Präfix für Logdateien
      STATE_KEY onepassword/state.json Pfad der Statusdatei
      OP_API_BASE https://events.1password.com Basis-URL der 1Password Events API
      OP_BEARER_TOKEN <your-bearer-token> 1Password Events API-Inhabertoken
      MAX_RECORDS 10000 Maximale Anzahl von Datensätzen pro Endpunkt und Ausführung
      PAGE_SIZE 1000 Einträge pro Seite (max. 1.000)
      LOOKBACK_HOURS 24 Anfänglicher Rückschauzeitraum in Stunden

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

    • Zeitlimit für die 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 oder passen Sie den Wert an die erwartete Last an.

  13. Klicken Sie auf Erstellen.

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

  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:

    • Erste Datei: main.py::

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
  timeout=urllib3.Timeout(connect=5.0, read=30.0),
  retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'onepassword')
STATE_KEY = os.environ.get('STATE_KEY', 'onepassword/state.json')
API_BASE = os.environ.get('OP_API_BASE')
BEARER_TOKEN = os.environ.get('OP_BEARER_TOKEN')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

# 1Password Events API v2 endpoints for sign-in and item usage
ENDPOINTS = {
  'signinattempts': '/api/v2/signinattempts',
  'itemusages': '/api/v2/itemusages',
}

def parse_datetime(value: str) -> datetime:
  """Parse RFC 3339 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 1Password
  sign-in attempt and item usage logs and write them to GCS
  as NDJSON.
  """
  if not all([GCS_BUCKET, API_BASE, BEARER_TOKEN]):
    print('Error: Missing required environment variables '
        '(GCS_BUCKET, OP_API_BASE, OP_BEARER_TOKEN)')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)

    # Load state (stores cursors per endpoint)
    state = load_state(bucket, STATE_KEY)

    now = datetime.now(timezone.utc)
    total_records = 0

    for event_type, path in ENDPOINTS.items():
      print(f'--- Processing endpoint: {event_type} ---')

      saved_cursor = state.get(f'cursor_{event_type}')

      records, last_cursor = fetch_endpoint(
        api_base=API_BASE,
        path=path,
        bearer_token=BEARER_TOKEN,
        saved_cursor=saved_cursor,
        lookback_hours=LOOKBACK_HOURS,
        page_size=PAGE_SIZE,
        max_records=MAX_RECORDS,
      )

      if records:
        timestamp = now.strftime('%Y%m%d_%H%M%S')
        object_key = (f'{GCS_PREFIX}/'
                f'{event_type}_{timestamp}.ndjson')
        blob = bucket.blob(object_key)

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

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

      # Save cursor even if no records (for next poll)
      if last_cursor:
        state[f'cursor_{event_type}'] = last_cursor

      total_records += len(records)

    # Save state with all cursors
    state['last_run'] = now.isoformat()
    save_state(bucket, STATE_KEY, state)

    print(f'Successfully processed {total_records} total records')

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

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

def save_state(bucket, key, state: dict):
  """Save state to GCS."""
  try:
    blob = bucket.blob(key)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json',
    )
    print(f'Saved state: {json.dumps(state)}')
  except Exception as e:
    print(f'Warning: Could not save state: {e}')

def fetch_endpoint(api_base, path, bearer_token, saved_cursor,
          lookback_hours, page_size, max_records):
  """
  Fetch events from a single 1Password Events API v2 endpoint.

  The 1Password Events API uses cursor-based pagination with POST
  requests. The first request sends a ResetCursor object with
  optional start_time and limit. Subsequent requests send the
  cursor returned from the previous response.

  Args:
    api_base: Events API base URL
    path: Endpoint path
    bearer_token: JWT bearer token
    saved_cursor: Cursor from previous run (or None)
    lookback_hours: Hours to look back on first run
    page_size: Max events per page (1-1000)
    max_records: Max total events per run

  Returns:
    Tuple of (records list, last_cursor string)
  """
  url = f'{api_base.rstrip("/")}{path}'

  headers = {
    'Authorization': f'Bearer {bearer_token}',
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  }

  records = []
  cursor = saved_cursor
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

    if len(records) >= max_records:
      print(f'Reached max_records limit ({max_records})')
      break

    # Build request body
    if cursor:
      # Continuing cursor: resume from last position
      body = json.dumps({'cursor': cursor})
    else:
      # ResetCursor: first request or no saved state
      start_time = (
        datetime.now(timezone.utc)
        - timedelta(hours=lookback_hours)
      )
      body = json.dumps({
        'limit': page_size,
        'start_time': start_time.strftime(
          '%Y-%m-%dT%H:%M:%SZ'
        ),
      })

    try:
      response = http.request(
        'POST', url, body=body, headers=headers,
      )

      # Handle rate limiting (600 req/min, 30000 req/hour)
      if response.status == 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, 60.0)
        continue

      backoff = 1.0

      if response.status != 200:
        response_text = response.data.decode('utf-8')
        print(f'HTTP Error {response.status}: '
            f'{response_text}')
        break

      data = json.loads(response.data.decode('utf-8'))

      page_items = data.get('items', [])
      cursor = data.get('cursor')
      has_more = data.get('has_more', False)

      if page_items:
        print(f'Page {page_num}: Retrieved '
            f'{len(page_items)} events')
        records.extend(page_items)

      if not has_more:
        print(f'No more pages (has_more=false)')
        break

      if not cursor:
        print(f'No cursor returned, stopping')
        break

    except urllib3.exceptions.HTTPError as e:
      print(f'HTTP error: {str(e)}')
      break
    except Exception as e:
      print(f'Error fetching events: {str(e)}')
      break

  print(f'Retrieved {len(records)} total records '
      f'from {page_num} pages')
  return records, cursor

    • 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 GCP Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name onepassword-logs-collector-hourly
    Region Dieselbe Region wie die Cloud Run-Funktion auswählen
    Frequenz 0 * * * * (stündlich zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema onepassword-logs-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 onepassword-logs-collector-hourly.
  2. Klicken Sie auf 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 onepassword-logs-collector.
  6. Klicken Sie auf den Tab Logs.

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

    --- Processing endpoint: signinattempts ---
Page 1: Retrieved X events
Wrote X signinattempts records to gs://onepassword-secops-logs/onepassword/signinattempts_YYYYMMDD_HHMMSS.ndjson
--- Processing endpoint: itemusages ---
Page 1: Retrieved X events
Wrote X itemusages records to gs://onepassword-secops-logs/onepassword/itemusages_YYYYMMDD_HHMMSS.ndjson
Successfully processed X total records

  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf onepassword-secops-logs.

  10. Rufen Sie den Ordner onepassword/ auf.

  11. Prüfen Sie, ob neue .ndjson-Dateien mit dem aktuellen Zeitstempel erstellt wurden.

Wenn Sie Fehler in den Logs sehen:

  • HTTP 401: Prüfen Sie das Bearertoken in der Umgebungsvariable OP_BEARER_TOKEN. Das Token ist möglicherweise abgelaufen.
  • HTTP 429: Ratenbegrenzung. Die Funktion wird automatisch mit Backoff wiederholt. Die 1Password Events API erlaubt 600 Anfragen pro Minute und 30.000 Anfragen pro Stunde.
  • Fehlende Umgebungsvariablen: Prüfen Sie, ob alle erforderlichen Variablen in der Konfiguration der Cloud Run-Funktion festgelegt sind.
  • Keine Datensätze zurückgegeben: Prüfen Sie mit dem Introspect-Endpunkt, ob Ihr Inhabertoken Zugriff auf die angeforderten Ereignistypen hat.

Google SecOps-Dienstkonto abrufen

Google SecOps verwendet ein eindeutiges Dienstkonto, um Daten aus Ihrem GCS-Bucket zu lesen. Sie müssen diesem Dienstkonto Zugriff auf Ihren Bucket gewähren.

E‑Mail-Adresse des Dienstkontos 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. 1Password Sign-In and Item Usage Logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie 1Password als Protokolltyp 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 für den nächsten Schritt.

  9. Klicken Sie auf Weiter.

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

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

      gs://onepassword-secops-logs/onepassword/

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen 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 erfolgreicher Ü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.

  11. Klicken Sie auf Weiter.

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

Das Google SecOps-Dienstkonto benötigt die Rolle Storage Object Viewer für Ihren GCS-Bucket.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf onepassword-secops-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
Kategorie security_result.category_details Der Wert wird aus dem Feld category im Rohlog übernommen.
client.app_name principal.application Der Wert wird aus dem Feld client.app_name im Rohlog übernommen.
client.app_version metadata.product_version Der Wert stammt aus dem Feld client.app_version im Rohlog.
client.ip_address principal.ip Der Wert wird aus dem Feld client.ip_address im Rohlog übernommen.
client.os_name principal.platform Der Wert wird aus dem Feld client.os_name im Rohlog übernommen und dem entsprechenden UDM-Plattformwert (LINUX, WINDOWS, MAC) zugeordnet.
client.os_version principal.platform_version Der Wert wird aus dem Feld client.os_version im Rohlog übernommen.
client.platform_name principal.resource.attribute.labels Der Wert stammt aus dem Feld client.platform_name im Rohlog.
client.platform_version principal.asset.platform_software.platform_version Der Wert stammt aus dem Feld client.platform_version im Rohlog.
country principal.location.country_or_region Der Wert wird aus dem Feld country im Rohlog übernommen, wenn location.country nicht vorhanden ist.
item_uuid security_result.about.resource.attribute.labels Der Wert wird aus dem Feld item_uuid im Rohlog übernommen.
location.city principal.location.city Der Wert wird aus dem Feld location.city im Rohlog übernommen.
location.country principal.location.country_or_region Der Wert wird aus dem Feld location.country im Rohlog übernommen.
location.latitude principal.location.region_latitude Der Wert stammt aus dem Feld location.latitude im Rohlog.
location.longitude principal.location.region_longitude Der Wert wird aus dem Feld location.longitude im Rohlog übernommen.
location.region principal.location.name Der Wert stammt aus dem Feld location.region im Rohlog.
session.ip principal.ip Der Wert wird aus dem Feld session.ip im Rohlog übernommen.
session_uuid network.session_id Der Wert stammt aus dem Feld session_uuid im Rohlog.
target_user.email target.user.email_addresses Der Wert wird aus dem Feld target_user.email im Rohlog übernommen.
target_user.uuid target.user.userid Der Wert stammt aus dem Feld target_user.uuid im Rohlog.
timestamp metadata.event_timestamp Der Wert wird aus dem Feld timestamp im Rohlog übernommen und in Sekunden und Nanosekunden umgerechnet.
Typ additional.fields Der Wert wird aus dem Feld type im Rohlog übernommen.
user.email principal.user.email_addresses Der Wert wird aus dem Feld user.email im Rohlog übernommen.
nutzer.name principal.user.user_display_name Der Wert stammt aus dem Feld user.name im Rohlog.
used_version additional.fields Der Wert wird aus dem Feld used_version im Rohlog übernommen.
uuid principal.resource.attribute.labels Der Wert stammt aus dem Feld uuid im Rohlog.
vault_uuid security_result.about.resource.attribute.labels Der Wert wird aus dem Feld vault_uuid im Rohlog übernommen.
– extensions.auth Für dieses Feld wird ein leeres Objekt erstellt.
– metadata.event_type Legen Sie USER_LOGIN fest, wenn die Kategorie success oder firewall_reported_success ist, STATUS_UPDATE, wenn keine Nutzerinformationen vorhanden sind, und andernfalls USER_UNCATEGORIZED.
– metadata.log_type Legen Sie ONEPASSWORD fest.
– metadata.product_name Legen Sie ONEPASSWORD fest.
– metadata.vendor_name Legen Sie ONEPASSWORD fest.
– security_result.action Legen Sie ALLOW fest, wenn die Kategorie success oder firewall_reported_success ist, BLOCK, wenn die Kategorie credentials_failed, mfa_failed, modern_version_failed oder firewall_failed ist. Andernfalls bleibt das Feld leer.
lt event.idm.read_only_udm.metadata.product_event_type Aus Änderungsprotokoll zugeordnet
item.actor_details.uuid principal.user.userid Aus Änderungsprotokoll zugeordnet
item.actor_details.name principal.user.user_display_name Aus Änderungsprotokoll zugeordnet
item.actor_details.email principal.email Aus Änderungsprotokoll zugeordnet
item.actor_uuid security_result.about.resource.attribute.labels Aus Änderungsprotokoll zugeordnet
item.object_type additional.fields Aus Änderungsprotokoll zugeordnet
item.object_uuid security_result.about.resource.attribute.labels Aus Änderungsprotokoll zugeordnet
item.aux_info additional.fields Aus Änderungsprotokoll zugeordnet
item.aux_uuid security_result.about.resource.attribute.labels Aus Änderungsprotokoll zugeordnet
item.session.uuid network.session_id Aus Änderungsprotokoll zugeordnet
item.session.device_uuid target.resource.product_object_id Aus Änderungsprotokoll zugeordnet
item.session.ip principal.ip Aus Änderungsprotokoll zugeordnet
target_user.name target.user.user_display_name Aus Änderungsprotokoll zugeordnet
uuid principal.userid Aus Änderungsprotokoll zugeordnet
type","action","used_version", additional.fields Aus Änderungsprotokoll zugeordnet
target_user.uuid target.user.product_object_id Aus Änderungsprotokoll zugeordnet

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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