OSINT et Reconnaissance Offensive : Du Renseignement Open Source au Pentest

1. Introduction : L'OSINT, fondation de toute opération offensive

Dans le domaine de la cybersécurité offensive, la phase de reconnaissance constitue le socle sur lequel repose l'ensemble d'un test d'intrusion. Avant de lancer le moindre exploit, avant même de scanner un port, le pentester professionnel consacre un temps considérable à collecter, analyser et structurer des informations provenant de sources ouvertes. Cette discipline, connue sous le nom d'OSINT (Open Source Intelligence), est héritée du renseignement militaire et a été adaptée aux besoins spécifiques de la sécurité informatique.

L'OSINT ne se résume pas à une simple recherche Google. Il s'agit d'un processus méthodique et structuré qui exploite l'ensemble des informations accessibles publiquement : registres DNS, certificats SSL, dépôts de code source, réseaux sociaux professionnels, bases de données de fuites, moteurs de recherche spécialisés comme Shodan ou Censys, et bien d'autres sources. La puissance de l'OSINT réside dans la corrélation de ces données fragmentaires pour construire une cartographie précise de la surface d'attaque d'une organisation.

Il est essentiel de distinguer le renseignement de la reconnaissance. Le renseignement (intelligence) désigne le processus complet de collecte, de traitement et d'analyse de l'information pour produire des connaissances exploitables. La reconnaissance, quant à elle, est la phase opérationnelle au cours de laquelle un pentester ou un attaquant explore activement la cible pour identifier des points d'entrée. L'OSINT alimente la reconnaissance, mais va au-delà en produisant une compréhension contextuelle de l'organisation cible : sa structure, ses technologies, ses processus métier et ses vulnérabilités potentielles.

Selon le rapport SANS 2025 sur le pentest, les équipes qui investissent plus de 30% de leur temps dans la phase de reconnaissance obtiennent un taux de compromission 2,7 fois supérieur à celles qui négligent cette étape. L'OSINT n'est pas un luxe ; c'est la différence entre un pentest superficiel et une opération qui reflète les méthodes réelles des attaquants sophistiqués.

Cet article propose un guide exhaustif de l'OSINT appliqué au pentest : du cycle théorique du renseignement aux outils pratiques, en passant par les techniques de reconnaissance passive et active, les workflows automatisés et les contre-mesures défensives. Les concepts présentés s'articulent avec d'autres techniques offensives abordées dans nos articles sur les attaques d'API, les attaques DNS ou le phishing avancé.

2. Le Cycle du Renseignement OSINT

L'OSINT professionnel ne se pratique pas de manière anarchique. Il s'appuie sur le cycle du renseignement, un processus itératif en cinq phases issu de la doctrine militaire et adapté au contexte de la cybersécurité. Chaque phase alimente la suivante et permet d'affiner progressivement la compréhension de la cible.

Phase 1 : Planification et Orientation

La planification est la phase la plus critique et souvent la plus négligée. Elle consiste à définir les Priority Intelligence Requirements (PIR) : quelles questions le renseignement doit-il permettre de répondre ? Dans le contexte d'un pentest, ces questions peuvent inclure :

• Quels sont les domaines, sous-domaines et plages IP associés à l'organisation ?
• Quelles technologies (CMS, frameworks, serveurs) sont utilisées en production ?
• Quels employés ont accès aux systèmes critiques et quelles sont leurs habitudes numériques ?
• Existe-t-il des fuites de données (credentials, documents internes) accessibles publiquement ?
• Quelle est la maturité sécurité de l'organisation (présence d'un SOC, WAF, EDR) ?

La définition du scope est déterminante. Un scope trop large dispersera les efforts ; un scope trop étroit risque de manquer des vecteurs d'attaque critiques. Le document de cadrage doit préciser les domaines autorisés, les adresses IP incluses et exclues, les filiales concernées et les limites légales de la mission. Cette phase produit un plan de collecte qui guidera les phases suivantes.

Phase 2 : Collecte

La collecte est la phase opérationnelle où les données brutes sont rassemblées à partir de multiples sources. En OSINT, les sources se catégorisent en plusieurs familles :

• Sources techniques : DNS, WHOIS, certificats SSL/TLS (Certificate Transparency), Shodan, Censys, ZoomEye.
• Sources web : moteurs de recherche (Google Dorks), archives web (Wayback Machine), cache.
• Sources humaines : réseaux sociaux (LinkedIn, Twitter/X, GitHub), forums spécialisés.
• Sources de fuites : bases de données compromises, paste sites, dark web marketplaces.
• Sources passives : metadata de documents, enregistrements historiques, OSINT gouvernemental.

L'efficacité de la collecte repose sur la diversification des sources et la systématisation du processus. Un pentester expérimenté ne se contente pas d'un seul outil : il croise les résultats de multiples sources pour construire une image complète et fiable.

Phase 3 : Traitement

Les données brutes collectées doivent être nettoyées, dédupliquées, normalisées et structurées avant de pouvoir être analysées. Cette phase implique la conversion des formats, l'élimination des faux positifs, la normalisation des noms de domaine et des adresses IP, et le stockage dans un format exploitable. Les outils comme Maltego ou SpiderFoot automatisent en partie ce processus en structurant les données sous forme de graphes de relations.

