Browse By

RDPY – Protocolo de área de trabalho remota em Twisted Python

RDPY é uma implementação Python pura do protocolo RDP (Remote Desktop Protocol) da Microsoft (cliente e lado do servidor). RDPY é construído sobre o motor de rede conduzido por eventos Twisted. RDPY suporte camada de segurança RDP padrão, RDP sobre SSL e autenticação NLA (através do protocolo de autenticação ntlmv2).

RDPY fornece os seguintes binários RDP e VNC:
  • RDP Man In The Middle, qual a sessão de registro
  • RDP Honeypot
  • Screenshot RDP
  • Cliente RDP
  • Cliente VNC
  • Screenshot VNC
  • RSS Player

Construir
RDPY é totalmente implementado em python, exceto o algoritmo de descompressão de bitmap que é implementado em C para fins de desempenho.

Dependências As
dependências só são necessárias para binários pyqt4:

  • rdpy-rdpclient
  • rdpy-rdpscreenshot
  • rdpy-vncclient
  • rdpy-vncscreenshot
  • rdpy-rssplayer


Exemplo de Linux para sistemas baseados em Debian:

sudo apt-get install python-qt4

OS X
Exemplo para OS X para instalar PyQt com homebrew

$ brew install qt sip pyqt

janelas

x86 x86_64
PyQt4 PyQt4
PyWin32 PyWin32

Construir

$ git clone https://github.com/citronneur/rdpy.git rdpy
$ pip install twisted pyopenssl qt4reactor service_identity rsa pyasn1
$ python rdpy/setup.py install

Ou use PIP:

$ pip install rdpy

Para virtualenv, você precisará vincular a biblioteca qt4 a ele:

$ ln -s /usr/lib/python2.7/dist-packages/PyQt4/ $VIRTUAL_ENV/lib/python2.7/site-packages/
$ ln -s /usr/lib/python2.7/dist-packages/sip.so $VIRTUAL_ENV/lib/python2.7/site-packages/

RDPY Binaries
RDPY vem com alguns binários muito úteis. Esses binários sãocompatíveis com linux e windows.

rdpy-rdpclient
rdpy-rdpclient é um simples cliente RDP Qt4.

$ rdpy-rdpclient.py [-u username] [-p password] [-d domain] [-r rss_ouput_file] [...] XXX.XXX.XXX.XXX[:3389]

Você pode usar rdpy-rdpclient em um Cenário de Sessão de Gravador, usado em rdpy-rdphoneypot.

rdpy-vncclient
rdpy-vncclient é um cliente VNC Qt4 simples.

$ rdpy-vncclient.py [-p password] XXX.XXX.XXX.XXX[:5900]

rdpy-rdpscreenshot
rdpy-rdpscreenshot salva a tela de login no arquivo.

$ rdpy-rdpscreenshot.py [-w width] [-l height] [-o output_file_path] XXX.XXX.XXX.XXX[:3389]

rdpy-vncscreenshot
rdpy-vncscreenshot salva a primeira atualização da tela no arquivo.

$ rdpy-vncscreenshot.py [-p password] [-o output_file_path] XXX.XXX.XXX.XXX[:5900]

rdpy-rdpmitm
rdpy-rdpmitm é um proxy RDP que permite fazer um ataque do homem no meio no protocolo RDP. Registre o Cenário de Sessão no arquivo rss que pode ser repetido pelo rdpy-rssplayer.

$ rdpy-rdpmitm.py -o output_dir [-l listen_port] [-k private_key_file_path] [-c certificate_file_path] [-r (for XP or server 2003 client)] target_host[:target_port]

O diretório de saída é usado para salvar o arquivo rss com o seguinte formato (YYYYMMDDHHMMSS_ip_index.rss) O ​​arquivo de chave particular e o arquivo de certificado são arquivos criptográficos clássicos para conexões SSL. O protocolo RDP pode negociar sua própria camada de segurança Se um dos dois parâmetros for omitido, o servidor usará o RDP padrão como camada de segurança.

rdpy-rdphoneypot
rdpy-rdphoneypot é um pote de mel RDP. Use Cenário de Sessão Gravada para reproduzir cenário através do Protocolo RDP.

$ rdpy-rdphoneypot.py [-l listen_port] [-k private_key_file_path] [-c certificate_file_path] rss_file_path_1 ... rss_file_path_N

O arquivo de chave particular e o arquivo de certificado são arquivos criptográficos clássicos para conexões SSL. O protocolo RDP pode negociar sua própria camada de segurança. Se um dos dois parâmetros for omitido, o servidor usa o padrão RDP como camada de segurança. Você pode especificar mais de um arquivo para corresponder ao tamanho de tela mais comum.

rdpy-rssplayer
rdpy-rssplayer é usado para reproduzir os arquivos de Cenário de Sessão de Registro (rss) gera por binários rdpy-rdpmitm ou rdpy-rdpclient.

$ rdpy-rssplayer.py rss_file_path

