gosecure/pyrdpRDP monster-in-the-middle (mitm) e biblioteca para Python com a capacidade de observar conexões ao vivo ou posteriormente
PyRDP é uma ferramenta e biblioteca Python de Monstro-no-Meio (MITM) do Protocolo de Área de Trabalho Remota (RDP).
Ele apresenta algumas ferramentas:
PyRDP foi apresentado em 2018 no qual demonstramos que podemos capturar um ator de ameaça real em ação. Esta ferramenta está sendo desenvolvida com casos de uso de pesquisa em pentest e malware em mente.
PyRDP deve funcionar em Python 3.7 e superior nas plataformas x86-64, ARM e ARM64.
Esta ferramenta foi testada para funcionar em Python 3.7 no Linux (Ubuntu 20.04, 22.04), Raspberry Pi e Windows. Não foi testada no macOS.
Duas técnicas de instalação são recomendadas: via pipx ou usando contêineres Docker.
A instalação a partir do código fonte ou a construção de contêineres Docker por conta própria é abordada na documentação de desenvolvimento.
Primeiro, certifique-se de instalar os pacotes pré-requisitos (estes estão listados para Ubuntu 22.04, você pode precisar ajustar para outras distribuições). Fornecemos dois tipos de instalação: uma completa e uma enxuta. Instale as dependências de acordo com seu caso de 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
Isto deve instalar as dependências necessárias para executar o PyRDP. Se optar por
instalar sem as dependências de GUI ou conversão de vídeo, não será possível usar
`pyrdp-player` sem o modo headless (`--headless`) ou `pyrdp-convert` para produzir saída de vídeo.
Certifique-se de que tem o `pipx` instalado. No Ubuntu 22.04:```sh
python3 -m pip install --user pipx
python3 -m pipx ensurepath
Certifique-se de ter o Python instalado. O Python da Windows Store não funcionou para mim no Windows 11. Recomendamos instalar o Python via Scoop.```sh scoop install python # if not installed already scoop install pipx pipx ensurepath
Faça logout e login novamente (para atualizar seu PATH).
##### Outros SOs
Para instalar o `pipx` em outros sistemas operacionais, veja aqui: <https://github.com/pypa/pipx#install-pipx>
#### Instalação
Para a experiência completa do PyRDP com a interface gráfica QT e a capacidade de converter capturas em vídeo:```sh
pipx install pyrdp-mitm[full]
Para a versão compacta destinada a ser executada em ambientes headless (servidores, RaspberryPi):```sh pipx install pyrdp-mitm
Você está pronto para começar! Consulte as [instruções de uso](#using-pyrdp).
### Usando a Imagem Docker
Este é o método de instalação mais fácil se você tiver o docker instalado e funcionando.```sh
docker pull gosecure/pyrdp:latest
Como alternativa, temos uma imagem mais enxuta sem as dependências de GUI e ffmpeg. Esta é a única imagem fornecida em plataformas ARM.```sh docker pull gosecure/pyrdp:latest-slim
Você pode encontrar a lista de todas as nossas imagens Docker [na página gosecure/pyrdp no DockerHub](https://hub.docker.com/r/gosecure/pyrdp/tags).
A tag `latest` refere-se à versão mais recente lançada, enquanto a tag `devel` é a imagem Docker construída a partir do nosso branch `main`.
## Usando PyRDP
### Usando o PyRDP Monster-in-the-Middle
Use `pyrdp-mitm <ServerIP>` ou `pyrdp-mitm <ServerIP>:<ServerPort>` para executar o MITM.
Supondo que você tenha um servidor RDP rodando em `192.168.1.10` e ouvindo na porta 3389, você executaria:```sh
pyrdp-mitm 192.168.1.10
Ao executar o MITM pela primeira vez, um diretório chamado pyrdp_output/ será criado em relação ao diretório de trabalho atual. Aqui está um exemplo da estrutura desse diretório:```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/` contém os certificados gerados armazenados usando o `CN` do certificado como nome do arquivo
* `files/` contém todos os arquivos capturados e são desduplicados salvando-os usando o hash SHA-256 do conteúdo como nome do arquivo
* `filesystems/` contém uma recriação do sistema de arquivos dos alvos classificados por IDs de sessão.
Para economizar espaço em sessões semelhantes, os arquivos são links simbólicos para os arquivos reais em `files/`.
* `logs/` contém todos os vários logs, a maioria nos formatos JSON e texto puro:
* `crawl`: o log do rastreador de arquivos
* `mitm`: o log principal do MITM
* `ntlmssp.log`: os hashes NetNTLM capturados
* `player.log`: o log do player
* `ssl.log`: os segredos mestre TLS armazenados em um formato compatível com Wireshark
* `replays/` contém todas as sessões PyRDP gravadas anteriormente, com carimbos de data/hora e IDs de sessão no nome do arquivo
#### Especificando a chave privada e o certificado
Se a geração de chave não funcionou ou você deseja usar uma chave e certificado personalizados, pode especificá-los usando os argumentos
`-c` e `-k`:```sh
pyrdp-mitm 192.168.1.10 -k private_key.pem -c certificate.pem
Network Level Authentication (NLA) é um recurso de segurança disponível desde o Windows Vista que adiciona segurança às conexões RDP. NLA depende do novo provedor de suporte de segurança CredSSP e é às vezes referido por esse nome. Um servidor que impõe NLA é mais difícil de atacar. Existem três estratégias diferentes que podem ser usadas:
Se tivermos acesso ao certificado e à chave privada do servidor, podemos realizar com sucesso um ataque MITM no RDP mesmo que o NLA esteja em vigor. Nós documentamos este ataque em nosso post de lançamento da versão 1.0. Instruções para extrair o certificado RDP e a chave privada estão disponíveis em nosso GitHub.
Com o certificado e a chave privada acessíveis, você só precisa definir a autenticação para ssp adicionando isso na linha de comando do pyrdp-mitm:```sh
--auth ssp -c <certificate.pem> -k <private-key.pem>
Isto permitirá a possibilidade de interceptar conexões que exigem NLA.
###### Redirecionamento alternativo de host quando o servidor exige NLA
Quando o PyRDP se conecta ao servidor RDP de destino (1), se esse servidor exigir NLA, então o PyRDP (2) substituirá a conexão para ir para outro host de sua escolha (3).
Por exemplo, isso pode ser usado para redirecionar para um servidor que se sabe que não exige NLA, ou poderia até redirecionar para uma VM sob o controle de um atacante.
Para ativar este recurso, especifique o endereço e a porta do host alternativo assim:
pyrdp-mitrdp.py <listen_port> <target_host>:<target_port> --alternative-host <alternative_host>:<alternative_port>
--nla-redirection-host 192.168.1.12 --nla-redirection-port 3389
```
Esta funcionalidade foi introduzida no PyRDP 1.1.0.
###### Capturando hashes NetNTLMv2
Os hashes NetNTLMv2 são úteis para um invasor, pois podem ser quebrados com relativa facilidade, permitindo que invasores aproveitem o acesso legítimo ao RDP ou tentem um ataque de reutilização de credenciais (credentials stuffing).
A partir da versão 1.1.0, o PyRDP tem a capacidade de capturar os hashes NetNTLMv2 do cliente através de uma conexão NLA (CredSSP) realizando a negociação e capturando as mensagens de autenticação NTLMSSP.
Na versão 1.2.0, esse suporte foi estendido para funcionar mesmo que não tenhamos o certificado e a chave privada do servidor, o que significa que a conexão não será um MITM bem-sucedido.
Isso é semelhante ao que o [Responder](https://github.com/lgandx/Responder) faz com o RDP.
O hash NetNTLMv2 capturado pode ser encontrado no arquivo de log `ntlmssp.log` e está
formatado para que ferramentas de cracking como [John The Ripper](https://www.openwall.com/john/) ou [hashcat](https://hashcat.net/hashcat/) possam ingeri-lo.
Esta técnica foi descrita em detalhes em uma postagem de blog: [Capturing RDP NetNTLMv2 Hashes: Attack details and a Technical How-To Guide](https://www.gosecure.net/blog/2022/01/17/capturing-rdp-netntlmv2-hashes-attack-details-and-a-technical-how-to-guide/)
Esta funcionalidade é compatível com `--auth ssp`, mas incompatível com `--nla-redirection-host`.
#### Conectando-se ao player do PyRDP
Se você quiser ver conexões RDP ao vivo através do player do PyRDP, precisará especificar o endereço IP e a porta na qual o player está ouvindo usando os argumentos `-i` e `-d`. Nota: o argumento da porta é opcional, a porta padrão é 3000.```sh
pyrdp-mitm 192.168.1.10 -i 127.0.0.1 -d 3000
```
##### Conectando a um player PyRDP quando o MITM está sendo executado em um servidor
Se você está executando o MITM em um servidor e ainda deseja ver conexões RDP ao vivo, você deve usar
[SSH remote port forwarding](https://www.booleanworld.com/guide-ssh-port-forwarding-tunnelling/)
para encaminhar uma porta no seu servidor para a porta do player na sua máquina. Depois disso, você passa `127.0.0.1` e a porta encaminhada
como argumentos para o MITM. Por exemplo, se a porta 4000 no servidor estiver encaminhada para a porta do player na sua máquina,
este seria o comando a ser usado:
```
python bin/pyrdp-mitm.py 127.0.0.1 4000
``````sh
pyrdp-mitm 192.168.1.10 -i 127.0.0.1 -d 4000
```
#### Executando payloads em novas conexões
O PyRDP suporta a execução de comandos de console ou payloads do PowerShell automaticamente quando novas conexões são feitas.
Devido à natureza do RDP, o processo é um pouco improvisado e nem sempre 100% confiável. Veja como funciona:
1. Aguardar a autenticação do usuário.
2. Bloquear a entrada/saída do cliente para ocultar o payload e evitar interferências.
3. Enviar uma sequência falsa Windows+R e executar `cmd.exe`.
4. Executar o payload como um comando de console e sair do console. Se um payload do PowerShell estiver configurado, ele é executado com `powershell -enc <PAYLOAD>`.
5. Aguardar um pouco para permitir que o payload seja concluído.
6. Restaurar a entrada/saída do cliente.
Para que isso funcione, você precisa definir 3 argumentos:
- o payload
- o atraso antes do início do payload
- a duração do payload
##### Definindo o payload
Você pode usar um dos seguintes argumentos para definir o payload a ser executado:
- `--payload`, uma string contendo comandos de console
- `--payload-powershell`, uma string contendo comandos do PowerShell
- `--payload-powershell-file`, um caminho para um script do PowerShell
##### Escolhendo quando iniciar o payload
No momento, o PyRDP não detecta quando o usuário está logado.
Você deve fornecer um tempo de espera antes de executar o payload.
Após esse tempo ter passado, ele enviará as sequências de teclas falsas e esperará que o payload seja executado corretamente.
Para fazer isso, você usa o argumento `--payload-delay`. O atraso é em milissegundos.
Por exemplo, se você espera que o usuário faça login nos primeiros 5 segundos, você usaria os seguintes argumentos:```sh
--payload-delay 5000
```
Isto poderia ser mais preciso aproveitando algumas mensagens trocadas durante a inicialização do RDPDR.
Veja [esta issue](https://github.com/GoSecure/pyrdp/issues/98) se estiver interessado em fazer isso funcionar melhor.
##### Escolhendo quando retomar a atividade normal
Como não há uma forma direta de saber quando o console parou de ser executado, você deve informar ao PyRDP por quanto tempo deseja
que a entrada/saída do cliente seja bloqueada. Recomendamos que defina este valor como o tempo máximo que você esperaria que o
console que está executando seu payload ficasse visível. Em outras palavras, o tempo que você esperaria que seu payload levasse para
ser concluído.
Para definir a duração do payload, utilize o argumento `--payload-duration` com um valor em milissegundos.
Por exemplo, se você espera que seu payload leve até 5 segundos para ser concluído, usaria o seguinte argumento:```sh
--payload-duration 5000
```
Isto bloqueará a entrada/saída do cliente por 5 segundos para ocultar o console e evitar interferências.
Após 5 segundos, a entrada/saída é restaurada ao normal.
#### Outros argumentos do MITM
Execute `pyrdp-mitm --help` para uma lista completa de argumentos.
##### `--no-downgrade`
Este argumento é útil ao executar PyRDP em cenários de Honeypot para evitar a identificação por scanners.
Quando a opção está ativada, o PyRDP não fará downgrade de extensões não suportadas e deixará o tráfego passar
de forma transparente. O player provavelmente não conseguirá reproduzir com sucesso o tráfego de vídeo, mas os seguintes
canais suportados ainda devem estar acessíveis:
- Gravação de teclas
- Atualizações de posição do mouse
- Acesso à área de transferência (passivamente)
- Acesso a unidades (passivamente)
Esta funcionalidade ainda está em desenvolvimento e algum downgrade é atualmente inevitável para permitir o estabelecimento
da conexão. Os seguintes não são atualmente afetados por esta opção e continuarão desativados:
- Criptografia FIPS
- Protocolos de criptografia não TLS
- Compressão ClientInfo
- Compressão de Canal Virtual
**NOTA**: Se poder eventualmente reproduzir a sessão completa for importante, uma boa solução é gravar o tráfego RDP bruto
usando Wireshark e manter os segredos mestre TLS. Sempre que o PyRDP adicionar suporte para extensões adicionais,
será então possível extrair um arquivo de reprodução RDP válido da captura de rede bruta.
##### `--transparent`
Diz ao PyRDP para tentar falsificar o endereço IP de origem do cliente para que o servidor veja o endereço IP real
em vez do do MITM. Esta opção só é útil em certos cenários onde o MITM é fisicamente um gateway entre clientes e o servidor
e vê todo o tráfego.
[Exemplos específicos podem ser encontrados aqui.](https://github.com/gosecure/pyrdp/blob/main/docs/transparent-proxy.md)
**NOTA**: Isto requer privilégios de root, funciona apenas em Linux e requer configuração manual de firewall para garantir
que o tráfego seja roteado corretamente.
##### `--no-gdi`: Desabilitar Pipeline de Gráficos Acelerados
PyRDP faz downgrade de vídeo para o pipeline de gráficos mais recente que suporta. Esta opção diz explicitamente ao
MITM para não usar as extensões de [Aceleração de Interface de Dispositivo Gráfico][gdi] para transmitir vídeo. A vantagem deste modo
é uma redução significativa na largura de banda necessária para conexões de alta resolução.
Note que algumas ordens de desenho do GDI estão atualmente não implementadas porque parecem não ser usadas. Se você tiver uma reprodução
que contenha alguma ordem não suportada ou não testada, não hesite em compartilhá-la com os mantenedores do projeto para que
o suporte possa ser adicionado conforme necessário. (Certifique-se de que o rastreio não contém informações sensíveis)
[gdi]: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpegdi/745f2eee-d110-464c-8aca-06fc1814f6ad
### Usando o PyRDP Player
Use `pyrdp-player` para executar o player.
#### Reproduzindo um arquivo de reprodução
Você pode usar o menu para abrir um novo arquivo de reprodução: File > Open.
Você também pode abrir arquivos de reprodução ao iniciar o player:```sh
pyrdp-player <FILE1> <FILE2> ...
```
#### Escutando por conexões ao vivo
O player sempre escuta por conexões ao vivo. Por padrão, a porta de escuta é 3000, mas pode ser alterada:```sh
pyrdp-player -p <PORT>
```
#### Alterando o endereço de escuta
Por padrão, o player só ouve conexões vindas da máquina local. Não recomendamos abrir o player
para outras máquinas. Se ainda assim quiser alterar o endereço de escuta, pode fazê-lo com `-b`:```sh
pyrdp-player -b <ADDRESS>
```
#### Outros argumentos do player
Execute `pyrdp-player --help` para uma lista completa de argumentos.
### Usando o Clonador de Certificados do PyRDP
NOTA: O uso desta ferramenta é opcional.
Desde a versão 1.0, o PyRDP gera certificados dinamicamente exatamente como esta ferramenta faria.
O clonador de certificados do PyRDP cria um novo certificado X509 usando os valores de um certificado existente de um servidor RDP.
Ele se conecta a um servidor RDP, baixa seu certificado, gera uma nova chave privada e substitui a chave pública e a assinatura do certificado usando a nova chave privada. Isso pode ser usado em um pentest se, por exemplo, você estiver tentando enganar um usuário legítimo para passar pelo seu MITM. Usar um certificado que se parece com um certificado legítimo pode aumentar sua taxa de sucesso.
#### Clonando um certificado
Você pode clonar um certificado usando `pyrdp-clonecert`:```sh
pyrdp-clonecert 192.168.1.10 cert.pem -o key.pem
```
O parâmetro `-o` define o nome do caminho a ser usado para a chave privada gerada.
#### Usando uma chave privada personalizada
Se quiser usar sua própria chave privada em vez de gerar uma nova:```sh
pyrdp-clonecert 192.168.1.10 cert.pem -i input_key.pem
```
#### Outros argumentos do clonador
Execute `pyrdp-clonecert --help` para ver uma lista completa de argumentos.
### Usando o PyRDP Convert
`pyrdp-convert` é um script auxiliar que realiza várias conversões úteis de vários formatos de entrada para vários formatos de saída.
O script tem maior chance de funcionar em tráfego capturado pelo PyRDP devido a recursos de protocolo RDP não suportados que podem ser usados em uma conexão não interceptada.
As seguintes entradas são suportadas:
- Captura de rede (PCAP) com segredos mestre TLS (menos confiável)
- Captura de rede (PCAP) no formato Exported PDUs Layer 7 (mais confiável)
- Arquivo de replay gerado pelo PyRDP
As seguintes saídas são suportadas:
- Arquivo de vídeo MP4
- JSON: uma sequência de eventos de baixo nível serializados em formato JSON
- Arquivo de replay compatível com `pyrdp-player`
Capturas de rede criptografadas (TLS) exigem que os segredos mestre TLS sejam fornecidos usando `--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
```
Observe que a conversão MP4 requer libavcodec e ffmpeg, portanto, pode exigir etapas extras no Windows.
Os rastros de rede descriptografados manualmente podem ser exportados do Wireshark selecionando `File > Export PDUs` e selecionando `OSI Layer 7`.
Primeiro, certifique-se de ter configurado o Wireshark para carregar segredos TLS:
Em seguida, exporte PDUs da Camada 7 OSI:
E opcionalmente, filtre o rastro para conter apenas a(s) conversa(ões) de interesse aplicando um filtro de exibição e clicando em `File > Export Specified Packets...`
Agora, este rastro pode ser usado diretamente no `pyrdp-convert`.
### Configurando o PyRDP
A maior parte da configuração do PyRDP é feita através de opções de linha de comando, mas também é possível usar um arquivo de configuração para determinadas configurações, como a configuração de log.
Os arquivos de configuração padrão usados pelo PyRDP estão localizados em [mitm.default.ini](https://github.com/gosecure/pyrdp/blob/main/pyrdp/mitm/mitm.default.ini) e [player.default.ini](https://github.com/gosecure/pyrdp/blob/main/pyrdp/player/player.default.ini). Ambos os arquivos são minuciosamente documentados e podem servir como base para configurações adicionais.
No futuro, há planos de suportar outros aspectos da configuração do PyRDP através desses arquivos de configuração.
### Uso Avançado
#### Usando PyRDP como Biblioteca
Se você está interessado em experimentar com RDP e criar suas próprias ferramentas, acesse nossa [seção de documentação](https://github.com/gosecure/pyrdp/blob/main/docs/README.md) para mais informações.
#### Usando PyRDP com twistd
O componente MITM do PyRDP também foi implementado como um plugin do twistd. Isso permite executá-lo em modo de depuração e obter um repl interativo de depuração (pdb) se você enviar um `SIGUSR2` para o processo twistd. Veja a [documentação do twistd](https://github.com/gosecure/pyrdp/blob/main/docs/twistd.md) para mais informações.
#### Usando PyRDP com Bettercap
Desenvolvemos nosso próprio módulo do Bettercap, `rdp.proxy`, para interceptar todas as conexões RDP em uma determinada LAN. Confira [este documento](https://github.com/gosecure/pyrdp/blob/main/docs/bettercap-rdp-mitm.md) para mais informações.
### Instruções Específicas de Uso com Docker
Como o Docker restringe as interações com o sistema host (sistema de arquivos e rede), a imagem Docker do PyRDP deve ser executada com alguns parâmetros dependendo do seu caso de uso. Esta seção documenta esses parâmetros.
Referimo-nos à imagem Docker fornecida publicamente, mas se você [construiu a sua própria](https://github.com/gosecure/pyrdp/blob/main/docs/devel.adoc), substitua `gosecure/pyrdp` pelo nome da sua imagem construída localmente.
#### Mapeando uma Porta de Escuta
Na maioria dos casos de interceptação, você precisará mapear uma porta do seu host para a imagem Docker. Isso é feito com os parâmetros `--publish` (`-p`) aplicados ao `docker run`.
Por exemplo, para escutar na porta 3389 (porta padrão do RDP) em todas as interfaces, use:```sh
docker run -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10
```
#### Armazenamento de Logs e Artefatos
Para armazenar permanentemente a saída do PyRDP (logs, arquivos, etc.), adicione a opção `--volume` (`-v`) ao comando anterior. Neste exemplo, armazenamos os arquivos relativamente ao diretório atual em `pyrdp_output`:```sh
docker run -v $PWD/pyrdp_output:/home/pyrdp/pyrdp_output -p 3389:3389 gosecure/pyrdp pyrdp-mitm 192.168.1.10
```
Certifique-se de que seu diretório de destino pertence a um usuário com UID 1000, caso contrário, você receberá erros de permissão negada.
Se você for o único usuário não-root no sistema, geralmente seu usuário receberá o UID 1000.
#### Registrando o endereço IP do host
Se você quiser que o PyRDP registre o endereço IP do host em seus logs, você pode definir a variável de ambiente `HOST_IP` ao usar `docker run`:```sh
docker run -p 3389:3389 -e HOST_IP=192.168.1.9 gosecure/pyrdp pyrdp-mitm 192.168.1.10
```
#### Usando o Player GUI no Docker
Usar o player exigirá que você exporte a variável de ambiente `DISPLAY` do host para o docker.
Isso redireciona a GUI do player para a tela do host.
Você também precisa expor a rede do host e impedir que o Qt use a Extensão de Memória Compartilhada MIT-SHM X11.
Para isso, adicione as opções `-e` e `--net` ao comando run:```sh
docker run -e DISPLAY=$DISPLAY -e QT_X11_NO_MITSHM=1 --net=host gosecure/pyrdp pyrdp-player
```
Lembre-se de que expor a rede do host ao docker pode comprometer o isolamento entre o seu contêiner e o host.
Se você planeja usar o player, o encaminhamento X11 usando uma conexão SSH seria uma maneira mais segura.
#### Convertendo vídeos no Docker
O processo de conversão de vídeo depende de PyAV, ffmpeg e QT, então você precisa da imagem docker normal, não a slim.
Você precisa de uma montagem de volume (`-v`) para compartilhar arquivos com o contêiner.
Aqui mapeamos nosso diretório local com `/shared/` no contêiner.```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/
```
A variável de ambiente `QT_QPA_PLATFORM=offscreen` é necessária [devido a um bug documentado aqui](https://github.com/GoSecure/pyrdp/issues/428).
Ela informa ao QT que é correto que nenhum ambiente de exibição está disponível.
## Histórico do PyRDP
* [Postagem do blog de introdução](https://www.gosecure.net/blog/2018/12/19/rdp-man-in-the-middle-smile-youre-on-camera) na qual [demonstramos que podemos capturar um ator de ameaça real em ação](https://www.youtube.com/watch?v=eB7RC9FmL6Q)
* [Palestra no NorthSec 2019](https://docs.google.com/presentation/d/1avcn8Sh2b3IE7AA0G9l7Cj5F1pxqizUm98IbXUo2cvY/edit#slide=id.g404b70030f_0_581) onde duas demonstrações foram realizadas:
* [Primeira demonstração](https://youtu.be/5JztJzi-m48): registro de credenciais, roubo de área de transferência, navegação de arquivos do lado do cliente e tomada de sessão
* [Segunda demonstração](https://youtu.be/bU67tj1RkMA): a execução de payloads de cmd ou powershell quando um cliente autentica com sucesso
* [Logotipo do PyRDP](https://github.com/gosecure/pyrdp/blob/main/docs/pyrdp-logo.png) licenciado sob CC-BY-SA 4.0.
* [Slides do BlackHat USA Arsenal 2019](https://docs.google.com/presentation/d/17P_l2n-hgCehQ5eTWilru4IXXHnGIRTj4ftoW4BiX5A/edit?usp=sharing)
* [Slides do DerbyCon 2019](https://docs.google.com/presentation/d/1UAiN2EZwDcmBjLe_t5HXB0LzbNclU3nnigC-XM4neIU/edit?usp=sharing) ([Vídeo](https://www.youtube.com/watch?v=zgt3N6Nrnss))
* [Blog: PyRDP no Piloto Automático](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: Capturando Hashes NetNTLMv2 do RDP: Detalhes do ataque e um guia técnico prático](https://www.gosecure.net/blog/2022/01/17/capturing-rdp-netntlmv2-hashes-attack-details-and-a-technical-how-to-guide/)
* [Slides do BlackHat USA Arsenal 2021](https://gosecure.github.io/presentations/2021-08-05_blackhat-usa/BlackHat-USA-21-Arsenal-PyRDP-OlivierBilodeau.pdf)
* [Apresentação: Eu Vi Você Jogar os Dados: Monitoramento RDP Sem Precedentes Revela as Táticas dos Atacantes](http://i.blackhat.com/BH-US-23/Presentations/US-23-Bilodeau-I-Watched-You-Roll-the-Die-Unparalleled-RDP-Monitoring.pdf) no BlackHat USA 2023
## Contribuindo para o PyRDP
Veja nossas [diretrizes de contribuição](https://github.com/gosecure/pyrdp/blob/main/CONTRIBUTING.md).
## Agradecimentos
O PyRDP utiliza código dos seguintes softwares de código aberto:
- [RC4-Python](https://github.com/bozhu/RC4-Python) para a implementação do RC4.
- [rdesktop](https://github.com/rdesktop/rdesktop) para descompressão de bitmap.
- [rdpy](https://github.com/citronneur/rdpy) para chaves RC4, as ligações de descompressão de bitmap e o código GUI base para o player do PyRDP.
- [FreeRDP](https://github.com/FreeRDP/FreeRDP) para a enumeração de códigos de varredura.