Collecter les résultats de DomainTools Iris Investigate

Compatible avec :

Ce document explique comment ingérer les résultats de DomainTools Iris Investigate dans Google Security Operations à l'aide de Google Cloud Storage. L'analyseur transforme les données JSON brutes de l'API Iris de DomainTools en un format structuré conforme au modèle de données unifié (UDM) de Google SecOps. Il extrait des informations sur les détails du domaine, les coordonnées, les risques de sécurité, les certificats SSL et d'autres attributs pertinents, et les mappe aux champs UDM correspondants pour une analyse cohérente et des renseignements sur les menaces.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

  • Une instance Google SecOps
  • Accès privilégié au compte DomainTools Enterprise (accès à l'API Iris Investigate)
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations pour créer et gérer des buckets GCS
  • Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des tâches Cloud Scheduler

Obtenir la clé API et le point de terminaison DomainTools

  1. Connectez-vous au tableau de bord de l'API DomainTools (seul le compte du propriétaire de l'API peut réinitialiser la clé API).
  2. Dans la section Mon compte, sélectionnez le lien Afficher le tableau de bord des API de l'onglet Récapitulatif du compte.
  3. Accédez à la section Nom d'utilisateur de l'API pour obtenir votre nom d'utilisateur.
  4. Dans le même onglet, recherchez votre clé API.

  5. Copiez et enregistrez la clé dans un emplacement sécurisé. Si vous avez besoin d'une nouvelle clé, sélectionnez Réinitialiser la clé API.

  6. Notez le point de terminaison Iris Investigate : https://api.domaintools.com/v1/iris-investigate/.

Créer un bucket Google Cloud Storage

  1. Accédez à la console Google Cloud.
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage> Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nommer votre bucket Saisissez un nom unique (par exemple, domaintools-iris).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion ou multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activer la gestion des versions des objets ou la règle de conservation

  6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service disposant des autorisations nécessaires pour écrire dans le bucket GCS et être appelée par Pub/Sub.

Créer un compte de service

  1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez domaintools-iris-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect DomainTools Iris Investigate logs.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets de l'espace de stockage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. Cliquez sur OK.

Ces rôles sont requis pour :

  • Administrateur des objets Storage : écrire des journaux dans le bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction
  • Demandeur Cloud Functions : autorise l'appel de fonctions

Accorder des autorisations IAM sur un bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, domaintools-iris-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
  6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub auquel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Create topic (Créer un sujet).
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez domaintools-iris-trigger.
    • Conservez les valeurs par défaut des autres paramètres.
  4. Cliquez sur Créer.

Créer une fonction Cloud Run pour collecter les journaux

