1Password-Protokolle erfassen

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 Daten zu Anmeldeversuchen und zur Verwendung von Elementen aus Ihrem 1Password Business-Konto.

Hinweise

Prüfen Sie, ob die folgenden Voraussetzungen erfüllt sind:

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

1Password-Anmeldedaten erfassen

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 Seite mit den Integrationsdetails auf Bearer-Token hinzufügen.
  2. Geben Sie die folgenden Konfigurationsdetails an:
    • Token Name: 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: Klicken Sie die folgenden Kästchen an:
      • Anmeldeversuche
      • Ereignisse zur Artikelnutzung
  3. Klicken Sie auf 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.

Events API-Basis-URL 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 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 & Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: 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-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.

Diese Rollen sind erforderlich für:

  • Storage-Objekt-Administrator: Protokolle in GCS-Bucket schreiben und Statusdateien verwalten
  • Cloud Run-Aufrufer: Pub/Sub darf die Funktion aufrufen.
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

IAM-Berechtigungen für GCS-Bucket erteilen

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-Objekt-Administrator 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. 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 onepassword-logs-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 Anmeldeversuchs- und Artikelnutzungslogs von der 1Password Events 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 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. 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 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 Protokolldateien
      STATE_KEY onepassword/state.json Statusdateipfad
      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ückblickzeitraum in Stunden

  10. Scrollen Sie im Bereich Variablen und Secrets 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 (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 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:

    • 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',
    'User-Agent': 'GoogleSecOps-1PasswordCollector/1.0',
  }

  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, wodurch die Cloud Run-Funktion ausgelöst wird.

  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 * * * * (jede Stunde, zur vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema onepassword-logs-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 onepassword-logs-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 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 Fehler in den Logs angezeigt werden:

  • HTTP 401: Prüfen Sie das Bearer-Token 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 Cloud Run-Funktionskonfiguration festgelegt sind.
  • Keine Datensätze zurückgegeben: Prüfen Sie mit dem Introspect-Endpunkt, ob Ihr Bearer-Token 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 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 Logtyp aus.

  7. Klicken Sie auf Dienstkonto abrufen. Es wird eine eindeutige E-Mail-Adresse für das Dienstkonto 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 Löschoption aus:

      • Nie: Es werden niemals Dateien nach Übertragungen gelöscht (empfohlen für Tests).
      • Übertragene Dateien löschen: Dateien werden nach der erfolgreichen Übertragung gelöscht.

      • Übertragene Dateien und leere Verzeichnisse löschen: Löscht Dateien und leere Verzeichnisse nach der erfolgreichen Übertragung.

    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden (Standard ist 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 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 die Rolle Storage-Objekt-Betrachter 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-Objekt-Betrachter 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 wird aus dem Feld client.app_version im Rohlog übernommen.
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 wird aus dem Feld client.platform_name im Rohlog übernommen.
client.platform_version principal.asset.platform_software.platform_version Der Wert wird aus dem Feld client.platform_version im Rohlog übernommen.
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 wird aus dem Feld location.latitude im Rohlog übernommen.
location.longitude principal.location.region_longitude Der Wert wird aus dem Feld location.longitude im Rohlog übernommen.
location.region principal.location.name Der Wert wird aus dem Feld location.region im Rohlog übernommen.
session.ip principal.ip Der Wert wird aus dem Feld session.ip im Rohlog übernommen.
session_uuid network.session_id Der Wert wird aus dem Feld session_uuid im Rohlog übernommen.
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 wird aus dem Feld target_user.uuid im Rohlog übernommen.
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 wird aus dem Feld user.name im Rohlog übernommen.
used_version additional.fields Der Wert wird aus dem Feld used_version im Rohlog übernommen.
uuid principal.resource.attribute.labels Der Wert wird aus dem Feld uuid im Rohlog übernommen.
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 Auf USER_LOGIN festgelegt, wenn die Kategorie success oder firewall_reported_success ist, STATUS_UPDATE, wenn keine Nutzerinformationen vorhanden sind, und USER_UNCATEGORIZED in allen anderen Fällen.
– metadata.log_type Legen Sie ONEPASSWORD fest.
– metadata.product_name Legen Sie ONEPASSWORD fest.
– metadata.vendor_name Legen Sie ONEPASSWORD fest.
– security_result.action Wird auf ALLOW gesetzt, wenn die Kategorie success oder firewall_reported_success ist, auf BLOCK, wenn die Kategorie credentials_failed, mfa_failed, modern_version_failed oder firewall_failed ist. Andernfalls bleibt das Feld leer.

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