1. Contexte, objectifs et cadre légal

Un audit de sécurité réseau a pour but d’identifier les actifs exposés, vulnérabilités exploitées et vecteurs d’attaque pour permettre au RSSI de prioriser des correctifs. Les objectifs typiques :

• Inventorier les équipements réseau et services (discovery) ;
• Identifier les versions de logiciels et systèmes d’exploitation ;
• Détecter vulnérabilités connues (CVE) et configurations faibles ;
• Vérifier la présence de services non autorisés ;
• Produire un rapport actionnable et priorisé.

Cadre légal :

• Obtenir une autorisation écrite signée par le DSI/RSSI et le propriétaire des ressources.
• Définir le scope (adresses IP, plages, horaires, exclusions).
• Planifier fenêtre d’audit (heures creuses si impact possible).
• Mettre en place un point de contact (SOC / NOC) pour interruption immédiate.

2. Choix d’outils et architecture d’audit

Outils recommandés :

• Nmap : discovery, fingerprinting, port scanning, NSE scripts. Site : https://nmap.org/
• Tenable Nessus : scanner de vulnérabilités commercial/entreprise, riche base CVE, reporting. Site : https://www.tenable.com/products/nessus
• Wireshark / tcpdump / tcpreplay : capture et replay PCAP pour validation.
• ELK / Splunk : ingestion logs Nessus/Nmap pour corrélation.
• TheHive / Cortex : playbooks d’automatisation et enrichissement (optionnel).

Architecture minimale :

• Station d’audit isolée (VM ou bastion) avec Nmap & Nessus CLI/GUI.
• Accès réseau vers la cible via segment de management ou VPN dédié.
• SIEM connecté pour ingestion des logs (si existant).

3. Préparatifs avant audit (autorisation, scope, sauvegarde)

Étapes impératives pas à pas :

1. Obtenir autorisation écrite :
   • Dans votre outil de gestion (ServiceNow / email interne), créer une demande avec : scope IPs, dates/horaires, type de tests (non intrusive / intrusive), contact d’urgence.
2. Définir scope :
   • Exemple de scope : 10.0.0.0/24, 203.0.113.15, exclure 10.0.0.5 (actif critique).
3. Notifier les équipes :
   • Envoyer email à NOC/SOC avec horaire, contact, rollback plan.
4. Sauvegardes :
   • Vérifier snapshots VM et backups des éléments critiques dans le scope.
5. Plan de rollback / arrêt :
   • Définir procédure d’arrêt si un scan provoque impact : CNTRL-C sur scan, contacter responsable local.

4. Installation rapide : Nmap (Linux) — étape par étape (Ubuntu/Debian)

But : installer Nmap, NSE, et outils utiles.

1. Ouvrez un terminal sur la machine d’audit (Ubuntu 22.04 LTS recommandé).
2. Mettre à jour le système :
   • Tapez : sudo apt update && sudo apt upgrade -y
3. Installer Nmap et utilitaires :
   • Tapez : sudo apt install -y nmap git wget tcpdump unzip
4. Vérifier l’installation :
   • Tapez : nmap --version
   • Sortie attendue : version Nmap, NSE scripts path.
5. Mettre à jour les scripts NSE (optionnel) :
   • Tapez : sudo nmap --script-updatedb
6. Installer Ncat (optionnel pour tests) :
   • Tapez : sudo apt install -y ncat

5. Installation rapide : Nessus (Tenable) — étape par étape (Ubuntu)

Pré-requis : licence Nessus ou Nessus Professional. Exemple installation Ubuntu Server.

1. Ouvrez un terminal SSH sur la VM destinée à Nessus.
2. Mettre à jour :
   • sudo apt update && sudo apt upgrade -y
