Raccogliere i log della piattaforma di isolamento di Menlo Security (MSIP)

Supportato in:

Questa guida spiega come importare i log di Menlo Security Isolation Platform (MSIP) in Google SecOps utilizzando Google Cloud Storage.

L'approccio incentrato sull'isolamento di Menlo Security divide la navigazione web e il recupero dei documenti tra il dispositivo dell'utente e un contenitore virtuale monouso (DVC) isolato lontano dall'endpoint. Tutto il codice rischioso viene eseguito nel DVC isolato e non raggiunge mai l'endpoint. Al browser dell'utente vengono inviati solo dati di visualizzazione sicuri. La piattaforma fornisce una registrazione completa per l'accesso web, gli eventi di controllo, la sicurezza email, le violazioni DLP e l'attività SMTP.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Accesso privilegiato al portale di amministrazione di Menlo Security
  • Autorizzazioni per creare token API in Menlo Security
  • Un progetto GCP con le API Cloud Storage, Cloud Run, Pub/Sub e Cloud Scheduler abilitate

Configura l'accesso all'API Menlo Security

Per consentire alla funzione Cloud Run di recuperare i log, devi creare un token API con l'autorizzazione API Log Export.

Crea token API

  1. Accedi al portale di amministrazione di Menlo Security all'indirizzo https://admin.menlosecurity.com.
  2. Vai a Impostazioni > Autenticazione > Token API.
  3. Fai clic su Crea token.
  4. Nel campo Nome token, inserisci un nome descrittivo (ad esempio, Chronicle GCS Integration).
  5. Nella sezione Autorizzazioni, seleziona API Export log.
  6. Fai clic su Crea o Salva.
  7. Copia e archivia in modo sicuro il token API generato.

Importante: il token API viene visualizzato una sola volta. Conservala in una posizione sicura subito dopo la creazione.

Autorizzazioni API richieste

  • Il token API richiede la seguente autorizzazione:

    Autorizzazione/Ambito Livello di accesso Finalità
    API Log Export Leggi Recuperare i log dall'API Menlo Security

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 menlo-security-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 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

Crea service account

  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 menlo-logs-collector-sa
    • Descrizione service account: inserisci Service account for Cloud Run function to collect Menlo Security 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 (menlo-security-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 (menlo-logs-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 menlo-logs-trigger
    • Lascia invariate le altre impostazioni predefinite.
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

  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 menlo-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 menlo-logs-trigger.
    4. Fai clic su Salva.

  6. Nella sezione Autenticazione:

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

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

  8. Vai alla scheda Sicurezza:

    • Service account: seleziona menlo-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 menlo-security-logs Nome bucket GCS
    GCS_PREFIX menlo-logs Prefisso per i file di log
    STATE_KEY menlo-logs/state.json Percorso file di stato
    MENLO_API_TOKEN your-menlo-api-token Token API Menlo Security
    MENLO_API_HOST logs.menlosecurity.com Host API di Menlo Security
    MENLO_LOG_TYPES web,audit,email,dlp Tipi di log separati da virgole
    LOOKBACK_HOURS 1 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 os
import json
import urllib3
import time
import uuid
from datetime import datetime, timezone, timedelta

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

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'menlo-logs')
STATE_KEY = os.environ.get('STATE_KEY', 'menlo-logs/state.json')
API_TOKEN = os.environ.get('MENLO_API_TOKEN')
API_HOST = os.environ.get('MENLO_API_HOST', 'logs.menlosecurity.com')
LOG_TYPES = os.environ.get('MENLO_LOG_TYPES', 'web').split(',')
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '1'))

@functions_framework.cloud_event
def main(cloud_event):
  if not all([GCS_BUCKET, API_TOKEN, API_HOST]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)
    state = load_state(bucket)
    now = datetime.now(timezone.utc).replace(microsecond=0)

    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 logs from {last_time.isoformat()} to {now.isoformat()}")

    total = 0
    newest_time = None

    for log_type in LOG_TYPES:
      log_type = log_type.strip()
      print(f"Fetching {log_type} logs...")
      events = fetch_logs(log_type, API_TOKEN, API_HOST, last_time, now)

      if events:
        object_key = f"{GCS_PREFIX}/{now:%Y/%m/%d}/menlo-{log_type}-{uuid.uuid4()}.ndjson"
        blob = bucket.blob(object_key)

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

        print(f"Uploaded {len(events)} {log_type} events to gs://{GCS_BUCKET}/{object_key}")
        total += len(events)

        for ev in events:
          ev_time = ev.get('timestamp') or ev.get('time') or ev.get('created_at')
          if ev_time and (newest_time is None or str(ev_time) > str(newest_time)):
            newest_time = str(ev_time)
      else:
        print(f"No {log_type} events found")

    save_state(bucket, newest_time if newest_time else now.isoformat())
    print(f"Successfully processed {total} total events")

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