La fonction Cloud Run est déclenchée par les messages Pub/Sub de Cloud Scheduler pour extraire les journaux de l'API DomainTools Iris Investigate et les écrire dans GCS.

  1. Dans la console GCP, accédez à Cloud Run.
  2. Cliquez sur Créer un service.
  3. Sélectionnez Fonction (utilisez un éditeur intégré pour créer une fonction).

  4. Dans la section Configurer, fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom du service domaintools-iris-collector
    Région Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
    Runtime (durée d'exécution) Sélectionnez Python 3.12 ou version ultérieure.

  5. Dans la section Déclencheur (facultatif) :

    1. Cliquez sur + Ajouter un déclencheur.
    2. Sélectionnez Cloud Pub/Sub.
    3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet Pub/Sub (domaintools-iris-trigger).
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

  8. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service (domaintools-iris-collector-sa).

  9. Accédez à l'onglet Conteneurs :

    1. Cliquez sur Variables et secrets.
    2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
    Nom de la variable Exemple de valeur Description
    GCS_BUCKET domaintools-iris Nom du bucket GCS dans lequel les données seront stockées.
    GCS_PREFIX domaintools/iris/ Préfixe GCS facultatif (sous-dossier) pour les objets.
    STATE_KEY domaintools/iris/state.json Clé de fichier d'état/de point de contrôle facultative.
    DT_API_KEY DT-XXXXXXXXXXXXXXXXXXXX Clé API DomainTools.
    USE_MODE HASH Sélectionnez le mode à utiliser : HASH, DOMAINS ou QUERY (un seul mode est actif à la fois).
    SEARCH_HASHES hash1;hash2;hash3 Obligatoire si USE_MODE=HASH. Liste des hachages de recherches enregistrées de l'interface utilisateur Iris, séparés par un point-virgule.
    DOMAINS example.com;domaintools.com Obligatoire si USE_MODE=DOMAINS. Liste de domaines séparés par un point-virgule.
    QUERY_LIST ip=1.1.1.1;ip=8.8.8.8;domain=example.org Obligatoire si USE_MODE=QUERY. Liste de chaînes de requête séparées par un point-virgule (k=v&k2=v2).
    PAGE_SIZE 500 Nombre de lignes par page (500 par défaut).
    MAX_PAGES 20 Nombre maximal de pages par requête.

  10. Dans la section Variables et secrets, faites défiler la page jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 900 secondes (15 minutes).

  11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • CPU : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (1 à 2 minutes).

  15. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

  1. Saisissez main dans Point d'entrée de la fonction.

  2. Dans l'éditeur de code intégré, créez deux fichiers :

    • Premier fichier : 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
    • Deuxième fichier : requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*

  3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

  4. Attendez la fin du déploiement (deux à trois minutes).

Créer une tâche Cloud Scheduler

Cloud Scheduler publie des messages sur le sujet Pub/Sub à intervalles réguliers, ce qui déclenche la fonction Cloud Run.

  1. Dans la console GCP, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom domaintools-iris-1h
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé).
    Type de cible Pub/Sub
    Topic Sélectionnez le sujet Pub/Sub (domaintools-iris-trigger).
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de planification

  • Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :

    Fréquence Expression Cron Cas d'utilisation
    Toutes les 5 minutes */5 * * * * Volume élevé, faible latence
    Toutes les 15 minutes */15 * * * * Volume moyen
    Toutes les heures 0 * * * * Standard (recommandé)
    Toutes les 6 heures 0 */6 * * * Traitement par lot à faible volume
    Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de votre fonction (domaintools-iris-collector).
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Recherchez les éléments suivants :

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

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

  10. Accédez au dossier de préfixe (domaintools/iris/).

  11. Vérifiez que de nouveaux fichiers .json ont été créés avec le code temporel actuel.

Si vous constatez des erreurs dans les journaux :

  • HTTP 401 : vérifiez les identifiants de l'API DomainTools dans les variables d'environnement.
  • HTTP 403 : vérifiez que le compte dispose des autorisations requises pour l'API Iris Investigate
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec un intervalle de temps.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.
  • USE_MODE non valide : vérifiez que USE_MODE est défini sur HASH, DOMAINS ou QUERY, et que les paramètres correspondants sont fournis.

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket GCS. Vous devez accorder à ce compte de service l'accès à votre bucket.

Obtenir l'adresse e-mail du compte de service

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, DomainTools Iris Investigate).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez DomainTools Threat Intelligence comme Type de journal.

  7. Cliquez sur Obtenir un compte de service. Une adresse e-mail unique pour le compte de service s'affiche, par exemple :

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

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin du rôle Lecteur des objets Storage sur votre bucket GCS.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuez des rôles : sélectionnez Lecteur des objets de l'espace de stockage.

  6. Cliquez sur Enregistrer.

Configurer un flux dans Google SecOps pour ingérer les résultats de DomainTools Iris Investigate

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, DomainTools Iris Investigate).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez DomainTools Threat Intelligence comme Type de journal.
  7. Cliquez sur Suivant.

  8. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket Storage : saisissez l'URI du bucket GCS avec le préfixe du chemin d'accès :

      gs://domaintools-iris/domaintools/iris/

      • Remplacez :

        • domaintools-iris : nom de votre bucket GCS.
        • domaintools/iris/ : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laisser vide pour la racine).

      • Exemples :

        • Bucket racine : gs://domaintools-iris/
        • Avec préfixe : gs://domaintools-iris/domaintools/iris/

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.

      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides après un transfert réussi.

    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.

    • Espace de noms de l'élément : domaintools.threat_intel

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

  10. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
