RDP monster-in-the-middle (mitm) e libreria per Python con la possibilità di osservare le connessioni in tempo reale o a posteriori
PyRDP è uno strumento e libreria Python per il Monster-in-the-Middle (MITM) del Remote Desktop Protocol (RDP).
Include alcuni strumenti:
PyRDP è stato introdotto nel 2018 in cui abbiamo dimostrato di poter catturare un vero attore di minacce in azione. Questo strumento viene sviluppato pensando sia ai casi d'uso di pentest che di ricerca sui malware.

PyRDP dovrebbe funzionare su Python 3.7 e successive sulle piattaforme x86-64, ARM e ARM64.
Questo strumento è stato testato su Python 3.7 su Linux (Ubuntu 20.04, 22.04), Raspberry Pi e Windows. Non è stato testato su macOS.
Sono consigliate due tecniche di installazione: tramite pipx o usando container Docker.
L'installazione dal sorgente o la creazione di container Docker personalizzati sono trattate nella documentazione di sviluppo.
Per prima cosa, assicurati di installare i pacchetti prerequisiti (sono elencati per Ubuntu 22.04, potrebbe essere necessario adattarli per altre distribuzioni). Forniamo due tipi di installazione: una completa e una ridotta. Installa le dipendenze in base al tuo caso d'uso.```sh
sudo apt install python3 python3-pip python3-venv
build-essential python3-dev openssl
libegl1 libxcb-cursor0 libxkbcommon-x11-0 libxcb-icccm4 libxcb-keysyms1
libnotify-bin
libavcodec58 libavdevice58
sudo apt install python3 python3-pip python3-venv
build-essential python3-dev git openssl
Questo dovrebbe installare le dipendenze necessarie per eseguire PyRDP. Se scegli di installare senza le dipendenze GUI o di conversione video, non sarà possibile utilizzare `pyrdp-player` senza la modalità headless (`--headless`) o `pyrdp-convert` per produrre output video. Assicurati di avere `pipx` installato. Su Ubuntu 22.04:```sh
python3 -m pip install --user pipx
python3 -m pipx ensurepath
Assicurati di avere Python installato. Python da Windows Store non ha funzionato per me su Windows 11. Consigliamo di installare Python tramite Scoop.```sh scoop install python # if not installed already scoop install pipx pipx ensurepath
Disconnettiti e riconnettiti (per aggiornare il PATH).
##### Altri sistemi operativi
Per installare `pipx` su altri sistemi operativi vedi qui: <https://github.com/pypa/pipx#install-pipx>
#### Installazione
Per l'esperienza completa di PyRDP con l'interfaccia QT e la possibilità di convertire le catture in video:```sh
pipx install pyrdp-mitm[full]
Per la versione compatta pensata per essere eseguita in ambienti headless (server, RaspberryPi):```sh pipx install pyrdp-mitm
You are ready to go! See the [usage instructions](#using-pyrdp).
### Utilizzo dell'immagine Docker
Questo è il metodo di installazione più semplice se hai docker installato e funzionante.```sh
docker pull gosecure/pyrdp:latest
In alternativa abbiamo un'immagine più snella senza interfaccia grafica e dipendenze ffmpeg. Questa è l'unica immagine fornita su piattaforme ARM.```sh docker pull gosecure/pyrdp:latest-slim
Puoi trovare l'elenco di tutte le nostre immagini Docker [sulla pagina gosecure/pyrdp di DockerHub](https://hub.docker.com/r/gosecure/pyrdp/tags).
Il tag `latest` si riferisce all'ultima versione rilasciata, mentre il tag `devel` è l'immagine docker costruita a partire dal nostro branch `main`.
## Utilizzo di PyRDP
### Utilizzo del Monster-in-the-Middle di PyRDP
Usa `pyrdp-mitm <ServerIP>` o `pyrdp-mitm <ServerIP>:<ServerPort>` per eseguire il MITM.
Supponendo di avere un server RDP in esecuzione su `192.168.1.10` e in ascolto sulla porta 3389, dovresti eseguire:```sh
pyrdp-mitm 192.168.1.10
Quando si esegue il MITM per la prima volta, verrà creata una directory chiamata pyrdp_output/ relativa alla directory di lavoro corrente. Ecco un esempio di layout di quella directory:```sh
pyrdp_output/
├── certs
│ ├── WinDev2108Eval.crt
│ └── WinDev2108Eval.pem
├── files
│ ├── e91c6a5eb3ca15df5a5cb4cf4ebb6f33b2d379a3a12d7d6de8c412d4323feb4c
│ ├── b14b26b7d02c85e74ab4f0d847553b2fdfaf8bc616f7c3efcc4771aeddd55700
├── filesystems
│ ├── romantic_kalam_8214773
│ │ └── device1
│ │ └── clipboard
| └── priv-esc.exe -> ../../../files/b14b26b7d02c85e74ab4f0d847553b2fdfaf8bc616f7c3efcc4771aeddd55700
│ └── happy_stonebraker_1992243
│ ├── device1
│ └── device2
| └── Users/User/3D Objects/desktop.ini -> ../../../../../../e91c6a5eb3ca15df5a5cb4cf4ebb6f33b2d379a3a12d7d6de8c412d4323feb4c
├── logs
│ ├── crawl.json
│ ├── crawl.log
│ ├── mitm.json
│ ├── mitm.log
│ ├── mitm.log.2021-08-26
│ ├── ntlmssp.log
│ ├── player.log
│ └── ssl.log
└── replays
├── rdp_replay_20231214_01-20-28_965_happy_stonebraker_1992243.pyrdp
└── rdp_replay_20231214_00-42-24_295_romantic_kalam_8214773.pyrdp
* `certs/` contiene i certificati generati memorizzati usando il `CN` del certificato come nome del file
* `files/` contiene tutti i file catturati e sono deduplicati salvandoli usando l'hash SHA-256 del contenuto come nome del file
* `filesystems/` contiene una ricostruzione del filesystem dei target classificati per ID di sessione.
Per risparmiare spazio su sessioni simili, i file sono collegamenti simbolici ai file effettivi in `files/`.
* `logs/` contiene tutti i vari log, la maggior parte in formato JSON e testo semplice:
* `crawl`: il log del crawler di file
* `mitm`: il log principale del MITM
* `ntlmssp.log`: gli hash NetNTLM catturati
* `player.log`: il log del player
* `ssl.log`: i segreti master TLS memorizzati in un formato compatibile con Wireshark
* `replays/` contiene tutte le sessioni PyRDP registrate in precedenza con timestamp e ID di sessione nel nome del file
#### Specificare la chiave privata e il certificato
Se la generazione delle chiavi non ha funzionato o desideri utilizzare una chiave e un certificato personalizzati, puoi specificarli usando gli argomenti `-c` e `-k`:```sh
pyrdp-mitm 192.168.1.10 -k private_key.pem -c certificate.pem
L'autenticazione a livello di rete (NLA) è una funzionalità di sicurezza disponibile da Windows Vista che aggiunge sicurezza alle connessioni RDP. NLA si basa sul nuovo provider di supporto per la sicurezza CredSSP e a volte viene indicato con questo nome. Un server che impone la NLA è più difficile da attaccare. Esistono tre diverse strategie che possono essere utilizzate:
Se abbiamo accesso al certificato e alla chiave privata del server, possiamo eseguire con successo un MITM su RDP anche se la NLA è imposta. Abbiamo documentato questo attacco nel nostro post del blog del rilascio 1.0. Le istruzioni per estrarre il certificato RDP e la chiave privata sono disponibili sul nostro GitHub.
Con il certificato e la chiave privata accessibili, è sufficiente impostare l'autenticazione su ssp aggiungendo questo sulla riga di comando di pyrdp-mitm:```sh
--auth ssp -c <certificate.pem> -k <private-key.pem>
Ciò permetterà di intercettare le connessioni con NLA applicato.
###### Reindirizzamento host alternativo quando il server applica NLA

Quando PyRDP si connette al server RDP di destinazione (1), se quel server applica NLA, PyRDP (2) sostituirà la connessione per andare invece su un altro host a tua scelta (3).
Ad esempio, questo può essere usato per reindirizzare verso un server noto per non applicare NLA, o potrebbe persino reindirizzare verso una VM sotto il controllo di un attaccante.
Per abilitare questa funzionalità, specifica l'indirizzo e la porta dell'host alternativo in questo modo:```sh
--nla-redirection-host 192.168.1.12 --nla-redirection-port 3389
Questa funzionalità è stata introdotta in PyRDP 1.1.0.
Gli hash NetNTLMv2 sono utili per un attaccante poiché possono essere craccati con relativa facilità, consentendo agli aggressori di sfruttare l'accesso RDP legittimo o tentare di riempire le credenziali.
A partire dalla versione 1.1.0, PyRDP è in grado di catturare gli hash NetNTLMv2 del client tramite una connessione NLA (CredSSP) effettuando la negoziazione e catturando i messaggi di autenticazione NTLMSSP.
Nella versione 1.2.0, questo supporto è stato esteso per funzionare anche se non si dispone del certificato e della chiave privata del server, il che significa che la connessione non sarà un MITM riuscito.
Questo è simile a ciò che fa Responder con RDP.
L'hash NetNTLMv2 catturato può essere trovato nel file di log ntlmssp.log ed è formattato in modo che strumenti di cracking come John The Ripper o hashcat possano elaborarlo.
Questa tecnica è stata descritta in dettaglio in un post del blog: Capturing RDP NetNTLMv2 Hashes: Attack details and a Technical How-To Guide
Questa funzionalità è compatibile con --auth ssp ma incompatibile con --nla-redirection-host.
Se desideri vedere le connessioni RDP in tempo reale attraverso il player PyRDP, dovrai specificare l'indirizzo IP e la porta su cui il
player è in ascolto utilizzando gli argomenti -i e -d. Nota: l'argomento della porta è facoltativo, la porta predefinita è 3000.```sh
pyrdp-mitm 192.168.1.10 -i 127.0.0.1 -d 3000
##### Connessione a un player PyRDP quando il MITM è in esecuzione su un server
Se stai eseguendo il MITM su un server e vuoi comunque vedere le connessioni RDP in tempo reale, dovresti usare il [port forwarding remoto SSH](https://www.booleanworld.com/guide-ssh-port-forwarding-tunnelling/) per inoltrare una porta del tuo server verso la porta del player sulla tua macchina. Una volta fatto, passa `127.0.0.1` e la porta inoltrata come argomenti al MITM. Ad esempio, se la porta 4000 sul server viene inoltrata verso la porta del player sulla tua macchina, questo è il comando da usare:```sh
pyrdp-mitm 192.168.1.10 -i 127.0.0.1 -d 4000
PyRDP supporta l'esecuzione automatica di comandi console o payload PowerShell quando vengono stabilite nuove connessioni. A causa della natura di RDP, il processo è un po' rozzo e non sempre affidabile al 100%. Ecco come funziona:
cmd.exe.powershell -enc <PAYLOAD>.Affinché funzioni, è necessario impostare 3 argomenti:
Puoi utilizzare uno dei seguenti argomenti per impostare il payload da eseguire:
--payload, una stringa contenente comandi console--payload-powershell, una stringa contenente comandi PowerShell--payload-powershell-file, un percorso a uno script PowerShellPer il momento, PyRDP non rileva quando l'utente ha effettuato l'accesso. Devi specificare un intervallo di tempo da attendere prima di eseguire il payload. Trascorso questo intervallo, invierà le sequenze fittizie di tasti e si aspetterà che il payload venga eseguito correttamente. Per fare ciò, si utilizza l'argomento --payload-delay. Il ritardo è in millisecondi. Ad esempio, se prevedi che l'utente abbia effettuato l'accesso entro i primi 5 secondi, dovresti utilizzare i seguenti argomenti:```sh
--payload-delay 5000
Ciò potrebbe essere reso più accurato sfruttando alcuni messaggi scambiati durante l'inizializzazione di RDPDR.
Vedi [questo problema](https://github.com/GoSecure/pyrdp/issues/98) se sei interessato a migliorare questo funzionamento.
##### Scegliere quando riprendere l'attività normale
Poiché non esiste un modo diretto per sapere quando la console ha smesso di funzionare, devi dire a PyRDP per quanto tempo vuoi che l'input / output del client venga bloccato. Ti consigliamo di impostare questo valore al massimo tempo che ti aspetteresti che la console che esegue il tuo payload sia visibile. In altre parole, il tempo che ti aspetteresti per il completamento del tuo payload.
Per impostare la durata del payload, usi l'argomento `--payload-duration` con un periodo di tempo in millisecondi.
Ad esempio, se prevedi che il tuo payload impieghi fino a 5 secondi per completarsi, useresti il seguente argomento:```sh
--payload-duration 5000
Questo bloccherà l'input / output del client per 5 secondi per nascondere la console e prevenire interferenze. Dopo 5 secondi, l'input / output verrà ripristinato alla normalità.
Esegui pyrdp-mitm --help per una lista completa di argomenti.
--no-downgradeQuesto argomento è utile quando si esegue PyRDP in scenari Honeypot per evitare il fingerprinting degli scanner. Quando l'opzione è abilitata, PyRDP non declasserà le estensioni non supportate e lascerà passare il traffico in modo trasparente. Il player probabilmente non sarà in grado di riprodurre correttamente il traffico video, ma i seguenti canali supportati dovrebbero essere ancora accessibili:
Questa funzionalità è ancora in fase di sviluppo e alcuni declassamenti sono attualmente inevitabili per consentire alla connessione di essere stabilita. I seguenti elementi non sono attualmente influenzati da questa opzione e rimarranno disabilitati:
NOTA: Se è importante poter riprodurre in futuro l'intera sessione, una buona soluzione è registrare il traffico RDP grezzo utilizzando Wireshark e conservare i segreti master TLS. Quando PyRDP aggiungerà il supporto per ulteriori estensioni, sarà possibile estrarre un file di riproduzione RDP valido dalla cattura di rete grezza.
--transparentIndica a PyRDP di tentare di falsificare l'indirizzo IP sorgente del client in modo che il server veda l'indirizzo IP reale invece di quello del MITM. Questa opzione è utile solo in determinati scenari in cui il MITM è fisicamente un gateway tra i client e il server e vede tutto il traffico. Esempi specifici possono essere trovati qui.
NOTA: Questo richiede privilegi di root, funziona solo su Linux e richiede la configurazione manuale del firewall per garantire che il traffico sia instradato correttamente.
--no-gdi: Disabilita la pipeline grafica accelerataPyRDP declassa il video alla pipeline grafica più recente che supporta. Questa opzione dice esplicitamente al MITM di non utilizzare le estensioni Graphics Device Interface Acceleration per lo streaming video. Il vantaggio di questa modalità è una significativa riduzione della larghezza di banda richiesta per connessioni ad alta risoluzione.
Nota che alcuni ordini di disegno GDI sono attualmente non implementati perché sembrano non essere utilizzati. Se hai una riproduzione che contiene un ordine non supportato o non testato, non esitare a condividerlo con i manutentori del progetto in modo che il supporto possa essere aggiunto secondo necessità. (Assicurati che la traccia non contenga informazioni sensibili)
Usa pyrdp-player per eseguire il player.
Puoi usare il menu per aprire un nuovo file di replay: File > Apri.
Puoi anche aprire file di replay all'avvio del player:```sh pyrdp-player ...
#### Ascolto delle connessioni live
Il giocatore ascolta sempre le connessioni live. Di default, la porta di ascolto è 3000, ma può essere modificata:```sh
pyrdp-player -p <PORT>
Per impostazione predefinita, il lettore ascolta solo le connessioni provenienti dalla macchina locale. Sconsigliamo di aprire il lettore
ad altre macchine. Se si desidera comunque cambiare l'indirizzo di ascolto, è possibile farlo con -b:```sh
pyrdp-player -b
#### Altri argomenti del player
Esegui `pyrdp-player --help` per un elenco completo degli argomenti.
### Utilizzo del Cloner di Certificati PyRDP
NOTA: L'uso di questo strumento è opzionale.
Dalla versione 1.0, PyRDP genera certificati al volo esattamente come farebbe questo strumento.
Il cloner di certificati PyRDP crea un nuovo certificato X509 utilizzando i valori del certificato di un server RDP esistente.
Si connette a un server RDP, scarica il suo certificato, genera una nuova chiave privata e sostituisce la
chiave pubblica e la firma del certificato utilizzando la nuova chiave privata. Questo può essere utilizzato in un penetration test se, ad esempio,
si sta cercando di ingannare un utente legittimo per farlo passare attraverso il tuo MITM. Utilizzare un certificato che assomiglia a un certificato
legittimo potrebbe aumentare il tasso di successo.
#### Clonazione di un certificato
È possibile clonare un certificato utilizzando `pyrdp-clonecert`:```sh
pyrdp-clonecert 192.168.1.10 cert.pem -o key.pem
Il parametro -o definisce il nome del percorso da utilizzare per la chiave privata generata.
Se vuoi utilizzare la tua chiave privata invece di generarne una nuova:```sh pyrdp-clonecert 192.168.1.10 cert.pem -i input_key.pem
#### Altri argomenti del cloner
Esegui `pyrdp-clonecert --help` per un elenco completo di argomenti.
### Utilizzo di PyRDP Convert
`pyrdp-convert` è uno script helper che esegue diverse conversioni utili da vari formati di input a vari formati di output.
Lo script ha le migliori possibilità di funzionare su traffico catturato da PyRDP a causa di funzionalità del protocollo RDP non supportate che potrebbero essere utilizzate in una connessione non intercettata.
I seguenti input sono supportati:
- Cattura di rete (PCAP) con segreti master TLS (meno affidabile)
- Cattura di rete (PCAP) in formato Exported PDUs Layer 7 (più affidabile)
- File di replay generato da PyRDP
I seguenti output sono supportati:
- File video MP4
- JSON: una sequenza di eventi di basso livello serializzati in formato JSON
- File di replay compatibile con `pyrdp-player`
Le catture di rete crittografate (TLS) richiedono che i segreti master TLS vengano forniti utilizzando `--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
Nota che la conversione MP4 richiede libavcodec e ffmpeg, quindi potrebbe richiedere passaggi aggiuntivi su Windows.
Le tracce di rete decriptate manualmente possono essere esportate da Wireshark selezionando File > Export PDUs e scegliendo OSI Layer 7.
Prima, assicurati di aver configurato Wireshark per caricare i segreti TLS:

Successivamente, esporta i PDU del livello OSI 7:

E opzionalmente, filtra la traccia per contenere solo le conversazioni di interesse applicando un filtro di visualizzazione e cliccando File > Export Specified Packets...

Ora questa traccia può essere usata direttamente in pyrdp-convert.
La maggior parte della configurazione di PyRDP viene effettuata tramite opzioni della riga di comando, ma è anche possibile utilizzare un file di configurazione per alcune impostazioni come la configurazione dei log.
I file di configurazione predefiniti utilizzati da PyRDP si trovano in mitm.default.ini e player.default.ini. Entrambi i file sono ampiamente documentati e possono servire come base per ulteriori configurazioni.
In futuro si prevede di supportare altri aspetti della configurazione di PyRDP attraverso quei file di configurazione.
Se sei interessato a sperimentare con RDP e creare i tuoi strumenti, vai alla nostra sezione documentazione per maggiori informazioni.
Il componente MITM di PyRDP è stato implementato anche come plugin twistd. Questo ti permette di eseguirlo in modalità debug e ti consente di ottenere un repl interattivo di debug (pdb) se invii un SIGUSR2 al processo twistd. Consulta la documentazione twistd per maggiori informazioni.
Abbiamo sviluppato il nostro modulo Bettercap, rdp.proxy, per fare monster-in-the-middle su tutte le connessioni RDP in una specifica LAN. Dai un'occhiata a questo documento per maggiori informazioni.
Poiché Docker limita le interazioni con il sistema host (filesystem e rete), l'immagine Docker di PyRDP deve essere eseguita con alcuni parametri a seconda del caso d'uso. Questa sezione documenta tali parametri.
Ci riferiamo all'immagine Docker fornita pubblicamente, ma se hai costruito la tua sostituisci gosecure/pyrdp con il nome della tua immagine costruita localmente.
Nella maggior parte dei casi di monster-in-the-middle, dovrai mappare una porta del tuo host nell'immagine Docker. Questo si ottiene con i parametri --publish (-p) applicati a docker run.
Ad esempio, per ascoltare sulla porta 3389 (la porta predefinita di RDP) su tutte le interfacce, usa:```sh docker run -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10
#### Archiviazione di Log e Artefatti
Per archiviare in modo permanente l'output di PyRDP (log, file, ecc.), aggiungi l'opzione `--volume` (`-v`) al comando precedente. In questo esempio archiviamo i file relativamente alla directory corrente in `pyrdp_output`:```sh
docker run -v $PWD/pyrdp_output:/home/pyrdp/pyrdp_output -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10
Assicurati che la directory di destinazione sia di proprietà di un utente con UID 1000, altrimenti riceverai errori di permesso negato. Se sei l'unico utente non root sul sistema, di solito al tuo utente verrà assegnato l'UID 1000.
Se vuoi che PyRDP registri l'indirizzo IP dell'host nei suoi log, puoi impostare la variabile d'ambiente HOST_IP quando usi docker run:```sh
docker run -p 3389:3389 -e HOST_IP=192.168.1.9 gosecure/pyrdp pyrdp-mitm 192.168.1.10
#### Utilizzare il player GUI in Docker
L'utilizzo del player richiede di esportare la variabile d'ambiente `DISPLAY` dall'host al docker. Questo reindirizza la GUI del player allo schermo dell'host. È inoltre necessario esporre la rete dell'host e impedire a Qt di utilizzare l'estensione di memoria condivisa MIT-SHM X11. Per farlo, aggiungi le opzioni `-e` e `--net` al comando run:```sh
docker run -e DISPLAY=$DISPLAY -e QT_X11_NO_MITSHM=1 --net=host gosecure/pyrdp pyrdp-player
Tieni presente che esporre la rete dell'host a docker può compromettere l'isolamento tra il contenitore e l'host. Se hai intenzione di utilizzare il player, l'inoltro X11 tramite una connessione SSH sarebbe un modo più sicuro.
Il processo di conversione video si basa su PyAV, ffmpeg e QT, quindi hai bisogno dell'immagine docker normale, non quella slim.
Hai bisogno di un mount di volume (-v) per condividere file con il contenitore.
Qui mappiamo la nostra directory locale con /shared/ nel contenitore.```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 variabile d'ambiente `QT_QPA_PLATFORM=offscreen` è richiesta [a causa di un bug documentato qui](https://github.com/GoSecure/pyrdp/issues/428). Dice a QT che è corretto che nessun ambiente di visualizzazione sia disponibile.
## PyRDP Lore
* [Introduction blog post](https://www.gosecure.net/blog/2018/12/19/rdp-man-in-the-middle-smile-youre-on-camera) in cui abbiamo [dimostrato di poter catturare un vero attore di minaccia in azione](https://www.youtube.com/watch?v=eB7RC9FmL6Q)
* [Talk at NorthSec 2019](https://docs.google.com/presentation/d/1avcn8Sh2b3IE7AA0G9l7Cj5F1pxqizUm98IbXUo2cvY/edit#slide=id.g404b70030f_0_581) dove sono state eseguite due demo:
* [First demo](https://youtu.be/5JztJzi-m48): registrazione delle credenziali, furto degli appunti, navigazione dei file lato client e presa di controllo della sessione
* [Second demo](https://youtu.be/bU67tj1RkMA): l'esecuzione di payload cmd o powershell quando un client si autentica con successo
* [PyRDP Logo](https://github.com/gosecure/pyrdp/blob/main/docs/pyrdp-logo.png) concesso in licenza CC-BY-SA 4.0.
* [Slide del BlackHat USA Arsenal 2019](https://docs.google.com/presentation/d/17P_l2n-hgCehQ5eTWilru4IXXHnGIRTj4ftoW4BiX5A/edit?usp=sharing)
* [Slide del DerbyCon 2019](https://docs.google.com/presentation/d/1UAiN2EZwDcmBjLe_t5HXB0LzbNclU3nnigC-XM4neIU/edit?usp=sharing) ([Video](https://www.youtube.com/watch?v=zgt3N6Nrnss))
* [Blog: PyRDP su pilota automatico](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/)
* [DefCon 2020 Demo Labs](https://www.youtube.com/watch?v=1q2Eo3x3u0g)
* [Blog: Cattura di hash RDP NetNTLMv2: Dettagli dell'attacco e guida tecnica passo-passo](https://www.gosecure.net/blog/2022/01/17/capturing-rdp-netntlmv2-hashes-attack-details-and-a-technical-how-to-guide/)
* [Slide del BlackHat USA Arsenal 2021](https://gosecure.github.io/presentations/2021-08-05_blackhat-usa/BlackHat-USA-21-Arsenal-PyRDP-OlivierBilodeau.pdf)
* [Presentazione: Ho guardato tirare i dadi: Monitoraggio RDP senza pari rivela l'arte degli attaccanti](http://i.blackhat.com/BH-US-23/Presentations/US-23-Bilodeau-I-Watched-You-Roll-the-Die-Unparalleled-RDP-Monitoring.pdf) al BlackHat USA 2023
## Contribuire a PyRDP
Vedi le nostre [linee guida per i contributi](https://github.com/gosecure/pyrdp/blob/main/CONTRIBUTING.md).
## Riconoscimenti
PyRDP utilizza codice dai seguenti software open-source:
- [RC4-Python](https://github.com/bozhu/RC4-Python) per l'implementazione di RC4.
- [rdesktop](https://github.com/rdesktop/rdesktop) per la decompressione delle bitmap.
- [rdpy](https://github.com/citronneur/rdpy) per le chiavi RC4, i binding di decompressione delle bitmap e il codice GUI di base per il player PyRDP.
- [FreeRDP](https://github.com/FreeRDP/FreeRDP) per l'enumerazione dei codici di scansione.