Raccogli i log di 1Password

Parser Version: 5.0

Supportata in:

Questo documento spiega come importare i log di 1Password in Google Security Operations utilizzando Google Cloud Storage V2.

1Password è una piattaforma di gestione delle password che aiuta i team ad archiviare, condividere e gestire in modo sicuro credenziali, secret e informazioni sensibili. L'API 1Password Events fornisce l'accesso ai dati relativi ai tentativi di accesso e all'utilizzo degli elementi dal tuo account 1Password Business.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto GCP con l'API Storage di Cloud Storage abilitata
  • Autorizzazioni per creare e gestire i bucket GCS
  • Autorizzazioni per gestire le policy IAM sui bucket GCS
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Un account 1Password Business
  • Un ruolo di proprietario o amministratore nel tuo account 1Password

Crea un bucket Google Cloud Storage

  1. Vai alla console Google Cloud.
  2. Seleziona il tuo progetto o creane uno nuovo.
  3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
  4. Fai clic su Crea bucket.

  5. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Assegna un nome al bucket Inserisci un nome globalmente univoco (ad esempio onepassword-secops-logs)
    Tipo di località Scegli in base alle tue esigenze (Regione, a due regioni, multiregionale)
    Località Seleziona la località (ad esempio us-central1)
    Classe di archiviazione Standard (consigliato per i log ad accesso frequente)
    Controllo degli accessi Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione

  6. Fai clic su Crea.

Raccogli le credenziali di 1Password

Configura l'integrazione dei report Eventi

  1. Accedi al tuo account su 1Password.com.
  2. Seleziona Integrazioni nella barra laterale.
  3. Se hai già configurato altre integrazioni, seleziona Directory nella pagina Integrazioni.
  4. Nella sezione Report Eventi, seleziona Altro.
  5. Nel campo Nome, inserisci un nome per l'integrazione (ad esempio Google SecOps Integration).
  6. Fai clic su Add Integration (Aggiungi integrazione).

Crea un token di connessione

  1. Nella pagina dei dettagli dell'integrazione, fai clic su Aggiungi un token di connessione.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome token: inserisci un nome descrittivo (ad esempio SecOps GCS Collector - SignIn and ItemUsage)
    • Scade dopo: seleziona il periodo di scadenza in base alle tue preferenze. Seleziona Mai per un token senza scadenza oppure scegli 30 giorni, 90 giorni o 180 giorni.
    • Eventi da segnalare: seleziona le seguenti caselle di controllo:
      • Tentativi di accesso
      • Eventi di utilizzo degli elementi
  3. Fai clic su Issue Token (Emetti token).

  4. Nella pagina Salva il token, fai clic su Salva in 1Password o copia il token e salvalo in un luogo sicuro.

  5. Fai clic su Visualizza i dettagli dell'integrazione per confermare che l'integrazione è attiva.

Determina l'URL di base dell'API Events

L'URL di base dipende dal server che ospita il tuo account 1Password:

Se il tuo account è ospitato su L'URL di base dell'API Events è
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

Testa l'accesso all'API

  • Testa le tue credenziali prima di procedere con l'integrazione:

    # 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"

Una risposta corretta restituisce un oggetto JSON con il campo features che elenca i tipi di eventi a cui il token può accedere (ad esempio, ["signinattempts", "itemusages"]).

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con le autorizzazioni per scrivere nel bucket GCS ed essere richiamata da Pub/Sub.

Crea service account

  1. Nella console Google Cloud, vai a IAM e amministrazione > Account di servizio.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome del service account: inserisci onepassword-logs-collector-sa
    • Descrizione account di servizio: inserisci Service account for Cloud Run function to collect 1Password logs
  4. Fai clic su Crea e continua.
  5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
    1. Fai clic su Seleziona un ruolo.
    2. Cerca e seleziona Storage Object Admin.
    3. Fai clic su + Aggiungi un altro ruolo.
    4. Cerca e seleziona Cloud Run Invoker.
    5. Fai clic su + Aggiungi un altro ruolo.
    6. Cerca e seleziona Cloud Functions Invoker.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono obbligatori per:

  • Storage Object Admin: scrive i log nel bucket GCS e gestisce i file di stato
  • Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
  • Cloud Functions Invoker: consente la chiamata della funzione