def fetch_logs(log_type, token, api_host, start, end):
  url = f"https://{api_host}/api/v1/logs/{log_type}"
  headers = {
    'Authorization': f'Token {token}',
    'Accept': 'application/json',
  }
  params = {
    'start': start.strftime('%Y-%m-%dT%H:%M:%SZ'),
    'end': end.strftime('%Y-%m-%dT%H:%M:%SZ'),
  }
  query = '&'.join(f'{k}={v}' for k, v in params.items())
  full_url = f'{url}?{query}'

  all_events = []
  backoff = 1.0

  while full_url:
    response = http.request('GET', full_url, headers=headers)

    if response.status == 429:
      retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
      print(f"Rate limited. Waiting {retry_after}s...")
      time.sleep(retry_after)
      backoff = min(backoff * 2, 60.0)
      continue

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

    backoff = 1.0
    data = json.loads(response.data.decode('utf-8'))
    events = data if isinstance(data, list) else data.get('events', data.get('data', []))
    all_events.extend(events)

    full_url = data.get('next') if isinstance(data, dict) else None

  print(f"Total {log_type} events fetched: {len(all_events)}")
  return all_events

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}")
    • 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 menlo-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 menlo-logs-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il tuo job (menlo-logs-collector-hourly).
  2. Fai clic su Forza esecuzione per attivare il job manualmente.
  3. Attendi alcuni secondi.
  4. Vai a Cloud Run > Servizi.
  5. Fai clic su menlo-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
Fetching web logs...
Total web events fetched: X
Uploaded X web events to gs://menlo-security-logs/menlo-logs/YYYY/MM/DD/menlo-web-UUID.ndjson
Successfully processed X total events

  8. Vai a Cloud Storage > Bucket.

  9. Fai clic su menlo-security-logs.

  10. Vai alla cartella menlo-logs/.

  11. Verifica che i nuovi file .ndjson siano stati creati con la data corrente.

