Raccogli i log di Okta Advanced Server Access

Supportato in:

Questo documento spiega come importare i log di Okta Advanced Server Access in Google Security Operations utilizzando Google Cloud Storage V2.

Okta Advanced Server Access (in precedenza ScaleFT) è una soluzione di gestione dell'accesso con privilegi che fornisce accesso SSH e RDP ai server con certificati effimeri e log di controllo completi. La piattaforma conserva gli eventi di controllo per 90 giorni e fornisce un'API per recuperarli per l'archiviazione e l'analisi a lungo termine nelle piattaforme SIEM.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto Google Cloud con le API Cloud Storage, Cloud Run, Pub/Sub e Cloud Scheduler abilitate
  • 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
  • Accesso amministratore al team Okta Advanced Server Access
  • Possibilità di creare utenti di servizio e chiavi API in Advanced Server Access

Configurare l'accesso all'API Okta Advanced Server Access

Per consentire a Google SecOps di recuperare gli eventi di controllo, devi creare un utente di servizio e generare una chiave API. Gli utenti di servizio sono account speciali progettati per l'automazione e le integrazioni API.

Crea un utente di servizio

  1. Accedi alla dashboard di Advanced Server Access.
  2. Vai a Utenti.
  3. Seleziona la scheda Utenti del servizio.
  4. Fai clic su Crea utente del servizio.

  5. Nel campo Nome utente, inserisci un nome descrittivo per l'utente del servizio (ad esempio, chronicle-integration).

  6. Fai clic su Create Service User (Crea utente di servizio).

Genera una chiave API

  1. Nella pagina dei dettagli dell'utente del servizio, fai clic su Crea chiave API.

  2. Copia e salva immediatamente le seguenti credenziali:

    • ID chiave API: un UUID che identifica la chiave API (ad esempio, 6052868b-1b04-4a14-8288-e6496d7f2f4b)
    • Secret della chiave API: una stringa secret con codifica Base64 utilizzata per autenticare le richieste API

  3. Fai clic su Fine.

Assegna l'utente del servizio a un gruppo con le autorizzazioni appropriate