Concedi le autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni in scrittura sul bucket GCS:

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul tuo bucket (onepassword-secops-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: inserisci onepassword-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com
    • Assegna i ruoli: seleziona Storage Object Admin
  6. Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub in cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console Google Cloud, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci onepassword-logs-trigger
    • Lascia invariate le altre impostazioni predefinite.
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dei tentativi di accesso e di utilizzo degli elementi dall'API 1Password Events e scriverli in GCS.

  1. Nella console Google Cloud, vai a Cloud Run.
  2. Fai clic su Crea servizio.
  3. Seleziona Funzione (utilizza un editor di modifica in linea per creare una funzione).

  4. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome servizio onepassword-logs-collector
    Regione Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)
    Tempo di esecuzione Seleziona Python 3.12 o versioni successive

  5. Nella sezione Trigger (facoltativo):

    1. Fai clic su + Aggiungi trigger.
    2. Seleziona Cloud Pub/Sub.
    3. In Seleziona un argomento Cloud Pub/Sub, scegli onepassword-logs-trigger.
    4. Fai clic su Salva.

  6. Nella sezione Autenticazione:

    1. Seleziona Richiedi autenticazione.
    2. Controlla Identity and Access Management (IAM).

  7. Scorri verso il basso ed espandi Container, networking, sicurezza.

  8. Vai alla scheda Sicurezza:

    • Service account: seleziona onepassword-logs-collector-sa

  9. Vai alla scheda Container:

    1. Fai clic su Variabili e secret.

    2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:

      Nome variabile Valore di esempio Descrizione
      GCS_BUCKET onepassword-secops-logs Nome bucket GCS
      GCS_PREFIX onepassword Prefisso per i file di log
      STATE_KEY onepassword/state.json Percorso del file di stato
      OP_API_BASE https://events.1password.com URL di base dell'API 1Password Events
      OP_BEARER_TOKEN <your-bearer-token> Token di connessione dell'API 1Password Events
      MAX_RECORDS 10000 Numero massimo di record per endpoint per esecuzione
      PAGE_SIZE 1000 Record per pagina (max 1000)
      LOOKBACK_HOURS 24 Periodo di riferimento iniziale in ore

  10. Nella sezione Variabili e secret, scorri fino a Richieste:

    • Timeout della richiesta: inserisci 600 secondi (10 minuti)

  11. Vai alla scheda Impostazioni:

    • Nella sezione Risorse:
      • Memoria: seleziona 512 MiB o un valore superiore
      • CPU: seleziona 1

  12. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0
    • Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto)

  13. Fai clic su Crea.

  14. Attendi la creazione del servizio (1-2 minuti).

  15. Dopo aver creato il servizio, l'editor di codice incorporato si aprirà automaticamente.

Aggiungi codice per la funzione

  1. Inserisci main nel campo Punto di ingresso.

  2. Nell'editor di codice incorporato, crea due file:

    • Primo file: 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

    • Secondo file: requirements.txt:

      functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

  4. Attendi il completamento del deployment (2-3 minuti).

Crea job Cloud Scheduler

