Raccogli i log degli avvisi di Intel 471 Watcher
Questo documento spiega come importare i log degli avvisi di Intel 471 Watcher in Google Security Operations utilizzando Google Cloud Storage V2.
Intel 471 è un'azienda di cyber threat intelligence che fornisce intelligence su avversari e malware provenienti dall'economia sommersa. Gli avvisi di Watcher sono notifiche generate dalla piattaforma Titan di Intel 471 quando vengono rilevati nuovi contenuti corrispondenti ai criteri di Watcher definiti dal cliente, consentendo una tempestiva consapevolezza delle minacce pertinenti come l'attività degli attori, i post dei forum e l'intelligence sui malware.
Prima di iniziare
Assicurati di soddisfare i seguenti prerequisiti:
- Un'istanza Google SecOps
- Un progetto GCP con l'API Storage di Cloud Storage abilitata
- 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
- Un abbonamento attivo a Intel 471 Titan con accesso all'API abilitato
- Accesso privilegiato al portale Intel 471 Titan
Crea un bucket Google Cloud Storage
- Vai alla console Google Cloud.
- Seleziona il tuo progetto o creane uno nuovo.
- Nel menu di navigazione, vai a Cloud Storage > Bucket.
- Fai clic su Crea bucket.
Fornisci i seguenti dettagli di configurazione:
Impostazione Valore Assegna un nome al bucket Inserisci un nome globalmente univoco (ad esempio intel471-watcher-alerts-logs)Tipo di località Scegli in base alle tue esigenze (Regione, a due regioni, multiregionale) Località Seleziona la località (ad esempio us-central1)Classe di archiviazione Standard (consigliato per i log ad accesso frequente) Controllo degli accessi Uniforme (consigliato) Strumenti di protezione (Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione Fai clic su Crea.
Raccogli le credenziali API Intel 471 Titan
Ottieni le credenziali API
- Accedi al portale Intel 471 Titan.
- Fai clic sull'icona del profilo utente nell'angolo in alto a destra.
- Vai alla sezione API.
- Copia e salva la chiave API visualizzata nella pagina.
- Prendi nota dell'indirizzo email associato al tuo account Intel 471 (l'indirizzo email che hai utilizzato per accedere).
Verifica le autorizzazioni
Per verificare che l'account disponga delle autorizzazioni richieste:
- Accedi al portale Intel 471 Titan.
- Vai a Watcher nel menu di navigazione.
- Se riesci a visualizzare le configurazioni e gli avvisi di Watcher esistenti, significa che disponi delle autorizzazioni necessarie.
- Se non riesci a visualizzare questa sezione, contatta l'amministratore di Intel 471 per concedere l'accesso all'API e le autorizzazioni di Watcher.
Testa l'accesso all'API
Testa le tue credenziali prima di procedere con l'integrazione:
# Replace with your actual credentials INTEL471_EMAIL="your-email@example.com" INTEL471_API_KEY="your-api-key" # Test API access curl -v -u "${INTEL471_EMAIL}:${INTEL471_API_KEY}" \ "https://api.intel471.com/v1/alerts?count=1"
Se il test ha esito positivo, dovresti ricevere una risposta JSON con un array alerts. Se ricevi un messaggio di errore:
- HTTP 401: verifica che l'indirizzo email e la chiave API siano corretti
- HTTP 403: verifica che l'account disponga delle autorizzazioni per gli avvisi di Watcher
- HTTP 429: limite di frequenza superato, attendi e riprova
Crea un account di servizio per la funzione Cloud Run
La funzione Cloud Run richiede un account di servizio con le autorizzazioni per scrivere nel bucket GCS ed essere richiamata da Pub/Sub.
Crea service account
- Nella console Google Cloud, vai a IAM e amministrazione > Account di servizio.
- Fai clic su Crea account di servizio.
- Fornisci i seguenti dettagli di configurazione:
- Nome del service account: inserisci
intel471-alerts-collector-sa - Descrizione account di servizio: inserisci
Service account for Cloud Run function to collect Intel 471 Watcher Alerts logs
- Nome del service account: inserisci
- Fai clic su Crea e continua.
- Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
- Fai clic su Seleziona un ruolo.
- Cerca e seleziona Storage Object Admin.
- Fai clic su + Aggiungi un altro ruolo.
- Cerca e seleziona Cloud Run Invoker.
- Fai clic su + Aggiungi un altro ruolo.
- Cerca e seleziona Cloud Functions Invoker.
- Fai clic su Continua.
- 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 della funzione
Concedi le autorizzazioni IAM sul bucket GCS
Concedi al account di servizio le autorizzazioni in scrittura sul bucket GCS:
- Vai a Cloud Storage > Bucket.
- Fai clic sul nome del bucket (ad esempio
intel471-watcher-alerts-logs). - Vai alla scheda Autorizzazioni.
- Fai clic su Concedi l'accesso.
- Fornisci i seguenti dettagli di configurazione:
- Aggiungi entità: inserisci l'indirizzo email del account di servizio (ad esempio
intel471-alerts-collector-sa@PROJECT_ID.iam.gserviceaccount.com) - Assegna i ruoli: seleziona Storage Object Admin
- Aggiungi entità: inserisci l'indirizzo email del account di servizio (ad esempio
- Fai clic su Salva.
Crea argomento Pub/Sub
Crea un argomento Pub/Sub in cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.
- Nella console Google Cloud, vai a Pub/Sub > Argomenti.
- Fai clic su Crea argomento.
- Fornisci i seguenti dettagli di configurazione:
- ID argomento: inserisci
intel471-alerts-trigger - Lascia invariate le altre impostazioni predefinite.
- ID argomento: inserisci
- 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 gli avvisi di Watcher dall'API Intel 471 Titan e scriverli in GCS.
- Nella console Google Cloud, vai a Cloud Run.
- Fai clic su Crea servizio.
- Seleziona Funzione (utilizza un editor di modifica in linea per creare una funzione).
Nella sezione Configura, fornisci i seguenti dettagli di configurazione:
Impostazione Valore Nome servizio intel471-alerts-collectorRegione Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)Tempo di esecuzione Seleziona Python 3.12 o versioni successive Nella sezione Trigger (facoltativo):
- Fai clic su + Aggiungi trigger.
- Seleziona Cloud Pub/Sub.
- In Seleziona un argomento Cloud Pub/Sub, scegli l'argomento Pub/Sub (ad esempio
intel471-alerts-trigger). - Fai clic su Salva.
Nella sezione Autenticazione:
- Seleziona Richiedi autenticazione.
- Controlla Identity and Access Management (IAM).
Scorri verso il basso ed espandi Container, networking, sicurezza.
Vai alla scheda Sicurezza:
- Service account: seleziona il account di servizio (ad esempio
intel471-alerts-collector-sa)
- Service account: seleziona il account di servizio (ad esempio
Vai alla scheda Container:
- Fai clic su Variabili e secret.
Fai clic su + Aggiungi variabile per ogni variabile di ambiente:
Nome variabile Valore di esempio Descrizione GCS_BUCKETintel471-watcher-alerts-logsNome bucket GCS GCS_PREFIXintel471-alertsPrefisso per i file di log STATE_KEYintel471-alerts/state.jsonPercorso del file di stato INTEL471_EMAILyour-email@example.comEmail dell'account Intel 471 INTEL471_API_KEYyour-api-keyChiave API Intel 471 MAX_RECORDS1000Numero massimo di record per esecuzione PAGE_SIZE100Record per pagina (massimo 100) LOOKBACK_HOURS24Periodo di riferimento iniziale
Nella sezione Variabili e secret, scorri verso il basso fino a Richieste:
- Timeout della richiesta: inserisci
600secondi (10 minuti)
- Timeout della richiesta: inserisci
Vai alla scheda Impostazioni:
- Nella sezione Risorse:
- Memoria: seleziona 512 MiB o un valore superiore
- CPU: seleziona 1
- Nella sezione Risorse:
Nella sezione Scalabilità della revisione:
- Numero minimo di istanze: inserisci
0 - Numero massimo di istanze: inserisci
100(o modifica in base al carico previsto)
- Numero minimo di istanze: inserisci
Fai clic su Crea.
Attendi la creazione del servizio (1-2 minuti). Dopo aver creato il servizio, l'editor di codice incorporato si aprirà automaticamente.
Aggiungi codice per la funzione
- Inserisci main nel campo Punto di ingresso.
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 import base64 # 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', 'intel471-alerts') STATE_KEY = os.environ.get('STATE_KEY', 'intel471-alerts/state.json') INTEL471_EMAIL = os.environ.get('INTEL471_EMAIL') INTEL471_API_KEY = os.environ.get('INTEL471_API_KEY') MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000')) PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '100')) LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_>HOURS', '24')) API_BASE = 'https://api.intel471.com/v1' def to_unix_millis(dt: datetime) - int: """Convert datetime to Unix epoch milliseconds.""" if dt.tzinfo is None: dt >= dt.replace(tzinfo=timezone.utc) dt = dt.astimezone(timezone.utc) return int(dt.timestamp() * 1000) 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 Intel 471 Watcher Alerts and write to GCS. Args: cloud_event: CloudEvent object containing Pub/Sub message """ if not all([GCS_BUCKET, INTEL471_EMAIL, INTEL471_API_KEY]): print('Error: Missing required environment variables') return try: # Get GCS bucket 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 alerts from {last_time.isoformat()} to {now.isoformat()}") # Convert to Unix milliseconds for Titan API start_millis = to_unix_millis(last_time) end_millis = to_unix_millis(now) # Fetch alerts records, newest_event_time = fetch_alerts( email=INTEL471_EMAIL, api_key=INTEL471_API_KEY, start_millis=start_millis, end_millis=end_millis, page_size=PAGE_SIZE, max_records=MAX_RECORDS, ) if not records: print("No new alert records found.") save_state(bucket, STATE_KEY, now.isoformat()) return # Write to GCS as NDJSONpan> timestamp = now.strftime('%Y%m%d_%H%M%S') object_key = f"{GCS_PREFIX}/alerts_{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}") # 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(records)} records") except Exception as e: print(f'Error processing alerts: {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_alerts(email: str, api_key: str, start_millis: int, end_millis: int, page_size: int, max_records: int): """ Fetch Watcher Alerts from Intel 471 Titan API with pagination and rate limiting. Args: email: Intel 471 account email api_key: Intel 471 API key start_millis: Start time in Unix epoch milliseconds end_millis: End time in Unix epoch milliseconds page_size: Number of records per page (max 100) max_records: Maximum total records to fetch Returns: Tuple of (records list, newest_event_time ISO string) """ endpoint = f"{API_BASE}/alerts" > # Build Basic Auth header auth_string = f"{email}:{api_key}" auth_bytes = auth_string.encode('utf-8') auth_b64 = base64.b64encode(auth_bytes).decode('utf-8') headers = { 'Authorization': f'Basic {auth_b64}', 'Accept': 'application/json', 'User-Agent': 'GoogleSecOps-Intel471Collector/1.0' } records = [] newest_time = None page_n&um = 0 backoff = 1.0 offset = 0 while True: page_num += 1 if len(records) = max_records: print(f"Reached max_records limit ({max_records})") break # Build request URL with pagination and time filtering current_page_size = min(page_size, max_records - len(records)) params = [] params.append(f"count={current_page_size}") params.append(f"offset={offset}") params.append(f"from={start_millis}") params.append(f"until={end_millis}") url = f"{endpoint}?{''.join(params)}" 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, 60.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 [], None data = json.loads(response.data.decode('utf-8')) # Extract results from alerts page_results = data.get('al>erts', []) if not page_results: print(f"No more results (empty page)") break print(f"Page {page_num}: Retrieved {len(page_results)} alerts") records.extend(page_results) # Track newest event time using foundTi>me (Unix milliseconds) for alert in page_results: try: found_time_ms = alert.get('foundTime') < if found_time_ms: event_dt = datetime.fromti<mestamp(found_time_ms / 1000, tz=timezone.utc) event_time = event_dt.isoformat() 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 alert_total = data.get('alertTotalCount', 0) if len(records) = alert_total: print(f"Retrieved all available alerts ({alert_total} total)") break if len(page_results) current_page_size: print(f"Reached last page (size={len(page_results)} limit={current_page_size})") break offset += len(page_results) except Exception as e: print(f"Error fetching alerts: {e}") return [], None print(f"Retrieved {len(records)} total records from {page_num} pages") return records, newest_timerequirements.txt:
functions-framework==3.* google-cloud-storage==2.* urllib3>=2.0.0
Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.
Attendi il completamento del deployment (2-3 minuti).
Crea job Cloud Scheduler
Cloud Scheduler pubblicherà i messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.
- Nella console Google Cloud, vai a Cloud Scheduler.
- Fai clic su Crea job.
Fornisci i seguenti dettagli di configurazione:
Impostazione Valore Nome intel471-alerts-collector-hourlyRegione 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 l'argomento Pub/Sub (ad esempio intel471-alerts-trigger).Corpo del messaggio {}(oggetto JSON vuoto)Fai clic su Crea.
Opzioni di frequenza di pianificazione
Scegli la frequenza in base al volume degli avvisi 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 * * * |
Basso volume, elaborazione batch |
| Ogni giorno | 0 0 * * * |
Raccolta dei dati storici |
Testa l'integrazione
- Nella console Cloud Scheduler, trova il tuo job (ad esempio
intel471-alerts-collector-hourly). - Fai clic su Forza esecuzione per attivare il job manualmente.
- Attendi alcuni secondi.
- Vai a Cloud Run > Servizi.
- Fai clic sul nome della funzione (ad esempio
intel471-alerts-collector). - Fai clic sulla scheda Log.
Verifica che la funzione sia stata eseguita correttamente. Cerca:
Fetching alerts from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00 Page 1: Retrieved X alerts Wrote X records to gs://bucket-name/intel471-alerts/alerts_YYYYMMDD_HHMMSS.ndjson Successfully processed X recordsVai a Cloud Storage > Bucket.
Fai clic sul nome del bucket (ad esempio
intel471-watcher-alerts-logs).Vai alla cartella del prefisso (ad esempio,
intel471-alerts/).Verifica che sia stato creato un nuovo file
.ndjsoncon il timestamp corrente.
Se visualizzi errori nei log:
- HTTP 401: controlla l'email e la chiave API di Intel 471 nelle variabili di ambiente
- HTTP 403: verifica che l'account disponga delle autorizzazioni per gli avvisi di Watcher
- HTTP 429: limitazione di frequenza. La funzione riproverà automaticamente con backoff
- Variabili di ambiente mancanti: verifica che tutte le variabili richieste siano impostate.
Recupera il account di servizio Google SecOps
Google SecOps utilizza un account di servizio univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo account di servizio l'accesso al tuo bucket.
Recupera l'indirizzo email del account di servizio
- Vai a Impostazioni > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > Feed.
- Fai clic su Aggiungi nuovo feed.
- Fai clic su Configura un singolo feed.
- Nel campo Nome feed, inserisci un nome per il feed (ad es.
Intel 471 Watcher Alerts). - Seleziona Google Cloud Storage V2 come Tipo di origine.
- Seleziona Intel 471 Watcher Alerts come Tipo di log.
Fai clic su Ottieni service account. Verrà visualizzato un indirizzo email univoco del account di servizio, ad esempio:
secops-12345678@secops-gcp-prod.iam.gserviceaccount.comCopia questo indirizzo email per utilizzarlo nel passaggio successivo.
Fai clic su Avanti.
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://intel471-watcher-alerts-logs/intel471-alerts/Sostituisci:
intel471-watcher-alerts-logs: il nome del tuo bucket GCS.intel471-alerts: prefisso/percorso della cartella in cui sono archiviati i log degli avvisi.
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.
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.
Fai clic su Avanti.
Controlla la nuova configurazione del feed di notizie nella schermata Finalizza, quindi 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.
- Vai a Cloud Storage > Bucket.
- Fai clic sul nome del bucket (ad esempio
intel471-watcher-alerts-logs). - Vai alla scheda Autorizzazioni.
- Fai clic su Concedi l'accesso.
- Fornisci i seguenti dettagli di configurazione:
- Aggiungi entità: incolla l'indirizzo email del account di servizio Google SecOps
- Assegna i ruoli: seleziona Storage Object Viewer
- Fai clic su Salva.
Tabella di mappatura UDM
| Campo del log | mappatura UDM | Logica |
|---|---|---|
| post.links.forum.uid | additional.fields | Campi di metadati aggiuntivi non coperti dai campi UDM standard |
| post.links.forum.name | additional.fields | |
| post.links.thread.uid | additional.fields | |
| post.links.thread.topic | additional.fields | |
| post.links.thread.count | additional.fields | |
| post.uid | additional.fields | |
| post.message | additional.fields | |
| highlight.field | additional.fields | |
| chunk.text | additional.fields | |
| chunk.hl | additional.fields | |
| actor.links.forumTotalCount | additional.fields | |
| actor.links.forumPrivateMessageTotalCount | additional.fields | |
| actor.links.instantMessageChannelTotalCount | additional.fields | |
| actor.links.reportTotalCount | additional.fields | |
| actor.links.instantMessageTotalCount | additional.fields | |
| actor.links.instantMessageServerTotalCount | additional.fields | |
| actor.links.forumPostTotalCount | additional.fields | |
| actor.lastUpdated | additional.fields | |
| actor.activeFrom | additional.fields | |
| actor.activeUntil | additional.fields | |
| data_leak_post.chunk_number | additional.fields | |
| data_leak_post.links.blog.uid | additional.fields | |
| data_leak_post.links.blog.name | additional.fields | |
| data_leak_post.links.thread.uid | additional.fields | |
| data_leak_post.links.thread.topic | additional.fields | |
| data_leak_post.links.thread.count | additional.fields | |
| data_leak_post.message | additional.fields | |
| actor.links.reports[].uid | additional.fields | |
| actor.links.reports[].admiraltyCode | additional.fields | |
| actor.links.reports[].dateOfInformation | additional.fields | |
| stato | additional.fields | |
| watcherUid | additional.fields | |
| watcherGroupUid | additional.fields | |
| report.uid | additional.fields | |
| report.admiraltyCode | additional.fields | |
| foundTime | additional.fields | |
| instantMessage.data.message.text | additional.fields | |
| instantMessage.data.message.uid | additional.fields | |
| instantMessage.data.channel.name | additional.fields | |
| instantMessage.data.channel.uid | additional.fields | |
| instantMessage.data.channel.url | additional.fields | |
| instantMessage.data.channel.registration_date | additional.fields | |
| instantMessage.data.channel.topic | additional.fields | |
| instantMessage.data.server.uid | additional.fields | |
| instantMessage.data.server.service_type | additional.fields | |
| post.links.forum.description | metadata.description | Descrizione dell'evento o dell'entità |
| actor.links.reports[].subject | metadata.description | |
| report.subject | metadata.description | |
| report.released | metadata.event_timestamp | Timestamp dell'evento |
| metadata.event_type | metadata.event_type | Tipo di evento (ad es. USER_LOGIN, NETWORK_CONNECTION) |
| uid | metadata.product_log_id | ID log del prodotto |
| data_leak_post.file_listing.download_url | principal.url | URL associato all'entità |
| actor.links.reports[].portalReportUrl | principal.url | |
| report.portalReportUrl | principal.url | |
| post.links.authorActor.handle | principal.user.attribute.labels | Attributi utente |
| actor.links.reports[].actorHandle | principal.user.attribute.labels | |
| instantMessage.data.actor.handle | principal.user.attribute.labels | |
| post.links.authorActor.uid | principal.user.userid | ID utente |
| actor.uid | principal.user.userid | |
| data_leak_post.uid | principal.user.userid | |
| instantMessage.data.actor.uid | principal.user.userid | |
report.uid |
event.idm.read_only_udm.metadata.additional.fields |
Mappato dal log delle modifiche |
report.admiraltyCode |
event.idm.read_only_udm.metadata.additional.fields |
Mappato dal log delle modifiche |
report.subject |
event.idm.read_only_udm.metadata.description |
Mappato dal log delle modifiche |
report.portalReportUrl |
event.idm.read_only_udm.principal.url |
Mappato dal log delle modifiche |
report.released |
event.idm.read_only_udm.metadata.event_timestamp |
Mappato dal log delle modifiche |
post.links.forum.description" and "actor.links.reports.subject |
metadata.description |
Mappato dal log delle modifiche |
post.links.authorActor.uid", "data_leak_post.uid" and "actor.uid |
principal.user.userid |
Mappato dal log delle modifiche |
post.links.authorActor.handle" and "actor.links.reports.actorHandle |
principal.user.attribute.labels |
Mappato dal log delle modifiche |
data_leak_post.file_listing.download_url" and "actor.links.reports.portalReportUrl |
principal.url |
Mappato dal log delle modifiche |
post.links.forum.uid", "post.links.forum.name", "post.links.thread.uid", "post.links.thread.topic", "post.links.thread.count", "post.uid", "post.message", "highlights.field", "highlights.chunks.text", "highlights.chunks.hl", "actor.links.forumTotalCount", "actor.links.forumPrivateMessageTotalCount", "actor.links.instantMessageChannelTotalCount", "actor.links.reportTotalCount", "actor.links.instantMessageTotalCount", "actor.links.instantMessageServerTotalCount", "actor.links.forumPostTotalCount", "actor.lastUpdated", "actor.activeFrom", "actor.activeUntil", "data_leak_post.chunk_number", "data_leak_post.links.blog.uid", "data_leak_post.links.blog.name", "data_leak_post.links.thread.uid", "data_leak_post.links.thread.topic", "data_leak_post.links.thread.count", "data_leak_post.message", "actor.links.reports.uid", "actor.links.reports.admiraltyCode", "actor.links.reports.dateOfInformation |
additional.fields |
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.