Phase 4 : Analyse

L'analyse transforme les données traitées en intelligence actionnable. C'est la phase où le pentester identifie des patterns, des corrélations et des opportunités. Par exemple :

• Un sous-domaine dev.entreprise.com utilise une version obsolète d'Apache, suggérant un environnement de développement exposé.
• Un employé du département IT a publié un fichier de configuration sur GitHub contenant des credentials, ce qui renvoie aux problématiques de secrets sprawl que nous avons détaillées.
• Les certificats SSL révèlent l'existence de sous-domaines internes (vpn.entreprise.com, admin.entreprise.com) non référencés publiquement.
• L'analyse des headers HTTP montre l'absence de WAF sur certains sous-domaines, ouvrant la voie à des attaques d'API directes.

Phase 5 : Diffusion

La dernière phase consiste à produire et diffuser les résultats sous une forme exploitable par les décideurs ou par les phases suivantes de l'opération. Dans le contexte d'un pentest, cela se traduit par un rapport de reconnaissance qui inclut la cartographie de la surface d'attaque, les vecteurs d'attaque identifiés, les priorités et les recommandations pour la suite de la mission.

Le modèle F3EAD appliqué au pentest

Le modèle F3EAD (Find, Fix, Finish, Exploit, Analyze, Disseminate), issu des opérations militaires de ciblage, est particulièrement adapté au pentest. Find correspond à l'identification des cibles potentielles (sous-domaines, services exposés). Fix consiste à confirmer et localiser précisément la cible (vérifier qu'un service est bien vulnérable). Finish est l'exécution de l'attaque. Exploit est l'exploitation post-compromission. Analyze est l'évaluation des résultats. Disseminate est le partage des conclusions. Ce modèle itératif permet d'ajuster continuellement la stratégie en fonction des découvertes.

3. Reconnaissance Passive

La reconnaissance passive consiste à collecter des informations sur une cible sans interagir directement avec ses systèmes. Aucun paquet n'est envoyé vers l'infrastructure de la cible, ce qui rend cette phase indétectable par les systèmes de défense. C'est l'essence même de l'OSINT appliqué au pentest.

3.1. Reconnaissance DNS

Le DNS (Domain Name System) est la première mine d'informations pour un pentester. L'analyse DNS passive permet de cartographier l'infrastructure d'une organisation sans déclencher la moindre alerte, et constitue un prérequis pour des attaques plus poussées comme celles détaillées dans notre article sur les attaques DNS.

WHOIS et informations d'enregistrement

Les requêtes WHOIS révèlent le propriétaire du domaine, les serveurs DNS autoritaires, les dates de création et d'expiration, et parfois les coordonnées du responsable technique. Bien que le RGPD ait réduit la quantité d'informations personnelles accessibles, les enregistrements restent riches en données techniques.

# Requête WHOIS classique
whois example.com

# Requête RDAP (successeur de WHOIS, format JSON)
curl -s "https://rdap.org/domain/example.com" | jq .

# Historique WHOIS via SecurityTrails
curl -s "https://api.securitytrails.com/v1/history/example.com/dns/a" \
  -H "APIKEY: votre_cle_api"

Enumération DNS et records

L'analyse des enregistrements DNS (A, AAAA, MX, NS, TXT, CNAME, SRV, SOA) fournit une cartographie de l'infrastructure. Les enregistrements TXT sont particulièrement intéressants car ils contiennent souvent des informations de validation (SPF, DKIM, DMARC, vérifications de services tiers).

# Enumération complète des records DNS
dig example.com ANY +noall +answer
dig example.com MX +short
dig example.com TXT +short
dig example.com NS +short

# Enregistrements SPF (révèlent les services de messagerie)
dig example.com TXT | grep "v=spf1"
# Résultat typique: "v=spf1 include:_spf.google.com include:sendgrid.net ~all"
# → L'organisation utilise Google Workspace et SendGrid

# Enumération SRV (révèlent les services internes)
dig _sip._tcp.example.com SRV
dig _ldap._tcp.example.com SRV

Enumération de sous-domaines

L'énumération de sous-domaines est l'une des techniques OSINT les plus puissantes. Elle révèle des services cachés, des environnements de développement exposés et des points d'entrée souvent moins sécurisés que le domaine principal.

# Amass - Le standard pour l'énumération passive
amass enum -passive -d example.com -o subdomains.txt

# Subfinder - Rapide et extensible
subfinder -d example.com -all -o subfinder_results.txt

# Combinaison des résultats
cat subdomains.txt subfinder_results.txt | sort -u > all_subs.txt

# crt.sh - Certificate Transparency Logs
curl -s "https://crt.sh/?q=%25.example.com&output=json" | \
  jq -r '.[].name_value' | sort -u

# DNSdumpster (API)
# Récupération passive de sous-domaines via DNS passif

# SecurityTrails API
curl -s "https://api.securitytrails.com/v1/domain/example.com/subdomains" \
  -H "APIKEY: votre_cle_api" | jq -r '.subdomains[]'

3.2. Certificats SSL et Certificate Transparency

