Raccogliere i log di Netwrix Auditor

Supportato in:

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

Netwrix Auditor è una piattaforma di visibilità per l'analisi del comportamento degli utenti e la mitigazione dei rischi che consente di controllare modifiche, configurazioni e accesso in ambienti IT ibridi. La piattaforma fornisce analisi della sicurezza per rilevare anomalie nel comportamento degli utenti e analizzare i pattern di minaccia prima che si verifichi una violazione dei dati. Dotata di un'API di integrazione RESTful, la piattaforma offre visibilità e controllo su tutti i tuoi sistemi IT on-premise o basati sul cloud in modo unificato.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto GCP con le API Cloud Storage, Cloud Run, Pub/Sub e Cloud Scheduler abilitate
  • 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
  • Accesso amministrativo a Netwrix Auditor Server
  • Un account di dominio Windows con le autorizzazioni appropriate per l'accesso API
  • Server Netwrix Auditor con l'API di integrazione abilitata (abilitata per impostazione predefinita)
  • Database di controllo configurato in Netwrix Auditor
  • Connettività di rete dalla funzione Cloud Run al server Netwrix Auditor sulla porta 9699 (predefinita)

Configurare l'accesso all'API Netwrix Auditor

Per consentire alla funzione Cloud Run di recuperare i record di attività, devi verificare che l'API Integration sia abilitata e creare un account di dominio Windows con il ruolo appropriato in Netwrix Auditor.

Verifica che l'API Integration sia abilitata

  1. Sul computer in cui è installato Netwrix Auditor Server, avvia Netwrix Auditor.
  2. Vai a Impostazioni > Integrazioni.
  3. Verifica che l'opzione Sfrutta l'API Integration sia abilitata.
  4. Prendi nota del numero di porta (il valore predefinito è 9699).

  5. Se devi modificare la porta:

    1. Fai clic su Modifica nella sezione Impostazioni API.
    2. Specifica un nuovo numero di porta.
    3. Fai clic su OK.

Crea un account di servizio per l'accesso API

  1. Sul controller di dominio Windows, apri Utenti e computer di Active Directory.
  2. Vai all'unità organizzativa in cui vuoi creare il account di servizio.
  3. Fai clic con il tasto destro del mouse sull'unità organizzativa > Nuovo > Utente.
  4. Nel campo Nome, inserisci Chronicle Integration.
  5. Nel campo Nome di accesso utente, inserisci chronicle-api (o il tuo nome utente preferito).
  6. Fai clic su Avanti.
  7. Inserisci una password efficace e configura le impostazioni della password in base ai criteri della tua organizzazione.
  8. Deseleziona la casella di controllo L'utente deve modificare la password al prossimo accesso.
  9. Seleziona La password non scade mai (opzione consigliata per i service account).
  10. Fai clic su Avanti > Fine.

Assegnare il ruolo di revisore globale

  1. Nella finestra principale di Netwrix Auditor, vai a Monitoring Plans (Piani di monitoraggio).
  2. Nell'albero dei piani di monitoraggio, seleziona Tutti i piani di monitoraggio (la cartella principale).
  3. Fai clic su Delega.
  4. Nella finestra di dialogo Delega, fai clic su Aggiungi utente.
  5. Nella finestra di dialogo Seleziona utente o gruppo:
    1. Fai clic su Sfoglia
    2. Nel campo Inserisci il nome dell'oggetto da selezionare, inserisci il nome utente chronicle-api.
    3. Fai clic su Controlla nomi per verificare l'account.
    4. Fai clic su OK.
  6. Nel menu a discesa Ruolo, seleziona Revisore globale.
  7. Fai clic su OK.

  8. Fai clic su Salva.

Registra le credenziali API

Registra le seguenti informazioni per configurare le variabili di ambiente della funzione Cloud Run:

  • Nome utente: l'account di dominio nel formato DOMAIN\username (ad esempio, ENTERPRISE\chronicle-api)
  • Password: la password dell'account di servizio
  • Nome host: il nome di dominio completo (FQDN) o l'indirizzo IP del server Netwrix Auditor (ad esempio, auditor.enterprise.local o 172.28.6.15)

  • Porta: la porta dell'API Integration (il valore predefinito è 9699)

Verifica le autorizzazioni

Per verificare che l'account disponga delle autorizzazioni richieste:

  1. In Netwrix Auditor, vai a Monitoring Plans.
  2. Seleziona Tutti i piani di monitoraggio.
  3. Fai clic su Delega.
  4. Verifica che l'account chronicle-api venga visualizzato con il ruolo Revisore globale.
  5. Se l'account non viene visualizzato, segui i passaggi descritti in Assegnare il ruolo Revisore globale sopra riportati.

Testare l'accesso API

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

    # Replace with your actual values
NETWRIX_HOST="auditor.enterprise.local"
NETWRIX_PORT="9699"
NETWRIX_USER="ENTERPRISE\\chronicle-api"
NETWRIX_PASS="your-password"

# Test API access (retrieve first batch of activity records)
curl -k --ntlm -u "${NETWRIX_USER}:${NETWRIX_PASS}" \
    "https://${NETWRIX_HOST}:${NETWRIX_PORT}/netwrix/api/v1/activity_records/enum" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json"

