Raccogliere gli audit log di Lucid

Supportato in:

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

Lucid Software offre una suite di collaborazione visiva che include Lucidchart, Lucidspark e Lucidscale. L'API Audit Logs, disponibile esclusivamente per i clienti di Enterprise Shield, acquisisce eventi di sicurezza e conformità in tutta l'organizzazione, tra cui accesso all'account, attività sui documenti, gestione degli utenti, azioni amministrative e operazioni del team.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto GCP con l'API Cloud Storage abilitata
  • Autorizzazioni per creare e gestire bucket GCS
  • Autorizzazioni per gestire le policy IAM nei bucket GCS
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Un account Lucid Enterprise Shield con privilegi di amministratore o proprietario dell'account
  • Accesso al Lucid Developer Portal con gli strumenti per sviluppatori abilitati

Attivare gli strumenti per sviluppatori in Lucid

Prima di creare le credenziali API, devi avere accesso al portale per sviluppatori Lucid. Esistono due modi per attivare gli strumenti per sviluppatori:

Opzione 1: attivare tramite le impostazioni utente

  1. Accedi a lucid.app.
  2. Fai clic sull'icona del profilo nell'angolo in alto a destra.
  3. Seleziona Impostazioni account.

  4. Seleziona la casella di controllo Attiva strumenti per sviluppatori.

Opzione 2: abilita tramite l'assegnazione del ruolo amministrativo

  1. Accedi a lucid.app come proprietario dell'account o amministratore del team.
  2. Vai al pannello di amministrazione.
  3. Vai alla sezione Utenti.
  4. Seleziona l'utente di destinazione.

  5. Modifica i ruoli dell'utente e assegna il ruolo Sviluppatore.

Configurare l'accesso all'API Lucid

Per consentire a Google SecOps di recuperare i log di controllo, devi creare un client OAuth 2.0 e generare un token di accesso a livello di account con l'ambito account.audit.logs.

Creare un'applicazione e un client OAuth 2.0

  1. Vai al portale per sviluppatori Lucid.
  2. Fai clic su Crea applicazione.
  3. Inserisci un nome per l'applicazione (ad esempio, Chronicle SIEM Integration).
  4. Fai clic sull'applicazione appena creata per accedere alle relative impostazioni.
  5. Vai alla scheda OAuth 2.0.

  6. Inserisci un nome per il client OAuth 2.0 (ad esempio, Chronicle Audit Log Collector).

  7. Fai clic su Crea client OAuth 2.0.

Registra le credenziali client

Dopo aver creato il client OAuth 2.0, il portale mostra le tue credenziali:

  • ID client: il tuo identificatore client univoco.
  • Client secret: la chiave segreta dell'API.

Importante: copia e salva immediatamente il client secret. Se il client secret è compromesso, fai clic sul pulsante Reimposta client secret nella pagina delle impostazioni di OAuth 2.0. La reimpostazione del secret revoca immediatamente l'accesso finché il nuovo secret non viene aggiornato nell'integrazione.

Registrare un URI di reindirizzamento

  1. Nella pagina delle impostazioni OAuth 2.0, fai clic su Aggiungi URI di reindirizzamento.

  2. Inserisci l'URI di reindirizzamento per l'integrazione. Se utilizzi il reindirizzamento di test fornito da Lucid, inserisci:

    https://lucid.app/oauth2/clients/<CLIENT_ID>/redirect

    Sostituisci <CLIENT_ID> con il tuo ID client effettivo.

Ottenere un token di accesso a livello di account

L'API Audit Logs richiede un token account (non un token utente). Un amministratore dell'account deve autorizzare il client OAuth 2.0 a creare un token per conto dell'account.

  1. Indirizza un amministratore dell'account al seguente URL di autorizzazione in un browser:

    https://lucid.app/oauth2/authorizeAccount?client_id=<CLIENT_ID>&redirect_uri=<REDIRECT_URI>&scope=account.audit.logs

    Sostituisci <CLIENT_ID> e <REDIRECT_URI> con i tuoi valori effettivi.

  2. L'amministratore esamina le autorizzazioni richieste nella schermata per il consenso e fa clic su Consenti.

  3. Lucid reindirizza all'URI di reindirizzamento con un parametro di query di autorizzazione code.

  4. Scambia il codice di autorizzazione con un token di accesso effettuando una richiesta POST all'endpoint del token:

    curl --request POST \
  --url https://api.lucid.co/oauth2/token \
  --header 'Content-Type: application/json' \
  --data '{
    "grant_type": "authorization_code",
    "client_id": "<CLIENT_ID>",
    "client_secret": "<CLIENT_SECRET>",
    "code": "<AUTHORIZATION_CODE>",
    "redirect_uri": "<REDIRECT_URI>"
  }'

  5. La risposta include un access_token e un refresh_token. Registra entrambi i valori in modo sicuro.

