Renseignement sur les menaces passif : collecter sans toucher la cible

Avant qu’une équipe de threat intelligence ne scanne quoi que ce soit, elle peut apprendre énormément sur un domaine grâce aux registres que d’autres parties tiennent déjà. Les journaux de certificats listent ses noms d’hôtes, les données d’enregistrement donnent ses dates et ses serveurs de noms, et les archives web montrent ce qu’il publiait autrefois. Pour les équipes de sécurité, cette phase passive est la partie la moins coûteuse et la plus discrète du travail, et elle montre ce que n’importe quel attaquant peut voir aussi.

Ce guide couvre les principales sources passives, un petit collecteur testé, et l’endroit où le terme « passif » cesse d’être vrai. Utilisez-le sur votre propre organisation ou dans un périmètre autorisé.

Ce que signifie « passif »

La collecte passive signifie que vos requêtes vont vers un tiers qui détient déjà les données, et jamais vers les serveurs de la cible. MITRE ATT&CK décrit la version côté attaquant sous Reconnaissance, y compris la recherche dans des « bases de données techniques librement accessibles » (T1596), avec des entrées pour le DNS et le DNS passif, le WHOIS, les certificats numériques, les CDN et les bases de données de scan.

MITRE explique aussi pourquoi les défenseurs devraient s’en préoccuper. Il indique que cette activité peut se dérouler en dehors du champ de visibilité de l’organisation ciblée, ce qui la rend difficile à détecter, et qu’elle ne peut pas être facilement atténuée par des contrôles préventifs. On ne peut pas empêcher quelqu’un de lire un journal public. Ce que l’on peut faire, c’est regarder en premier et réduire ce que ces journaux révèlent.

Les sources qui valent la peine d’être consultées

Source	Ce qu’elle apporte	Ses limites
Journaux Certificate Transparency	Noms d’hôtes sur les certificats TLS émis	Montre des noms, pas s’ils sont actifs ; les wildcards masquent les sous-domaines
RDAP	Registrar, dates, serveurs de noms	Les données personnelles sont généralement masquées
Archives web	Anciennes pages, URL et hôtes	Seulement ce qui a été capturé, souvent vieux de plusieurs années
DNS passif	Vers quelles IP un nom a résolu, et quand	Surtout commercial, et la couverture varie
Bases de données de scan Internet	Ports ouverts et bannières vus par quelqu’un d’autre	Instantanés, pouvant être obsolètes

Certificate Transparency est la source gratuite la plus riche. La RFC 9162 décrit un protocole pour « enregistrer publiquement l’existence » des certificats TLS afin que quiconque puisse auditer les autorités de certification, et les journaux sont en ajout seul (append-only). Cela signifie aussi qu’un certificat pour staging.internal-tool.example.com reste visible, même si l’hôte n’a duré qu’une semaine.

RDAP est le remplaçant structuré du WHOIS. L’ICANN indique que depuis le 28 janvier 2025, les registres et bureaux d’enregistrement de domaines génériques de premier niveau doivent fournir RDAP et ne sont plus tenus de fournir WHOIS, donc les nouveaux outils devraient commencer par là.

Notre guide sur ce qu’est l’OSINT et où se situent ses limites légales couvre la discipline au sens large, y compris les sources concernant les personnes, que ce guide laisse de côté.

Un petit collecteur passif

Le script ci-dessous interroge trois services tiers au sujet d’un domaine et ne se connecte jamais au domaine lui-même. Il fonctionne sous Python 3.9 et versions ultérieures et ne nécessite que requests. Il continue de fonctionner quand une source est indisponible, car les services publics gratuits le sont souvent : lors des tests de ce code, crt.sh et la Wayback Machine ont chacun renvoyé des erreurs et des timeouts pendant plusieurs minutes d’affilée.

from __future__ import annotations

import sys
import time

import requests

TIMEOUT = (10, 60)
HEADERS = {"User-Agent": "passive-recon-demo/1.0"}


def get_json(url, params=None):
    """Every request goes to a third-party source, never to the target itself."""
    for attempt in range(3):
        try:
            r = requests.get(url, params=params, headers=HEADERS, timeout=TIMEOUT)
            r.raise_for_status()
            return r.json()
        except requests.RequestException:
            if attempt == 2:
                raise
            time.sleep(10 * (attempt + 1))  # free public services go down often


def in_scope(host, domain):
    """The domain or a real subdomain of it; CT names also hold labels and lookalikes."""
    return " " not in host and (host == domain or host.endswith("." + domain))


def certificate_names(domain):
    """Hostnames from Certificate Transparency logs, through crt.sh."""
    rows = get_json("https://crt.sh/", {"q": f"%.{domain}", "output": "json"})
    names = {n.strip().lower() for row in rows for n in row["name_value"].splitlines()}
    return sorted(n for n in names if "*" not in n and in_scope(n, domain))


def archived_hosts(domain, limit=500):
    """Hostnames the Wayback Machine has captured, without loading any live page."""
    rows = get_json("https://web.archive.org/cdx/search/cdx", {
        "url": domain, "matchType": "domain", "output": "json",
        "fl": "original", "limit": limit,
    })
    urls = [row[0] for row in rows[1:]]  # the first row is the header
    hosts = {u.split("//")[-1].split("/")[0].split(":")[0].lower() for u in urls}
    return sorted(h for h in hosts if in_scope(h, domain))


