Raccogliere i log di Privacy-i

Supportato in:

Google SecOps SIEM

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

Privacy-i è una piattaforma di monitoraggio della conformità e della privacy dei dati degli endpoint sviluppata da Somansa (ora acquisita da Mitsui Bussan Secure Directions). La piattaforma fornisce rilevamento di dati sensibili, classificazione e applicazione delle norme relative ai dati sensibili negli endpoint. L'API REST Privacy-i fornisce accesso programmatico ai log di ispezione, alle segnalazioni di un problema e ai dati sull'attività degli agenti.

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 sui bucket GCS
• Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
• Accesso amministrativo alla console di gestione di Privacy-i
• Credenziali API (chiave API o credenziali OAuth2) per l'API REST Privacy-i

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 privacy-i-logs).
   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 ad accesso frequente)
   Controllo dell'accesso	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 dell'API Privacy-i

Ottieni la chiave API

1. Accedi alla console di gestione Privacy-i con le credenziali di amministratore.
2. Vai a Settings > API Management (o System > API Configuration).
3. Fai clic su Genera chiave API.
4. Inserisci un nome per la chiave API (ad esempio, Google SecOps Integration).

5. Copia e salva i seguenti dettagli in una posizione sicura:

   • Chiave API: il valore della chiave API generata
   • URL del server: l'URL del server di gestione di Privacy-i (ad esempio, https://privacy-i.your-domain.com)
   Nota: la chiave API viene visualizzata una sola volta. Conservala in modo sicuro. In caso di smarrimento, dovrai rigenerarlo.

Determinare l'URL di base dell'API

L'URL di base dell'API Privacy-i è l'URL del server di gestione:

Formato	Esempio
URL del server	https://privacy-i.your-domain.com/api

Nota: sostituisci privacy-i.your-domain.com con il nome host effettivo del server di gestione Privacy-i.

Testare l'accesso API

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

  # Replace with your actual credentials
  PRIVACY_I_API_KEY="your-api-key"
  PRIVACY_I_BASE_URL="https://privacy-i.your-domain.com/api"
  
  # Test API access - list recent events
  curl -s -X GET "${PRIVACY_I_BASE_URL}/v1/events?limit=1" \
    -H "Authorization: Bearer ${PRIVACY_I_API_KEY}" \
    -H "Accept: application/json"
  

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni di scrittura nel bucket GCS e di invocazione da parte di 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 privacy-i-logs-collector-sa
   • Descrizione service account: inserisci Service account for Cloud Run function to collect Privacy-i 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 di funzioni

Concedi autorizzazioni IAM sul bucket GCS

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