Les Certificate Transparency Logs (CT Logs) sont des registres publics et immuables de tous les certificats SSL/TLS émis par les autorités de certification. Depuis 2018, tous les certificats doivent y être enregistrés pour être considérés comme valides par Chrome. Cette exigence crée une mine d'or pour l'OSINT.

# Recherche via crt.sh (interface web des CT Logs)
# Trouve tous les certificats émis pour un domaine
curl -s "https://crt.sh/?q=%25.example.com&output=json" | \
  jq -r '.[].name_value' | sed 's/\*\.//g' | sort -u

# Censys - Recherche de certificats
censys search "parsed.subject.common_name: example.com" \
  --index-type certificates

# Analyse d'un certificat spécifique
echo | openssl s_client -connect example.com:443 2>/dev/null | \
  openssl x509 -noout -text | grep -A1 "Subject Alternative Name"
# → Révèle les SAN (Subject Alternative Names) = sous-domaines supplémentaires

Les certificats wildcard (*.example.com) sont particulièrement révélateurs : ils indiquent que l'organisation dispose de nombreux sous-domaines. Les certificats de développement ou de staging émis par Let's Encrypt peuvent révéler des environnements de pré-production exposés sur Internet.

3.3. Google Dorks avancés

Les Google Dorks exploitent les opérateurs avancés de recherche Google pour découvrir des informations sensibles indexées par le moteur. Cette technique, également connue sous le nom de Google Hacking, reste l'un des vecteurs OSINT les plus sous-estimés et les plus efficaces.

Voici 20 dorks essentiels pour la reconnaissance offensive :

Catégorie	Google Dork	Objectif
Fichiers sensibles	site:example.com filetype:pdf	Documents PDF (organigrammes, rapports)
Configuration	site:example.com filetype:env	Fichiers .env exposés (credentials)
Configuration	site:example.com filetype:xml inurl:sitemap	Sitemaps (cartographie du site)
Backups	site:example.com ext:sql | ext:bak | ext:old	Fichiers de sauvegarde exposés
Panels admin	site:example.com inurl:admin | inurl:login	Pages d'administration
Erreurs	site:example.com intitle:"Index of /"	Directory listing activé
API	site:example.com inurl:api | inurl:swagger	Documentation API exposée
Git	site:example.com inurl:.git	Dépôts Git exposés
WordPress	site:example.com inurl:wp-content | inurl:wp-includes	Détection WordPress (voir notre article hacking WordPress)
Logs	site:example.com filetype:log	Fichiers de logs exposés
Emails	site:example.com intext:"@example.com"	Adresses email dans les pages
Credentials	site:example.com intext:"password" filetype:txt	Mots de passe dans des fichiers texte
Errors	site:example.com "SQL syntax" | "mysql_fetch"	Erreurs SQL exposées
Cloud	site:s3.amazonaws.com "example"	Buckets S3 associés
Cloud	site:blob.core.windows.net "example"	Azure Blobs associés
Pastebin	site:pastebin.com "example.com"	Données sur paste sites
GitHub	site:github.com "example.com" password | secret | key	Secrets dans le code source
Conf	site:example.com intitle:"phpinfo()"	Pages phpinfo exposées
Jenkins	site:example.com intitle:"Dashboard [Jenkins]"	Instances Jenkins exposées
Camera	site:example.com inurl:"/view.shtml"	Caméras IP accessibles

3.4. Shodan, Censys et ZoomEye

Les moteurs de recherche spécialisés dans l'indexation des services Internet constituent une source d'information majeure pour la reconnaissance passive. Contrairement aux scanners actifs, l'interrogation de ces moteurs ne génère aucun trafic vers la cible.

Shodan : le moteur de recherche de l'IoT

# Recherche par organisation
shodan search "org:Example Corp"

# Recherche par plage IP
shodan search "net:203.0.113.0/24"

# Recherche par domaine avec filtre de port
shodan search "hostname:example.com port:443"

# Filtres avancés
shodan search "ssl.cert.subject.cn:example.com" --fields ip_str,port,org,os

# Requêtes avancées avec facets
shodan stats --facets port "org:Example Corp"
# → Distribution des ports ouverts dans l'organisation

# Vulnérabilités connues
shodan search "vuln:CVE-2021-44228 org:Example Corp"
# → Log4Shell sur les systèmes de l'organisation

# Monitoring continu
shodan alert create "Example Corp" 203.0.113.0/24
shodan alert triggers --add new_service

Censys : focus sur les certificats et services

# Recherche de services
censys search "services.tls.certificates.leaf.subject.common_name: example.com"

# Recherche par ASN
censys search "autonomous_system.asn: 12345"

# API Censys v2
curl -s "https://search.censys.io/api/v2/hosts/search" \
  -H "Authorization: Basic $(echo -n 'API_ID:API_SECRET' | base64)" \
  -d '{"q": "services.tls.certificates.leaf.subject.common_name: example.com"}'

3.5. Archives web et données historiques

La Wayback Machine (web.archive.org) conserve des instantanés historiques de sites web, parfois depuis plus de 20 ans. Ces archives peuvent révéler d'anciennes pages d'administration, des fichiers de configuration supprimés, des technologies antérieures encore en place, ou des informations sensibles qui ont depuis été retirées.

