Collecter les résultats de DomainTools Iris Investigate

Version de l'analyseur : 1.0

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 les informations liées aux détails du domaine, aux coordonnées, aux risques de sécurité, aux certificats SSL et à d'autres attributs pertinents, puis les mappe aux champs UDM correspondants pour une analyse et un renseignement sur les menaces cohérents.

Avant de commencer

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

  • Une instance Google SecOps
  • Accès privilégié au compte d'entreprise DomainTools (accès API à Iris Investigate)
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations de créer et de 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 jobs 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 propriétaire de l'API peut réinitialiser la clé API).
  2. Dans la section My Account (Mon compte), sélectionnez le lien View API Dashboard (Afficher le tableau de bord de l'API) situé dans l'onglet Account Summary (Récapitulatif du compte).
  3. Accédez à la section API Username (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
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, domaintools-iris).
    Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux fréquemment consultés)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions d'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 autorisé à é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 Storage.
    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 de l'espace de stockage : écrire des journaux dans un 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 le 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 dans lequel 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 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 des messages Pub/Sub provenant de Cloud Scheduler pour récupérer 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 de modification directe 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).
    Durée d'exécution Sélectionnez Python 3.12 ou une 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. Vérifiez 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, séparés par un point-virgule, provenant de l'UI Iris.
    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.
      • Processeur : 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éé (une à deux 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 publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera 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, à l'heure pile)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé)
    Type de cible Pub/Sub
    Sujet 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 programmation

  • 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 de faible volume
    Tous les jours 0 0 * * * Collecte des données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Forcer l'exécution 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 a bien été exécutée. 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 du préfixe (domaintools/iris/).

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

Si des erreurs s'affichent 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 effectue automatiquement une nouvelle tentative avec intervalle exponentiel entre les tentatives.
  • 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 > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  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 Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique 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 doit disposer 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.
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  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 > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  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 de stockage : saisissez l'URI du bucket GCS avec le chemin d'accès du préfixe :

      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 (laissez ce champ vide pour la racine).

      • Exemples :

        • Bucket racine : gs://domaintools-iris/
        • Avec le 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 les fichiers 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 une fois le transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours. La valeur par défaut est de 180 jours.

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

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  9. Cliquez sur Suivant.

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

Exemples de journaux DomainTools Iris Investigate compatibles

  • Enrichissement de domaine standard (de base)

    {
  "domain": "example-sanitized-01.com",
  "whois_url": "https://whois.domaintools.com/example-sanitized-01.com",
  "active": false,
  "admin_contact": {
    "name": {
      "value": "REDACTED_NAME"
    },
    "org": {
      "value": "Sanitized Corp"
    },
    "email": [
      {
        "value": "admin@example-sanitized.com"
      }
    ]
  },
  "ip": [
    {
      "address": {
        "value": "192.168.1.100"
      },
      "asn": [
        {
          "value": 12345
        }
      ],
      "isp": {
        "value": "Generic ISP"
      }
    }
  ],
  "domain_risk": {
    "risk_score": 46,
    "components": [
      {
        "name": "proximity",
        "risk_score": 5
      },
      {
        "name": "threat_profile_phishing",
        "risk_score": 46
      }
    ]
  },
  "timestamp": "2023-11-21T12:15:50.130728Z"
}

  • Schéma de marketing/suivi avancé

    {
  "domain": "analytics-tracker-sample.com",
  "google_analytics": {
    "value": "UA-000000-0"
  },
  "ga4": [
    {
      "value": "G-YYYYYYYYYX"
    }
  ],
  "gtm_codes": [
    {
      "value": "GTM-YYYX"
    }
  ],
  "fb_codes": [
    {
      "value": "1234567890"
    }
  ],
  "baidu_codes": [
    {
      "value": "hash_masked_value"
    }
  ],
  "yandex_codes": [
    {
      "value": "98765432"
    }
  ],
  "matomo_codes": [
    {
      "value": "https://analytics.internal-sanitized.net/"
    }
  ]
}

  • Schéma tagué et surveillé

    {
  "domain": "monitored-threat.net",
  "monitor_domain": true,
  "monitoring_domain_list_name": "Watchlist_Alpha",
  "tags": [
    {
      "label": "Sanitized_Tag",
      "scope": "group",
      "tagged_at": "2020-12-02T13:33:40Z"
    }
  ],
  "registrar": {
    "value": "Safe-Registrar LLC"
  }
}

  • Schéma de réponse SSL et Web à haut risque

    {
  "domain": "high-risk-malware.org",
  "domain_risk": {
    "risk_score": 100,
    "components": [
      {
        "name": "threat_profile_malware",
        "risk_score": 95
      }
    ]
  },
  "ssl_info": [
    {
      "hash": {
        "value": "sha1_masked_hash_sequence"
      },
      "common_name": {
        "value": "www.sanitized-cert.com"
      },
      "issuer_common_name": {
        "value": "Sanitized CA"
      },
      "not_after": {
        "value": 20251231
      }
    }
  ],
  "website_response": 200,
  "server_type": "Sanitized-Server-v1.0",
  "website_title": "Sanitized Landing Page"
}

Table de mappage UDM

Champ du journal mappage UDM Logique
actif principal.domain.status Mappé directement à partir du champ actif dans le 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 Mappé directement à partir du champ admin_contact.city.value du journal brut.
admin_contact.country.value principal.domain.admin.office_address.country_or_region Mappé directement à 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 Mappé directement à partir du champ admin_contact.name.value dans le journal brut.
admin_contact.org.value principal.domain.admin.company_name Mappé directement à partir du champ admin_contact.org.value dans le journal brut.
admin_contact.phone.value principal.domain.admin.phone_numbers Mappé directement à 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 Mappé directement à partir du champ admin_contact.state.value dans le journal brut.
admin_contact.street.value principal.domain.admin.office_address.name Mappé directement à partir du champ admin_contact.street.value dans le journal brut.
alexa about.labels.alexa Mappé directement à partir du champ alexa dans le journal brut et ajouté en tant qu'étiquette 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 Mappé directement à partir du champ billing_contact.city.value dans le journal brut.
billing_contact.country.value principal.domain.billing.office_address.country_or_region Mappé directement à 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 Mappé directement à 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 Mappé directement à 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 Mappé directement à partir du champ billing_contact.state.value dans le journal brut.
billing_contact.street.value principal.domain.billing.office_address.name Mappé directement à partir du champ billing_contact.street.value dans le journal brut.
create_date.value principal.domain.creation_time Converti au format de code temporel à partir du champ create_date.value du journal brut.
data_updated_timestamp principal.domain.audit_update_time Converti au format de code temporel à partir du champ data_updated_timestamp du journal brut.
domaine principal.hostname Mappé directement à partir du champ de 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 Mappé directement à partir du champ domain_risk.components.[].name du journal brut.
domain_risk.components.[].risk_score security_result.risk_score Mappé directement à 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é à 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 de code temporel à 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 qu'étiquette 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 d'adresses IP est mappé à principal.ip.
ip.[].address.value about.labels.ip_address Les éléments restants du tableau d'adresses IP sont ajoutés en tant qu'étiquettes 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é sur network.asn.
ip.[].asn.[].value about.labels.asn Les éléments restants des tableaux ip.asn sont ajoutés en tant qu'étiquettes avec la clé "asn" dans l'objet "about".
ip.[].country_code.value principal.location.country_or_region La valeur country_code.value du premier élément du tableau ip est mappée à principal.location.country_or_region.
ip.[].country_code.value about.location.country_or_region La valeur country_code.value 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 Mappé directement à partir du champ monitor_domain du journal brut et ajouté en tant qu'étiquette dans l'objet "about".
monitoring_domain_list_name about.labels.monitoring_domain_list_name Mappé directement à 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 Mappé directement à 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 qu'étiquette 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 qu'étiquette avec la clé "ip" dans l'objet "about".
popularity_rank about.labels.popularity_rank Mappé directement à partir du champ "popularity_rank" dans le journal brut et ajouté en tant qu'étiquette 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 Mappé directement à partir du champ registrant_contact.city.value dans le journal brut.
registrant_contact.country.value principal.domain.registrant.office_address.country_or_region Mappé directement à 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 registrant.
registrant_contact.name.value principal.domain.registrant.user_display_name Mappé directement à partir du champ registrant_contact.name.value dans le journal brut.
registrant_contact.org.value principal.domain.registrant.company_name Mappé directement à partir du champ registrant_contact.org.value dans le journal brut.
registrant_contact.phone.value principal.domain.registrant.phone_numbers Mappé directement à 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 qu'étiquette avec la clé "postal" dans l'attribut registrant.
registrant_contact.state.value principal.domain.registrant.office_address.state Mappé directement à partir du champ registrant_contact.state.value dans le journal brut.
registrant_contact.street.value principal.domain.registrant.office_address.name Mappé directement à 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 Mappé directement à partir du champ spf_info du journal brut et ajouté en tant qu'étiquette 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 qu'étiquette 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 qu'étiquette 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 à network.tls.server.certificate.sha1.
ssl_info.[].hash.value about.labels.hash La valeur hash.value des éléments restants du tableau ssl_info est mappée à 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 à network.tls.server.certificate.issuer.
ssl_info.[].issuer_common_name.value about.labels.issuer_common_name La valeur issuer_common_name.value des éléments restants du tableau ssl_info est mappée à about.labels.issuer_common_name.
ssl_info.[].not_after.value network.tls.server.certificate.not_after La valeur not_after.value du premier élément du tableau ssl_info est convertie au format de code temporel et mappée à network.tls.server.certificate.not_after.
ssl_info.[].not_after.value about.labels.not_after La valeur not_after.value des éléments restants du tableau ssl_info est mappée à about.labels.not_after.
ssl_info.[].not_before.value network.tls.server.certificate.not_before La valeur not_before.value 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.value des éléments restants du tableau ssl_info est mappée à 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.value 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 Mappé directement à partir du champ technical_contact.city.value dans le journal brut.
technical_contact.country.value principal.domain.tech.office_address.country_or_region Mappé directement à 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 qu'étiquette avec la clé "fax" dans l'attribut technique.
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 Mappé directement à partir du champ technical_contact.org.value dans le journal brut.
technical_contact.phone.value principal.domain.tech.phone_numbers Mappé directement à 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 qu'étiquette avec la clé "postal" dans l'attribut tech.
technical_contact.state.value principal.domain.tech.office_address.state Mappé directement à 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 Mappé directement à partir du champ "tld" dans le journal brut et ajouté en tant qu'étiquette dans l'objet "about".
code temporel about.labels.timestamp Mappé directement à partir du champ de code temporel dans le journal brut et ajouté en tant qu'étiquette 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 Mappé directement à partir du champ website_title dans le journal brut et ajouté en tant qu'étiquette dans l'objet about.
whois_url principal.domain.whois_server Mappé directement à partir du champ whois_url du 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 "domain".
edr.client.ip_addresses Définissez cette valeur sur celle du premier élément du tableau "ip", à savoir "ip.[0].address.value".
edr.raw_event_name Défini sur "STATUS_UPDATE" si principal.hostname est présent, sinon défini sur "GENERIC_EVENT".
metadata.event_timestamp Copié à partir du champ create_time de premier niveau dans le journal brut.
metadata.event_type Défini sur "STATUS_UPDATE" si principal.hostname est présent, sinon défini sur "GENERIC_EVENT".
metadata.log_type Définissez cette option sur "DOMAINTOOLS_THREATINTEL".
metadata.product_name Définissez cette option sur "DOMAINTOOLS".
metadata.vendor_name Définissez cette option sur "DOMAINTOOLS".

Journal des modifications

Afficher le journal des modifications de cet analyseur

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