Cloud Scheduler pubblicherà i messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console Google Cloud, vai a Cloud Scheduler.
  2. Fai clic su Crea job.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome onepassword-logs-collector-hourly
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza 0 * * * * (ogni ora, allo scoccare dell'ora)
    Fuso orario Seleziona il fuso orario (consigliato UTC)
    Tipo di target Pub/Sub
    Argomento Seleziona onepassword-logs-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Opzioni di frequenza di pianificazione

Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

Frequenza Espressione cron Caso d'uso
Ogni 5 minuti */5 * * * * Volume elevato, bassa latenza
Ogni 15 minuti */15 * * * * Volume medio
Ogni ora 0 * * * * Standard (consigliato)
Ogni 6 ore 0 */6 * * * Basso volume, elaborazione batch
Ogni giorno 0 0 * * * Raccolta dei dati storici

Testa l'integrazione

  1. Nella console Cloud Scheduler, individua onepassword-logs-collector-hourly.
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi alcuni secondi.
  4. Vai a Cloud Run > Servizi.
  5. Fai clic su onepassword-logs-collector.
  6. Fai clic sulla scheda Log.

  7. Verifica che la funzione sia stata eseguita correttamente. Cerca:

    --- 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. Vai a Cloud Storage > Bucket.

  9. Fai clic su onepassword-secops-logs.

  10. Vai alla cartella onepassword/.

  11. Verifica che i nuovi file .ndjson siano stati creati con il timestamp corrente.

Se visualizzi errori nei log:

  • HTTP 401: controlla il token di connessione nella variabile di ambiente OP_BEARER_TOKEN. Il token potrebbe essere scaduto.
  • HTTP 429: limitazione di frequenza. La funzione riprova automaticamente con backoff. L'API 1Password Events consente 600 richieste al minuto e 30.000 richieste all'ora.
  • Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione della funzione Cloud Run.
  • Nessun record restituito: verifica che il token di connessione abbia accesso ai tipi di eventi richiesti utilizzando l'endpoint di introspezione.

Recupera il account di servizio Google SecOps

Google SecOps utilizza un account di servizio univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo account di servizio l'accesso al tuo bucket.

Recupera l'indirizzo email del account di servizio

  1. Vai a Impostazioni > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad es. 1Password Sign-In and Item Usage Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona 1Password come Tipo di log.

  7. Fai clic su Ottieni service account. Verrà visualizzato un indirizzo email univoco del account di servizio, ad esempio:

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

  8. Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

  9. Fai clic su Avanti.

  10. Specifica i valori per i seguenti parametri di input:

    • URL bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

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

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
      • Elimina i file trasferiti: elimina i file dopo il trasferimento riuscito.

      • Elimina i file trasferiti e le directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

    • Età massima dei file: includi i file modificati negli ultimi giorni (il valore predefinito è 180 giorni)

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

  11. Fai clic su Avanti.

  12. Controlla la nuova configurazione del feed di notizie nella schermata Finalizza e poi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps deve avere il ruolo Storage Object Viewer nel bucket GCS.

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic su onepassword-secops-logs.
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: incolla l'indirizzo email del account di servizio Google SecOps
    • Assegna i ruoli: seleziona Storage Object Viewer

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
categoria security_result.category_details Il valore viene preso dal campo category nel log non elaborato.
client.app_name principal.application Il valore viene preso dal campo client.app_name nel log non elaborato.
client.app_version metadata.product_version Il valore viene preso dal campo client.app_version nel log non elaborato.
client.ip_address principal.ip Il valore viene preso dal campo client.ip_address nel log non elaborato.
client.os_name principal.platform Il valore viene preso dal campo client.os_name nel log non elaborato e mappato al valore della piattaforma UDM corrispondente (LINUX, WINDOWS, MAC).
client.os_version principal.platform_version Il valore viene preso dal campo client.os_version nel log non elaborato.
client.platform_name principal.resource.attribute.labels Il valore viene preso dal campo client.platform_name nel log non elaborato.
client.platform_version principal.asset.platform_software.platform_version Il valore viene preso dal campo client.platform_version nel log non elaborato.
country principal.location.country_or_region Il valore viene preso dal campo country nel log non elaborato se location.country non è presente.
item_uuid security_result.about.resource.attribute.labels Il valore viene preso dal campo item_uuid nel log non elaborato.
location.city principal.location.city Il valore viene preso dal campo location.city nel log non elaborato.
location.country principal.location.country_or_region Il valore viene preso dal campo location.country nel log non elaborato.
location.latitude principal.location.region_latitude Il valore viene preso dal campo location.latitude nel log non elaborato.
location.longitude principal.location.region_longitude Il valore viene preso dal campo location.longitude nel log non elaborato.
location.region principal.location.name Il valore viene preso dal campo location.region nel log non elaborato.
session.ip principal.ip Il valore viene preso dal campo session.ip nel log non elaborato.
session_uuid network.session_id Il valore viene preso dal campo session_uuid nel log non elaborato.
target_user.email target.user.email_addresses Il valore viene preso dal campo target_user.email nel log non elaborato.
target_user.uuid target.user.userid Il valore viene preso dal campo target_user.uuid nel log non elaborato.
timestamp metadata.event_timestamp Il valore viene preso dal campo timestamp nel log non elaborato e convertito in secondi e nanosecondi.
tipo additional.fields Il valore viene preso dal campo type nel log non elaborato.
user.email principal.user.email_addresses Il valore viene preso dal campo user.email nel log non elaborato.
nome.utente principal.user.user_display_name Il valore viene preso dal campo user.name nel log non elaborato.
used_version additional.fields Il valore viene preso dal campo used_version nel log non elaborato.
uuid principal.resource.attribute.labels Il valore viene preso dal campo uuid nel log non elaborato.
vault_uuid security_result.about.resource.attribute.labels Il valore viene preso dal campo vault_uuid nel log non elaborato.
N/D extensions.auth Viene creato un oggetto vuoto per questo campo.
N/D metadata.event_type Imposta su USER_LOGIN se la categoria è success o firewall_reported_success, STATUS_UPDATE se non sono presenti informazioni sull'utente e USER_UNCATEGORIZED in caso contrario.
N/D metadata.log_type Da impostare su ONEPASSWORD.
N/D metadata.product_name Da impostare su ONEPASSWORD.
N/D metadata.vendor_name Da impostare su ONEPASSWORD.
N/D security_result.action Imposta su ALLOW se la categoria è success o firewall_reported_success, BLOCK se la categoria è credentials_failed, mfa_failed, modern_version_failed o firewall_failed, altrimenti lascia vuoto.
lt event.idm.read_only_udm.metadata.product_event_type Mappato dal log delle modifiche
item.actor_details.uuid principal.user.userid Mappato dal log delle modifiche
item.actor_details.name principal.user.user_display_name Mappato dal log delle modifiche
item.actor_details.email principal.email Mappato dal log delle modifiche
item.actor_uuid security_result.about.resource.attribute.labels Mappato dal log delle modifiche
item.object_type additional.fields Mappato dal log delle modifiche
item.object_uuid security_result.about.resource.attribute.labels Mappato dal log delle modifiche
item.aux_info additional.fields Mappato dal log delle modifiche
item.aux_uuid security_result.about.resource.attribute.labels Mappato dal log delle modifiche
item.session.uuid network.session_id Mappato dal log delle modifiche
item.session.device_uuid target.resource.product_object_id Mappato dal log delle modifiche
item.session.ip principal.ip Mappato dal log delle modifiche
target_user.name target.user.user_display_name Mappato dal log delle modifiche
uuid principal.userid Mappato dal log delle modifiche
type","action","used_version", additional.fields Mappato dal log delle modifiche
target_user.uuid target.user.product_object_id Mappato dal log delle modifiche

Log delle modifiche

Visualizza il log delle modifiche per questo parser

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.