PyRDP

PyRDP est un outil et une bibliothèque Python pour l'attaque de type Monstre-du-Milieu (MITM) sur le protocole RDP (Remote Desktop Protocol).

Il propose plusieurs outils :

Monstre-du-Milieu RDP
- Enregistre les identifiants en texte clair ou les hachages NetNTLM utilisés lors de la connexion
- Intercepte les données copiées dans le presse-papiers
- Sauvegarde une copie des fichiers transférés sur le réseau
- Parcourt les lecteurs partagés en arrière-plan et les sauvegarde localement
- Enregistre des relectures des connexions pour les consulter ultérieurement

pyrdp-mitm 192.168.1.10 -i 127.0.0.1 -d 4000 ``` #### Exécution de payloads sur les nouvelles connexions PyRDP permet d'exécuter automatiquement des commandes console ou des payloads PowerShell lors de l'établissement de nouvelles connexions. En raison de la nature du RDP, le processus est un peu bancal et pas toujours fiable à 100 %. Voici comment cela fonctionne : 1. Attendre que l'utilisateur soit authentifié. 2. Bloquer l'entrée / sortie du client pour masquer le payload et empêcher toute interférence. 3. Envoyer une fausse séquence Windows+R et lancer `cmd.exe`. 4. Exécuter le payload en tant que commande console et fermer la console. Si un payload PowerShell est configuré, il est exécuté avec `powershell -enc <PAYLOAD>`. 5. Attendre un peu pour permettre au payload de se terminer. 6. Restaurer l'entrée / sortie du client. Pour que cela fonctionne, vous devez définir 3 arguments : - le payload - le délai avant le démarrage du payload - la durée du payload ##### Définition du payload Vous pouvez utiliser l'un des arguments suivants pour définir le payload à exécuter : - `--payload`, une chaîne contenant des commandes console - `--payload-powershell`, une chaîne contenant des commandes PowerShell - `--payload-powershell-file`, un chemin vers un script PowerShell ##### Choix du moment de démarrage du payload Pour l'instant, PyRDP ne détecte pas quand l'utilisateur est connecté. Vous devez lui indiquer un temps d'attente avant d'exécuter le payload. Une fois ce temps écoulé, il enverra les fausses séquences de touches et s'attendra à ce que le payload s'exécute correctement. Pour cela, vous utilisez l'argument `--payload-delay`. Le délai est en millisecondes. Par exemple, si vous pensez que l'utilisateur sera connecté dans les 5 premières secondes, vous utiliserez les arguments suivants :```sh --payload-delay 5000 ``` Cela pourrait être rendu plus précis en exploitant certains messages échangés lors de l'initialisation RDPDR. Voir [cette issue](https://github.com/GoSecure/pyrdp/issues/98) si vous êtes intéressé à améliorer cela. ##### Choisir quand reprendre l'activité normale Parce qu'il n'y a pas de moyen direct de savoir quand la console a cessé de fonctionner, vous devez indiquer à PyRDP combien de temps vous voulez bloquer l'entrée / sortie du client. Nous vous recommandons de définir cela sur la durée maximale pendant laquelle vous pensez que la console exécutant votre payload sera visible. En d'autres termes, le temps que vous estimez nécessaire pour que votre payload se termine. Pour définir la durée du payload, vous utilisez l'argument `--payload-duration` avec une durée en millisecondes. Par exemple, si vous pensez que votre payload prendra jusqu'à 5 secondes pour se terminer, vous utiliseriez l'argument suivant :```sh --payload-duration 5000 ``` Cela bloquera l'entrée / sortie du client pendant 5 secondes pour masquer la console et éviter les interférences. Après 5 secondes, l'entrée / sortie est rétablie normalement. #### Autres arguments MITM Exécutez `pyrdp-mitm --help` pour une liste complète des arguments. ##### `--no-downgrade` Cet argument est utile lors de l'exécution de PyRDP dans des scénarios Honeypot pour éviter le fingerprinting des scanners. Lorsque l'option est activée, PyRDP ne déclassera pas les extensions non prises en charge et laissera passer le trafic de manière transparente. Le lecteur ne pourra probablement pas relire avec succès le trafic vidéo, mais les canaux pris en charge suivants devraient toujours être accessibles : - Enregistrement des frappes - Mises à jour de la position de la souris - Accès au presse-papiers (passivement) - Accès au disque (passivement) Cette fonctionnalité est encore en cours de développement et un certain déclassement est actuellement inévitable pour permettre l'établissement de la connexion. Les éléments suivants ne sont actuellement pas affectés par cette option et resteront désactivés : - Chiffrement FIPS - Protocoles de chiffrement non-TLS - Compression ClientInfo - Compression de canal virtuel **NOTE** : Si pouvoir relire ultérieurement la session complète est important, une bonne solution est d'enregistrer le trafic RDP brut en utilisant Wireshark et de conserver les secrets maîtres TLS. Lorsque PyRDP ajoutera la prise en charge d'extensions supplémentaires, il deviendra alors possible d'extraire un fichier de relecture RDP valide à partir de la capture réseau brute. ##### `--transparent` Demande à PyRDP de tenter d'usurper l'adresse IP source du client afin que le serveur voie la véritable adresse IP au lieu de celle du MITM. Cette option n'est utile que dans certains scénarios où le MITM est physiquement une passerelle entre les clients et le serveur et voit tout le trafic. [Des exemples spécifiques peuvent être trouvés ici.](https://github.com/gosecure/pyrdp/blob/main/docs/transparent-proxy.md) **NOTE** : Cela nécessite les privilèges root, ne fonctionne que sous Linux et nécessite une configuration manuelle du pare-feu pour garantir que le trafic est correctement routé. ##### `--no-gdi` : Désactiver le pipeline graphique accéléré PyRDP dégrade la vidéo au pipeline graphique le plus récent qu'il prend en charge. Cette option indique explicitement au MITM de ne pas utiliser les extensions [Graphics Device Interface Acceleration][gdi] pour diffuser la vidéo. L'avantage de ce mode est une réduction significative de la bande passante requise pour les connexions haute résolution. Notez que certains ordres de dessin GDI ne sont actuellement pas implémentés car ils semblent inutilisés. Si vous avez une relecture qui contient un ordre non pris en charge ou non testé, n'hésitez pas à la partager avec les mainteneurs du projet afin que la prise en charge puisse être ajoutée si nécessaire. (Assurez-vous que la trace ne contient pas d'informations sensibles) [gdi]: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpegdi/745f2eee-d110-464c-8aca-06fc1814f6ad ### Utilisation du lecteur PyRDP Utilisez `pyrdp-player` pour lancer le lecteur. #### Lecture d'un fichier de relecture Vous pouvez utiliser le menu pour ouvrir un nouveau fichier de relecture : Fichier > Ouvrir. Vous pouvez également ouvrir des fichiers de relecture au lancement du lecteur :```sh pyrdp-player <FILE1> <FILE2> ... ``` #### Écoute des connexions en direct Le lecteur écoute toujours les connexions en direct. Par défaut, le port d'écoute est 3000, mais il peut être changé :```sh pyrdp-player -p <PORT> ``` #### Modifier l'adresse d'écoute Par défaut, le lecteur écoute uniquement les connexions provenant de la machine locale. Nous ne recommandons pas d'ouvrir le lecteur à d'autres machines. Si vous souhaitez tout de même modifier l'adresse d'écoute, vous pouvez le faire avec `-b`:```sh pyrdp-player -b <ADDRESS> ``` #### Autres arguments du player Exécutez `pyrdp-player --help` pour une liste complète des arguments. ### Utilisation du cloner de certificat PyRDP NOTE: L'utilisation de cet outil est optionnelle. Depuis la version 1.0, PyRDP génère des certificats à la volée exactement comme cet outil le ferait. Le cloner de certificat PyRDP crée un tout nouveau certificat X509 en utilisant les valeurs d'un certificat de serveur RDP existant. Il se connecte à un serveur RDP, télécharge son certificat, génère une nouvelle clé privée et remplace la clé publique et la signature du certificat en utilisant la nouvelle clé privée. Cela peut être utilisé lors d'un pentest si, par exemple, vous essayez de tromper un utilisateur légitime pour qu'il passe par votre MITM. Utiliser un certificat qui ressemble à un certificat légitime pourrait augmenter votre taux de réussite. #### Clonage d'un certificat Vous pouvez cloner un certificat en utilisant `pyrdp-clonecert` :```sh pyrdp-clonecert 192.168.1.10 cert.pem -o key.pem ``` Le paramètre `-o` définit le nom du chemin à utiliser pour la clé privée générée. #### Utilisation d'une clé privée personnalisée Si vous souhaitez utiliser votre propre clé privée au lieu d'en générer une nouvelle :```sh pyrdp-clonecert 192.168.1.10 cert.pem -i input_key.pem ``` #### Autres arguments du cloner Exécutez `pyrdp-clonecert --help` pour obtenir la liste complète des arguments. ### Utilisation de PyRDP Convert `pyrdp-convert` est un script utilitaire qui effectue plusieurs conversions utiles depuis différents formats d'entrée vers différents formats de sortie. Le script a la meilleure chance de fonctionner sur le trafic capturé par PyRDP en raison des fonctionnalités du protocole RDP non prises en charge qui pourraient être utilisées dans une connexion non interceptée. Les entrées suivantes sont prises en charge : - Capture réseau (PCAP) avec secrets maîtres TLS (moins fiable) - Capture réseau (PCAP) au format Exported PDUs Layer 7 (plus fiable) - Fichier de rejeu généré par PyRDP Les sorties suivantes sont prises en charge : - Fichier vidéo MP4 - JSON : une séquence d'événements de bas niveau sérialisée au format JSON - Fichier de rejeu compatible avec `pyrdp-player` Les captures réseau chiffrées (TLS) nécessitent que les secrets maîtres TLS soient fournis en utilisant `--secrets ssl.log`.```sh # Export the session coming client 10.2.0.198 to a .pyrdp file. pyrdp-convert --src 10.2.0.198 --secrets ssl.log -o path/to/output capture.pcap # Or as an MP4 video pyrdp-convert --src 10.2.0.198 --secrets ssl.log -o path/to/output -f mp4 capture.pcap # List the sessions in a network trace, along with the decryptable ones. pyrdp-convert --list-only capture.pcap ``` Notez que la conversion MP4 nécessite libavcodec et ffmpeg, cela peut donc nécessiter des étapes supplémentaires sous Windows. Les traces réseau déchiffrées manuellement peuvent être exportées depuis Wireshark en sélectionnant `File > Export PDUs` et en choisissant `OSI Layer 7`. Tout d'abord, assurez-vous d'avoir configuré Wireshark pour charger les secrets TLS : ![Configure TLS secrets log](https://assets.kitploit.com/production/public/readmes/2804/a1879de263d379e8ddd92a3136aa71696eed7b5e6d08627c235f1ae002bbdebd.png) Ensuite, exportez les PDU de la couche OSI 7 : ![Export OSI Layer 7](https://assets.kitploit.com/production/public/readmes/2804/1ad4cf5aac57e4c9cde86cd9e66ab816421d47e7700ff7a233171d0c9e651db1.png) Et éventuellement, filtrez la trace pour ne contenir que la ou les conversations d'intérêt en appliquant un filtre d'affichage et en cliquant sur `File > Export Specified Packets...` ![Optionally filtering the exported trace](https://assets.kitploit.com/production/public/readmes/2804/5eec655f453a4ab364f63d6fa374ede3bfc66c17ba5b13671c362956bdae089b.png) Maintenant, cette trace peut être utilisée directement dans `pyrdp-convert`. ### Configuration de PyRDP La plupart de la configuration de PyRDP se fait via les options de ligne de commande, mais il est également possible d'utiliser un fichier de configuration pour certains paramètres tels que la configuration des logs. Les fichiers de configuration par défaut utilisés par PyRDP se trouvent dans [mitm.default.ini](https://github.com/gosecure/pyrdp/blob/main/pyrdp/mitm/mitm.default.ini) et [player.default.ini](https://github.com/gosecure/pyrdp/blob/main/pyrdp/player/player.default.ini). Les deux fichiers sont entièrement documentés et peuvent servir de base pour une configuration plus poussée. À l'avenir, il est prévu de prendre en charge d'autres aspects de la configuration de PyRDP via ces fichiers de configuration. ### Utilisation avancée #### Utiliser PyRDP comme une bibliothèque Si vous souhaitez expérimenter avec RDP et créer vos propres outils, rendez-vous dans notre [section documentation](https://github.com/gosecure/pyrdp/blob/main/docs/README.md) pour plus d'informations. #### Utiliser PyRDP avec twistd Le composant MITM de PyRDP a également été implémenté comme un plugin twistd. Cela permet de l'exécuter en mode débogage et d'obtenir un REPL de débogage interactif (pdb) si vous envoyez un `SIGUSR2` au processus twistd. Consultez la [documentation twistd](https://github.com/gosecure/pyrdp/blob/main/docs/twistd.md) pour plus d'informations. #### Utiliser PyRDP avec Bettercap Nous avons développé notre propre module Bettercap, `rdp.proxy`, pour monster-in-the-middle toutes les connexions RDP sur un LAN donné. Consultez [ce document](https://github.com/gosecure/pyrdp/blob/main/docs/bettercap-rdp-mitm.md) pour plus d'informations. ### Instructions spécifiques à Docker Étant donné que Docker restreint les interactions avec le système hôte (système de fichiers et réseau), l'image Docker PyRDP doit être exécutée avec certains paramètres en fonction de votre cas d'utilisation. Cette section documente ces paramètres. Nous faisons référence à l'image Docker fournie publiquement, mais si vous avez [construit la vôtre](https://github.com/gosecure/pyrdp/blob/main/docs/devel.adoc), remplacez `gosecure/pyrdp` par le nom de votre image construite localement. #### Mappage d'un port d'écoute Dans la plupart des cas de monster-in-the-middle, vous devrez mapper un port de votre hôte vers l'image Docker. Cela se fait via les paramètres `--publish` (`-p`) appliqués à `docker run`. Par exemple, pour écouter sur le port 3389 (port par défaut de RDP) sur toutes les interfaces, utilisez :```sh docker run -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10 ``` #### Stockage des journaux et artefacts Pour stocker la sortie de PyRDP de manière permanente (journaux, fichiers, etc.), ajoutez l'option `--volume` (`-v`) à la commande précédente. Dans cet exemple, nous stockons les fichiers par rapport au répertoire courant dans `pyrdp_output`:```sh docker run -v $PWD/pyrdp_output:/home/pyrdp/pyrdp_output -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10 ``` Assurez-vous que votre répertoire de destination appartient à un utilisateur avec un UID de 1000, sinon vous obtiendrez des erreurs de permission refusée. Si vous êtes le seul utilisateur non-root sur le système, généralement votre utilisateur se verra attribuer l'UID 1000. #### Journalisation de l'adresse IP de l'hôte Si vous souhaitez que PyRDP enregistre l'adresse IP de l'hôte dans ses journaux, vous pouvez définir la variable d'environnement `HOST_IP` lors de l'utilisation de `docker run` :```sh docker run -p 3389:3389 -e HOST_IP=192.168.1.9 gosecure/pyrdp pyrdp-mitm 192.168.1.10 ``` #### Utilisation du lecteur GUI dans Docker L'utilisation du lecteur nécessite d'exporter la variable d'environnement `DISPLAY` de l'hôte vers le conteneur Docker. Cela redirige l'interface graphique du lecteur vers l'écran de l'hôte. Vous devez également exposer le réseau de l'hôte et empêcher Qt d'utiliser l'extension de mémoire partagée MIT-SHM X11. Pour ce faire, ajoutez les options `-e` et `--net` à la commande run :```sh docker run -e DISPLAY=$DISPLAY -e QT_X11_NO_MITSHM=1 --net=host gosecure/pyrdp pyrdp-player ``` Gardez à l'esprit que l'exposition du réseau de l'hôte à docker peut compromettre l'isolation entre votre conteneur et l'hôte. Si vous prévoyez d'utiliser le lecteur, le transfert X11 via une connexion SSH serait une manière plus sécurisée. #### Conversion de vidéos dans Docker Le processus de conversion vidéo repose sur PyAV, ffmpeg et QT, vous avez donc besoin de l'image Docker standard, pas de la version allégée. Vous avez besoin d'un montage de volume (`-v`) pour partager des fichiers avec le conteneur. Ici, nous mappons notre répertoire local avec `/shared/` dans le conteneur.```sh docker run -e QT_QPA_PLATFORM=offscreen -v $PWD/:/shared gosecure/pyrdp pyrdp-convert -f mp4 <filename-relative-to-volume-in-/shared/> -o /shared/ ``` La variable d'environnement `QT_QPA_PLATFORM=offscreen` est requise [en raison d'un bogue documenté ici](https://github.com/GoSecure/pyrdp/issues/428). Elle indique à QT qu'il est correct qu'aucun environnement d'affichage ne soit disponible. ## PyRDP Lore * [Article de blog d'introduction](https://www.gosecure.net/blog/2018/12/19/rdp-man-in-the-middle-smile-youre-on-camera) dans lequel nous avons [démontré que nous pouvions attraper un véritable acteur malveillant en action](https://www.youtube.com/watch?v=eB7RC9FmL6Q) * [Conférence à NorthSec 2019](https://docs.google.com/presentation/d/1avcn8Sh2b3IE7AA0G9l7Cj5F1pxqizUm98IbXUo2cvY/edit#slide=id.g404b70030f_0_581) où deux démonstrations ont été réalisées : * [Première démo](https://youtu.be/5JztJzi-m48) : enregistrement des identifiants, vol du presse-papiers, navigation dans les fichiers côté client et prise de contrôle de session * [Deuxième démo](https://youtu.be/bU67tj1RkMA) : l'exécution de payloads cmd ou powershell lorsqu'un client s'authentifie avec succès * [Logo PyRDP](https://github.com/gosecure/pyrdp/blob/main/docs/pyrdp-logo.png) sous licence CC-BY-SA 4.0. * [Diapositives BlackHat USA Arsenal 2019](https://docs.google.com/presentation/d/17P_l2n-hgCehQ5eTWilru4IXXHnGIRTj4ftoW4BiX5A/edit?usp=sharing) * [Diapositives DerbyCon 2019](https://docs.google.com/presentation/d/1UAiN2EZwDcmBjLe_t5HXB0LzbNclU3nnigC-XM4neIU/edit?usp=sharing) ([Vidéo](https://www.youtube.com/watch?v=zgt3N6Nrnss)) * [Blog : PyRDP en pilote automatique](https://www.gosecure.net/blog/2020/02/26/pyrdp-on-autopilot-unattended-credential-harvesting-and-client-side-file-stealing/) * [Blog : PyRDP 1.0](https://www.gosecure.net/blog/2020/10/20/announcing-pyrdp-1-0/) * [Demo Labs DefCon 2020](https://www.youtube.com/watch?v=1q2Eo3x3u0g) * [Blog : Capture des hashs NetNTLMv2 RDP : Détails de l'attaque et guide technique](https://www.gosecure.net/blog/2022/01/17/capturing-rdp-netntlmv2-hashes-attack-details-and-a-technical-how-to-guide/) * [Diapositives BlackHat USA Arsenal 2021](https://gosecure.github.io/presentations/2021-08-05_blackhat-usa/BlackHat-USA-21-Arsenal-PyRDP-OlivierBilodeau.pdf) * [Présentation : I Watched You Roll the Die: Unparalleled RDP Monitoring Reveal Attackers' Tradecraft](http://i.blackhat.com/BH-US-23/Presentations/US-23-Bilodeau-I-Watched-You-Roll-the-Die-Unparalleled-RDP-Monitoring.pdf) à BlackHat USA 2023 ## Contribuer à PyRDP Voir nos [directives de contribution](https://github.com/gosecure/pyrdp/blob/main/CONTRIBUTING.md). ## Remerciements PyRDP utilise du code provenant des logiciels open-source suivants : - [RC4-Python](https://github.com/bozhu/RC4-Python) pour l'implémentation de RC4. - [rdesktop](https://github.com/rdesktop/rdesktop) pour la décompression des bitmaps. - [rdpy](https://github.com/citronneur/rdpy) pour les clés RC4, les liaisons de décompression des bitmaps et le code GUI de base pour le lecteur PyRDP. - [FreeRDP](https://github.com/FreeRDP/FreeRDP) pour l'énumération des codes de balayage.

pyrdp

Populaires

Table des matières

Systèmes pris en charge

Installation

Utilisation de pipx

Dépendances

Linux

Full install (GUI, convert captures to video)

Slim install (no GUI, no conversion to video possible)

Windows

Connexions Monster-in-the-Middle Network Level Authentication (NLA)

Monster-in-the-Middle NLA

Capture des hashs NetNTLMv2

Connexion au lecteur PyRDP