Una risposta positiva restituisce un oggetto JSON contenente un array di record di attività e un ContinuationMark per la paginazione.

Creazione di 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 netwrix-auditor-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 a cui si accede di frequente)
    Controllo dell'accesso Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Attiva 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 Accounts.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome del service account: inserisci netwrix-audit-collector-sa
    • Descrizione service account: inserisci Service account for Cloud Run function to collect Netwrix Auditor 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 Amministratore oggetti di archiviazione.
    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 Invoker di Cloud Functions.
  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 (netwrix-auditor-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 (netwrix-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 GCP, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci netwrix-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 record di attività dall'API Netwrix Auditor Integration e scriverli in GCS.

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

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

    Impostazione Valore
    Nome servizio netwrix-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 netwrix-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 (Account di servizio): seleziona netwrix-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 netwrix-auditor-logs Nome del bucket GCS
    GCS_PREFIX netwrix-audit Prefisso per i file di log
    STATE_KEY netwrix-audit/state.json Percorso file di stato
    NETWRIX_HOST auditor.enterprise.local FQDN o IP del server Netwrix Auditor
    NETWRIX_PORT 9699 Porta API di integrazione
    NETWRIX_USER ENTERPRISE\chronicle-api Account di dominio nel formato DOMINIO\nomeutente
    NETWRIX_PASS your-password Password del service account
    MAX_RECORDS 10000 Numero massimo di record per esecuzione
    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 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 requests
from requests_ntlm import HttpNtlmAuth
from datetime import datetime, timezone, timedelta
import time
import urllib3

# Suppress insecure HTTPS warnings for self-signed certificates
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'netwrix-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'netwrix-audit/state.json')
NETWRIX_HOST = os.environ.get('NETWRIX_HOST')
NETWRIX_PORT = os.environ.get('NETWRIX_PORT', '9699')
NETWRIX_USER = os.environ.get('NETWRIX_USER')
NETWRIX_PASS = os.environ.get('NETWRIX_PASS')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

def parse_datetime(value):
  """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 Netwrix Auditor
  activity records and write to GCS.

  Args:
    cloud_event: CloudEvent object containing Pub/Sub message
  """

  if not all([GCS_BUCKET, NETWRIX_HOST, NETWRIX_USER, NETWRIX_PASS]):
    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_time = parse_datetime(state['last_event_time'])
        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 activity records from {last_time.isoformat()} "
        f"to {now.isoformat()}")

    records, newest_event_time = fetch_activity_records(
      last_time, now
    )

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

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

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

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

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

def load_state(bucket):
  """Load state from GCS."""
  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):
  """Save the last event timestamp to GCS state file."""
  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 fetch_activity_records(start_time, end_time):
  """
  Fetch activity records from Netwrix Auditor Integration API
  using the enum endpoint with continuation mark pagination.

  The API returns up to 1000 records per request. Subsequent
  requests include the ContinuationMark from the previous
  response to retrieve the next batch.

  Args:
    start_time: Start time for filtering records
    end_time: End time for filtering records

  Returns:
    Tuple of (records list, newest_event_time ISO string)
  """
  base_url = (
    f"https://{NETWRIX_HOST}:{NETWRIX_PORT}"
    f"/netwrix/api/v1/activity_records/enum"
  )
  auth = HttpNtlmAuth(NETWRIX_USER, NETWRIX_PASS)
  session = requests.Session()
  session.auth = auth
  session.verify = False
  session.headers.update({
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'User-Agent': 'GoogleSecOps-NetwrixCollector/1.0'
  })

  all_records = []
  newest_time = None
  continuation_mark = None
  page_num = 0
  backoff = 1.0

  while True:
    page_num += 1

    if len(all_records) >= MAX_RECORDS:
      print(f"Reached max_records limit ({MAX_RECORDS})")
      break

    try:
      if continuation_mark:
        response = session.post(
          base_url,
          json={"ContinuationMark": continuation_mark},
          timeout=(10, 60)
        )
      else:
        response = session.get(
          base_url,
          timeout=(10, 60)
        )

      if response.status_code == 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, 30.0)
        continue

      backoff = 1.0

      if response.status_code != 200:
        print(f"HTTP Error: {response.status_code}")
        print(f"Response body: {response.text}")
        return all_records, newest_time

      data = response.json()

      page_results = data.get('ActivityRecordList', [])
      continuation_mark = data.get('ContinuationMark')

      if not page_results:
        print("No more activity records (empty page)")
        break

      # Filter records by time window
      filtered = []
      for record in page_results:
        when = record.get('When')
        if when:
          try:
            record_time = parse_datetime(when)
            if start_time <= record_time <= end_time:
              filtered.append(record)
            if (newest_time is None or
                record_time >
                parse_datetime(newest_time)):
              newest_time = when
          except Exception as e:
            print(f"Warning: Could not parse "
                f"record time: {e}")
            filtered.append(record)
        else:
          filtered.append(record)

      print(f"Page {page_num}: Retrieved "
          f"{len(page_results)} records, "
          f"{len(filtered)} within time window")
      all_records.extend(filtered)

      if not continuation_mark:
        print("No more pages (no ContinuationMark)")
        break

    except requests.exceptions.Timeout:
      print(f"Request timeout on page {page_num}")
      return all_records, newest_time
    except Exception as e:
      print(f"Error fetching activity records: {e}")
      return all_records, newest_time

  print(f"Retrieved {len(all_records)} total records "
      f"from {page_num} pages")
  return all_records, newest_time
    • requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
