Raccogliere i risultati di DomainTools Iris Investigate

Supportato in:

Google secops SIEM

Questo documento spiega come importare i risultati di DomainTools Iris Investigate in Google Security Operations utilizzando Google Cloud Storage. Il parser trasforma i dati JSON non elaborati dell'API Iris di DomainTools in un formato strutturato conforme al modello UDM (Unified Data Model) di Google SecOps. Estrae informazioni relative a dettagli del dominio, informazioni di contatto, rischi per la sicurezza, certificati SSL e altri attributi pertinenti, mappandoli ai campi UDM corrispondenti per un'analisi coerente e per la threat intelligence.

Prima di iniziare

Assicurati di disporre dei seguenti prerequisiti:

Un'istanza Google SecOps
Accesso privilegiato all'account aziendale DomainTools (accesso API a Iris Investigate)
Un progetto GCP con l'API Cloud Storage abilitata
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

Ottieni la chiave API e l'endpoint DomainTools

Accedi alla dashboard API di DomainTools (solo l'account proprietario dell'API può reimpostare la chiave API).
Nella sezione Il mio account, seleziona il link Visualizza dashboard API nella scheda Riepilogo account.
Vai alla sezione Nome utente API per ottenere il tuo nome utente.
Nella stessa scheda, individua la chiave API.
Copia e salva la chiave in un luogo sicuro. Se hai bisogno di una nuova chiave, seleziona Reimposta chiave API.

Nota: la creazione di una nuova chiave comporta l'eliminazione immediata di quella esistente. L'operazione non può essere annullata.
Prendi nota dell'endpoint Iris Investigate: https://api.domaintools.com/v1/iris-investigate/.

Creazione di 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 univoco globale (ad esempio `domaintools-iris`).
Tipo di località	Scegli in base alle tue esigenze (regione singola, doppia regione, più regioni)
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

Fai clic su Crea.

Crea un service account per la funzione Cloud Run

La funzione Cloud Run richiede un service account con autorizzazioni di scrittura nel bucket GCS e di invocazione da parte di Pub/Sub.

Crea service account

Nella console Google Cloud, vai a IAM e amministrazione > Service Accounts.
Fai clic su Crea service account.
Fornisci i seguenti dettagli di configurazione:
- Nome del service account: inserisci domaintools-iris-collector-sa.
- Descrizione service account: inserisci Service account for Cloud Run function to collect DomainTools Iris Investigate logs.
Fai clic su Crea e continua.
Nella sezione Concedi a questo service account 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.
Fai clic su Continua.
Fai clic su Fine.

Questi ruoli sono necessari per:

Amministratore oggetti Storage: scrive i log nel bucket GCS e gestisce i file di stato
Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
Cloud Functions Invoker: consente la chiamata di funzioni

Concedi autorizzazioni IAM sul bucket GCS

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

Vai a Cloud Storage > Bucket.
Fai clic sul nome del bucket.
Vai alla scheda Autorizzazioni.
Fai clic su Concedi l'accesso.
Fornisci i seguenti dettagli di configurazione:
- Aggiungi entità: inserisci l'email del service account (ad es. domaintools-iris-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
- Assegna i ruoli: seleziona Storage Object Admin.
Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

Nella console GCP, vai a Pub/Sub > Argomenti.
Fai clic su Crea argomento.
Fornisci i seguenti dettagli di configurazione:
- ID argomento: inserisci domaintools-iris-trigger.
- Lascia le altre impostazioni sui valori predefiniti.
Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run viene attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log dall'API DomainTools Iris Investigate e li scrive in GCS.

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

Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

Impostazione	Valore
Nome servizio	`domaintools-iris-collector`
Regione	Seleziona la regione corrispondente al tuo bucket GCS (ad esempio `us-central1`)
Runtime	Seleziona Python 3.12 o versioni successive