Verifica l'accesso API

  • Verifica che il token di accesso funzioni effettuando una richiesta di test:

    curl --request GET \
  --url 'https://api.lucid.co/auditLogs?pageSize=1' \
  --header 'Authorization: Bearer <ACCESS_TOKEN>' \
  --header 'Lucid-Api-Version: 1' \
  --header 'Accept: application/json'

Una risposta positiva restituisce un array JSON di eventi dei log di controllo.

Autorizzazioni API richieste

  • Il client OAuth 2.0 richiede il seguente ambito:

    Ambito Tipo di token Finalità
    account.audit.logs Account Recuperare gli eventi dei log di controllo per l'account

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 univoco globale (ad esempio lucid-audit-logs-gcs).
    Tipo di località Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
    Località Seleziona la posizione (ad esempio, us-central1).
    Classe di archiviazione Standard (consigliato per i log a cui si accede di 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.

Crea un account di servizio per la funzione Cloud Run

  1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome del service account: inserisci lucid-audit-collector-sa
    • Descrizione service account: inserisci Service account for Cloud Run function to collect Lucid audit 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.

Concedi autorizzazioni IAM sul bucket GCS

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

Crea argomento Pub/Sub

  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 lucid-audit-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 dall'API Lucid Audit Logs 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 in linea per creare una funzione).

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

    Impostazione Valore
    Nome servizio lucid-audit-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 lucid-audit-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 lucid-audit-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 lucid-audit-logs-gcs Nome bucket GCS
    GCS_PREFIX lucid-audit Prefisso per i file di log
    STATE_KEY lucid-audit/state.json Percorso file di stato
    LUCID_CLIENT_ID your-oauth-client-id ID client OAuth 2.0 di Lucid
    LUCID_CLIENT_SECRET your-oauth-client-secret Client secret OAuth 2.0 di Lucid
    LUCID_REFRESH_TOKEN your-refresh-token Token di aggiornamento OAuth 2.0 di Lucid
    LOOKBACK_HOURS 24 Periodo di riferimento iniziale
    PAGE_SIZE 200 Record per pagina API (max. 200)
    MAX_PAGES 50 Numero massimo di pagine per esecuzione

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

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

  13. Fai clic su Crea.

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

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

Aggiungi codice per la funzione

  1. Inserisci main nel campo Entry point (Punto di ingresso).
  2. Nell'editor di codice incorporato, crea due file:

  • main.py:

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

http = urllib3.PoolManager(
    timeout=urllib3.Timeout(connect=10.0, read=60.0),
    retries=False,
)

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'lucid-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'lucid-audit/state.json')
LUCID_CLIENT_ID = os.environ.get('LUCID_CLIENT_ID')
LUCID_CLIENT_SECRET = os.environ.get('LUCID_CLIENT_SECRET')
LUCID_REFRESH_TOKEN = os.environ.get('LUCID_REFRESH_TOKEN')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '200'))
MAX_PAGES = int(os.environ.get('MAX_PAGES', '50'))

API_BASE = 'https://api.lucid.co'

@functions_framework.cloud_event
def main(cloud_event):
    if not all([GCS_BUCKET, LUCID_CLIENT_ID, LUCID_CLIENT_SECRET, LUCID_REFRESH_TOKEN]):
        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_val = state['last_event_time']
                if last_val.endswith('Z'):
                    last_val = last_val[:-1] + '+00:00'
                last_time = datetime.fromisoformat(last_val)
                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 audit logs from {last_time.isoformat()} to {now.isoformat()}")

        access_token, new_refresh_token = refresh_access_token()

        if new_refresh_token:
            save_refresh_token(bucket, new_refresh_token)

        records, newest_event_time = fetch_audit_logs(access_token, last_time, now)

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

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

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

        print(f"Wrote {len(records)} records to 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)} audit log records")

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

def refresh_access_token():
    url = f"{API_BASE}/oauth2/token"
    body = json.dumps({
        'grant_type': 'refresh_token',
        'refresh_token': LUCID_REFRESH_TOKEN,
        'client_id': LUCID_CLIENT_ID,
        'client_secret': LUCID_CLIENT_SECRET
    }).encode('utf-8')

    response = http.request(
        'POST', url,
        body=body,
        headers={'Content-Type': 'application/json'}
    )

    if response.status != 200:
        raise Exception(
            f"Token refresh failed: {response.status} - "
            f"{response.data.decode('utf-8')}"
        )

    data = json.loads(response.data.decode('utf-8'))
    access_token = data.get('access_token')
    new_refresh_token = data.get('refresh_token')

    if not access_token:
        raise Exception("No access_token in token refresh response")

    print("Successfully refreshed Lucid API access token")
    return access_token, new_refresh_token