requests>=2.31.0
requests-ntlm>=1.2.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

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

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome netwrix-audit-collector-hourly
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza 0 * * * * (ogni ora, all'ora)
    Fuso orario Seleziona il fuso orario (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona netwrix-audit-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 (netwrix-audit-collector-hourly).
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi qualche secondo.
  4. Vai a Cloud Run > Servizi.
  5. Fai clic su netwrix-audit-collector.
  6. Fai clic sulla scheda Log.

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

    Fetching activity records from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X records, X within time window
Wrote X records to gs://netwrix-auditor-logs/netwrix-audit/netwrix_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic su netwrix-auditor-logs.

  10. Vai alla cartella netwrix-audit/.

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

Se visualizzi errori nei log:

  • HTTP 401: verifica che le variabili di ambiente NETWRIX_USER e NETWRIX_PASS siano corrette e utilizza il formato DOMAIN\username
  • HTTP 403: verifica che il account di servizio disponga del ruolo Revisore globale in Netwrix Auditor
  • HTTP 429: limitazione di frequenza: la funzione verrà ritentata automaticamente con backoff esponenziale
  • Timeout di connessione: verifica la connettività di rete da Cloud Run al server Netwrix Auditor sulla porta 9691. Assicurati che sia configurato un connettore VPC o Cloud VPN se il server è on-premise
  • Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione della funzione Cloud Run

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, Netwrix Auditor Activity Records).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Netwrix come tipo di log.
  7. Fai clic su Ottieni service account.

  8. Verrà visualizzato un indirizzo email del account di servizio univoco. Ad esempio:

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

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

  10. Fai clic su Avanti.

  11. 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://netwrix-auditor-logs/netwrix-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

  12. Fai clic su Avanti.

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

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic su netwrix-auditor-logs.
  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 Logic
Opcode about.labels Etichette associate alle informazioni della sezione Chi
Sottotitoli codificati about.resource.attribute.labels Etichette degli attributi per la risorsa nella sezione Informazioni
Attività additional.fields Campi aggiuntivi contenenti informazioni extra sull'evento
Cosa additional.fields
Notifica additional.fields
Descrizione additional.fields
Aggiunta additional.fields
Rimosso additional.fields
service_type additional.fields
Dettagli additional.fields
extensions.auth.type extensions.auth.type Tipo di autenticazione utilizzato
EventReceivedTime metadata.collected_timestamp Timestamp in cui l'evento è stato raccolto dal sistema
Messaggio metadata.description Descrizione dell'evento
event_type metadata.event_type Tipo di evento
EventType metadata.product_event_type Tipo di evento specifico per il prodotto
EventID metadata.product_log_id Identificatore log specifico del prodotto
SourceModuleType observer.application Applicazione che ha osservato l'evento
Nome host principal.asset.hostname Nome host della risorsa associata al soggetto
Dove principal.asset.hostname
Workstation principal.asset.hostname
device_name principal.asset.hostname
Workstation principal.hostname Nome host dell'entità
device_name principal.hostname
ProcessID principal.process.pid ID processo dell'entità
Nome principal.resource.name Nome della risorsa associata al principal
Chi principal.user.user_display_name Nome visualizzato dell'utente
SourceName security_result.about.resource.attribute.labels Etichette degli attributi delle risorse per la sezione Informazioni nel risultato di sicurezza
azione security_result.action Azione intrapresa nel risultato di sicurezza
action_details security_result.action_details Dettagli dell'azione nel risultato di sicurezza
backup_name security_result.description Descrizione del risultato di sicurezza
service_failed security_result.description
Parole chiave security_result.detection_fields Campi utilizzati per il rilevamento nel risultato di sicurezza
RecordNumber security_result.detection_fields
session_ID security_result.detection_fields
allow_connection_with_desktop security_result.detection_fields
service_account security_result.detection_fields
Gravità security_result.severity Livello di gravità del risultato di sicurezza
SeverityValue security_result.severity
riepilogo security_result.summary Riepilogo del risultato di sicurezza
application_name target.application Applicazione sul target
Nome host target.asset.hostname Il nome host della risorsa associata al target
Dove target.asset.hostname
file_path target.file.full_path Percorso completo del file di destinazione
Dimensioni target.file.size Dimensioni del file di destinazione
Nome host target.hostname Nome host della destinazione
Dove target.hostname
Tipo target.resource.attribute.labels Etichette degli attributi per la risorsa di destinazione
SourceModuleName target.resource.name Nome della risorsa di destinazione
DataSource metadata.product_name Nome del prodotto che ha generato l'evento
metadata.vendor_name metadata.vendor_name Nome del fornitore

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