def registration(domain):
    """Registrar and key dates from RDAP, the structured successor to WHOIS."""
    data = get_json(f"https://rdap.org/domain/{domain}")
    dates = {e["eventAction"]: e["eventDate"][:10] for e in data.get("events", [])}
    return {"registered": dates.get("registration"), "expires": dates.get("expiration"),
            "nameservers": sorted(n["ldhName"].lower() for n in data.get("nameservers", []))}


def collect(domain):
    sources = {"certificates": certificate_names, "archive": archived_hosts,
               "rdap": registration}
    found, failed = {}, {}
    for name, fetch in sources.items():
        try:
            found[name] = fetch(domain)
        except (requests.RequestException, ValueError, KeyError) as exc:
            failed[name] = type(exc).__name__  # a source being down is a result too
    return found, failed


if __name__ == "__main__":
    domain = sys.argv[1] if len(sys.argv) > 1 else "example.com"
    found, failed = collect(domain)
    hosts = set(found.get("certificates", [])) | set(found.get("archive", []))
    only_ct = set(found.get("certificates", [])) - set(found.get("archive", []))
    only_archive = set(found.get("archive", [])) - set(found.get("certificates", []))
    print(f"{domain}: {len(hosts)} hostnames seen by third parties")
    print(f"  in certificates only: {sorted(only_ct)[:6]}")
    print(f"  in the archive only:  {sorted(only_archive)[:6]}")
    print(f"  registration: {found.get('rdap')}")
    print(f"  sources unavailable: {failed or 'none'}")

Sortie pour example.com :

example.com: 7 hostnames seen by third parties
  in certificates only: ['dev.example.com', 'emudhra-lab.example.com', 'm.example.com', 'products.example.com', 'support.example.com']
  in the archive only:  []
  registration: {'registered': '1995-08-14', 'expires': '2027-08-13', 'nameservers': ['elliott.ns.cloudflare.com', 'hera.ns.cloudflare.com']}
  sources unavailable: none

Deux détails de ce code viennent directement des tests. Les journaux de certificats contiennent plus que de simples noms d’hôtes : une première version utilisait une simple vérification de suffixe et laissait passer un libellé de certificat contenant des espaces ainsi qu’un nom proche mais différent, m.testexample.com. C’est pourquoi in_scope vérifie qu’il s’agit bien d’un sous-domaine entier. L’autre détail est que chaque source voit des choses différentes, il vaut donc mieux les comparer plutôt que de faire confiance à une seule. Un nom d’hôte présent seulement dans d’anciennes archives a peut-être disparu, et un nom présent seulement dans des certificats récents est peut-être nouveau.

Où le passif cesse d’être passif

La limite est plus facile à franchir qu’il n’y paraît.

• Ouvrir une URL trouvée. Visiter un nom d’hôte actif issu de vos résultats envoie à la cible une requête provenant de votre IP.
• Pages archivées avec des ressources actives. Une page sauvegardée peut quand même tenter de charger des images ou des scripts depuis le site d’origine. Désactivez le chargement externe, ou lisez la réponse brute.
• Résolutions DNS. Une requête passant par un résolveur peut atteindre les serveurs de noms faisant autorité de la cible. Les données de DNS passif historiques ne le font pas.
• Vos requêtes sont visibles par la source. Le service que vous interrogez sait ce que vous regardez. Pour les investigations sensibles, réfléchissez à ce que cela révèle, et lisez ses conditions d’utilisation et ses limites de débit.

Traitez les résultats comme des pistes. Les registres deviennent obsolètes, les certificats survivent aux hôtes, et l’hébergement partagé rend l’historique des IP trompeur.

Que faire des résultats

Pour les défenseurs, le résultat est une liste de ce que le monde extérieur peut déjà voir. Une routine raisonnable :

1. Comparer avec votre inventaire d’actifs. Un nom d’hôte que vous ne pouvez rattacher à aucun propriétaire est la véritable trouvaille.
2. Vérifier ce que vos noms révèlent. Des noms comme vpn-old ou jenkins-test dans des journaux publics aident les attaquants. Envisagez des certificats wildcard pour le nommage interne lorsque c’est pertinent, tout en pesant leurs propres risques.
3. Répéter l’opération, et alerter sur ce qui est nouveau. Notre guide sur la surveillance continue de la surface d’attaque externe montre comment transformer cela en un diff avec des responsables désignés.
4. Passer aux vérifications actives de manière délibérée. Vérifiez directement vos propres actifs. Pour tout ce qui sort de votre organisation, obtenez d’abord une autorisation. Lorsque la recherche sur les menaces doit observer ce qu’un site suspect montre à de vrais visiteurs dans un pays donné, il s’agit d’un travail actif avec ses propres règles, abordé dans notre article sur les proxies résidentiels pour la threat intelligence.

En résumé

La collecte passive donne une image utile d’un domaine pour un coût quasi nul et sans l’alerter. Commencez par les journaux de certificats, le RDAP et les archives, comparez-les, traitez ce que vous trouvez comme des pistes, et soyez honnête sur le moment où votre travail cesse d’être passif. Faites d’abord le test sur vous-même, car n’importe qui d’autre le peut aussi.

Sources et références

• MITRE ATT&CK, Reconnaissance (TA0043) : attack.mitre.org
• MITRE ATT&CK, Search Open Technical Databases (T1596) : attack.mitre.org
• RFC 9162, Certificate Transparency Version 2.0 : rfc-editor.org
• Certificate Transparency, How CT works : certificate.transparency.dev
• RFC 9083, JSON Responses for RDAP : rfc-editor.org
• ICANN, Registration Data Access Protocol : icann.org
• Internet Archive, Wayback CDX Server API : github.com/internetarchive/wayback