def fetch_audit_logs(access_token, start_time, end_time):
    records = []
    newest_time = None
    page_num = 0
    next_page_url = None

    since_str = start_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')
    until_str = end_time.strftime('%Y-%m-%dT%H:%M:%S.000Z')

    while page_num < MAX_PAGES:
        page_num += 1

        if next_page_url:
            url = next_page_url
        else:
            url = (
                f"{API_BASE}/auditLogs"
                f"?pageSize={PAGE_SIZE}"
                f"&since={since_str}"
                f"&until={until_str}"
            )

        headers = {
            'Authorization': f'Bearer {access_token}',
            'Lucid-Api-Version': '1',
            'Accept': 'application/json'
        }

        response = http.request('GET', url, headers=headers)

        if response.status == 429:
            print(f"Rate limited on page {page_num}. Stopping pagination.")
            break

        if response.status != 200:
            print(
                f"API error on page {page_num}: {response.status} - "
                f"{response.data.decode('utf-8')}"
            )
            break

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

        if not page_results:
            print(f"No more results at page {page_num}")
            break

        records.extend(page_results)
        print(f"Page {page_num}: Retrieved {len(page_results)} events "
              f"(total: {len(records)})")

        for event in page_results:
            try:
                event_time = event.get('eventTimestamp')
                if event_time:
                    if newest_time is None or event_time > newest_time:
                        newest_time = event_time
            except Exception as e:
                print(f"Warning: Could not parse event time: {e}")

        link_header = response.headers.get('Link', '')
        next_page_url = parse_link_header(link_header)

        if not next_page_url:
            print(f"No next page link found. Pagination complete.")
            break

        if len(page_results) < PAGE_SIZE:
            break

    print(f"Total audit log records fetched: {len(records)} from {page_num} pages")
    return records, newest_time

def parse_link_header(link_header):
    if not link_header:
        return None

    match = re.search(r'<([^>]+)>;\s*rel="next"', link_header)
    if match:
        return match.group(1)
    return None