Nella sezione Trigger (facoltativo):
1. Fai clic su + Aggiungi trigger.
2. Seleziona Cloud Pub/Sub.
3. In Seleziona un argomento Cloud Pub/Sub, scegli l'argomento Pub/Sub (domaintools-iris-trigger).
4. Fai clic su Salva.
Nella sezione Autenticazione:
1. Seleziona Richiedi autenticazione.
2. Controlla Identity and Access Management (IAM).
Nota: Pub/Sub gestirà automaticamente l'autenticazione quando viene richiamata la funzione.
Scorri verso il basso ed espandi Container, networking, sicurezza.
Vai alla scheda Sicurezza:
- Service account: seleziona il service account (domaintools-iris-collector-sa).

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_BUCKET`	`domaintools-iris`	Nome del bucket GCS in cui verranno archiviati i dati.
`GCS_PREFIX`	`domaintools/iris/`	Prefisso GCS (sottocartella) facoltativo per gli oggetti.
`STATE_KEY`	`domaintools/iris/state.json`	Chiave facoltativa del file di stato/checkpoint.
`DT_API_KEY`	`DT-XXXXXXXXXXXXXXXXXXXX`	Chiave API DomainTools.
`USE_MODE`	`HASH`	Seleziona la modalità da utilizzare: `HASH`, `DOMAINS` o `QUERY` (solo una è attiva alla volta).
`SEARCH_HASHES`	`hash1;hash2;hash3`	Obbligatorio se `USE_MODE=HASH`. Elenco separato da punto e virgola degli hash delle ricerche salvate dall'interfaccia utente di Iris.
`DOMAINS`	`example.com;domaintools.com`	Obbligatorio se `USE_MODE=DOMAINS`. Elenco di domini separati da punti e virgola.
`QUERY_LIST`	`ip=1.1.1.1;ip=8.8.8.8;domain=example.org`	Obbligatorio se `USE_MODE=QUERY`. Elenco di stringhe di query separate da punto e virgola (`k=v&k2=v2`).
`PAGE_SIZE`	`500`	Righe per pagina (valore predefinito 500).
`MAX_PAGES`	`20`	Numero massimo di pagine per richiesta.

Nella sezione Variabili e secret, scorri verso il basso fino a Richieste:
- Timeout richiesta: inserisci 900 secondi (15 minuti).
Vai alla scheda Impostazioni:
- Nella sezione Risorse:
  - Memoria: seleziona 512 MiB o un valore superiore.
  - CPU: seleziona 1.
Nella sezione Scalabilità della revisione:
- Numero minimo di istanze: inserisci 0.
- Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).
Fai clic su Crea.
Attendi la creazione del servizio (1-2 minuti).
Dopo aver creato il servizio, si apre automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

Inserisci main in Entry point della funzione

Nell'editor di codice incorporato, crea due file:

Primo file: main.py:

import functions_framework
from google.cloud import storage
import json
import os
import urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError
import time
from datetime import datetime, timezone

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get("GCS_BUCKET", "").strip()
GCS_PREFIX = os.environ.get("GCS_PREFIX", "domaintools/iris/").strip()
STATE_KEY = os.environ.get("STATE_KEY", "domaintools/iris/state.json").strip()
DT_API_KEY = os.environ.get("DT_API_KEY", "").strip()
USE_MODE = os.environ.get("USE_MODE", "HASH").strip().upper()
SEARCH_HASHES = [h.strip() for h in os.environ.get("SEARCH_HASHES", "").split(";") if h.strip()]
DOMAINS = [d.strip() for d in os.environ.get("DOMAINS", "").split(";") if d.strip()]
QUERY_LIST = [q.strip() for q in os.environ.get("QUERY_LIST", "").split(";") if q.strip()]
PAGE_SIZE = int(os.environ.get("PAGE_SIZE", "500"))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))
USE_NEXT = os.environ.get("USE_NEXT", "true").lower() == "true"
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
RETRIES = int(os.environ.get("HTTP_RETRIES", "2"))

BASE_URL = "https://api.domaintools.com/v1/iris-investigate/"
HDRS = {
    "X-Api-Key": DT_API_KEY,
    "Accept": "application/json",
}

def _http_post(url: str, body: dict) -> dict:
    """Make HTTP POST request with form-encoded body."""
    req = Request(url, method="POST")
    for k, v in HDRS.items():
        req.add_header(k, v)
    req.add_header("Content-Type", "application/x-www-form-urlencoded")

    encoded_body = urllib.parse.urlencode(body, doseq=True).encode('utf-8')

    attempt = 0
    while True:
        try:
            with urlopen(req, data=encoded_body, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            if e.code in (429, 500, 502, 503, 504) and attempt < RETRIES:
                delay = int(e.headers.get("Retry-After", "2"))
                time.sleep(max(1, delay))
                attempt += 1
                continue
            raise

def _write_page(bucket, obj: dict, label: str, page: int) -> str:
    ts = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
    key = f"{GCS_PREFIX.rstrip('/')}/{ts}-{label}-p{page:05d}.json"
    blob = bucket.blob(key)
    blob.upload_from_string(
        json.dumps(obj, separators=(",", ":")),
        content_type="application/json"
    )
    return key

def _first_page_params() -> dict:
    params = {"page_size": str(PAGE_SIZE)}
    if USE_NEXT:
        params["next"] = "true"
    return params

def _paginate(bucket, label: str, params: dict) -> tuple:
    pages = 0
    total = 0

    while pages < MAX_PAGES:
        data = _http_post(BASE_URL, params)
        _write_page(bucket, data, label, pages)
        resp = data.get("response") or {}
        results = resp.get("results") or []
        total += len(results)
        pages += 1

        next_url = resp.get("next") if isinstance(resp, dict) else None
        if next_url:
            parsed = urllib.parse.urlparse(next_url)
            params = dict(urllib.parse.parse_qsl(parsed.query))
            continue

        if resp.get("has_more_results") and resp.get("position"):
            base = _first_page_params()
            base.pop("next", None)
            base["position"] = resp["position"]
            params = base
            continue
        break
    return pages, total

def run_hashes(bucket, hashes: list) -> dict:
    agg_pages = agg_results = 0
    for h in hashes:
        params = _first_page_params()
        params["search_hash"] = h
        p, r = _paginate(bucket, f"hash-{h}", params)
        agg_pages += p
        agg_results += r
    return {"pages": agg_pages, "results": agg_results}

def run_domains(bucket, domains: list) -> dict:
    agg_pages = agg_results = 0
    for d in domains:
        params = _first_page_params()
        params["domain"] = d
        p, r = _paginate(bucket, f"domain-{d}", params)
        agg_pages += p
        agg_results += r
    return {"pages": agg_pages, "results": agg_results}

def run_queries(bucket, queries: list) -> dict:
    agg_pages = agg_results = 0
    for q in queries:
        base = _first_page_params()
        for k, v in urllib.parse.parse_qsl(q, keep_blank_values=True):
            base.setdefault(k, v)
        p, r = _paginate(bucket, f"query-{q.replace('=', '-')}", base)
        agg_pages += p
        agg_results += r
    return {"pages": agg_pages, "results": agg_results}

@functions_framework.cloud_event
def main(cloud_event):
    """
    Cloud Run function triggered by Pub/Sub to fetch DomainTools Iris Investigate results and write to GCS.

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

    if not GCS_BUCKET:
        print("Error: GCS_BUCKET environment variable not set")
        return

    try:
        bucket = storage_client.bucket(GCS_BUCKET)

        if USE_MODE == "HASH" and SEARCH_HASHES:
            res = run_hashes(bucket, SEARCH_HASHES)
        elif USE_MODE == "DOMAINS" and DOMAINS:
            res = run_domains(bucket, DOMAINS)
        elif USE_MODE == "QUERY" and QUERY_LIST:
            res = run_queries(bucket, QUERY_LIST)
        else:
            raise ValueError(
                "Invalid USE_MODE or missing parameters. Set USE_MODE to HASH | DOMAINS | QUERY "
                "and provide SEARCH_HASHES | DOMAINS | QUERY_LIST accordingly."
            )

        print(f"Successfully processed: {json.dumps({'ok': True, 'mode': USE_MODE, **res})}")

    except Exception as e:
        print(f"Error processing DomainTools Iris data: {str(e)}")
        raise

Secondo file: requirements.txt::

functions-framework==3.*
google-cloud-storage==2.*

Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.
Attendi il completamento del deployment (2-3 minuti).

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

Crea job Cloud Scheduler

Cloud Scheduler pubblicherà messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

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

Fornisci i seguenti dettagli di configurazione:

Impostazione	Valore
Nome	`domaintools-iris-1h`
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 l'argomento Pub/Sub (`domaintools-iris-trigger`)
Corpo del messaggio	`{}` (oggetto JSON vuoto)

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

Nella console Cloud Scheduler, trova il job.
Fai clic su Forza esecuzione per attivare il job manualmente.
Aspetta alcuni secondi.
Vai a Cloud Run > Servizi.
Fai clic sul nome della funzione (domaintools-iris-collector).
Fai clic sulla scheda Log.

Verifica che la funzione sia stata eseguita correttamente. Cerca quanto segue:

Successfully processed: {"ok": true, "mode": "HASH", "pages": X, "results": Y}

Vai a Cloud Storage > Bucket.
Fai clic sul nome del bucket.
Vai alla cartella del prefisso (domaintools/iris/).
Verifica che siano stati creati nuovi file .json con il timestamp corrente.

Se visualizzi errori nei log:

HTTP 401: controlla le credenziali dell'API DomainTools nelle variabili di ambiente
HTTP 403: verifica che l'account disponga delle autorizzazioni richieste per l'API Iris Investigate
HTTP 429: limitazione della frequenza: la funzione riproverà automaticamente con backoff
Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate
USE_MODE non valido: verifica che USE_MODE sia impostato su HASH, DOMAINS o QUERY e che siano forniti i parametri corrispondenti

Recuperare il service account Google SecOps

Google SecOps utilizza un service account univoco per leggere i dati dal tuo bucket GCS. Devi concedere a questo service account l'accesso al tuo bucket.

Recuperare l'email del service account

Vai a Impostazioni SIEM > 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 esempio, DomainTools Iris Investigate).
Seleziona Google Cloud Storage V2 come Tipo di origine.
Seleziona DomainTools Threat Intelligence come Tipo di log.
Fai clic su Ottieni service account. Viene visualizzata un'email del service account univoca, ad esempio:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
Copia questo indirizzo email per utilizzarlo nel passaggio successivo.

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

Concedi le autorizzazioni IAM al service account Google SecOps

Il service account Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel bucket GCS.

Vai a Cloud Storage > Bucket.
Fai clic sul nome del bucket.
Vai alla scheda Autorizzazioni.
Fai clic su Concedi l'accesso.
Fornisci i seguenti dettagli di configurazione:
- Aggiungi entità: incolla l'email del service account Google SecOps.
- Assegna i ruoli: seleziona Visualizzatore oggetti Storage.
Fai clic su Salva.

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

Configura un feed in Google SecOps per importare i risultati di DomainTools Iris Investigate

Vai a Impostazioni SIEM > 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 esempio, DomainTools Iris Investigate).
Seleziona Google Cloud Storage V2 come Tipo di origine.
Seleziona DomainTools Threat Intelligence come Tipo di log.
Fai clic su Avanti.
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://domaintools-iris/domaintools/iris/
```
  - Sostituisci:
    - domaintools-iris: il nome del bucket GCS.
    - domaintools/iris/: (Facoltativo) prefisso/percorso della cartella in cui vengono archiviati i log (lascia vuoto per la radice).
  - Esempi:
    - Bucket radice: gs://domaintools-iris/
    - Con prefisso: gs://domaintools-iris/domaintools/iris/
  Nota: includi sempre la barra finale (/) alla fine dell'URI.
- Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:
  - Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
  - Elimina 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.
    
    Nota :se selezioni un'opzione di eliminazione, il service account deve disporre del ruolo Storage Object Admin anziché di Storage Object Viewer. Aggiorna le autorizzazioni IAM di conseguenza.
- Età massima del file: includi i file modificati nell'ultimo numero di giorni. Il valore predefinito è 180 giorni.
- Spazio dei nomi dell'asset: domaintools.threat_intel
- Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Funzione logica
attivo	principal.domain.status	Mappato direttamente dal campo attivo nel log non elaborato.
additional_whois_email.[].value	about.labels.additional_whois_email	Estratto dall'array additional_whois_email e aggiunto come etichetta nell'oggetto about.
adsense.value	about.labels.adsense	Estratto da adsense.value e aggiunto come etichetta nell'oggetto about.
admin_contact.city.value	principal.domain.admin.office_address.city	Mappato direttamente dal campo admin_contact.city.value nel log non elaborato.
admin_contact.country.value	principal.domain.admin.office_address.country_or_region	Mappato direttamente dal campo admin_contact.country.value nel log non elaborato.
admin_contact.email.[].value	principal.domain.admin.email_addresses	Estratto dall'array admin_contact.email e aggiunto al campo email_addresses.
admin_contact.fax.value	principal.domain.admin.attribute.labels.fax	Estratto da admin_contact.fax.value e aggiunto come etichetta con la chiave "fax" nell'attributo admin.
admin_contact.name.value	principal.domain.admin.user_display_name	Mappato direttamente dal campo admin_contact.name.value nel log non elaborato.
admin_contact.org.value	principal.domain.admin.company_name	Mappato direttamente dal campo admin_contact.org.value nel log non elaborato.
admin_contact.phone.value	principal.domain.admin.phone_numbers	Mappato direttamente dal campo admin_contact.phone.value nel log non elaborato.
admin_contact.postal.value	principal.domain.admin.attribute.labels.postal	Estratto da admin_contact.postal.value e aggiunto come etichetta con la chiave "postal" nell'attributo admin.
admin_contact.state.value	principal.domain.admin.office_address.state	Mappato direttamente dal campo admin_contact.state.value nel log non elaborato.
admin_contact.street.value	principal.domain.admin.office_address.name	Mappato direttamente dal campo admin_contact.street.value nel log non elaborato.
alexa	about.labels.alexa	Mappato direttamente dal campo alexa nel log non elaborato e aggiunto come etichetta nell'oggetto about.
baidu_codes.[].value	about.labels.baidu_codes	Estratto dall'array baidu_codes e aggiunto come etichetta nell'oggetto about.
billing_contact.city.value	principal.domain.billing.office_address.city	Mappato direttamente dal campo billing_contact.city.value nel log non elaborato.
billing_contact.country.value	principal.domain.billing.office_address.country_or_region	Mappato direttamente dal campo billing_contact.country.value nel log non elaborato.
billing_contact.email.[].value	principal.domain.billing.email_addresses	Estratto dall'array billing_contact.email e aggiunto al campo email_addresses.
billing_contact.fax.value	principal.domain.billing.attribute.labels.fax	Estratto da billing_contact.fax.value e aggiunto come etichetta con la chiave "fax" nell'attributo di fatturazione.
billing_contact.name.value	principal.domain.billing.user_display_name	Mappato direttamente dal campo billing_contact.name.value nel log non elaborato.
billing_contact.org.value	principal.domain.billing.company_name	Mappato direttamente dal campo billing_contact.org.value nel log non elaborato.
billing_contact.phone.value	principal.domain.billing.phone_numbers	Mappato direttamente dal campo billing_contact.phone.value nel log non elaborato.
billing_contact.postal.value	principal.domain.billing.attribute.labels.postal	Estratto da billing_contact.postal.value e aggiunto come etichetta con la chiave "postal" nell'attributo di fatturazione.
billing_contact.state.value	principal.domain.billing.office_address.state	Mappato direttamente dal campo billing_contact.state.value nel log non elaborato.
billing_contact.street.value	principal.domain.billing.office_address.name	Mappato direttamente dal campo billing_contact.street.value nel log non elaborato.
create_date.value	principal.domain.creation_time	Convertito nel formato timestamp dal campo create_date.value nel log non elaborato.
data_updated_timestamp	principal.domain.audit_update_time	Convertito nel formato timestamp dal campo data_updated_timestamp nel log non elaborato.
dominio	principal.hostname	Mappato direttamente dal campo del dominio nel log non elaborato.
domain_risk.components.[].evidence	security_result.detection_fields.evidence	Estratto dall'array domain_risk.components.[].evidence e aggiunto come campo di rilevamento con la chiave "evidence" nell'oggetto security_result.
domain_risk.components.[].name	security_result.category_details	Mappato direttamente dal campo domain_risk.components.[].name nel log non elaborato.
domain_risk.components.[].risk_score	security_result.risk_score	Mappato direttamente dal campo domain_risk.components.[].risk_score nel log non elaborato.
domain_risk.components.[].threats	security_result.threat_name	Il primo elemento dell'array domain_risk.components.[].threats viene mappato a security_result.threat_name.
domain_risk.components.[].threats	security_result.detection_fields.threats	Gli elementi rimanenti dell'array domain_risk.components.[].threats vengono aggiunti come campi di rilevamento con la chiave "threats" nell'oggetto security_result.
domain_risk.risk_score	security_result.risk_score	Mappato direttamente dal campo domain_risk.risk_score nel log non elaborato.
email_domain.[].value	about.labels.email_domain	Estratto dall'array email_domain e aggiunto come etichetta nell'oggetto about.
expiration_date.value	principal.domain.expiration_time	Convertito nel formato timestamp dal campo expiration_date.value nel log non elaborato.
fb_codes.[].value	about.labels.fb_codes	Estratto dall'array fb_codes e aggiunto come etichetta nell'oggetto about.
first_seen.value	principal.domain.first_seen_time	Convertito nel formato timestamp dal campo first_seen.value nel log non elaborato.
ga4.[].value	about.labels.ga4	Estratto dall'array GA4 e aggiunto come etichetta nell'oggetto about.
google_analytics.value	about.labels.google_analytics	Estratto da google_analytics.value e aggiunto come etichetta nell'oggetto about.
gtm_codes.[].value	about.labels.gtm_codes	Estratto dall'array gtm_codes e aggiunto come etichetta nell'oggetto about.
hotjar_codes.[].value	about.labels.hotjar_codes	Estratto dall'array hotjar_codes e aggiunto come etichetta nell'oggetto about.
ip.[].address.value	principal.ip	Il primo elemento dell'array ip è mappato su principal.ip.
ip.[].address.value	about.labels.ip_address	Gli elementi rimanenti dell'array ip vengono aggiunti come etichette con la chiave "ip_address" nell'oggetto about.
ip.[].asn.[].value	network.asn	Il primo elemento del primo array ip.asn è mappato su network.asn.
ip.[].asn.[].value	about.labels.asn	Gli elementi rimanenti degli array ip.asn vengono aggiunti come etichette con la chiave "asn" nell'oggetto about.
ip.[].country_code.value	principal.location.country_or_region	country_code.value del primo elemento dell'array ip viene mappato a principal.location.country_or_region.
ip.[].country_code.value	about.location.country_or_region	Il valore country_code degli elementi rimanenti nell'array ip viene mappato su about.location.country_or_region.
ip.[].isp.value	principal.labels.isp	isp.value del primo elemento dell'array ip viene mappato a principal.labels.isp.
ip.[].isp.value	about.labels.isp	isp.value degli elementi rimanenti nell'array ip viene mappato a about.labels.isp.
matomo_codes.[].value	about.labels.matomo_codes	Estratto dall'array matomo_codes e aggiunto come etichetta nell'oggetto about.
monitor_domain	about.labels.monitor_domain	Mappato direttamente dal campo monitor_domain nel log non elaborato e aggiunto come etichetta nell'oggetto about.
monitoring_domain_list_name	about.labels.monitoring_domain_list_name	Mappato direttamente dal campo monitoring_domain_list_name nel log non elaborato e aggiunto come etichetta nell'oggetto about.
mx.[].domain.value	about.domain.name	Mappato direttamente dal campo mx.[].domain.value nel log non elaborato.
mx.[].host.value	about.hostname	Mappato direttamente dal campo mx.[].host.value nel log non elaborato.
mx.[].ip.[].value	about.ip	Estratto dall'array mx.[].ip e aggiunto al campo ip.
mx.[].priority	about.security_result.priority_details	Mappato direttamente dal campo mx.[].priority nel log non elaborato.
name_server.[].domain.value	about.labels.name_server_domain	Estratto da name_server.[].domain.value e aggiunto come etichetta con la chiave "name_server_domain" nell'oggetto about.
name_server.[].host.value	principal.domain.name_server	Estratto da name_server.[].host.value e aggiunto al campo name_server.
name_server.[].host.value	about.domain.name_server	Estratto da name_server.[].host.value e aggiunto al campo name_server.
name_server.[].ip.[].value	about.labels.ip	Estratto dall'array name_server.[].ip e aggiunto come etichetta con la chiave "ip" nell'oggetto about.
popularity_rank	about.labels.popularity_rank	Mappato direttamente dal campo popularity_rank nel log non elaborato e aggiunto come etichetta nell'oggetto about.
redirect.value	about.labels.redirect	Estratto da redirect.value e aggiunto come etichetta nell'oggetto about.
redirect_domain.value	about.labels.redirect_domain	Estratto da redirect_domain.value e aggiunto come etichetta nell'oggetto about.
registrant_contact.city.value	principal.domain.registrant.office_address.city	Mappato direttamente dal campo registrant_contact.city.value nel log non elaborato.
registrant_contact.country.value	principal.domain.registrant.office_address.country_or_region	Mappato direttamente dal campo registrant_contact.country.value nel log non elaborato.
registrant_contact.email.[].value	principal.domain.registrant.email_addresses	Estratto dall'array registrant_contact.email e aggiunto al campo email_addresses.
registrant_contact.fax.value	principal.domain.registrant.attribute.labels.fax	Estratto da registrant_contact.fax.value e aggiunto come etichetta con la chiave "fax" nell'attributo del registrante.
registrant_contact.name.value	principal.domain.registrant.user_display_name	Mappato direttamente dal campo registrant_contact.name.value nel log non elaborato.
registrant_contact.org.value	principal.domain.registrant.company_name	Mappato direttamente dal campo registrant_contact.org.value nel log non elaborato.
registrant_contact.phone.value	principal.domain.registrant.phone_numbers	Mappato direttamente dal campo registrant_contact.phone.value nel log non elaborato.
registrant_contact.postal.value	principal.domain.registrant.attribute.labels.postal	Estratto da registrant_contact.postal.value e aggiunto come etichetta con la chiave "postal" nell'attributo del registrante.
registrant_contact.state.value	principal.domain.registrant.office_address.state	Mappato direttamente dal campo registrant_contact.state.value nel log non elaborato.
registrant_contact.street.value	principal.domain.registrant.office_address.name	Mappato direttamente dal campo registrant_contact.street.value nel log non elaborato.
registrant_name.value	about.labels.registrant_name	Estratto da registrant_name.value e aggiunto come etichetta nell'oggetto about.
registrant_org.value	about.labels.registrant_org	Estratto da registrant_org.value e aggiunto come etichetta nell'oggetto about.
registrar.value	principal.domain.registrar	Mappato direttamente dal campo registrar.value nel log non elaborato.
registrar_status	about.labels.registrar_status	Estratto dall'array registrar_status e aggiunto come etichetta nell'oggetto about.
server_type	network.tls.client.server_name	Mappato direttamente dal campo server_type nel log non elaborato.
soa_email.[].value	principal.user.email_addresses	Estratto dall'array soa_email e aggiunto al campo email_addresses.
spf_info	about.labels.spf_info	Mappato direttamente dal campo spf_info nel log non elaborato e aggiunto come etichetta nell'oggetto about.
ssl_email.[].value	about.labels.ssl_email	Estratto dall'array ssl_email e aggiunto come etichetta nell'oggetto about.
ssl_info.[].alt_names.[].value	about.labels.alt_names	Estratto dall'array ssl_info.[].alt_names e aggiunto come etichetta nell'oggetto about.
ssl_info.[].common_name.value	about.labels.common_name	Estratto da ssl_info.[].common_name.value e aggiunto come etichetta nell'oggetto about.
ssl_info.[].duration.value	about.labels.duration	Estratto da ssl_info.[].duration.value e aggiunto come etichetta nell'oggetto about.
ssl_info.[].email.[].value	about.labels.ssl_info_email	Estratto dall'array ssl_info.[].email e aggiunto come etichetta con la chiave "ssl_info_email" nell'oggetto about.
ssl_info.[].hash.value	network.tls.server.certificate.sha1	hash.value del primo elemento dell'array ssl_info viene mappato a network.tls.server.certificate.sha1.
ssl_info.[].hash.value	about.labels.hash	hash.value degli elementi rimanenti nell'array ssl_info viene mappato su about.labels.hash.
ssl_info.[].issuer_common_name.value	network.tls.server.certificate.issuer	issuer_common_name.value del primo elemento dell'array ssl_info viene mappato a network.tls.server.certificate.issuer.
ssl_info.[].issuer_common_name.value	about.labels.issuer_common_name	Il valore di issuer_common_name degli elementi rimanenti nell'array ssl_info viene mappato su about.labels.issuer_common_name.
ssl_info.[].not_after.value	network.tls.server.certificate.not_after	Il valore not_after.value del primo elemento dell'array ssl_info viene convertito nel formato timestamp e mappato a network.tls.server.certificate.not_after.
ssl_info.[].not_after.value	about.labels.not_after	Il valore not_after.value degli elementi rimanenti nell'array ssl_info viene mappato su about.labels.not_after.
ssl_info.[].not_before.value	network.tls.server.certificate.not_before	not_before.value del primo elemento dell'array ssl_info viene convertito nel formato timestamp e mappato a network.tls.server.certificate.not_before.
ssl_info.[].not_before.value	about.labels.not_before	Il valore not_before.value degli elementi rimanenti nell'array ssl_info viene mappato su about.labels.not_before.
ssl_info.[].organization.value	network.organization_name	organization.value del primo elemento dell'array ssl_info viene mappato a network.organization_name.
ssl_info.[].organization.value	about.labels.organization	organization.value degli elementi rimanenti nell'array ssl_info viene mappato su about.labels.organization.
ssl_info.[].subject.value	about.labels.subject	Estratto da ssl_info.[].subject.value e aggiunto come etichetta nell'oggetto about.
statcounter_project_codes.[].value	about.labels.statcounter_project_codes	Estratto dall'array statcounter_project_codes e aggiunto come etichetta nell'oggetto about.
statcounter_security_codes.[].value	about.labels.statcounter_security_codes	Estratto dall'array statcounter_security_codes e aggiunto come etichetta nell'oggetto about.
tags.[].label	about.file.tags	Estratto da tags.[].label e aggiunto al campo dei tag.
tags.[].scope	security_result.detection_fields.scope	Estratto da tags.[].scope e aggiunto come campo di rilevamento con la chiave "scope" nell'oggetto security_result.
tags.[].tagged_at	security_result.detection_fields.tagged_at	Estratto da tags.[].tagged_at e aggiunto come campo di rilevamento con la chiave "tagged_at" nell'oggetto security_result.
technical_contact.city.value	principal.domain.tech.office_address.city	Mappato direttamente dal campo technical_contact.city.value nel log non elaborato.
technical_contact.country.value	principal.domain.tech.office_address.country_or_region	Mappato direttamente dal campo technical_contact.country.value nel log non elaborato.
technical_contact.email.[].value	principal.domain.tech.email_addresses	Estratto dall'array technical_contact.email e aggiunto al campo email_addresses.
technical_contact.fax.value	principal.domain.tech.attribute.labels.fax	Estratto da technical_contact.fax.value e aggiunto come etichetta con la chiave "fax" nell'attributo tecnico.
technical_contact.name.value	principal.domain.tech.user_display_name	Mappato direttamente dal campo technical_contact.name.value nel log non elaborato.
technical_contact.org.value	principal.domain.tech.company_name	Mappato direttamente dal campo technical_contact.org.value nel log non elaborato.
technical_contact.phone.value	principal.domain.tech.phone_numbers	Mappato direttamente dal campo technical_contact.phone.value nel log non elaborato.
technical_contact.postal.value	principal.domain.tech.attribute.labels.postal	Estratto da technical_contact.postal.value e aggiunto come etichetta con la chiave "postal" nell'attributo tecnico.
technical_contact.state.value	principal.domain.tech.office_address.state	Mappato direttamente dal campo technical_contact.state.value nel log non elaborato.
technical_contact.street.value	principal.domain.tech.office_address.name	Mappato direttamente dal campo technical_contact.street.value nel log non elaborato.
tld	about.labels.tld	Mappato direttamente dal campo tld nel log non elaborato e aggiunto come etichetta nell'oggetto about.
timestamp	about.labels.timestamp	Mappato direttamente dal campo timestamp nel log non elaborato e aggiunto come etichetta nell'oggetto about.
website_response	principal.network.http.response_code	Mappato direttamente dal campo website_response nel log non elaborato.
website_title	about.labels.website_title	Mappato direttamente dal campo website_title nel log non elaborato e aggiunto come etichetta nell'oggetto about.
whois_url	principal.domain.whois_server	Mappato direttamente dal campo whois_url nel log non elaborato.
yandex_codes.[].value	about.labels.yandex_codes	Estratto dall'array yandex_codes e aggiunto come etichetta nell'oggetto about.
edr.client.hostname		Impostato sul valore del campo del dominio.
edr.client.ip_addresses		Impostato sul valore del primo elemento dell'array ip, in particolare ip.[0].address.value.
edr.raw_event_name		Impostato su "STATUS_UPDATE" se è presente principal.hostname, altrimenti impostato su "GENERIC_EVENT".
metadata.event_timestamp		Copiato dal campo create_time di primo livello nel log non elaborato.
metadata.event_type		Impostato su "STATUS_UPDATE" se è presente principal.hostname, altrimenti impostato su "GENERIC_EVENT".
metadata.log_type		Imposta su "DOMAINTOOLS_THREATINTEL".
metadata.product_name		Imposta il valore su "DOMAINTOOLS".
metadata.vendor_name		Imposta il valore su "DOMAINTOOLS".

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