citronneur/rdpyProtocolo de Área de Trabalho Remota no Twisted Python
Remote Desktop Protocol em Python com Twisted.
RDPY é uma implementação puramente Python do protocolo Microsoft RDP (Remote Desktop Protocol) (lado cliente e servidor). RDPY é construído sobre o motor de rede orientado a eventos Twisted. RDPY suporta a 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:
RDPY está completamente implementado em Python, exceto o algoritmo de descompressão de bitmap que é implementado em C para desempenho.
As dependências são necessárias apenas para os binários pyqt4:
Exemplo para sistemas baseados em Debian:
sudo apt-get install python-qt4
Exemplo para OS X para instalar PyQt com homebrew
$ brew install qt sip pyqt
$ 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, será necessário ligar 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 vem com alguns binários muito úteis. Estes binários são compatíveis com Linux e Windows.
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]
Pode usar rdpy-rdpclient num Cenário de Sessão de Gravação, utilizado no rdpy-rdphoneypot.
rdpy-vncclient é um simples cliente VNC Qt4.
$ rdpy-vncclient.py [-p password] XXX.XXX.XXX.XXX[:5900]
rdpy-rdpscreenshot guarda o ecrã de login num ficheiro.
$ rdpy-rdpscreenshot.py [-w width] [-l height] [-o output_file_path] XXX.XXX.XXX.XXX[:3389]
rdpy-vncscreenshot guarda a primeira atualização do ecrã num ficheiro.
$ rdpy-vncscreenshot.py [-p password] [-o output_file_path] XXX.XXX.XXX.XXX[:5900]
rdpy-rdpmitm é um proxy RDP que permite realizar um ataque Man In The Middle no protocolo RDP. Grava o Cenário de Sessão num ficheiro rss que pode ser reproduzido 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 guardar o ficheiro rss com o seguinte formato (YYYYMMDDHHMMSS_ip_index.rss) O ficheiro de chave privada e o ficheiro de certificado são ficheiros criptográficos clássicos para ligações SSL. O protocolo RDP pode negociar a sua própria camada de segurança. Se um dos parâmetros for omitido, o servidor usa o RDP padrão como camada de segurança.
rdpy-rdphoneypot é um Honeypot RDP. Use um Cenário de Sessão Gravada para reproduzir o 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 ficheiro de chave privada e o ficheiro de certificado são ficheiros criptográficos clássicos para ligações SSL. O protocolo RDP pode negociar a sua própria camada de segurança. Se um dos parâmetros for omitido, o servidor usa o RDP padrão como camada de segurança. Pode especificar mais de um ficheiro para corresponder a mais tamanhos de ecrã comuns.
rdpy-rssplayer é usado para reproduzir ficheiros de Cenário de Sessão Gravada (rss) gerados quer pelos binários rdpy-rdpmitm ou rdpy-rdpclient.
$ rdpy-rssplayer.py rss_file_path
RDPY também pode ser usado como um widget Qt através da classe rdpy.ui.qt4.QRemoteDesktop. Pode ser incorporado na sua própria aplicação Qt. O qt4reactor deve ser usado na sua aplicação para que Twisted e Qt funcionem em conjunto. Para mais detalhes, veja as fontes do rdpy-rdpclient.
Em poucas palavras, RDPY pode ser usado como uma biblioteca de protocolos com um motor twisted.
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()
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, 3, 4 or 5 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()
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()