RDPY Qt Widget
RDPY também pode ser usado como widget Qtp através da classe rdpy.ui.qt4.QRemoteDesktop. Ele pode ser incorporado em sua própria aplicação Qt. O tt4reactor deve ser usado em seu aplicativo para Twisted e Qt para trabalharem juntos. Para obter mais detalhes, consulte as fontes do rdpy-rdpclient.

Biblioteca RDPY
Em poucas palavras, o RDPY pode ser usado como uma biblioteca de protocolo com um mecanismo torcido.

Cliente RDP simples

from rdpy.protocol.rdp import rdp

class MyRDPFactory(rdp.ClientFactory):

    def clientConnectionLost(self, connector, reason):
        reactor.stop()

    def clientConnectionFailed(self, connector, reason):
        reactor.stop()

    def buildObserver(self, controller, addr):

        class MyObserver(rdp.RDPClientObserver):

            def onReady(self):
                """
                @summary: Call when stack is ready
                """
                #send 'r' key
                self._controller.sendKeyEventUnicode(ord(unicode("r".toUtf8(), encoding="UTF-8")), True)
                #mouse move and click at pixel 200x200
                self._controller.sendPointerEvent(200, 200, 1, true)

            def onUpdate(self, destLeft, destTop, destRight, destBottom, width, height, bitsPerPixel, isCompress, data):
                """
                @summary: Notify bitmap update
                @param destLeft: xmin position
                @param destTop: ymin position
                @param destRight: xmax position because RDP can send bitmap with padding
                @param destBottom: ymax position because RDP can send bitmap with padding
                @param width: width of bitmap
                @param height: height of bitmap
                @param bitsPerPixel: number of bit per pixel
                @param isCompress: use RLE compression
                @param data: bitmap data
                """
                
            def onSessionReady(self):
          """
          @summary: Windows session is ready
          """

            def onClose(self):
                """
                @summary: Call when stack is close
                """

        return MyObserver(controller)

from twisted.internet import reactor
reactor.connectTCP("XXX.XXX.XXX.XXX", 3389, MyRDPFactory())
reactor.run()

Servidor RDP Simples

from rdpy.protocol.rdp import rdp

class MyRDPFactory(rdp.ServerFactory):

    def buildObserver(self, controller, addr):

        class MyObserver(rdp.RDPServerObserver):

            def onReady(self):
                """
                @summary: Call when server is ready
                to send and receive messages
                """

            def onKeyEventScancode(self, code, isPressed):
                """
                @summary: Event call when a keyboard event is catch in scan code format
                @param code: scan code of key
                @param isPressed: True if key is down
                @see: rdp.RDPServerObserver.onKeyEventScancode
                """

            def onKeyEventUnicode(self, code, isPressed):
                """
                @summary: Event call when a keyboard event is catch in unicode format
                @param code: unicode of key
                @param isPressed: True if key is down
                @see: rdp.RDPServerObserver.onKeyEventUnicode
                """

            def onPointerEvent(self, x, y, button, isPressed):
                """
                @summary: Event call on mouse event
                @param x: x position
                @param y: y position
                @param button: 1, 2 or 3 button
                @param isPressed: True if mouse button is pressed
                @see: rdp.RDPServerObserver.onPointerEvent
                """

            def onClose(self):
                """
                @summary: Call when human client close connection
                @see: rdp.RDPServerObserver.onClose
                """

        return MyObserver(controller)

from twisted.internet import reactor
reactor.listenTCP(3389, MyRDPFactory())
reactor.run()

Cliente VNC simples

from rdpy.protocol.rfb import rfb

class MyRFBFactory(rfb.ClientFactory):

    def clientConnectionLost(self, connector, reason):
        reactor.stop()

    def clientConnectionFailed(self, connector, reason):
        reactor.stop()

    def buildObserver(self, controller, addr):
        class MyObserver(rfb.RFBClientObserver):

            def onReady(self):
                """
                @summary: Event when network stack is ready to receive or send event
                """

            def onUpdate(self, width, height, x, y, pixelFormat, encoding, data):
                """
                @summary: Implement RFBClientObserver interface
                @param width: width of new image
                @param height: height of new image
                @param x: x position of new image
                @param y: y position of new image
                @param pixelFormat: pixefFormat structure in rfb.message.PixelFormat
                @param encoding: encoding type rfb.message.Encoding
                @param data: image data in accordance with pixel format and encoding
                """

            def onCutText(self, text):
                """
                @summary: event when server send cut text event
                @param text: text received
                """

            def onBell(self):
                """
                @summary: event when server send biiip
                """

            def onClose(self):
                """
                @summary: Call when stack is close
                """

        return MyObserver(controller)

from twisted.internet import reactor
reactor.connectTCP("XXX.XXX.XXX.XXX", 3389, MyRFBFactory())
reactor.run()
Download

Deixe uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *

Este site utiliza o Akismet para reduzir spam. Fica a saber como são processados os dados dos comentários.