def load_state(bucket):
    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):
    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 save_refresh_token(bucket, new_refresh_token):
    try:
        token_key = f"{GCS_PREFIX}/refresh_token.json"
        blob = bucket.blob(token_key)
        blob.upload_from_string(
            json.dumps({'refresh_token': new_refresh_token}, indent=2),
            content_type='application/json'
        )
        print("Saved new refresh token to GCS")
    except Exception as e:
        print(f"Warning: Could not save refresh token: {e}")

  • requirements.txt:

      functions-framework==3.*
  google-cloud-storage==2.*
  urllib3>=2.0.0
  ```
  1. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

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

Crea job Cloud Scheduler

  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 lucid-audit-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 (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona lucid-audit-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il tuo job (lucid-audit-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 lucid-audit-collector.
  6. Fai clic sulla scheda Log.

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

    Fetching audit logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Successfully refreshed Lucid API access token
Page 1: Retrieved X events (total: X)
Wrote X records to gs://lucid-audit-logs-gcs/lucid-audit/lucid_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X audit log records

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic su lucid-audit-logs-gcs.

  10. Vai alla cartella lucid-audit/.

  11. Verifica che sia stato creato un nuovo file .ndjson con il timestamp corrente.

Se nei log vengono visualizzati errori:

  • HTTP 401: verifica che le variabili di ambiente LUCID_CLIENT_ID, LUCID_CLIENT_SECRET e LUCID_REFRESH_TOKEN siano corrette
  • HTTP 403: verifica che il client OAuth 2.0 abbia l'ambito account.audit.logs e che il token sia un token account
  • HTTP 429: limitazione della frequenza: la funzione interromperà la paginazione e riprenderà alla successiva esecuzione pianificata
  • Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione di Cloud Run Functions

Categorie di eventi di audit log

I log di controllo Lucid sono organizzati nelle seguenti categorie di eventi:

Categoria Descrizione
Accessi Eventi associati agli accessi degli utenti
Contenuti Eventi associati all'accesso e alla modifica di documenti e cartelle
Amministrazione Eventi associati all'attività amministrativa e alle modifiche all'account
Utente Eventi associati alle azioni dell'utente nelle impostazioni personali
Team Eventi associati alle operazioni del team

Per un elenco completo dei tipi di eventi e dei relativi schemi, consulta la documentazione Eventi dei log di controllo di Lucid.

Ambiente FedRAMP

Gli utenti nell'ambiente Lucid FedRAMP utilizzano autorizzazioni ed endpoint API diversi. Per gli URL degli endpoint corretti, consulta la documentazione relativa all'ambiente Lucid FedRAMP.

Recuperare il account di servizio Google SecOps

  1. Vai a Impostazioni SIEM > 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 esempio, Lucid Audit Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Lucid come Tipo di log.

  7. Fai clic su Ottieni service account. Verrà visualizzato un indirizzo email del account di servizio univoco, 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 del bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

      gs://lucid-audit-logs-gcs/lucid-audit/

    • 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 file trasferiti: elimina i file dopo il trasferimento riuscito.

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

    • Età massima del file: includi i file modificati nell'ultimo numero di 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 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 Visualizzatore oggetti Storage nel tuo bucket GCS.

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

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
document_opened additional.fields Unite alle etichette create da ogni campo di origine, se non vuoto
share_link_enable additional.fields
restricted_account_enable additional.fields
event1.documentIds additional.fields
team_folder additional.fields
method_type additional.fields
extensions.auth.type extensions.auth.type Imposta "AUTHTYPE_UNSPECIFIED" per gli eventi di accesso/disconnessione
eventTimestamp metadata.event_timestamp Convertito utilizzando la corrispondenza della data ISO8601 o AAAA-MM-GGTHH:mm:ss.SSSSSSZ
has_user_login metadata.event_type Impostato in base ai flag has_*: USER_LOGIN se has_user_login e has_target_user, USER_LOGOUT se has_user_logout e has_target_user, USER_RESOURCE_UPDATE_CONTENT se has_user_resource_updated e has_target_resource e has_principal_user, USER_CREATION se has_principal_user e has_target_application e has_target_user, USER_RESOURCE_CREATION se has_target_resource e has_principal_user, FILE_CREATION se has_target_file e has_principal e has_target, USER_RESOURCE_ACCESS se has_target_resource, USER_COMMUNICATION se has_principal_user, STATUS_UPDATE se has_principal e has_target false, altrimenti GENERIC_EVENT
has_user_logout metadata.event_type
has_user_resource_updated metadata.event_type
has_principal_user metadata.event_type
has_target_resource metadata.event_type
has_target_file metadata.event_type
has_principal metadata.event_type
has_target_user metadata.event_type
has_target_application metadata.event_type
has_target metadata.event_type
event1.event1Type metadata.product_event_type Valore copiato direttamente
actor.actorIp principal.asset.ip Valore copiato direttamente se non è vuoto
actor.actorIp principal.ip Valore copiato direttamente se non è vuoto
actor.actorAccountId principal.resource.id Valore copiato direttamente se non è vuoto
actor.actorClient principal.resource.name Valore copiato direttamente se non è vuoto
flowId principal.resource.product_object_id Valore copiato direttamente se non è vuoto
actor.actorType principal.user.attribute.roles Unito da actor_type se eventType non è login/logout e actor_type non è vuoto
actor.actorEmail principal.user.email_addresses Unito se actor_email non è vuoto e l'indirizzo email è valido e eventType non è login/logout
actor.actorUserId principal.user.userid Valore copiato direttamente se non è vuoto e eventType non è login/logout
event1.registrationMethod security_result.description Valore copiato direttamente se non è vuoto
event1.source target.application Valore copiato direttamente se non è vuoto
event1.publishedLink.link target.file.full_path Valore copiato direttamente se non è vuoto
event1.filename target.file.names Unito se non vuoto
targetData._targetType target.resource.attribute.labels Unito alle etichette create da ogni campo di origine, se non è vuoto
targetData._targetId target.resource.attribute.labels
event1.format target.resource.attribute.labels
event1.method target.resource.attribute.labels
event1.publishedLink.format target.resource.attribute.labels
accountId target.resource.id Valore copiato direttamente se non è vuoto
event1.destinationFolderName target.resource.name Impostato su destinationFolderName se non è vuoto, altrimenti su folderName se non è vuoto, altrimenti su publishedLink.name se non è vuoto
event1.folderName target.resource.name
event1.publishedLink.name target.resource.name
event1.documentId target.resource.product_object_id Valore copiato direttamente se non è vuoto
actor.actorType target.user.attribute.roles Unito da actor_type se eventType è login/logout e da event_role se non è vuoto
event1.role target.user.attribute.roles
actor.actorEmail target.user.email_addresses Unito da actor_email se login/logout e valido e da userEmail in _target
targetData.userEmail target.user.email_addresses
event1.destinationFolderId target.user.product_object_id Impostato su destinationFolderId se non è vuoto, altrimenti su folderId se non è vuoto
event1.folderId target.user.product_object_id
targetData.displayName target.user.user_display_name Valore copiato direttamente se non è vuoto
actor.actorUserId target.user.userid Valore copiato direttamente se non è vuoto e eventType è login/logout
event1.product metadata.product_name Valore del prodotto se non è vuoto, altrimenti "LUCID"
metadata.vendor_name metadata.vendor_name Imposta su "LUCID"

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.