Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
pyrdp — RDP monster-in-the-middle (mitm) e libreria per Python con la possibilità di osservare le connessioni in tempo reale o a posteriori | Kitploit
Strumenti/GitHubGitHub/gosecure/pyrdp
ExploitNetwork ForensicsRaccolta InformazioniSicurezza di ReteAnalisi MalwareCTFPenetration TestingApprendimento e FormazioneRed TeamingRisposta agli IncidentiSviluppo PayloadLab e Pratica
1.8k272223 mesi faRevisionato da Kitploit
GitHubgosecure/pyrdp

pyrdp

RDP monster-in-the-middle (mitm) e libreria per Python con la possibilità di osservare le connessioni in tempo reale o a posteriori

Vedi RepositorySito web

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

PyRDP

Tests Black Hat Arsenal 2019 Black Hat Arsenal 2021 Black Hat Arsenal 2022

PyRDP è uno strumento e libreria Python per il Monster-in-the-Middle (MITM) del Remote Desktop Protocol (RDP).

PyRDP Logo

Include alcuni strumenti:

  • RDP Monster-in-the-Middle
    • Registra le credenziali in testo chiaro o gli hash NetNTLM utilizzati durante la connessione
    • Intercetta i dati copiati negli appunti
    • Salva una copia dei file trasferiti sulla rete
    • Esplora le unità condivise in background e le salva localmente
    • Salva replay delle connessioni per poterli consultare in seguito
    • Esegue comandi console o payload PowerShell automaticamente sulle nuove connessioni
  • RDP Player:
    • Visualizza le connessioni RDP in tempo reale dal MITM
    • Riproduce i replay delle connessioni RDP
    • Prende il controllo delle sessioni RDP attive nascondendo le proprie azioni
    • Elenca le unità mappate del client e scarica file da esse durante le sessioni attive
  • Strumento di conversione:
    • Converte i replay RDP in video per una condivisione più semplice
    • Converte i replay RDP in una sequenza di eventi di basso livello serializzati in formato JSON
    • Converte i PCAP in replay, video o eventi JSON
    • Converte i PCAP decriptati (PDU L7) in replay, video o eventi JSON
  • RDP Certificate Cloner:
    • Crea un certificato X509 autofirmato con gli stessi campi del certificato di un server RDP
  • 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.

    Replica di una sessione RDP con PyRDP Player

    Indice

    • Sistemi supportati
    • Installazione
      • Usando pipx
      • Usando l'immagine Docker
    • Usare PyRDP
      • Usare PyRDP Monster-in-the-Middle
      • Usare PyRDP Player
      • Usare PyRDP Certificate Cloner
      • Usare PyRDP Convert
      • Configurare PyRDP
      • Utilizzo avanzato
      • Istruzioni specifiche per Docker
    • Storia di PyRDP
    • Contribuire a PyRDP
    • Ringraziamenti

    Sistemi supportati

    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.

    Installazione

    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.

    Usando pipx

    Dipendenze

    Linux

    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

    Full install (GUI, convert captures to video)

    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

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

    sudo apt install python3 python3-pip python3-venv
    build-essential python3-dev git openssl

    root@kitploit:~
    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
    
    Windows

    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

    root@kitploit:~
    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

    root@kitploit:~
    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

    root@kitploit:~
    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

    root@kitploit:~
    * `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
    
    Connessioni Monster-in-the-Middle con autenticazione a livello di rete (NLA)

    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:

    • Ottenere il certificato e la chiave privata del server
    • Utilizzare una funzionalità di reindirizzamento dell'host
    • Catturare l'hash NetNTLMv2 del client e craccarlo
    Monster-in-the-Middle NLA

    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>

    root@kitploit:~
    Ciò permetterà di intercettare le connessioni con NLA applicato.
    
    ###### Reindirizzamento host alternativo quando il server applica NLA
    
    ![Diagramma che spiega il reindirizzamento NLA](https://assets.kitploit.com/production/public/readmes/2804/e74aa87cc1cfb892b9070fe387c9530e4e99973b2d780b72f6c118abf1ec8a5b.png)
    
    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.

    Acquisizione di hash NetNTLMv2

    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.

    Connessione al player PyRDP

    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

    root@kitploit:~
    ##### 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
    

    Esecuzione di payload su nuove connessioni

    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:

    1. Attendi che l'utente sia autenticato.
    2. Blocca l'input/output del client per nascondere il payload e prevenire interferenze.
    3. Invia una sequenza finta Windows+R ed esegui cmd.exe.
    4. Esegui il payload come comando console ed esci dalla console. Se è configurato un payload PowerShell, viene eseguito con powershell -enc <PAYLOAD>.
    5. Attendi un po' per consentire il completamento del payload.
    6. Ripristina l'input/output del client.

    Affinché funzioni, è necessario impostare 3 argomenti:

    • il payload
    • il ritardo prima dell'avvio del payload
    • la durata del payload
    Impostazione del payload

    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 PowerShell
    Scelta del momento di avvio del payload

    Per 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

    root@kitploit:~
    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à.

    Altri argomenti MITM

    Esegui pyrdp-mitm --help per una lista completa di argomenti.

    --no-downgrade

    Questo 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:

    • Registrazione dei tasti premuti
    • Aggiornamenti della posizione del mouse
    • Accesso agli appunti (passivo)
    • Accesso alle unità (passivo)

    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:

    • Crittografia FIPS
    • Protocolli di crittografia non TLS
    • Compressione ClientInfo
    • Compressione dei canali virtuali

    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.

    --transparent

    Indica 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 accelerata

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

    Utilizzo del PyRDP Player

    Usa pyrdp-player per eseguire il player.

    Riproduzione di un file di replay

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

    root@kitploit:~
    #### 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>
    

    Cambiare l'indirizzo di ascolto

    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

    root@kitploit:~
    #### 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.

    Utilizzare una chiave privata personalizzata

    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

    root@kitploit:~
    #### 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:

    Configura il log dei segreti TLS

    Successivamente, esporta i PDU del livello OSI 7:

    Esporta il 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...

    Filtraggio opzionale della traccia esportata

    Ora questa traccia può essere usata direttamente in pyrdp-convert.

    Configurazione di PyRDP

    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.

    Utilizzo Avanzato

    Utilizzare PyRDP come Libreria

    Se sei interessato a sperimentare con RDP e creare i tuoi strumenti, vai alla nostra sezione documentazione per maggiori informazioni.

    Utilizzare PyRDP con twistd

    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.

    Utilizzare PyRDP con Bettercap

    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.

    Istruzioni d'Uso Specifiche per Docker

    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.

    Mappatura di una Porta in Ascolto

    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

    root@kitploit:~
    #### 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.

    Registrazione dell'indirizzo IP dell'host

    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

    root@kitploit:~
    #### 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.

    Conversione di video in Docker

    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/

    root@kitploit:~
    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.
    
    Scarica lo strumento