actif principal.domain.status Mappé directement à partir du champ actif du journal brut.
additional_whois_email.[].value about.labels.additional_whois_email Extrait du tableau "additional_whois_email" et ajouté en tant que libellé dans l'objet "about".
adsense.value about.labels.adsense Extrait de adsense.value et ajouté en tant que libellé dans l'objet "about".
admin_contact.city.value principal.domain.admin.office_address.city Directement mappé à partir du champ admin_contact.city.value dans le journal brut.
admin_contact.country.value principal.domain.admin.office_address.country_or_region Directement mappé à partir du champ admin_contact.country.value dans le journal brut.
admin_contact.email.[].value principal.domain.admin.email_addresses Extrait du tableau admin_contact.email et ajouté au champ email_addresses.
admin_contact.fax.value principal.domain.admin.attribute.labels.fax Extrait de admin_contact.fax.value et ajouté en tant qu'étiquette avec la clé "fax" dans l'attribut admin.
admin_contact.name.value principal.domain.admin.user_display_name Directement mappé à partir du champ admin_contact.name.value dans le journal brut.
admin_contact.org.value principal.domain.admin.company_name Directement mappé à partir du champ admin_contact.org.value dans le journal brut.
admin_contact.phone.value principal.domain.admin.phone_numbers Directement mappé à partir du champ admin_contact.phone.value dans le journal brut.
admin_contact.postal.value principal.domain.admin.attribute.labels.postal Extrait de admin_contact.postal.value et ajouté en tant qu'étiquette avec la clé "postal" dans l'attribut admin.
admin_contact.state.value principal.domain.admin.office_address.state Directement mappé à partir du champ admin_contact.state.value dans le journal brut.
admin_contact.street.value principal.domain.admin.office_address.name Directement mappé à partir du champ admin_contact.street.value dans le journal brut.
alexa about.labels.alexa Directement mappé à partir du champ "alexa" dans le journal brut et ajouté en tant que libellé dans l'objet "about".
baidu_codes.[].value about.labels.baidu_codes Extrait du tableau baidu_codes et ajouté en tant que libellé dans l'objet "about".
billing_contact.city.value principal.domain.billing.office_address.city Directement mappé à partir du champ billing_contact.city.value dans le journal brut.
billing_contact.country.value principal.domain.billing.office_address.country_or_region Directement mappé à partir du champ billing_contact.country.value dans le journal brut.
billing_contact.email.[].value principal.domain.billing.email_addresses Extrait du tableau billing_contact.email et ajouté au champ email_addresses.
billing_contact.fax.value principal.domain.billing.attribute.labels.fax Extrait de billing_contact.fax.value et ajouté en tant qu'étiquette avec la clé "fax" dans l'attribut de facturation.
billing_contact.name.value principal.domain.billing.user_display_name Directement mappé à partir du champ billing_contact.name.value dans le journal brut.
billing_contact.org.value principal.domain.billing.company_name Mappé directement à partir du champ billing_contact.org.value dans le journal brut.
billing_contact.phone.value principal.domain.billing.phone_numbers Directement mappé à partir du champ billing_contact.phone.value dans le journal brut.
billing_contact.postal.value principal.domain.billing.attribute.labels.postal Extrait de billing_contact.postal.value et ajouté en tant qu'étiquette avec la clé "postal" dans l'attribut de facturation.
billing_contact.state.value principal.domain.billing.office_address.state Directement mappé à partir du champ billing_contact.state.value dans le journal brut.
billing_contact.street.value principal.domain.billing.office_address.name Directement mappé à partir du champ billing_contact.street.value dans le journal brut.
create_date.value principal.domain.creation_time Converti au format d'horodatage à partir du champ "create_date.value" du journal brut.
data_updated_timestamp principal.domain.audit_update_time Converti au format d'horodatage à partir du champ "data_updated_timestamp" du journal brut.
domaine principal.hostname Mappé directement à partir du champ "domaine" dans le journal brut.
domain_risk.components.[].evidence security_result.detection_fields.evidence Extrait du tableau domain_risk.components.[].evidence et ajouté en tant que champ de détection avec la clé "evidence" dans l'objet security_result.
domain_risk.components.[].name security_result.category_details Directement mappé à partir du champ domain_risk.components.[].name dans le journal brut.
domain_risk.components.[].risk_score security_result.risk_score Directement mappé à partir du champ domain_risk.components.[].risk_score dans le journal brut.
domain_risk.components.[].threats security_result.threat_name Le premier élément du tableau domain_risk.components.[].threats est mappé sur security_result.threat_name.
domain_risk.components.[].threats security_result.detection_fields.threats Les éléments restants du tableau domain_risk.components.[].threats sont ajoutés en tant que champs de détection avec la clé "threats" dans l'objet security_result.
domain_risk.risk_score security_result.risk_score Mappé directement à partir du champ "domain_risk.risk_score" dans le journal brut.
email_domain.[].value about.labels.email_domain Extrait du tableau email_domain et ajouté en tant que libellé dans l'objet "about".
expiration_date.value principal.domain.expiration_time Converti au format d'horodatage à partir du champ "expiration_date.value" du journal brut.
fb_codes.[].value about.labels.fb_codes Extrait du tableau fb_codes et ajouté en tant que libellé dans l'objet "about".
first_seen.value principal.domain.first_seen_time Converti au format d'horodatage à partir du champ "first_seen.value" du journal brut.
ga4.[].value about.labels.ga4 Extrait du tableau GA4 et ajouté en tant que libellé dans l'objet "about".
google_analytics.value about.labels.google_analytics Extrait de google_analytics.value et ajouté en tant que libellé dans l'objet "about".
gtm_codes.[].value about.labels.gtm_codes Extrait du tableau gtm_codes et ajouté en tant que libellé dans l'objet "about".
hotjar_codes.[].value about.labels.hotjar_codes Extrait du tableau hotjar_codes et ajouté en tant que libellé dans l'objet "about".
ip.[].address.value principal.ip Le premier élément du tableau "ip" est mappé à "principal.ip".
ip.[].address.value about.labels.ip_address Les éléments restants du tableau "ip" sont ajoutés en tant que libellés avec la clé "ip_address" dans l'objet "about".
ip.[].asn.[].value network.asn Le premier élément du premier tableau ip.asn est mappé à network.asn.
ip.[].asn.[].value about.labels.asn Les éléments restants des tableaux ip.asn sont ajoutés en tant que libellés avec la clé "asn" dans l'objet "about".
ip.[].country_code.value principal.location.country_or_region La valeur country_code du premier élément du tableau ip est mappée sur principal.location.country_or_region.
ip.[].country_code.value about.location.country_or_region La valeur country_code des éléments restants du tableau "ip" est mappée à about.location.country_or_region.
ip.[].isp.value principal.labels.isp La valeur isp.value du premier élément du tableau ip est mappée à principal.labels.isp.
ip.[].isp.value about.labels.isp La valeur isp.value des éléments restants du tableau ip est mappée à about.labels.isp.
matomo_codes.[].value about.labels.matomo_codes Extrait du tableau matomo_codes et ajouté en tant que libellé dans l'objet "about".
monitor_domain about.labels.monitor_domain Directement mappé à partir du champ "monitor_domain" du journal brut et ajouté en tant que libellé dans l'objet "about".
monitoring_domain_list_name about.labels.monitoring_domain_list_name Directement mappé à partir du champ "monitoring_domain_list_name" du journal brut et ajouté en tant qu'étiquette dans l'objet "about".
mx.[].domain.value about.domain.name Directement mappé à partir du champ mx.[].domain.value dans le journal brut.
mx.[].host.value about.hostname Mappé directement à partir du champ mx.[].host.value dans le journal brut.
mx.[].ip.[].value about.ip Extrait du tableau mx.[].ip et ajouté au champ "ip".
mx.[].priority about.security_result.priority_details Mappé directement à partir du champ mx.[].priority dans le journal brut.
name_server.[].domain.value about.labels.name_server_domain Extrait de name_server.[].domain.value et ajouté en tant que libellé avec la clé "name_server_domain" dans l'objet "about".
name_server.[].host.value principal.domain.name_server Extrait de name_server.[].host.value et ajouté au champ name_server.
name_server.[].host.value about.domain.name_server Extrait de name_server.[].host.value et ajouté au champ name_server.
name_server.[].ip.[].value about.labels.ip Extrait du tableau name_server.[].ip et ajouté en tant que libellé avec la clé "ip" dans l'objet "about".
popularity_rank about.labels.popularity_rank Directement mappé à partir du champ "popularity_rank" du journal brut et ajouté en tant que libellé dans l'objet "about".
redirect.value about.labels.redirect Extrait de redirect.value et ajouté en tant que libellé dans l'objet "about".
redirect_domain.value about.labels.redirect_domain Extrait de redirect_domain.value et ajouté en tant que libellé dans l'objet "about".
registrant_contact.city.value principal.domain.registrant.office_address.city Directement mappé à partir du champ registrant_contact.city.value dans le journal brut.
registrant_contact.country.value principal.domain.registrant.office_address.country_or_region Directement mappé à partir du champ registrant_contact.country.value dans le journal brut.
registrant_contact.email.[].value principal.domain.registrant.email_addresses Extrait du tableau registrant_contact.email et ajouté au champ email_addresses.
registrant_contact.fax.value principal.domain.registrant.attribute.labels.fax Extrait de registrant_contact.fax.value et ajouté en tant qu'étiquette avec la clé "fax" dans l'attribut du déposant.
registrant_contact.name.value principal.domain.registrant.user_display_name Directement mappé à partir du champ registrant_contact.name.value dans le journal brut.
registrant_contact.org.value principal.domain.registrant.company_name Directement mappé à partir du champ registrant_contact.org.value dans le journal brut.
registrant_contact.phone.value principal.domain.registrant.phone_numbers Directement mappé à partir du champ registrant_contact.phone.value dans le journal brut.
registrant_contact.postal.value principal.domain.registrant.attribute.labels.postal Extrait de registrant_contact.postal.value et ajouté en tant que libellé avec la clé "postal" dans l'attribut registrant.
registrant_contact.state.value principal.domain.registrant.office_address.state Directement mappé à partir du champ registrant_contact.state.value dans le journal brut.
registrant_contact.street.value principal.domain.registrant.office_address.name Directement mappé à partir du champ registrant_contact.street.value dans le journal brut.
registrant_name.value about.labels.registrant_name Extrait de registrant_name.value et ajouté en tant que libellé dans l'objet "about".
registrant_org.value about.labels.registrant_org Extrait de registrant_org.value et ajouté en tant que libellé dans l'objet "about".
registrar.value principal.domain.registrar Mappé directement à partir du champ "registrar.value" dans le journal brut.
registrar_status about.labels.registrar_status Extrait du tableau registrar_status et ajouté en tant que libellé dans l'objet "about".
server_type network.tls.client.server_name Mappé directement à partir du champ "server_type" dans le journal brut.
soa_email.[].value principal.user.email_addresses Extrait du tableau soa_email et ajouté au champ email_addresses.
spf_info about.labels.spf_info Directement mappé à partir du champ "spf_info" du journal brut et ajouté en tant que libellé dans l'objet "about".
ssl_email.[].value about.labels.ssl_email Extrait du tableau ssl_email et ajouté en tant que libellé dans l'objet "about".
ssl_info.[].alt_names.[].value about.labels.alt_names Extrait du tableau ssl_info.[].alt_names et ajouté en tant que libellé dans l'objet "about".
ssl_info.[].common_name.value about.labels.common_name Extrait de ssl_info.[].common_name.value et ajouté en tant que libellé dans l'objet "about".
ssl_info.[].duration.value about.labels.duration Extrait de ssl_info.[].duration.value et ajouté en tant que libellé dans l'objet "about".
ssl_info.[].email.[].value about.labels.ssl_info_email Extrait du tableau ssl_info.[].email et ajouté en tant que libellé avec la clé "ssl_info_email" dans l'objet "about".
ssl_info.[].hash.value network.tls.server.certificate.sha1 La valeur hash.value du premier élément du tableau ssl_info est mappée sur network.tls.server.certificate.sha1.
ssl_info.[].hash.value about.labels.hash La valeur hash des éléments restants du tableau ssl_info est mappée sur about.labels.hash.
ssl_info.[].issuer_common_name.value network.tls.server.certificate.issuer La valeur issuer_common_name.value du premier élément du tableau ssl_info est mappée sur network.tls.server.certificate.issuer.
ssl_info.[].issuer_common_name.value about.labels.issuer_common_name La valeur issuer_common_name des éléments restants du tableau ssl_info est mappée sur about.labels.issuer_common_name.
ssl_info.[].not_after.value network.tls.server.certificate.not_after La valeur not_after du premier élément du tableau ssl_info est convertie au format d'horodatage et mappée à network.tls.server.certificate.not_after.
ssl_info.[].not_after.value about.labels.not_after La valeur not_after des éléments restants du tableau ssl_info est mappée sur about.labels.not_after.
ssl_info.[].not_before.value network.tls.server.certificate.not_before La valeur not_before du premier élément du tableau ssl_info est convertie au format de code temporel et mappée sur network.tls.server.certificate.not_before.
ssl_info.[].not_before.value about.labels.not_before La valeur not_before des éléments restants du tableau ssl_info est mappée sur about.labels.not_before.
ssl_info.[].organization.value network.organization_name La valeur organization.value du premier élément du tableau ssl_info est mappée à network.organization_name.
ssl_info.[].organization.value about.labels.organization La valeur organization des éléments restants du tableau ssl_info est mappée à about.labels.organization.
ssl_info.[].subject.value about.labels.subject Extrait de ssl_info.[].subject.value et ajouté en tant que libellé dans l'objet "about".
statcounter_project_codes.[].value about.labels.statcounter_project_codes Extrait du tableau statcounter_project_codes et ajouté en tant que libellé dans l'objet "about".
statcounter_security_codes.[].value about.labels.statcounter_security_codes Extrait du tableau statcounter_security_codes et ajouté en tant que libellé dans l'objet "about".
tags.[].label about.file.tags Extrait de tags.[].label et ajouté au champ "tags".
tags.[].scope security_result.detection_fields.scope Extrait de tags.[].scope et ajouté en tant que champ de détection avec la clé "scope" dans l'objet security_result.
tags.[].tagged_at security_result.detection_fields.tagged_at Extrait de tags.[].tagged_at et ajouté en tant que champ de détection avec la clé "tagged_at" dans l'objet security_result.
technical_contact.city.value principal.domain.tech.office_address.city Directement mappé à partir du champ technical_contact.city.value dans le journal brut.
technical_contact.country.value principal.domain.tech.office_address.country_or_region Directement mappé à partir du champ technical_contact.country.value dans le journal brut.
technical_contact.email.[].value principal.domain.tech.email_addresses Extrait du tableau technical_contact.email et ajouté au champ email_addresses.
technical_contact.fax.value principal.domain.tech.attribute.labels.fax Extrait de technical_contact.fax.value et ajouté en tant que libellé avec la clé "fax" dans l'attribut tech.
technical_contact.name.value principal.domain.tech.user_display_name Mappé directement à partir du champ technical_contact.name.value dans le journal brut.
technical_contact.org.value principal.domain.tech.company_name Directement mappé à partir du champ technical_contact.org.value dans le journal brut.
technical_contact.phone.value principal.domain.tech.phone_numbers Directement mappé à partir du champ technical_contact.phone.value dans le journal brut.
technical_contact.postal.value principal.domain.tech.attribute.labels.postal Extrait de technical_contact.postal.value et ajouté en tant que libellé avec la clé "postal" dans l'attribut tech.
technical_contact.state.value principal.domain.tech.office_address.state Directement mappé à partir du champ technical_contact.state.value dans le journal brut.
technical_contact.street.value principal.domain.tech.office_address.name Mappé directement à partir du champ technical_contact.street.value dans le journal brut.
tld about.labels.tld Directement mappé à partir du champ "tld" du journal brut et ajouté en tant que libellé dans l'objet "about".
timestamp about.labels.timestamp Directement mappé à partir du champ d'horodatage du journal brut et ajouté en tant que libellé dans l'objet "about".
website_response principal.network.http.response_code Mappé directement à partir du champ "website_response" dans le journal brut.
website_title about.labels.website_title Directement mappé à partir du champ "website_title" du journal brut et ajouté en tant que libellé dans l'objet "about".
whois_url principal.domain.whois_server Mappé directement à partir du champ "whois_url" dans le journal brut.
yandex_codes.[].value about.labels.yandex_codes Extrait du tableau yandex_codes et ajouté en tant que libellé dans l'objet "about".
edr.client.hostname Définissez la valeur du champ "Domaine".
edr.client.ip_addresses Définissez la valeur du premier élément du tableau "ip", plus précisément ip.[0].address.value.
edr.raw_event_name Définissez la valeur sur "STATUS_UPDATE" si principal.hostname est présent, sinon définissez-la sur "GENERIC_EVENT".
metadata.event_timestamp Copié à partir du champ "create_time" de premier niveau dans le journal brut.
metadata.event_type Définissez la valeur sur "STATUS_UPDATE" si principal.hostname est présent, sinon définissez-la sur "GENERIC_EVENT".
metadata.log_type Défini sur "DOMAINTOOLS_THREATINTEL".
metadata.product_name Définissez-le sur "DOMAINTOOLS".
metadata.vendor_name Définissez-le sur "DOMAINTOOLS".

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.