3. Télécharger le package Nessus :
   • Allez sur le site Tenable → téléchargez le .deb adapté (https://www.tenable.com/products/nessus/nessus-professional-downloads).
   • Ou en CLI (exemple, vérifier URL à jour) :

wget https://www.tenable.com/downloads/api/v1/public/pages/nessus/downloads/XXXXX -O Nessus.deb

4. Installer :
   • sudo dpkg -i Nessus.deb
   • Si dépendances manquantes : sudo apt -f install -y

5. Démarrer le service :
   • sudo systemctl enable –now nessusd
   • Vérifier : sudo systemctl status nessusd

6. Configurer via web :
   • Ouvrez navigateur → https://:8834/
   • Cliquez Get started → accepter EULA → créer compte admin local → saisir activation code (fourni par Tenable) → installer plugins (long, patience).

7. Vérifier plugins : Dashboard Nessus → Plugins → confirmer mise à jour complète.

6. Phase 1 — Collecte passive et reconnaissance

Avant de lancer des scans actifs, effectuer collecte passive pour limiter impact et mieux cibler.

Étapes :

1. DNS reconnaissance (clic/commande) :
   • dig AXFR example.com @ns1.example.com (si autorisé)
   • dig +short www.example.com
2. WHOIS :
   • whois example.com
3. Reconnaissance publique :
   • sublist3r -d example.com (recherche sous-domaines)
   • crt.sh : visiter https://crt.sh/ et rechercher %.example.com pour certs TLS.
   • URL : https://crt.sh/
4. Netflow / logs : demander au NOC export NetFlow/RSPAN pour période si possible (analyse des IPs talkers).
5. Passive DNS / Threat Intel :
   • Interroger VirusTotal API ou AbuseIPDB pour IPs repérées.

7. Phase 2 — Scans Nmap détaillés (commands + NSE)

7.1 Règles d’or

• Toujours respecter le scope et les horaires.
• Commencer par scan léger puis intensifier si autorisé.

7.2 Commandes Nmap essentielles (clic/commande)

Discovery rapide :

# Scan ping pour détecter hôtes actifs dans une plage
sudo nmap -sn 10.0.0.0/24 -oA scans/01_ping_scan

• -sn : ping scan (no port scan)
• -oA : sortie en formats normal/gnmap/xml

Scan ports rapides (top 100) :

sudo nmap -sS -Pn --top-ports 100 -oA scans/02_top100 10.0.0.0/24

• -sS : SYN scan
• -Pn : treat hosts as up (si firewall blocks ICMP)

Scan complet des 65535 ports (lent) :

sudo nmap -sS -p- -T4 -oA scans/03_fullports 10.0.0.5

• -p- : tous ports
• -T4 : timing aggressive (ajuster si risque d’impact)

Version detection & scripts :

sudo nmap -sS -sV -sC -O -p22,80,443 -oA scans/04_service_detect 10.0.0.5

• -sV : service/version detection
• -sC : run default scripts
• -O : OS detection

Nmap Scripting Engine (NSE) exemples :

• http-enum : enumerates common web paths.
• ssl-cert : fetches certificate details.
• smb-os-discovery : SMB OS info (Windows).
  Commande :

sudo nmap -p 80,443 --script=http-enum,http-title,ssl-cert -oA scans/05_http 10.0.0.0/24

Scan parallèle & mass scanning (large fleets) :

• Utiliser -T3 or -T4 carefully. For large scope, split into smaller ranges.

7.3 Exemples d’analyse NSE (pas à pas)

1) Tester vuln SSL/TLS (Heartbleed, POODLE, etc.) :

sudo nmap --script ssl-heartbleed,ssl-poodle -p 443 -oA scans/ssl_checks 10.0.0.5

2) Détecter services SMB et version :

sudo nmap -p 445 --script smb-os-discovery -oA scans/smb 10.0.0.0/24

3) Rechercher pages administratives courantes :

sudo nmap -p80,443 --script http-enum --script-args http-enum.paths=/admin,/login -oA scans/http_enum 10.0.0.0/24

7.4 Exporter résultats Nmap pour corrélation