Gli utenti del servizio devono essere membri di un gruppo con ruoli appropriati a livello di team per accedere all'API Audits.

  1. Nella dashboard di Advanced Server Access, vai a Groups (Gruppi).
  2. Seleziona un gruppo esistente o creane uno nuovo per l'accesso API.
  3. Fai clic sul nome del gruppo per aprirne i dettagli.
  4. Seleziona la scheda Utenti.
  5. Fai clic su Aggiungi utente.
  6. Cerca e seleziona l'utente del servizio (ad esempio, chronicle-integration).
  7. Fai clic su Aggiungi.
  8. Seleziona la scheda Ruoli.

  9. Assicurati che al gruppo sia assegnato uno dei seguenti ruoli a livello di team:

    • reporting_user: accesso in sola lettura a tutti gli endpoint (consigliato per l'importazione dei log)
    • access_admin: accesso amministrativo completo (concede tutte le autorizzazioni CRUD)

  10. Se il ruolo richiesto non è assegnato, fai clic su Aggiungi ruolo, seleziona reporting_user o access_admin e fai clic su Salva.

Verifica le autorizzazioni

Per verificare che l'utente del servizio disponga delle autorizzazioni richieste:

  1. Nella dashboard Advanced Server Access, vai a Gruppi.
  2. Fai clic sul gruppo contenente l'utente di servizio (ad esempio chronicle-integration).
  3. Seleziona la scheda Ruoli.
  4. Verifica che sia elencato il ruolo reporting_user o access_admin.
  5. Se non riesci a visualizzare la scheda Ruoli, contatta l'amministratore per concedere l'accesso appropriato.

Testare l'accesso API

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

    # Replace with your actual credentials
TEAM_NAME="your-team-name"
KEY_ID="your-api-key-id"
KEY_SECRET="your-api-key-secret"

# Obtain bearer token
TOKEN=$(curl -s -X POST "https://app.scaleft.com/v1/teams/${TEAM_NAME}/service_token" \
    -H "Content-Type: application/json" \
    -d "{\"key_id\": \"${KEY_ID}\", \"key_secret\": \"${KEY_SECRET}\"}" \
    | python3 -c "import sys,json; print(json.load(sys.stdin)['bearer_token'])")

# Test audit events access
curl -s -H "Authorization: Bearer ${TOKEN}" \
    "https://app.scaleft.com/v1/teams/${TEAM_NAME}/auditsV2?count=5" \
    | python3 -m json.tool

Una risposta positiva restituisce un array JSON di eventi di controllo recenti.

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 okta-asa-audit-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) 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 okta-asa-collector-sa
    • Descrizione service account: inserisci Service account for Cloud Run function to collect Okta Advanced Server Access 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 (okta-asa-audit-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 (okta-asa-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 okta-asa-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 Okta Advanced Server Access Audits 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 okta-asa-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 okta-asa-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 okta-asa-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 okta-asa-audit-logs Nome bucket GCS
    GCS_PREFIX okta-asa-audit Prefisso per i file di log
    STATE_KEY okta-asa-audit/state.json Percorso file di stato
    ASA_TEAM_NAME your-team-name Nome del team Advanced Server Access
    ASA_KEY_ID your-api-key-id ID chiave API utente del servizio
    ASA_KEY_SECRET your-api-key-secret Secret della chiave API dell'utente del servizio
    MAX_RECORDS 5000 Numero massimo di record per esecuzione
    PAGE_SIZE 1000 Record per pagina API (max 1000)
    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

  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 time

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', 'okta-asa-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'okta-asa-audit/state.json')
ASA_TEAM_NAME = os.environ.get('ASA_TEAM_NAME')
ASA_KEY_ID = os.environ.get('ASA_KEY_ID')
ASA_KEY_SECRET = os.environ.get('ASA_KEY_SECRET')
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'))

ASA_API_BASE = 'https://app.scaleft.com'

@functions_framework.cloud_event
def main(cloud_event):
  if not all([GCS_BUCKET, ASA_TEAM_NAME, ASA_KEY_ID, ASA_KEY_SECRET]):
    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_offset'):
      last_offset = state['last_offset']
    else:
      last_offset = None

    print(f"Starting audit log collection (last_offset={last_offset})")

    token = get_bearer_token()

    records, newest_offset = fetch_audit_events(
      token=token,
      last_offset=last_offset,
      page_size=PAGE_SIZE,
      max_records=MAX_RECORDS,
    )

    if not records:
      print("No new audit records found.")
      return

    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/okta_asa_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_offset:
      save_state(bucket, newest_offset)

    print(f"Successfully processed {len(records)} records")

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

def get_bearer_token():
  url = f"{ASA_API_BASE}/v1/teams/{ASA_TEAM_NAME}/service_token"
  body = json.dumps({
    'key_id': ASA_KEY_ID,
    'key_secret': ASA_KEY_SECRET
  }).encode('utf-8')

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

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

  data = json.loads(response.data.decode('utf-8'))
  token = data.get('bearer_token')
  if not token:
    raise Exception("No bearer_token in service token response")

  print("Successfully obtained ASA bearer token")
  return token

def fetch_audit_events(token, last_offset, page_size, max_records):
  endpoint = f"{ASA_API_BASE}/v1/teams/{ASA_TEAM_NAME}/auditsV2"

  headers = {
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
  }

  records = []
  page_num = 0
  backoff = 1.0
  current_offset = last_offset

  while True:
    page_num += 1

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

    params = [f"count={page_size}"]
    if current_offset:
      params.append(f"offset={current_offset}")

    url = f"{endpoint}?{'&'.join(params)}"

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

      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 == 401:
        print("Token expired (401). Refreshing bearer token...")
        token = get_bearer_token()
        headers['Authorization'] = f'Bearer {token}'
        continue

      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, current_offset

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

      page_results = data.get('list', [])

      if not page_results:
        print(f"No more results (empty page)")
        break

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

      # Extract next offset from Link header for pagination
      link_header = response.headers.get('Link', '')
      next_offset = extract_next_offset(link_header)

      if next_offset:
        current_offset = next_offset
      else:
        print("No more pages (no next link)")
        break

    except Exception as e:
      print(f"Error fetching audit events: {e}")
      return records, current_offset

  print(f"Retrieved {len(records)} total records from {page_num} pages")
  return records, current_offset

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

  parts = link_header.split(',')
  for part in parts:
    if 'rel="next"' in part:
      url_part = part.split(';')[0].strip().strip('<>')
      if 'offset=' in url_part:
        for param in url_part.split('?')[-1].split('&'):
          if param.startswith('offset='):
            return param.split('=', 1)[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_offset):
  try:
    state = {
      'last_offset': last_offset,
      '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_offset={last_offset}")
  except Exception as e:
    print(f"Warning: Could not save state: {e}")

    • 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

  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 okta-asa-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 okta-asa-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 (okta-asa-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 okta-asa-collector.
  6. Fai clic sulla scheda Log.

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

    Starting audit log collection (last_offset=None)
Successfully obtained ASA bearer token
Page 1: Retrieved X events
Wrote X records to gs://okta-asa-audit-logs/okta-asa-audit/okta_asa_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic su okta-asa-audit-logs.

  10. Vai alla cartella okta-asa-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 ASA_KEY_ID e ASA_KEY_SECRET siano corrette
  • HTTP 403: verifica che l'utente del servizio abbia il ruolo reporting_user o access_admin
  • HTTP 429: limitazione di frequenza. La funzione riproverà automaticamente con backoff esponenziale
  • Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate nella configurazione di Cloud Run Functions

Recuperare il account di servizio Google SecOps

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed di notizie.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Okta ASA Audit Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Okta Advanced Server Access come Tipo di log.
  7. Fai clic su Get Service Account (Ottieni service account).

  8. Viene visualizzata un'email del account di servizio univoca. 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://okta-asa-audit-logs/okta-asa-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 i file trasferiti e le 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 okta-asa-audit-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 Storage Object Viewer

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
details.actor.details.email principal.user.email_addresses Valore copiato direttamente
details.actor.details.first_name principal.user.first_name Valore copiato direttamente
details.actor.details.full_name principal.user.user_display_name Valore copiato direttamente
details.actor.details.last_name principal.user.last_name Valore copiato direttamente
details.actor.details.user_type principal.user.attribute.roles Valore copiato direttamente
details.actor.id principal.user.employee_id Valore copiato direttamente
details.actor.name principal.user.userid Valore di details.actor.name se non è vuoto, altrimenti details.unix_user_name
details.unix_user_name principal.user.userid
details.actor.status principal.user.attribute.labels Unito come etichetta con chiave "actor_status"
details.actor.team_name principal.user.department Valore copiato direttamente
details.actor.user_type principal.user.attribute.labels Unito come etichetta con la chiave "actor_user_type"
details.client.description principal.application Valore copiato direttamente
details.client.encrypted principal.asset.attribute.labels Convertito in stringa, unito come etichetta con la chiave "details_client_encrypted"
details.client.hostname principal.hostname, principal.asset.hostname Valore copiato direttamente
details.client.id principal.user.product_object_id Valore copiato direttamente
details.client.os principal.platform Imposta WINDOWS se corrisponde a (?i)Win|win; LINUX se corrisponde a (?i)Lin|lin; MAC se corrisponde a (?i)Mac|ios|mac; ANDROID se corrisponde a (?i)Android|android
details.client.os principal.platform_version Estrai major.minor.patch dalla stringa del sistema operativo utilizzando grok
details.client.state principal.resource.attribute.labels Unito come etichetta con la chiave "client_state"
details.client.user_name target.user.userid Valore copiato direttamente
details.client_ip principal.ip, principal.asset.ip IP estratto utilizzando il pattern grok
details.from_address principal.ip, principal.asset.ip IP estratto utilizzando il pattern grok
details.project.create_server_users target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_create_server_users"
details.project.force_shared_ssh_users target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_force_shared_ssh_users"
details.project.forward_traffic target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_forward_traffic"
details.project.id target.resource.id Valore copiato direttamente
details.project.name target.resource.name Valore copiato direttamente
details.project.next_unix_gid target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "next_unix_gid"
details.project.next_unix_uid target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "next_unix_uid"
details.project.rdp_session_recording target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_rdp_session_recording"
details.project.require_preauth_for_creds target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_require_preauth_for_creds"
details.project.ssh_certificate_type target.resource.attribute.labels Unito come etichetta con la chiave "project_ssh_certificate_type"
details.project.ssh_session_recording target.resource.attribute.labels Convertito in stringa, unito come etichetta con la chiave "project_ssh_session_recording"
details.project.team target.resource.attribute.labels Unito come etichetta con la chiave "project_team"
details.server.alt_names target.hostname, target.asset.hostname, target.resource.attribute.labels Il primo alt_name è impostato su target.hostname e target.asset.hostname, gli altri vengono uniti come etichette con la chiave "alt_name"
details.server.hostname intermediary_value.hostname Valore copiato direttamente
details.server.id intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "details_server_id"
details.server.os intermediary_value.platform_version Valore copiato direttamente
details.server.os intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "details_server_os"
details.server.os_type intermediary_value.platform Impostato su LINUX se corrisponde a (?i)linux; WINDOWS se corrisponde a (?i)windows; MAC se corrisponde a (?i)mac
details.server.services intermediary_value.resource.attribute.labels Unite come etichette con la chiave "server_services {index}"
details.server.source intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "server_source"
details.server.source_details.cloud_account intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "server_source_details_cloud_account"
details.server.source_details.cloud_provider intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "server_source_details_cloud_provider"
details.server.source_details.instance_id intermediary_value.resource.attribute.labels Unito come etichetta con la chiave "server_source_details_instance_id"
details.server.state target.asset.attribute.labels Convertito in stringa, unito come etichetta con la chiave "server_state"
details.server.team_name intermediary_value.user.department Valore copiato direttamente
details.server_hostnames target.hostname, target.resource.attribute.labels Il primo nome host è impostato su target.hostname, gli altri vengono uniti come etichette con la chiave "server_hostname {index}"
details.server_id target.resource.attribute.labels Unito come etichetta con la chiave "details_server_id"
details.server_os target.platform_version Valore copiato direttamente
details.server_os_type target.platform Imposta LINUX se le corrispondenze sono (?i)linux; WINDOWS se le corrispondenze sono (?i)windows; MAC se le corrispondenze sono (?i)mac
details.server_state target.resource.attribute.labels Unito come etichetta con la chiave "details_server_state"
details.session_type extensions.auth.auth_details Valore copiato direttamente
details.session_type security_result.detection_fields Unito come etichetta con la chiave "session_type"
details.servers intermediario Elaborato e unito come oggetto intermedio
details.ssh_algorithm network.tls.cipher Valore copiato direttamente
details.ssh_key_fingerprint target.asset.attribute.labels Unito come etichetta con la chiave "ssh_key_fingerprint"
details.ssh_public_key security_result.detection_fields Unito come etichetta con la chiave "ssh_public_key"
details.target_server target.application Valore copiato direttamente
details.team_id principal.resource.id Valore copiato direttamente
details.team_id target.resource.id Valore copiato direttamente
details.team_name additional.fields Unito come etichetta con la chiave "team_name"
details.trace_id network.session_id Valore copiato direttamente
details.type metadata.product_event_type Valore copiato direttamente
details.username target.user.user_display_name Valore copiato direttamente
details.via network.session_id Valore copiato direttamente
details_server intermediary_value Elaborati e uniti come oggetto intermediary_value
id additional.fields Unito come etichetta con la chiave "id"
timestamp metadata.event_timestamp Convertito utilizzando il formato ISO8601
extensions.auth.type extensions.auth.type Impostato su "SSO" se metadata.event_type è USER_LOGIN
intermediary_value intermediario Unito da intermediary_value se non è vuoto
has_principal_user metadata.event_type Impostato su USER_LOGIN se has_principal_user e has_target_user o has_principal_user e has_target e details_type corrisponde ad accesso; altrimenti USER_UNCATEGORIZED se has_principal_user; altrimenti STATUS_UPDATE se has_principal
has_target_user metadata.event_type
metadata.product_name metadata.product_name Imposta su "OKTA_SCALEFT"
metadata.vendor_name metadata.vendor_name Imposta su "OKTA_SCALEFT"
desc event.idm.read_only_udm.metadata.description Mappato dal log delle modifiche
asset_id event.idm.read_only_udm.target.asset.asset_id Mappato dal log delle modifiche
details.hostname event.idm.read_only_udm.principal.hostname e event.idm.read_only_udm.principal.asset.hostname Mappato dal log delle modifiche
details.actor event.idm.read_only_udm.principal.user.userid Mappato dal log delle modifiche
details.client event.idm.read_only_udm.principal.hostname e event.idm.read_only_udm.principal.asset.hostname Mappato dal log delle modifiche
details.username event.idm.read_only_udm.target.user.user_display_name Mappato dal log delle modifiche
details.server.server_accounts.username event.idm.read_only_udm.target.user.user_display_name Mappato dal log delle modifiche
details.project event.idm.read_only_udm.target.resource.attribute.cloud.project.name Mappato dal log delle modifiche
details.server.server_accounts event.idm.read_only_udm.target.asset.attribute.labels Mappato dal log delle modifiche
"id" event.idm.read_only_udm.additional.fields Mappato dal log delle modifiche
"details.from_address" event.idm.read_only_udm.principal.ip Mappato dal log delle modifiche
"details.client_ip" event.idm.read_only_udm.principal.ip Mappato dal log delle modifiche
"details.from_address" event.idm.read_only_udm.principal.asset.ip Mappato dal log delle modifiche
"details.client_ip" event.idm.read_only_udm.principal.asset.ip Mappato dal log delle modifiche
"details.type" event.idm.read_only_udm.metadata.product_event_type Mappato dal log delle modifiche
"details.actor.status" event.idm.read_only_udm.principal.user.attribute.labels Mappato dal log delle modifiche
"details.actor.user_type" event.idm.read_only_udm.principal.user.attribute.labels Mappato dal log delle modifiche
"details.session_type" event.idm.read_only_udm.extensions.auth.auth_details Mappato dal log delle modifiche
"details.actor.name" event.idm.read_only_udm.principal.user.userid Mappato dal log delle modifiche
"details.unix_user_name" event.idm.read_only_udm.principal.user.userid Mappato dal log delle modifiche
"details.actor.details.full_name" event.idm.read_only_udm.principal.user.user_display_name Mappato dal log delle modifiche
"details.actor.details.first_name" event.idm.read_only_udm.principal.user.first_name Mappato dal log delle modifiche
"details.actor.details.last_name" event.idm.read_only_udm.principal.user.last_name Mappato dal log delle modifiche
"details.actor.id" event.idm.read_only_udm.principal.user.employee_id Mappato dal log delle modifiche
"details.actor.team_name" event.idm.read_only_udm.principal.user.department Mappato dal log delle modifiche
"details.client.hostname" event.idm.read_only_udm.principal.hostname Mappato dal log delle modifiche
"details.client.hostname" event.idm.read_only_udm.principal.asset.hostname Mappato dal log delle modifiche
"details.client.id" event.idm.read_only_udm.principal.user.product_object_id Mappato dal log delle modifiche
"details.client.description" event.idm.read_only_udm.principal.application Mappato dal log delle modifiche
"details.client.os" event.idm.read_only_udm.principal.platform Mappato dal log delle modifiche
"details_client_os" event.idm.read_only_udm.principal.platform_version Mappato dal log delle modifiche
"details.actor.details.email" event.idm.read_only_udm.principal.user.email_addresses Mappato dal log delle modifiche
"details.team_id" event.idm.read_only_udm.target.resource.id Mappato dal log delle modifiche
"details.project.id" event.idm.read_only_udm.target.resource.id Mappato dal log delle modifiche
"details.team_name" event.idm.read_only_udm.additional.fields Mappato dal log delle modifiche
"details.client.state" event.idm.read_only_udm.principal.resource.attribute.labels Mappato dal log delle modifiche
"details.target_server" event.idm.read_only_udm.target.application Mappato dal log delle modifiche
"details.via" event.idm.read_only_udm.network.session_id Mappato dal log delle modifiche
"details.trace_id" event.idm.read_only_udm.network.session_id Mappato dal log delle modifiche
"details_session_type" event.idm.read_only_udm.security_result.detection_fields Mappato dal log delle modifiche
"details.ssh_public_key" event.idm.read_only_udm.security_result.detection_fields Mappato dal log delle modifiche
"details.actor.details.user_type" event.idm.read_only_udm.principal.user.attribute.roles Mappato dal log delle modifiche
"details.project.name" event.idm.read_only_udm.target.resource.name Mappato dal log delle modifiche
"details.server.id" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.server.state" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.team" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.create_server_users" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.force_shared_ssh_users" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.forward_traffic" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.next_unix_gid" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.next_unix_uid" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.rdp_session_recording" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.require_preauth_for_creds" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.ssh_certificate_type" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.project.ssh_session_recording" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"serverhostname" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"alt_name" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.ssh_key_fingerprint" event.idm.read_only_udm.target.resource.attribute.labels Mappato dal log delle modifiche
"details.server.os" event.idm.read_only_udm.target.platform_version Mappato dal log delle modifiche
"detailsserver.os" event.idm.read_only_udm.target.platform_version Mappato dal log delle modifiche
"details.server.os_type" event.idm.read_only_udm.target.platform Mappato dal log delle modifiche
"detailsserver.os_type" event.idm.read_only_udm.target.platform Mappato dal log delle modifiche
"details_team_id" event.idm.read_only_udm.principal.resource.id Mappato dal log delle modifiche
"details.client.encrypted" event.idm.read_only_udm.principal.asset.attribute.labels Mappato dal log delle modifiche
"details.client.user_name" event.idm.read_only_udm.target.user.userid Mappato dal log delle modifiche
"timestamp" event.idm.read_only_udm.metadata.event_timestamp Mappato dal log delle modifiche
"serverhostname" event.idm.read_only_udm.target.hostname Mappato dal log delle modifiche
"alt_name" event.idm.read_only_udm.target.hostname Mappato dal log delle modifiche
"alt_name" event.idm.read_only_udm.target.asset.hostname Mappato dal log delle modifiche
"intermediary" event.idm.read_only_udm.intermediary Mappato dal log delle modifiche
"intermediary_value" event.idm.read_only_udm.intermediary Mappato dal log delle modifiche
"detailsserver.sftd_version" event.idm.read_only_udm.metadata.product_version Mappato dal log delle modifiche
"details.server.sftd_version" event.idm.read_only_udm.metadata.product_version Mappato dal log delle modifiche
"detailsserver.state" event.idm.read_only_udm.target.asset.attribute.labels Mappato dal log delle modifiche
"detailsserver.managed" event.idm.read_only_udm.target.asset.attribute.labels Mappato dal log delle modifiche
"detailsserver.ssh_key_fingerprint" event.idm.read_only_udm.target.asset.attribute.labels Mappato dal log delle modifiche
"details.username" event.idm.read_only_udm.target.user.user_display_name Mappato dal log delle modifiche
"details.ssh_algorithm" event.idm.read_only_udm.network.tls.cipher 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.