# waybackurls - Extraire toutes les URLs archivées
echo "example.com" | waybackurls | sort -u > wayback_urls.txt

# Filtrer par extensions intéressantes
cat wayback_urls.txt | grep -E "\.(php|asp|aspx|jsp|json|xml|conf|env|bak|sql)$"

# gau (GetAllUrls) - Combine Wayback + OTX + Common Crawl
echo "example.com" | gau --threads 5 | sort -u > all_urls.txt

# Rechercher des endpoints API historiques
cat all_urls.txt | grep -i "api\|graphql\|rest\|v1\|v2" | sort -u

3.6. Réseaux sociaux et HUMINT numérique

Les réseaux sociaux professionnels, en particulier LinkedIn, sont une source d'information stratégique pour la reconnaissance. L'analyse des profils permet d'identifier les technologies utilisées (compétences listées par les employés), la structure organisationnelle (organigramme), les employés clés (RSSI, administrateurs système), et les habitudes de l'organisation. Cette connaissance est également précieuse pour la préparation de campagnes de phishing ciblé.

• LinkedIn : technologies stack, organigramme, offres d'emploi (révèlent les technologies recherchées), publications d'employés.
• GitHub : dépôts publics de l'organisation et de ses employés, commits contenant des secrets, fichiers de configuration, structures de projets internes. Ce vecteur est directement lié au secrets sprawl.
• Twitter/X : annonces techniques, discussions entre équipes, informations sur les incidents en cours.
• Metadata EXIF : les photos et documents publiés contiennent des métadonnées (géolocalisation, logiciels utilisés, noms d'utilisateurs, imprimantes réseau).

# GitDorker - Google Dorks appliqués à GitHub
python3 GitDorker.py -tf tokens.txt -d example.com -q "password"

# truffleHog - Recherche de secrets dans les dépôts
trufflehog github --org example-org

# Metagoofil - Extraction de metadata depuis des documents publics
metagoofil -d example.com -t pdf,doc,xls,pptx -l 100 -o metadata_results/

# ExifTool - Analyse de métadonnées d'images
exiftool photo_corporate.jpg
# → GPS coordinates, camera model, software, author name

3.7. Fuites de données et breach databases

La vérification des fuites de données permet d'évaluer l'exposition de l'organisation aux compromissions antérieures et d'identifier des credentials potentiellement réutilisés.

• Have I Been Pwned (HIBP) : vérifie si des adresses email de l'organisation apparaissent dans des fuites connues. L'API permet l'interrogation automatisée par domaine.
• DeHashed : moteur de recherche de fuites qui permet de rechercher par email, nom d'utilisateur, IP, nom, numéro de téléphone.
• IntelX (Intelligence X) : agrège des données de fuites, paste sites, et archives diverses.
• Snusbase : base de données de fuites avec recherche par email, username, IP, hash.

# HIBP API - Vérifier un domaine
curl -s "https://haveibeenpwned.com/api/v3/breaches" \
  -H "hibp-api-key: votre_cle" | jq '.[] | select(.Domain == "example.com")'

# h8mail - Agrégation de fuites par email
h8mail -t user@example.com --config h8mail_config.ini

# Recherche sur les paste sites
# PasteBin, GhostBin, Rentry, etc.
# Outils : PSBDMP, Pastehunter

4. Reconnaissance Active

Contrairement à la reconnaissance passive, la reconnaissance active implique une interaction directe avec les systèmes de la cible. Les paquets sont envoyés, les services sont interrogés, et les réponses sont analysées. Cette phase est détectable par les IDS/IPS, les WAF et les systèmes de monitoring. Elle nécessite impérativement une autorisation écrite du client dans le cadre d'un pentest.

4.1. Scanning réseau

Le scanning réseau est la première étape de la reconnaissance active. Il permet d'identifier les hôtes actifs, les ports ouverts et les services en écoute. Le choix de l'outil et de la technique de scan dépend du contexte : furtivité requise, taille du périmètre, temps disponible.

Nmap : le standard de référence

# Découverte d'hôtes (host discovery)
nmap -sn 203.0.113.0/24 -oA host_discovery

# Scan TCP SYN (half-open) - Le plus courant
nmap -sS -sV -sC -O -p- -T4 --min-rate 1000 target.com -oA full_scan

# Scan furtif avec timing agressif contrôlé
nmap -sS -Pn -p 21,22,23,25,53,80,110,111,135,139,143,443,445,993,995,\
1723,3306,3389,5900,8080,8443 target.com -T2 --scan-delay 500ms

# Scripts NSE pour la reconnaissance
nmap --script=http-enum,http-title,http-methods,http-robots.txt \
  -p 80,443,8080,8443 target.com

# Détection de vulnérabilités avec NSE
nmap --script=vuln -p 80,443 target.com

# Découverte SMB (Active Directory)
nmap --script=smb-enum-shares,smb-enum-users,smb-os-discovery \
  -p 445 target.com

Masscan : le scanner haute vitesse

# Scan massif à haute vitesse (attention au rate)
masscan 203.0.113.0/24 -p1-65535 --rate=10000 -oJ masscan_results.json

# Cibler les ports web
masscan 203.0.113.0/24 -p80,443,8080,8443,8000,8888 --rate=5000 -oL web_ports.txt

# Combiner avec Nmap pour le fingerprinting
masscan 203.0.113.0/24 -p1-65535 --rate=10000 -oL open_ports.txt
# Puis fingerprinting précis avec Nmap sur les ports découverts
nmap -sV -sC -p $(cat open_ports.txt | awk '{print $3}' | sort -u | tr '\n' ',') target.com

RustScan : rapidité et intégration Nmap

# Scan rapide avec handoff automatique à Nmap
rustscan -a target.com -- -sV -sC -A

# Scan avec timing personnalisé
rustscan -a target.com --ulimit 5000 -b 4500 -- -Pn -sV

4.2. Fingerprinting Web

Le fingerprinting web identifie les technologies utilisées par les applications web : serveur HTTP, framework applicatif, CMS, bibliothèques JavaScript, WAF. Ces informations orientent la recherche de vulnérabilités spécifiques.

# WhatWeb - Identification des technologies web
whatweb -v target.com

# Wappalyzer CLI (via webanalyze)
webanalyze -host https://target.com -crawl 2

# Analyse des headers HTTP
curl -sI https://target.com | grep -iE "server|x-powered|x-aspnet|x-generator"

# httpx - Probe HTTP massive avec fingerprinting
echo "target.com" | httpx -title -tech-detect -status-code -content-length \
  -web-server -ip -cname -cdn -json -o httpx_results.json

# Détection de WAF
wafw00f https://target.com

# Nuclei - Fingerprinting ciblé avec templates
nuclei -u https://target.com -t technologies/ -silent

4.3. Directory et file bruteforcing

Le bruteforcing de répertoires et de fichiers découvre des ressources non référencées : pages d'administration, backups, fichiers de configuration, endpoints API cachés. Cette technique est complémentaire à l'analyse des URLs historiques issue de la reconnaissance passive.

# ffuf - Le plus rapide et flexible
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/raft-large-directories.txt \
  -u https://target.com/FUZZ -mc 200,301,302,403 -fc 404 \
  -H "User-Agent: Mozilla/5.0" -t 50 -o ffuf_results.json

# Gobuster - Bruteforce de répertoires
gobuster dir -u https://target.com -w /usr/share/wordlists/dirb/big.txt \
  -t 50 -x php,asp,aspx,jsp,html,js,txt,bak -o gobuster_results.txt

# Feroxbuster - Récursif et intelligent
feroxbuster -u https://target.com -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt \
  --depth 3 --threads 50 --collect-backups --collect-extensions

# Recherche de fichiers sensibles spécifiques
ffuf -w /usr/share/seclists/Discovery/Web-Content/quickhits.txt \
  -u https://target.com/FUZZ -mc 200 -fc 404

4.4. API Discovery

La découverte d'API est devenue un enjeu majeur avec la prolifération des architectures microservices. Les endpoints API non documentés ou mal sécurisés constituent une surface d'attaque considérable, comme le détaille notre article sur les attaques d'API GraphQL et REST.

# Découverte de documentation API
ffuf -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -u https://target.com/FUZZ -mc 200

# Fichiers Swagger/OpenAPI
for path in swagger.json openapi.json api-docs swagger/v1/swagger.json; do
  curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" \
    "https://target.com/$path"
done

# Introspection GraphQL
curl -s -X POST https://target.com/graphql \
  -H "Content-Type: application/json" \
  -d '{"query": "{__schema{types{name,fields{name,type{name}}}}}"}'

# Kiterunner - Découverte avancée d'endpoints API
kr scan https://target.com -w routes-large.kite -x 5 --fail-status-codes 404,503

4.5. Email Harvesting

La collecte d'adresses email est essentielle pour les tests de phishing et la vérification de fuites de données. Les adresses email suivent souvent un pattern prévisible (prenom.nom@domaine.com) qui permet d'extrapoler l'ensemble des adresses de l'organisation.

# theHarvester - L'outil classique
theHarvester -d example.com -b all -l 500 -f theharvester_results

# Hunter.io API
curl -s "https://api.hunter.io/v2/domain-search?domain=example.com&api_key=KEY" | \
  jq '.data.emails[].value'

# Phonebook.cz (via API)
curl -s "https://phonebook.cz/api/v1/search?q=example.com&type=email"

# crosslinked - Extraction LinkedIn pour générer des emails
crosslinked -f '{first}.{last}@example.com' 'Example Corp'

# Vérification de la validité des emails
# smtp-user-enum, EmailHarvester, Holehe (réseaux sociaux)

5. Outils OSINT Majeurs

L'écosystème des outils OSINT est vaste et en évolution constante. Cette section présente les outils les plus puissants et les plus utilisés par les professionnels de la cybersécurité offensive.

5.1. Maltego : l'analyse de liens

Maltego est l'outil de référence pour l'analyse visuelle de liens et la corrélation de données OSINT. Son architecture repose sur le concept de transforms : des modules qui prennent une entité en entrée (domaine, email, IP, personne) et retournent des entités liées.

• Transforms : plus de 150 transforms natifs + marketplace communautaire. Chaque transform interroge une source de données (DNS, WHOIS, réseaux sociaux, Shodan, VirusTotal, etc.).
• Graphes de liens : visualisation des relations entre entités sous forme de graphes interactifs. Permet d'identifier des patterns et des corrélations non évidentes.
• Machines : workflows automatisés qui enchaînent plusieurs transforms selon une logique prédéfinie (par exemple : domaine → sous-domaines → IPs → services → technologies).
• Collaboration : Maltego permet le travail en équipe sur un même graphe, essentiel pour les grandes opérations de reconnaissance.

Un workflow Maltego typique pour le pentest commence par l'entité domaine racine, applique les transforms DNS (sous-domaines, MX, NS), puis enrichit avec les IPs associées, les services découverts, les personnes liées (WHOIS), et les technologies détectées. Le graphe résultant offre une vue d'ensemble immédiate de la surface d'attaque.

5.2. Recon-ng : la modularité

Recon-ng est un framework de reconnaissance modulaire en ligne de commande, inspiré de Metasploit. Son architecture repose sur un marketplace de modules qui couvrent l'ensemble des besoins OSINT.

# Installation et configuration
recon-ng
[recon-ng][default] > marketplace install all
[recon-ng][default] > workspaces create example_corp

# Configuration des clés API
[recon-ng][example_corp] > keys add shodan_api VOTRE_CLE
[recon-ng][example_corp] > keys add virustotal_api VOTRE_CLE

# Workflow de reconnaissance
[recon-ng][example_corp] > db insert domains example.com
[recon-ng][example_corp] > modules load recon/domains-hosts/hackertarget
[recon-ng][example_corp] > run
[recon-ng][example_corp] > modules load recon/domains-hosts/certificate_transparency
[recon-ng][example_corp] > run
[recon-ng][example_corp] > modules load recon/hosts-hosts/resolve
[recon-ng][example_corp] > run

# Reporting
[recon-ng][example_corp] > modules load reporting/html
[recon-ng][example_corp] > options set FILENAME /tmp/recon_report.html
[recon-ng][example_corp] > run

5.3. SpiderFoot : l'automatisation OSINT

SpiderFoot est un outil d'automatisation OSINT qui interroge simultanément plus de 200 sources de données. Il se distingue par son interface web intuitive, sa capacité à corréler automatiquement les résultats et sa fonctionnalité de scan profiles prédéfinis.

• Scan passif : n'interagit pas avec la cible, utilise uniquement des sources tierces.
• Scan actif : inclut le scanning réseau, le fingerprinting et l'analyse active.
• Scan exhaustif : combine passif et actif pour une couverture maximale.
• API intégrée : s'intègre facilement dans des pipelines d'automatisation.

5.4. Amass : le moteur de reconnaissance

OWASP Amass est le standard de facto pour l'énumération de sous-domaines et la cartographie d'infrastructure. Son architecture multi-sources (50+ intégrations passives) et sa capacité de résolution DNS à grande échelle en font l'outil le plus complet dans sa catégorie.

# Configuration (config.ini)
# Définir les clés API pour maximiser les résultats
# SecurityTrails, Censys, Shodan, VirusTotal, PassiveTotal...

# Enumération passive complète
amass enum -passive -d example.com -config config.ini -o amass_passive.txt

# Enumération active avec brute-force
amass enum -active -brute -d example.com -w subdomains-top1million-5000.txt \
  -config config.ini -o amass_active.txt

# Visualisation de l'infrastructure
amass viz -d example.com -dot amass_graph.dot
# Puis : dot -Tpng amass_graph.dot -o infrastructure_map.png

# Tracking des changements dans le temps
amass track -d example.com -config config.ini

5.5. Tableau comparatif des outils

Outil	Type	Passif	Actif	Interface	Forces
Maltego	Framework	Oui	Oui	GUI	Visualisation, corrélation
Recon-ng	Framework	Oui	Oui	CLI	Modularité, scripting
SpiderFoot	Scanner	Oui	Oui	Web/CLI	200+ sources, automatisation
Amass	Enumérateur	Oui	Oui	CLI	Sous-domaines, graphes
theHarvester	Collecteur	Oui	Non	CLI	Emails, sous-domaines
Shodan CLI	Moteur	Oui	Non	CLI/Web	Services exposés, IoT
Censys	Moteur	Oui	Non	CLI/Web	Certificats, IPv4
FOCA	Metadata	Oui	Non	GUI	Extraction metadata docs
Metagoofil	Metadata	Oui	Non	CLI	Metadata, utilisateurs

6. Automatisation et Workflows de Reconnaissance

L'automatisation de la reconnaissance est devenue incontournable pour les équipes offensives professionnelles et les programmes de bug bounty. Les pipelines automatisés permettent de couvrir une surface d'attaque en expansion constante tout en garantissant la reproductibilité des résultats. L'automatisation est également essentielle dans le contexte des attaques supply chain, où la surface d'attaque s'étend aux dépendances et aux fournisseurs.

6.1. Pipeline ProjectDiscovery

L'écosystème ProjectDiscovery (subfinder, httpx, nuclei, dnsx, notify, katana, etc.) constitue la base de la plupart des pipelines de reconnaissance modernes. Leur interopérabilité via stdin/stdout permet de construire des chaînes de traitement puissantes.

# Pipeline complet : sous-domaines → probe → scan
subfinder -d example.com -all -silent | \
  dnsx -silent -a -resp-only | \
  httpx -silent -title -tech-detect -status-code -follow-redirects | \
  tee live_hosts.txt

# Scan de vulnérabilités sur les hôtes vivants
cat live_hosts.txt | awk '{print $1}' | \
  nuclei -t cves/ -t exposures/ -t misconfiguration/ \
  -severity critical,high -silent -o nuclei_results.txt

# Notification des découvertes critiques
cat nuclei_results.txt | notify -provider-config notify-config.yaml

# Pipeline complet automatisé
subfinder -d example.com -all -silent | \
  httpx -silent -json -o httpx.json && \
  cat httpx.json | jq -r '.url' | \
  nuclei -t cves/ -severity critical,high -o vulns.txt && \
  cat vulns.txt | notify -bulk

6.2. Frameworks de reconnaissance intégrés

Plusieurs frameworks open source intègrent l'ensemble du pipeline de reconnaissance dans un outil unique, automatisant les étapes de collecte, enrichissement, scanning et reporting.

ReconFTW

ReconFTW est l'un des frameworks les plus complets. Il orchestre plus de 30 outils dans un workflow cohérent et produit un rapport structuré. Sa configuration par fichier YAML permet d'adapter le pipeline à chaque mission.

# Lancement d'une reconnaissance complète
./reconftw.sh -d example.com -r -o /tmp/recon_results/

# Mode sous-domaines uniquement
./reconftw.sh -d example.com -s

# Mode full avec notification Slack
./reconftw.sh -d example.com -r --notify

LazyRecon

LazyRecon se distingue par sa simplicité et sa rapidité de déploiement. Il automatise l'énumération de sous-domaines, le scanning de ports, le fingerprinting web et la recherche de vulnérabilités dans un script unique.

Osmedeus

Osmedeus apporte une couche de sophistication supplémentaire avec son système de workflows modulaires, son interface web de monitoring et sa capacité de distribution sur plusieurs machines via Axiom.

6.3. Scaling avec Axiom

Axiom est un framework de distribution qui permet de lancer des outils de reconnaissance sur une flotte de VPS cloud. Au lieu d'exécuter un scan depuis une seule machine, Axiom le distribue sur 10, 50 ou 100 instances, réduisant considérablement le temps d'exécution et diversifiant les adresses IP sources.

# Créer une flotte de 20 instances
axiom-fleet create -i 20 -t default

# Distribuer un scan subfinder
axiom-scan example.com -m subfinder -o subfinder_distributed.txt

# Distribuer un scan nuclei
axiom-scan urls.txt -m nuclei -t cves/ -o nuclei_distributed.txt

# Détruire la flotte
axiom-fleet destroy

6.4. Intégration CI/CD pour le bug bounty

Les bug bounty hunters les plus performants intègrent leurs pipelines de reconnaissance dans des systèmes de CI/CD (GitHub Actions, GitLab CI) pour automatiser le monitoring continu de leurs cibles. Cette approche permet de détecter les changements de surface d'attaque (nouveaux sous-domaines, nouveaux services, nouvelles vulnérabilités) dès qu'ils apparaissent.

# .github/workflows/recon.yml
name: Automated Reconnaissance
on:
  schedule:
    - cron: '0 6 * * *'  # Chaque jour à 6h
  workflow_dispatch:

jobs:
  recon:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install tools
        run: |
          go install github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
          go install github.com/projectdiscovery/httpx/cmd/httpx@latest
          go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
          
      - name: Subdomain enumeration
        run: subfinder -dL targets.txt -all -silent -o new_subs.txt
        
      - name: Compare with previous results
        run: |
          comm -13 <(sort previous_subs.txt) <(sort new_subs.txt) > diff_subs.txt
          if [ -s diff_subs.txt ]; then
            echo "NEW_SUBS=true" >> $GITHUB_ENV
          fi
          
      - name: Scan new subdomains
        if: env.NEW_SUBS == 'true'
        run: |
          cat diff_subs.txt | httpx -silent | nuclei -t cves/ -severity critical,high -o alerts.txt
          
      - name: Notify
        if: env.NEW_SUBS == 'true'
        run: |
          cat alerts.txt | notify -provider-config config/notify.yaml

6.5. Scripting Python pour l'OSINT

Python reste le langage de prédilection pour le développement d'outils OSINT personnalisés. Les bibliothèques clés incluent :

#!/usr/bin/env python3
"""
Script OSINT personnalisé - Enumération et enrichissement
"""
import requests
import json
import dns.resolver
from concurrent.futures import ThreadPoolExecutor

class OSINTRecon:
    def __init__(self, domain):
        self.domain = domain
        self.subdomains = set()
        self.results = {}
    
    def crtsh_enum(self):
        """Enumération via Certificate Transparency Logs"""
        url = f"https://crt.sh/?q=%25.{self.domain}&output=json"
        try:
            resp = requests.get(url, timeout=30)
            data = resp.json()
            for entry in data:
                names = entry.get('name_value', '').split('\n')
                for name in names:
                    name = name.strip().lstrip('*.')
                    if name.endswith(self.domain):
                        self.subdomains.add(name)
        except Exception as e:
            print(f"[!] crt.sh error: {e}")
    
    def resolve_subdomains(self):
        """Résolution DNS des sous-domaines découverts"""
        resolver = dns.resolver.Resolver()
        resolver.timeout = 3
        
        def resolve(sub):
            try:
                answers = resolver.resolve(sub, 'A')
                ips = [str(r) for r in answers]
                return sub, ips
            except:
                return sub, []
        
        with ThreadPoolExecutor(max_workers=20) as executor:
            futures = {executor.submit(resolve, sub): sub 
                      for sub in self.subdomains}
            for future in futures:
                sub, ips = future.result()
                if ips:
                    self.results[sub] = ips
    
    def run(self):
        print(f"[*] OSINT Recon pour {self.domain}")
        self.crtsh_enum()
        print(f"[+] {len(self.subdomains)} sous-domaines trouvés")
        self.resolve_subdomains()
        print(f"[+] {len(self.results)} sous-domaines résolus")
        return self.results

if __name__ == "__main__":
    recon = OSINTRecon("example.com")
    results = recon.run()
    print(json.dumps(results, indent=2))

7. Contre-Mesures et Réduction de Surface d'Attaque

Comprendre l'OSINT offensif permet de mieux se défendre. La réduction de la surface d'attaque est un processus continu qui nécessite une vigilance permanente et une approche proactive.

7.1. Attack Surface Management (ASM)

Les solutions ASM représentent l'évolution défensive de l'OSINT. Elles reproduisent en continu les méthodes de reconnaissance des attaquants pour identifier proactivement les expositions. Les principales plateformes incluent :

• Randori (IBM) : émule la perspective de l'attaquant pour identifier et prioriser les surfaces d'attaque les plus attractives.
• Detectify : combine l'expertise de la communauté bug bounty avec un scanning automatisé pour détecter les vulnérabilités exposées.
• CrowdStrike Falcon Surface : intègre la threat intelligence avec la cartographie de surface d'attaque pour contextualiser les risques.
• ProjectDiscovery Cloud : version cloud des outils open source ProjectDiscovery avec monitoring continu et alerting.

7.2. Monitoring proactif

Au-delà des solutions ASM commerciales, les organisations peuvent mettre en place un monitoring OSINT proactif à moindre coût en utilisant les outils open source présentés dans cet article. L'objectif est de détecter les changements de surface d'attaque avant qu'un attaquant ne les exploite.

# Script de monitoring quotidien (cron)
#!/bin/bash
DOMAIN="example.com"
DATE=$(date +%Y%m%d)
PREV_DIR="/opt/recon/previous"
CURR_DIR="/opt/recon/current"

# Enumération quotidienne
subfinder -d $DOMAIN -all -silent -o $CURR_DIR/subs_$DATE.txt

# Détection de nouveaux sous-domaines
comm -13 <(sort $PREV_DIR/subs_latest.txt) <(sort $CURR_DIR/subs_$DATE.txt) \
  > $CURR_DIR/new_subs_$DATE.txt

# Alerte si nouveaux sous-domaines
if [ -s $CURR_DIR/new_subs_$DATE.txt ]; then
  cat $CURR_DIR/new_subs_$DATE.txt | \
    httpx -silent -title -status-code -tech-detect | \
    notify -provider-config /opt/recon/notify.yaml -bulk
fi

# Mise à jour de la référence
cp $CURR_DIR/subs_$DATE.txt $PREV_DIR/subs_latest.txt

8. Conclusion

L'OSINT et la reconnaissance offensive ne sont pas de simples étapes préliminaires d'un test d'intrusion : elles en constituent le fondement stratégique. La qualité de la reconnaissance détermine directement la pertinence et l'efficacité des phases d'exploitation qui suivent. Un pentester qui maîtrise l'OSINT identifie des vecteurs d'attaque invisibles pour un scanner automatisé, et reproduit fidèlement les méthodes des attaquants sophistiqués.

Les principes présentés dans cet article s'appliquent à l'ensemble du spectre offensif : des tests d'intrusion mandatés aux programmes de bug bounty, en passant par le red teaming et l'évaluation de la posture sécurité. La maîtrise du cycle du renseignement, la connaissance approfondie des outils (Amass, Shodan, Maltego, Recon-ng, Nuclei), et la capacité à automatiser les workflows constituent les compétences différenciantes du pentester professionnel.

Du côté défensif, l'OSINT offre aux organisations une perspective unique sur leur propre exposition. En adoptant la posture de l'attaquant, les équipes sécurité peuvent identifier proactivement les faiblesses de leur surface d'attaque et y remédier avant qu'elles ne soient exploitées. L'investissement dans des solutions ASM et des processus de monitoring continu n'est plus optionnel dans un paysage de menaces en constante évolution.

Enfin, l'OSINT doit toujours s'exercer dans le respect du cadre légal et éthique. La frontière entre la reconnaissance légitime et l'accès frauduleux est parfois ténue, et seule une pratique rigoureusement encadrée (mandat écrit, respect du périmètre, documentation exhaustive) permet de tirer parti de ces techniques en toute légalité.