• Les fichiers scans/*.xml produits par -oA sont exploitables par SIEM ou par des scripts Python (lib libnmap) pour consolider avec Nessus.

8. Phase 3 — Scans de vulnérabilités avec Nessus (configuration, politiques, exécution)

8.1 Création d’une politique Nessus (pas à pas)

1. Ouvrir Nessus Web UI : https://<nessus-server-ip>:8834/ → login admin.
2. Menu → Scans → New Scan.
3. Choisir template :
   • Basic Network Scan pour débuter ; Advanced Scan pour options fines ; Credentialed Patch Audit pour audits avec cred.
4. Configurer General Settings :
   • Name: Scan_Prod_10.0.0.0-24
   • Targets: 10.0.0.0/24 (ou host list).
5. Credentials (fortement recommandé) :
   • Onglet Credentials → ajouter credentials SSH (Linux) ou SMB/Windows (user with admin rights) pour scans credentialed qui détectent correctifs manquants et versions.
   • Pas à pas : Add → Windows → Username → Domain → Password → Test → Save.
6. Plugins :
   • Onglet Plugins → sélectionner catégories : Windows, Unix, Web Servers, Databases, SCADA selon scope. Désactiver plugins à risque si souhaité.
7. Advanced Settings :
   • Scanner options : Max checks per host, Port scan options (safest default).
   • Schedule : run now or schedule.

8.2 Lancer le scan (pas à pas)

1. Dans Nessus → Scans → sélectionner la politique → Launch.
2. Monitor progress : onglet Running → cliquer sur le scan pour voir les hôtes découverts, vulnérabilités.
3. Exporter résultats :
   • Après fin, Report → Export → formats : .nessus (XML), .csv, .pdf.
   • Pour intégration SIEM utiliser .nessus ou .csv.

8.3 Exemples de scan credentialed vs non-credentialed

• Non-credentialed (safe, découverte) : détecte services, versions, vulnérabilités exposées.
• Credentialed (plus profond) : connecte au host via SMB/WinRM/SSH et vérifie correctifs, configurations (recommandé pour inventaire de patchs).

8.4 Politique d’acceptation de risque

• Lors de scans intrusifs (vérification d’exploitation), activer only if authorized, et tester en environnement pilote.

9. Automatisation : exécuter et orchestrer scans (CLI, scripts, API Nessus)

9.1 Lancer Nmap en batch script (cron)

Script sample run_nmap_batch.sh :

#!/bin/bash
OUTDIR=/var/audit/scans/$(date +%F)
mkdir -p $OUTDIR
# Ping scan
nmap -sn 10.0.0.0/24 -oA $OUTDIR/01_ping
# Top ports
nmap -sS -Pn --top-ports 100 -oA $OUTDIR/02_top100 10.0.0.0/24
# Service detect on discovered hosts
grep "Nmap scan report for" $OUTDIR/01_ping.gnmap | awk '{print $5}' | xargs -I{} nmap -sV -sC -O -p- -oA $OUTDIR/03_service_{} {}

• Planification : crontab -e → ajouter 0 2 * * Sun /usr/local/bin/run_nmap_batch.sh >> /var/log/nmap_cron.log 2>&1

9.2 Nessus API (exemples curl) — lancer scan et récupérer rapport

Utiliser l’API Nessus (token) : générer token via UI (MyAccount → API Keys).

1) Auth to API (if using session) — modern Nessus uses API keys.

2) Launch scan (example using scan UUID):

# Variables
NESSUS_URL="https://nessus-server:8834"
API_KEY="YOUR_ACCESS_KEY"
API_SECRET="YOUR_SECRET_KEY"
SCAN_ID=12345

curl -k -X POST -H "X-ApiKeys: accessKey=${API_KEY}; secretKey=${API_SECRET}" \
  -H "Content-Type: application/json" \
  -d '{"scan_id":'${SCAN_ID}'}' \
  ${NESSUS_URL}/scans/${SCAN_ID}/launch

3) Download report:

curl -k -H "X-ApiKeys: accessKey=${API_KEY}; secretKey=${API_SECRET}" \
  ${NESSUS_URL}/scans/${SCAN_ID} | jq '.info'
# Export
curl -k -H "X-ApiKeys: accessKey=${API_KEY}; secretKey=${API_SECRET}" \
  ${NESSUS_URL}/scans/${SCAN_ID}/export -d '{"format":"nessus"}'
# then download using export file id

Consulter la doc API Nessus pour endpoints exacts : https://developer.tenable.com/

9.3 Orchestration et ticketing

• Après fin de scan, automatiser création ticket ServiceNow via REST API pour vulnérabilités critiques (CVSS ≥ 7.0) — exemple curl plus bas en section 14.

10. Analyse des résultats : corrélation Nmap + Nessus, priorisation

10.1 Enrichir résultats

• Nmap XML → mapping ports/services → pour chaque service vérifier vuln Nessus → prioriser en fonction CVSS, présence d’exploit public (ExploitDB), présence dans AD/DMZ.

10.2 Priorisation recommandée (exemple)

• Critique (P0) : CVSS ≥ 9, exploit public, exécution remote initielle (RCE) sur périmètre public / service exposé.
• Haute (P1) : CVSS 7–8.9, privilege escalation possible, data exfiltration vectors.
• Moyenne (P2) : CVSS 4–6.9, moins critique mais à corriger.
• Basse (P3) : infos leakage, version detection sans exploit connu.

10.3 Exemple d’analyse combinée (clic/commande)

1. Extraire hôtes vulnérables :
   • grep "Host:" scans/04_service_detect.nmap -A 5 | ... (scripts Python recommended)
2. Regrouper par CVSS : importer .nessus XML dans Python (lib xml.etree) et bucket by severity.
3. Produire tableau récapitulatif : colonne IP | Hostname | Port | Service | CVE | CVSS | Exploit | Remédiation recommandée.

11. Validation et tests non-destructifs (replay PCAP, tests faibles)

But : prouver qu’une vulnérabilité est réellement exploitable en protégeant disponibilité.

11.1 Capturer trafic suspect (tcpdump)

sudo tcpdump -i eth0 host 10.0.0.5 -w /tmp/capture_10.0.0.5.pcap

11.2 Replay PCAP (tcpreplay) — test non-destructif

1. Installer tcpreplay : sudo apt install -y tcpreplay
2. Rejouer pcap sur environnement LAB (jamais en prod) :
   • sudo tcpreplay -i eth1 /tmp/sample.pcap
3. Observer détection : vérifier si IDS/IPS détecte la même signature.

11.3 Test d’exploitation contrôlé (exemple CVE non-destructif)

• Préférer scripts de vérification passive (check-only) fournis par Nessus ou Nmap NSE (ex: http-sql-injection script may be intrusive — use with written approval).

12. Rédaction du rapport d’audit (modèle prêt à transmettre au DSI/RSSI)

Fournir un rapport professionnel, clair et priorisé. Exemple de structure :

Page de garde

• Titre : Audit de sécurité réseau — Nmap & Nessus
• Organisation : Nom de la société
• Périmètre : liste d’adresses IP et services
• Date : YYYY-MM-DD
• Auditeurs : noms et contacts

Résumé Exécutif (1 page)

• Contexte, période de l’audit, objectifs
• Principales conclusions (ex: 3 vulnérabilités critiques découvertes, 12 hautes, 45 moyennes)
• Impact potentiel résumé
• Recommandation priorisée (POC, patch, segmentation)

Détails Techniques (par asset)

• Host : 10.0.0.5 (web01)
• Nmap findings : ports open, services version (ex: Apache 2.4.29)
• Nessus findings : CVE list, CVSS, description, evidence (output snippet), exploitability, remediation steps.
• Proofs : logs, pcap snippets (base64 or file attachments) — ne pas inclure données sensibles.

Priorisation & Plan d’action

Priorité	IP/Asset	Vulnérabilité (CVE)	CVSS	Recommandation	Responsable

Annexes

• Commandes Nmap utilisées (list), politiques Nessus, export brut (.nessus), captures PCAP.

Modèle d’une entrée de vulnérabilité (copier) :

Vuln ID : VULN-2025-001
Nom : Apache HTTPD mod_ssl outdated (CVE-2024-XXXX)
CVSS v3 : 9.1 (Critical)
Description : ... (2-3 lignes)
Evidence : Nessus report snippet (plugin id X)
Impact : RCE possible leading to full compromise of web server
Remediation : Apply patch to Apache 2.4.51 or later; disable SSLv3; update ciphers to TLS 1.2+ using AES-GCM
Verification : After patch, run `nmap -sV --script ssl-cert -p 443 10.0.0.5` and confirm version
Deadline recommandé : 7 jours
Responsable : Admin Web / N° ticket (ServiceNow-12345)

13. Plan de remédiation et priorisation — actions correctives détaillées

Pour chaque sévérité, actions concrètes pas à pas ou commandes :

13.1 Vulnérabilité Critique (ex : RCE sur service web)

1. Isolation : mettre host en maintenance ; si possible, déplacer via VLAN isolé.
   • CLI switch (ex Cisco) : configure terminal → interface GigabitEthernet1/0/5 → switchport access vlan 999 → shutdown (work with NOC).
2. Appliquer correctif : suivez vendor patch steps. Exemple Linux apt:

sudo apt update
sudo apt install --only-upgrade apache2 -y
sudo systemctl restart apache2

3. Vérifier : exécuter nmap -sV -p443 –script ssl-cert 10.0.0.5 et vérifier version.
4. Close ticket : documenter dans ServiceNow ticket, joindre preuve.

13.2 Vulnérabilité Haute (ex : missing patches, default creds)

• For Windows: run wmic qfe list or use SCCM/WSUS to deploy patch. For default creds: rotate creds immediately, force password policy.

13.3 Vulnérabilité Moyenne/Basse

• Planifier patch window, mitigations (WAF rule, iptables block, disabling service).

14. Procédure d’escalade et modèle de ticket ServiceNow / flux SOAR (TheHive)

14.1 Règle d’escalade automatique (exemple)

• Si Nessus trouve CVSS ≥ 9 AND exploit public → créer ticket P0 in ServiceNow AND create case in TheHive AND block source IP on perimeter FW (API).

Exemple curl crée ticket ServiceNow (clic/commande) :

curl -k -u 'svc_snm:password' \
  -H "Content-Type: application/json" \
  -X POST "https://instance.service-now.com/api/now/table/incident" \
  -d '{
    "short_description":"[P0] Vuln critique trouvée sur 10.0.0.5 - CVE-XXXX-XXXX",
    "description":"Nessus: plugin id 12345 - RCE. Evidence attached. Remediation: patch apache.",
    "urgency":"1",
    "impact":"1",
    "assignment_group":"Security Operations"
  }'

Remplacer credentials par token/secure vault.

14.2 Template TheHive playbook (sommaire)

• Trigger : new critical vuln
• Automated actions :
  • Enrich IP/Asset via VirusTotal/MISP (Cortex analyzers)
  • Query SIEM for related events
  • Create ServiceNow Incident (as above)
  • Notify Slack/Teams SOC channel
  • Assign to responder N2

15. Checklist post-audit & bonnes pratiques pour le suivi continu

• Tous les tickets P0/P1 créés et assignés
• Preuves de remediation fournies (screenshots, outputs)
• Retest planifié (scan de verification) : re-run scans après patch (schedule 7 days)
• Intégration des résultats dans CMDB (configuration management)
• Mise en place de scans récurrents (weekly/monthly) automatisés
• Documenter exceptions (assets non patchables) et compensating controls (WAF, ACL)

16. Annexes : scripts, commandes, modèles

16.1 Script : lancer Nessus scan via API (bash)

#!/bin/bash
# Launch Nessus scan via API
NESSUS_URL="https://nessus-server:8834"
API_KEY="ACCESS_KEY"
API_SECRET="SECRET_KEY"
SCAN_ID=12345

# Launch
curl -k -s -X POST \
  -H "X-ApiKeys: accessKey=${API_KEY}; secretKey=${API_SECRET}" \
  -H "Content-Type: application/json" \
  -d "{\"scan_id\":${SCAN_ID}}" \
  ${NESSUS_URL}/scans/${SCAN_ID}/launch | jq .

16.2 Script : parser Nmap XML et générer CSV (python minimal)

# parse_nmap_xml.py
import sys, xml.etree.ElementTree as ET, csv
xmlfile=sys.argv[1]
tree=ET.parse(xmlfile)
root=tree.getroot()
with open('nmap_services.csv','w',newline='') as csvfile:
    writer=csv.writer(csvfile)
    writer.writerow(['host','ip','port','protocol','service','product','version'])
    for host in root.findall('host'):
        addr = host.find('address').get('addr')
        for port in host.findall(".//port"):
            p=port.get('portid')
            proto=port.get('protocol')
            svc=port.find('service')
            prod=svc.get('product') if svc is not None else ''
            ver=svc.get('version') if svc is not None else ''
            writer.writerow(['','%s'%addr,p,proto,svc.get('name') if svc is not None else '',prod,ver])

Exécution : python3 parse_nmap_xml.py scans/04_service_detect.xml

16.3 Modèle de rapport (word / markdown) — inclure en annexe

(Le modèle s’insère dans la section 12 et peut être exporté en PDF)

Remarques finales

• Respect légal : effectuer uniquement des audits autorisés.
• Sécurité des clés : stocker API keys Nessus et credentials dans un coffre sûr (HashiCorp Vault).
• Re-tests : programmer un re-scan après remediation pour vérifier correction.

Conclusion

Un audit réseau efficace combine reconnaissance structurée (Nmap) et scanning de vulnérabilités profond (Nessus), complété par des tests de validation non-destructifs. La valeur ajoutée est dans l’analyse et la priorisation contextualisée — corriger d’abord ce qui menace la disponibilité ou les données sensibles.

Besoin d’un audit complet, d’un POC ou d’une mission de remédiation ?
Contactez nos experts pour planifier un audit piloté (livrable : rapport technique + rapport exécutif + playbooks d’escalade) :

1. Cliquez sur le bouton ci-dessous pour accéder à notre formulaire de Contact.
2. Remplissez le formulaire avec : objet “Audit Nmap & Nessus”, périmètre (IPs), interlocuteur DSI/RSSI, préférence date.
3. Cliquer sur Envoyer.
   Un responsable technique vous recontactera sous 48 heures ouvrées pour cadrage et proposition.

Liens externes recommandés

• Nmap (site officiel) : https://nmap.org/
• Nmap Scripting Engine (NSE) docs : https://nmap.org/book/nse.html
• Tenable Nessus (product) : https://www.tenable.com/products/nessus
• Nessus API documentation (Tenable) : https://developer.tenable.com/
• Wireshark (capture) : https://www.wireshark.org/
• tcpreplay (pcap replay) : https://tcpreplay.appneta.com/
• CVE Details (vuln DB) : https://www.cvedetails.com/
• Exploit Database : https://www.exploit-db.com/
• OWASP Testing Guide : https://owasp.org/www-project-web-security-testing-guide/