1. Vai a Cloud Storage > Bucket.
2. Fai clic sul nome del bucket (ad esempio privacy-i-logs).
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 (ad esempio, privacy-i-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 a 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 privacy-i-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 dall'API REST Privacy-i e scriverli in GCS.

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

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

   Impostazione	Valore
   Nome servizio	privacy-i-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 l'argomento privacy-i-logs-trigger.
   4. Fai clic su Salva.

6. Nella sezione Autenticazione:

   1. Seleziona Richiedi autenticazione.
   2. Controlla Identity and Access Management (IAM).
   Nota: Pub/Sub gestirà automaticamente l'autenticazione quando viene richiamata la funzione.

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

8. Vai alla scheda Sicurezza:

   • Service account: seleziona il account di servizio privacy-i-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	privacy-i-logs	Nome bucket GCS
   GCS_PREFIX	privacy-i	Prefisso per i file di log
   STATE_KEY	privacy-i/state.json	Percorso file di stato
   PRIVACY_I_API_KEY	your-api-key	Chiave API Privacy-i
   PRIVACY_I_BASE_URL	https://privacy-i.your-domain.com/api	URL di base dell'API Privacy-i
   MAX_RECORDS	5000	Numero massimo di record per esecuzione
   PAGE_SIZE	1000	Record per pagina
   LOOKBACK_HOURS	24	Periodo di riferimento iniziale

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 (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, si aprirà automaticamente l'editor di codice incorporato.

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', 'privacy-i')
     STATE_KEY = os.environ.get('STATE_KEY', 'privacy-i/state.json')
     PRIVACY_I_API_KEY = os.environ.get('PRIVACY_I_API_KEY')
     PRIVACY_I_BASE_URL = os.environ.get('PRIVACY_I_BASE_URL')
     MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
     PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
     LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
     
     def parse_datetime(value: str) -> datetime:
       """Parse ISO datetime string to datetime object."""
       if value.endswith("Z"):
         value = value[:-1] + "+00:00"
       return datetime.fromisoformat(value)
     
     @functions_framework.cloud_event
     def main(cloud_event):
       """
       Cloud Run function triggered by Pub/Sub to fetch Privacy-i
       inspection and incident logs and write to GCS.
     
       Args:
         cloud_event: CloudEvent object containing Pub/Sub message
       """
     
       if not all([GCS_BUCKET, PRIVACY_I_API_KEY, PRIVACY_I_BASE_URL]):
         print('Error: Missing required environment variables')
         return
     
       try:
         bucket = storage_client.bucket(GCS_BUCKET)
     
         # Load state
         state = load_state(bucket, STATE_KEY)
     
         # Determine time window
         now = datetime.now(timezone.utc)
         last_time = None
     
         if isinstance(state, dict) and state.get("last_event_time"):
           try:
             last_time = parse_datetime(state["last_event_time"])
             # Overlap by 2 minutes to catch any delayed events
             last_time = last_time - timedelta(minutes=2)
           except Exception as e:
             print(f"Warning: Could not parse last_event_time: {e}")
     
         if last_time is None:
           last_time = now - timedelta(hours=LOOKBACK_HOURS)
     
         print(f"Fetching logs from {last_time.isoformat()} to {now.isoformat()}")
     
         # Fetch logs from multiple endpoints
         all_records = []
         newest_event_time = None
     
         for endpoint_type in ['events', 'incidents']:
           records, newest_time = fetch_logs(
             endpoint_type=endpoint_type,
             start_time=last_time,
             end_time=now,
             page_size=PAGE_SIZE,
             max_records=MAX_RECORDS,
           )
           all_records.extend(records)
           if newest_time:
             if newest_event_time is None or parse_datetime(newest_time) > parse_datetime(newest_event_time):
               newest_event_time = newest_time
     
         if not all_records:
           print("No new log records found.")
           save_state(bucket, STATE_KEY, now.isoformat())
           return
     
         # Write to GCS as NDJSON
         timestamp = now.strftime('%Y%m%d_%H%M%S')
         object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
         blob = bucket.blob(object_key)
     
         ndjson = '\n'.join([json.dumps(record, ensure_ascii=False) for record in all_records]) + '\n'
         blob.upload_from_string(ndjson, content_type='application/x-ndjson')
     
         print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")
     
         # Update state with newest event time
         if newest_event_time:
           save_state(bucket, STATE_KEY, newest_event_time)
         else:
           save_state(bucket, STATE_KEY, now.isoformat())
     
         print(f"Successfully processed {len(all_records)} 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, last_event_time_iso: str):
       """Save the last event timestamp to GCS state file."""
       try:
         state = {'last_event_time': last_event_time_iso}
         blob = bucket.blob(key)
         blob.upload_from_string(
           json.dumps(state, indent=2),
           content_type='application/json'
         )
         print(f"Saved state: last_event_time={last_event_time_iso}")
       except Exception as e:
         print(f"Warning: Could not save state: {e}")
     
     def fetch_logs(endpoint_type: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int):
       """
       Fetch logs from Privacy-i REST API
       with offset-based pagination and rate limiting.
     
       Args:
         endpoint_type: API endpoint type (events, incidents)
         start_time: Start time for log query
         end_time: End time for log query
         page_size: Number of records per page
         max_records: Maximum total records to fetch
     
       Returns:
         Tuple of (records list, newest_event_time ISO string)
       """
       api_base = PRIVACY_I_BASE_URL.rstrip('/')
       endpoint = f"{api_base}/v1/{endpoint_type}"
     
       headers = {
         'Authorization': f'Bearer {PRIVACY_I_API_KEY}',
         'Accept': 'application/json',
         'User-Agent': 'GoogleSecOps-PrivacyICollector/1.0'
       }
     
       records = []
       newest_time = None
       page_num = 0
       offset = 0
       backoff = 1.0
     
       start_iso = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
       end_iso = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')
     
       while True:
         page_num += 1
     
         if len(records) >= max_records:
           print(f"Reached max_records limit ({max_records}) for {endpoint_type}")
           break
     
         url = f"{endpoint}?startDate={start_iso}&endDate={end_iso}&limit={min(page_size, max_records - len(records))}&offset={offset}"
     
         try:
           response = http.request('GET', url, headers=headers)
     
           # Handle rate limiting with exponential backoff
           if response.status == 429:
             retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
             print(f"Rate limited (429). Retrying after {retry_after}s...")
             time.sleep(retry_after)
             backoff = min(backoff * 2, 30.0)
             continue
     
           backoff = 1.0
     
           if response.status != 200:
             print(f"HTTP Error: {response.status}")
             response_text = response.data.decode('utf-8')
             print(f"Response body: {response_text}")
             return records, newest_time
     
           data = json.loads(response.data.decode('utf-8'))
     
           page_results = data.get('data', data.get('results', data.get('items', [])))
     
           if not page_results:
             print(f"No more results (empty page) for {endpoint_type}")
             break
     
           print(f"{endpoint_type} page {page_num}: Retrieved {len(page_results)} events")
     
           # Add endpoint type for identification
           for event in page_results:
             event['_privacy_i_log_type'] = endpoint_type
     
           records.extend(page_results)
     
           # Track newest event time
           for event in page_results:
             try:
               event_ts = event.get('timestamp') or event.get('eventTime') or event.get('createdAt')
               if event_ts:
                 event_time = str(event_ts)
                 if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time):
                   newest_time = event_time
             except Exception as e:
               print(f"Warning: Could not parse event time: {e}")
     
           # Check for more results
           total = data.get('total', data.get('totalCount', 0))
           if total and (offset + len(page_results)) >= total:
             print(f"No more pages for {endpoint_type} (reached total)")
             break
     
           if len(page_results) < page_size:
             print(f"No more pages for {endpoint_type} (last page not full)")
             break
     
           offset += len(page_results)
     
         except Exception as e:
           print(f"Error fetching {endpoint_type} logs: {e}")
           return records, newest_time
     
       print(f"Retrieved {len(records)} total {endpoint_type} records from {page_num} pages")
       return records, newest_time
     

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

   Nota: la configurazione del trigger Pub/Sub crea automaticamente le sottoscrizioni e le autorizzazioni necessarie.

Crea job Cloud Scheduler

Cloud Scheduler pubblicherà 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	privacy-i-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 (UTC consigliato)
   Tipo di target	Pub/Sub
   Argomento	Seleziona l'argomento privacy-i-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 * * *	Volume basso, elaborazione batch
Ogni giorno	0 0 * * *	Raccolta dei dati storici

Testare l'integrazione

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

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

   Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
   events page 1: Retrieved X events
   incidents page 1: Retrieved X events
   Wrote X records to gs://privacy-i-logs/privacy-i/logs_YYYYMMDD_HHMMSS.ndjson
   Successfully processed X records
   

8. Vai a Cloud Storage > Bucket.

9. Fai clic sul nome del bucket (privacy-i-logs).

10. Vai alla cartella privacy-i/.

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

Se visualizzi errori nei log:

• HTTP 401: controlla la chiave API nelle variabili di ambiente
• HTTP 403: verifica che la chiave API disponga delle autorizzazioni richieste nella console di gestione Privacy-i
• HTTP 429: limitazione della frequenza: la funzione verrà ritentata automaticamente con backoff
• Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate

Configura un feed in Google SecOps per importare i log di Privacy-i

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, Privacy-i Logs).
5. Seleziona Google Cloud Storage V2 come Tipo di origine.
6. Seleziona Privacy-i come Tipo di log.

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

   [e-mail]
   

8. Copia l'indirizzo email.

   Nota :ogni istanza di Google SecOps ha un account di servizio univoco. Non utilizzare service account di altre documentazioni o esempi.

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://privacy-i-logs/privacy-i/
      

      • Sostituisci:
        • privacy-i-logs: il nome del bucket GCS.
        • privacy-i: prefisso/percorso della cartella facoltativo in cui sono archiviati i log (lascia vuoto per la directory principale).
    Nota: includi sempre la barra finale (/) alla fine dell'URI.

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

        Nota: se selezioni un'opzione di eliminazione, il account di servizio deve disporre del ruolo Storage Object Admin anziché Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.

    • 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 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 sul nome del bucket.
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.

Nota: se prevedi di utilizzare l'opzione di eliminazione "Elimina i file trasferiti" o "Elimina i file trasferiti e le directory vuote", assegna il ruolo Storage Object Admin anziché Storage Object Viewer.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logica
has_principal, has_target_file, has_user	metadata.event_type	Impostato su SCAN_FILE se has_principal e has_target_file, altrimenti USER_UNCATEGORIZED se has_user, altrimenti STATUS_UPDATE se has_principal, altrimenti GENERIC_EVENT
elog_incidentlogguid, efile_incidentlogguid, guid	metadata.product_log_id	Valore di elog_incidentlogguid se non è vuoto, altrimenti efile_incidentlogguid se non è vuoto, altrimenti guid
datatype	metadata.product_event_type	Valore copiato direttamente
productversion	metadata.product_version	Valore copiato direttamente
	metadata.product_name	Impostato su "PRIVACY_I"
	metadata.vendor_name	Imposta su "PRIVACY_I"
dfile_agentip, ip	principal.asset.ip	Unito da dfile_agentip se non è vuoto, quindi ip se non è vuoto
dfile_agentip, ip	principal.ip	Unito da dfile_agentip se non è vuoto, quindi ip se non è vuoto
dfile_computername	principal.asset.asset_id	Concatenato come "Computer:%{dfile_computername}"
computername	principal.asset.hostname	Concatenato come "Computer:%{computername}"
osserial_label, computerguid_label	principal.asset.attribute.labels	Unito da osserial_label e computerguid_label
productid	principal.asset.product_object_id	Valore copiato direttamente
dlog_ostype, osname	principal.platform	Impostato in base all'enumerazione dlog_ostype (0=WINDOWS,1=LINUX,2=MAC), quindi sovrascritto in base all'espressione regolare osname
macaddr	principal.mac	Unito da macaddr
dfile_userid, userid, admin_id	principal.user.userid	Impostato su dfile_userid, poi sovrascritto da userid se non è vuoto, poi da admin_id se non è vuoto
dfile_username, empname, admin_name	principal.user.user_display_name	Impostato su dfile_username, poi sovrascritto da empname se non vuoto, poi da admin_name se non vuoto
dfile_deptname	principal.user.department	Valore copiato direttamente
logintime	principal.user.last_login_time	Convertito utilizzando il formato data aaaa-MM-gg HH:mm:ss
job	principal.user.title	Valore copiato direttamente
dfile_patterninfo	security_result	Estratti da JSON e strutturati in campi di rilevamento
categoria	security_result.category_details	Valore copiato direttamente
logtype	security_result.action	Valore copiato direttamente
elog_detectedapplicationname	target.application	Valore copiato direttamente
dfile_filecreatedtime	target.file.create_time	Convertito utilizzando il formato data ISO8601
dfile_fileextension	target.file.mime_type	Valore copiato direttamente
dfile_filename	target.file.names	Unito da dfile_filename
dfile_filesize	target.file.size	Convertito in numero intero
dfile_firstscannedpath	target.file.full_path	Valore copiato direttamente
dfile_firstscannedtime	target.file.first_seen_time	Convertito utilizzando il formato data ISO8601
dfile_filemodifiedtime	target.file.last_modification_time	Convertito utilizzando il formato data ISO8601
efile_fileaccessedtime	target.file.last_access_time	Convertito utilizzando il formato data aaaa-MM-gg HH:mm:ss
efile_resulttime	target.file.last_analysis_time	Convertito utilizzando il formato data ISO8601
efile_patternguid_label, dfile_dataformatname_label, dfile_filerelationguid_label, dfile_inspectcount_label, dfile_inspectendtime_label, dfile_inspectstarttime_label, dfile_inspectfilecount_label, dfile_inspectpropertycount_label, dfile_inspectpropertyfilecount_label, dfile_inspectlogtime_label, dfile_filetype_label, dlog_inspectinfo_label, dlog_inspectexaminationtype_label, dlog_inspecttype_label, dfile_encryptfiletype_label, dfile_scanlogtype_label, dfile_policyname_label, elog_mediaguid_label, elog_mediaid_label, loggroup_label, agent_id_label, logouttime_label, packageinstalledtime_label, registeredtime_label, detail_label	additional.fields	Uniti da più campi etichetta

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.