Se nei log vengono visualizzati errori:

  • HTTP 401: verifica che la variabile di ambiente MENLO_API_TOKEN sia corretta
  • HTTP 403: verifica che il token API disponga dell'autorizzazione API Log Export.
  • HTTP 429: limitazione della frequenza. La funzione verrà ritentata automaticamente con backoff.
  • 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.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Menlo Security MSIP Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Menlo Security 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://menlo-security-logs/menlo-logs/

    • 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

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic su menlo-security-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 Logica
customer_name intermediary.hostname Imposta se customer_name non è IP
customer_name intermediary.ip Estratto da customer_name se IP o dagli IP xff_ip
xff_ip intermediary.ip
event_data.event_time metadata.event_timestamp Analizzati utilizzando grok e il filtro data
request_type metadata.event_type Logica condizionale basata su questi campi
has_principal metadata.event_type
has_top_url metadata.event_type
has_dest metadata.event_type
log_type metadata.log_type Valore copiato direttamente
event_data.name metadata.product_event_type Valore copiato direttamente
reqId metadata.product_log_id Valore copiato direttamente
event_data.version metadata.product_version Valore copiato direttamente
event_data.protocol network.application_protocol Mappato utilizzando l'elenco di protocolli predefiniti
request_type network.http.method Valore copiato direttamente
referer network.http.referral_url Valore copiato direttamente
response_code network.http.response_code Convertito in numero intero
event_data.user-agent network.http.user_agent Valore copiato direttamente
full_session_id network.session_id Valore copiato direttamente
browser_and_version principal.application Valore copiato direttamente
event_data.x-client-ip principal.asset.ip Valore di event_data.x-client-ip se non è vuoto, altrimenti src_ip
src_ip principal.asset.ip
gruppi principal.group.product_object_id Valore copiato direttamente
event_data.x-client-ip principal.ip Valore di event_data.x-client-ip se non è vuoto, altrimenti src_ip
src_ip principal.ip
regione principal.location.country_or_region Valore della regione se non è vuoto, altrimenti egress_country
egress_country principal.location.country_or_region
region_name principal.location.name Valore copiato direttamente
egress_ip principal.nat_ip Valore copiato direttamente
event_data.userid principal.user.email_addresses Unito se corrisponde all'espressione regolare dell'email
event_data.userid principal.user.userid Valore copiato direttamente
event_data.domain security_result.about.administrative_domain Valore copiato direttamente
event_data.url security_result.about.url Valore copiato direttamente
event_data.pe_action security_result.action Mappato su ALLOW, BLOCK o ALLOW_WITH_MODIFICATION
event_data.categories security_result.category_details Uniti da event_data.categories (estratte o dirette) e casb_cat_name
casb_cat_name security_result.category_details
event_data.risk_score security_result.confidence_details Valore copiato direttamente
content-type security_result.detection_fields Uniti da vari campi dell'etichetta
prodotto security_result.detection_fields
minacce security_result.detection_fields
virusDetails security_result.detection_fields
sandboxResult security_result.detection_fields
fullScanResult security_result.detection_fields
tab_id security_result.detection_fields
pe_reason security_result.detection_fields
ua_type security_result.detection_fields
email_isolation_state security_result.detection_fields
document_url security_result.detection_fields
archive_path security_result.detection_fields
casb_app_name security_result.detection_fields
casb_fun_name security_result.detection_fields
casb_org_name security_result.detection_fields
casb_profile_id security_result.detection_fields
casb_profile_name security_result.detection_fields
casb_profile_type security_result.detection_fields
casb_risk_score security_result.detection_fields
connId security_result.detection_fields
origin_country security_result.detection_fields
egress_country security_result.detection_fields
is_casb_ddl security_result.detection_fields
is_iframe security_result.detection_fields
parent_file_id security_result.detection_fields
parent_filename security_result.detection_fields
parent_sha256 security_result.detection_fields
parent_tid security_result.detection_fields
root_file_id security_result.detection_fields
root_filename security_result.detection_fields
root_sha256 security_result.detection_fields
casb_risk_score security_result.risk_score Convertito in numero decimale
casb_profile_id security_result.rule_id Valore copiato direttamente
pe_rulename security_result.rule_name Valore copiato direttamente
casb_profile_name security_result.rule_set Valore copiato direttamente
casb_profile_type security_result.rule_type Valore copiato direttamente
event_data.severity security_result.severity_details Valore copiato direttamente
magicName security_result.summary Concatenato come "%{magicName} è %{threats}."
minacce security_result.summary
threat_types security_result.threat_name Valore copiato direttamente
origin_ip src.ip Valore copiato direttamente
origin_country src.location.country_or_region Valore copiato direttamente
event_data.dst target.asset.ip Estratto da event_data.dst o dst utilizzando il pattern IP grok
dst target.asset.ip
filename target.file.full_path Valore copiato direttamente
mimeType target.file.mime_type Valore copiato direttamente
sha256 target.file.sha256 Valore copiato direttamente
file_size target.file.size Convertito in float e poi in uinteger
event_data.dst target.ip Estratto da event_data.dst o dst utilizzando il pattern IP grok
dst target.ip
top_url target.url Estratto utilizzando il pattern grok URI
metadata.product_name metadata.product_name Impostato su "MENLO SECURITY"
metadata.vendor_name metadata.vendor_name Impostato su "MENLO SECURITY"
region event.idm.read_only_udm.principal.location.country_or_region Mappato dal log delle modifiche
region_name event.idm.read_only_udm.principal.location.name Mappato dal log delle modifiche
src_ip event.idm.read_only_udm.principal.ip e event.idm.read_only_udm.principal.asset.ip Mappato dal log delle modifiche
groups event.idm.read_only_udm.principal.group.product_object_id Mappato dal log delle modifiche
content-type event.idm.read_only_udm.security_result.detection_fields Mappato dal log delle modifiche
product event.idm.read_only_udm.security_result.detection_fields Mappato dal log delle modifiche
mimeType event.idm.read_only_udm.target.file.mime_type 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.