From 3f56b25f46c9047955a6dee695bd0de09e45d336 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 14 Apr 2020 21:56:46 +0200 Subject: [PATCH] Start python3 --- .gitignore | 2 + README.md | 4 +- bin/rdpy-rdpclient.py | 33 +- bin/rdpy-rdphoneypot.py | 6 +- bin/rdpy-rdpmitm.py | 5 +- bin/rdpy-rdpscreenshot.py | 6 +- ext/rle.c | 13 +- rdpy/{protocol/rdp => core}/lic.py | 10 +- rdpy/{protocol => core/nla}/__init__.py | 0 rdpy/{protocol/rdp => core}/nla/cssp.py | 8 +- rdpy/{protocol/rdp => core}/nla/ntlm.py | 6 +- rdpy/{protocol/rdp => core}/nla/sspi.py | 2 +- rdpy/{protocol/rdp => core/pdu}/__init__.py | 0 rdpy/{protocol/rdp => core}/pdu/caps.py | 9 +- rdpy/{protocol/rdp => core}/pdu/data.py | 8 +- rdpy/{protocol/rdp => core}/pdu/layer.py | 13 +- rdpy/{protocol/rdp => core}/pdu/order.py | 6 +- rdpy/{protocol/rdp => core}/rdp.py | 117 +-- rdpy/{protocol/rdp => core}/sec.py | 15 +- .../rdp/nla => core/t125}/__init__.py | 0 rdpy/{protocol/rdp => core}/t125/ber.py | 4 +- rdpy/{protocol/rdp => core}/t125/gcc.py | 10 +- rdpy/{protocol/rdp => core}/t125/mcs.py | 12 +- rdpy/{protocol/rdp => core}/t125/per.py | 4 +- rdpy/{protocol/rdp => core}/tpkt.py | 7 +- rdpy/{protocol/rdp => core}/x224.py | 40 +- rdpy/{protocol/rdp/pdu => model}/__init__.py | 0 rdpy/{core => model}/const.py | 0 rdpy/{core => model}/error.py | 0 rdpy/{core => model}/filetimes.py | 0 rdpy/{core => model}/layer.py | 98 +-- rdpy/{core => model}/log.py | 2 +- rdpy/{core => model}/rss.py | 4 +- rdpy/{core => model}/scancode.py | 0 rdpy/{core => model}/type.py | 10 +- rdpy/protocol/rdp/t125/__init__.py | 0 rdpy/protocol/rfb/__init__.py | 0 rdpy/protocol/rfb/rfb.py | 765 ------------------ rdpy/ui/qt4.py | 145 +--- setup.py | 20 +- test/test_protocol_rdp_ber.py | 4 +- test/test_protocol_rdp_cssp_ntlm.py | 2 +- test/test_protocol_rdp_lic.py | 2 +- test/test_protocol_rdp_per.py | 4 +- test/test_protocol_rdp_tpkt.py | 4 +- test/test_protocol_rdp_x224.py | 2 +- 46 files changed, 256 insertions(+), 1146 deletions(-) rename rdpy/{protocol/rdp => core}/lic.py (98%) rename rdpy/{protocol => core/nla}/__init__.py (100%) rename rdpy/{protocol/rdp => core}/nla/cssp.py (98%) rename rdpy/{protocol/rdp => core}/nla/ntlm.py (99%) rename rdpy/{protocol/rdp => core}/nla/sspi.py (98%) rename rdpy/{protocol/rdp => core/pdu}/__init__.py (100%) rename rdpy/{protocol/rdp => core}/pdu/caps.py (98%) rename rdpy/{protocol/rdp => core}/pdu/data.py (99%) rename rdpy/{protocol/rdp => core}/pdu/layer.py (99%) rename rdpy/{protocol/rdp => core}/pdu/order.py (96%) rename rdpy/{protocol/rdp => core}/rdp.py (91%) rename rdpy/{protocol/rdp => core}/sec.py (98%) rename rdpy/{protocol/rdp/nla => core/t125}/__init__.py (100%) rename rdpy/{protocol/rdp => core}/t125/ber.py (98%) rename rdpy/{protocol/rdp => core}/t125/gcc.py (98%) rename rdpy/{protocol/rdp => core}/t125/mcs.py (98%) rename rdpy/{protocol/rdp => core}/t125/per.py (98%) rename rdpy/{protocol/rdp => core}/tpkt.py (98%) rename rdpy/{protocol/rdp => core}/x224.py (88%) rename rdpy/{protocol/rdp/pdu => model}/__init__.py (100%) rename rdpy/{core => model}/const.py (100%) rename rdpy/{core => model}/error.py (100%) rename rdpy/{core => model}/filetimes.py (100%) rename rdpy/{core => model}/layer.py (83%) rename rdpy/{core => model}/log.py (98%) rename rdpy/{core => model}/rss.py (98%) rename rdpy/{core => model}/scancode.py (100%) rename rdpy/{core => model}/type.py (99%) delete mode 100644 rdpy/protocol/rdp/t125/__init__.py delete mode 100644 rdpy/protocol/rfb/__init__.py delete mode 100644 rdpy/protocol/rfb/rfb.py diff --git a/.gitignore b/.gitignore index 56750d3..8824504 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,5 @@ README.md~ dist/* build/* rdpy.egg-info/* +*.pyd +.idea diff --git a/README.md b/README.md index dd6543e..1ad6ec6 100644 --- a/README.md +++ b/README.md @@ -145,7 +145,7 @@ In a nutshell RDPY can be used as a protocol library with a twisted engine. ### Simple RDP Client ```python -from rdpy.protocol.rdp import rdp +from rdpy.core import rdp class MyRDPFactory(rdp.ClientFactory): @@ -201,7 +201,7 @@ reactor.run() ### Simple RDP Server ```python -from rdpy.protocol.rdp import rdp +from rdpy.core import rdp class MyRDPFactory(rdp.ServerFactory): diff --git a/bin/rdpy-rdpclient.py b/bin/rdpy-rdpclient.py index 660bfa4..33fe370 100755 --- a/bin/rdpy-rdpclient.py +++ b/bin/rdpy-rdpclient.py @@ -23,13 +23,13 @@ example of use rdpy as rdp client import sys, os, getopt, socket -from PyQt4 import QtGui, QtCore +from PyQt5 import QtWidgets from rdpy.ui.qt4 import RDPClientQt -from rdpy.protocol.rdp import rdp -from rdpy.core.error import RDPSecurityNegoFail -from rdpy.core import rss +from rdpy.model.error import RDPSecurityNegoFail +from rdpy.model import rss +from rdpy.core import rdp -import rdpy.core.log as log +import rdpy.model.log as log log._LOG_LEVEL = log.Level.INFO @@ -87,6 +87,7 @@ class RDPClientQtRecorder(RDPClientQt): self._rssRecorder.close() RDPClientQt.closeEvent(self, e) + class RDPClientQtFactory(rdp.ClientFactory): """ @summary: Factory create a RDP GUI client @@ -211,7 +212,7 @@ def autoDetectKeyboardLayout(): return "en" def help(): - print """ + print(""" Usage: rdpy-rdpclient [options] ip[:port]" \t-u: user name \t-p: password @@ -222,7 +223,7 @@ def help(): \t-k: keyboard layout [en|fr] [default : en] \t-o: optimized session (disable costly effect) [default : False] \t-r: rss_filepath Recorded Session Scenario [default : None] - """ + """) if __name__ == '__main__': @@ -236,7 +237,7 @@ if __name__ == '__main__': optimized = False recodedPath = None keyboardLayout = autoDetectKeyboardLayout() - + try: opts, args = getopt.getopt(sys.argv[1:], "hfou:p:d:w:l:k:r:") except getopt.GetoptError: @@ -270,19 +271,11 @@ if __name__ == '__main__': ip, port = args[0], "3389" #create application - app = QtGui.QApplication(sys.argv) - - #add qt4 reactor - import qt4reactor - qt4reactor.install() + app = QtWidgets.QApplication(sys.argv) if fullscreen: - width = QtGui.QDesktopWidget().screenGeometry().width() - height = QtGui.QDesktopWidget().screenGeometry().height() + width = QtWidgets.QDesktopWidget().screenGeometry().width() + height = QtWidgets.QDesktopWidget().screenGeometry().height() log.info("keyboard layout set to %s"%keyboardLayout) - - from twisted.internet import reactor - reactor.connectTCP(ip, int(port), RDPClientQtFactory(width, height, username, password, domain, fullscreen, keyboardLayout, optimized, "nego", recodedPath)) - reactor.runReturn() - app.exec_() \ No newline at end of file + sys.exit(app.exec_()) \ No newline at end of file diff --git a/bin/rdpy-rdphoneypot.py b/bin/rdpy-rdphoneypot.py index 575215b..b98a3b3 100755 --- a/bin/rdpy-rdphoneypot.py +++ b/bin/rdpy-rdphoneypot.py @@ -22,10 +22,10 @@ RDP Honey pot use Rss scenario file to simulate RDP server """ -import sys, os, getopt, time, datetime +import sys, getopt, datetime -from rdpy.core import log, error, rss -from rdpy.protocol.rdp import rdp +from rdpy.core import log, rss +from rdpy.core import rdp from twisted.internet import reactor log._LOG_LEVEL = log.Level.INFO diff --git a/bin/rdpy-rdpmitm.py b/bin/rdpy-rdpmitm.py index f0b317d..11db8c6 100755 --- a/bin/rdpy-rdpmitm.py +++ b/bin/rdpy-rdpmitm.py @@ -29,13 +29,12 @@ Client RDP -> | ProxyServer | ProxyClient | -> Server RDP ----------------- """ -import sys import os import argparse import time -from rdpy.core import log, error, rss -from rdpy.protocol.rdp import rdp +from rdpy.core import log, rss +from rdpy.core import rdp from twisted.internet import reactor log._LOG_LEVEL = log.Level.INFO diff --git a/bin/rdpy-rdpscreenshot.py b/bin/rdpy-rdpscreenshot.py index b87008a..3d5ff53 100755 --- a/bin/rdpy-rdpscreenshot.py +++ b/bin/rdpy-rdpscreenshot.py @@ -24,15 +24,13 @@ take screenshot of login page """ import getopt -import os import sys -from PyQt4 import QtCore, QtGui -from rdpy.protocol.rdp import rdp +from PyQt4 import QtGui +from rdpy.core import rdp from rdpy.ui.qt4 import RDPBitmapToQtImage import rdpy.core.log as log from rdpy.core.error import RDPSecurityNegoFail -from twisted.internet import task # set log level log._LOG_LEVEL = log.Level.INFO diff --git a/ext/rle.c b/ext/rle.c index 2d7da8d..590560c 100644 --- a/ext/rle.c +++ b/ext/rle.c @@ -938,10 +938,19 @@ static PyMethodDef rle_methods[] = {"bitmap_decompress", bitmap_decompress_wrapper, METH_VARARGS, "decompress bitmap from microsoft rle algorithm."}, {NULL, NULL, 0, NULL} }; + +static struct PyModuleDef rle = +{ + PyModuleDef_HEAD_INIT, + "rle", /* name of module */ + "", /* module documentation, may be NULL */ + -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ + rle_methods +}; PyMODINIT_FUNC -initrle(void) +PyInit_rle(void) { - (void) Py_InitModule("rle", rle_methods); + (void) PyModule_Create(&rle); } diff --git a/rdpy/protocol/rdp/lic.py b/rdpy/core/lic.py similarity index 98% rename from rdpy/protocol/rdp/lic.py rename to rdpy/core/lic.py index f22f4d4..d67f6d2 100644 --- a/rdpy/protocol/rdp/lic.py +++ b/rdpy/core/lic.py @@ -22,11 +22,11 @@ @see: http://msdn.microsoft.com/en-us/library/cc241880.aspx """ -from rdpy.core.type import CompositeType, CallableValue, UInt8, UInt16Le, UInt32Le, String, sizeof, FactoryType, ArrayType, Stream -from rdpy.core.error import InvalidExpectedDataException -import rdpy.core.log as log -import sec -from t125 import gcc +from rdpy.model.type import CompositeType, CallableValue, UInt8, UInt16Le, UInt32Le, String, sizeof, FactoryType, ArrayType, Stream +from rdpy.model.error import InvalidExpectedDataException +import rdpy.model.log as log +from rdpy.core import sec +from rdpy.core.t125 import gcc from rdpy.security import rc4 from rdpy.security import rsa_wrapper as rsa diff --git a/rdpy/protocol/__init__.py b/rdpy/core/nla/__init__.py similarity index 100% rename from rdpy/protocol/__init__.py rename to rdpy/core/nla/__init__.py diff --git a/rdpy/protocol/rdp/nla/cssp.py b/rdpy/core/nla/cssp.py similarity index 98% rename from rdpy/protocol/rdp/nla/cssp.py rename to rdpy/core/nla/cssp.py index 6d76756..f064142 100644 --- a/rdpy/protocol/rdp/nla/cssp.py +++ b/rdpy/core/nla/cssp.py @@ -27,11 +27,9 @@ import pyasn1.codec.der.encoder as der_encoder import pyasn1.codec.der.decoder as der_decoder import pyasn1.codec.ber.encoder as ber_encoder -from rdpy.core.type import Stream -from twisted.internet import protocol -from OpenSSL import crypto +from rdpy.model.type import Stream from rdpy.security import x509 -from rdpy.core import error +from rdpy.model import error class NegoToken(univ.Sequence): componentType = namedtype.NamedTypes( @@ -175,7 +173,7 @@ def encodeDERTCredentials(domain, username, password): return der_encoder.encode(credentials) -class CSSP(protocol.Protocol): +class CSSP: """ @summary: Handle CSSP connection Proxy class for authentication diff --git a/rdpy/protocol/rdp/nla/ntlm.py b/rdpy/core/nla/ntlm.py similarity index 99% rename from rdpy/protocol/rdp/nla/ntlm.py rename to rdpy/core/nla/ntlm.py index 3d541f6..633bf3e 100644 --- a/rdpy/protocol/rdp/nla/ntlm.py +++ b/rdpy/core/nla/ntlm.py @@ -23,12 +23,12 @@ """ import hashlib, hmac, struct, datetime -import sspi +from rdpy.core.nla import sspi import rdpy.security.pyDes as pyDes import rdpy.security.rc4 as rc4 from rdpy.security.rsa_wrapper import random -from rdpy.core.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt24Le, UInt32Le, sizeof, Stream -from rdpy.core import filetimes, error +from rdpy.model.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt24Le, UInt32Le, sizeof, Stream +from rdpy.model import filetimes, error class MajorVersion(object): """ diff --git a/rdpy/protocol/rdp/nla/sspi.py b/rdpy/core/nla/sspi.py similarity index 98% rename from rdpy/protocol/rdp/nla/sspi.py rename to rdpy/core/nla/sspi.py index b8a3a7d..597ef54 100644 --- a/rdpy/protocol/rdp/nla/sspi.py +++ b/rdpy/core/nla/sspi.py @@ -21,7 +21,7 @@ @summary: security service provider interface (Microsoft) """ -from rdpy.core.error import CallPureVirtualFuntion +from rdpy.model.error import CallPureVirtualFuntion class IAuthenticationProtocol(object): """ diff --git a/rdpy/protocol/rdp/__init__.py b/rdpy/core/pdu/__init__.py similarity index 100% rename from rdpy/protocol/rdp/__init__.py rename to rdpy/core/pdu/__init__.py diff --git a/rdpy/protocol/rdp/pdu/caps.py b/rdpy/core/pdu/caps.py similarity index 98% rename from rdpy/protocol/rdp/pdu/caps.py rename to rdpy/core/pdu/caps.py index 1944357..14b2d89 100644 --- a/rdpy/protocol/rdp/pdu/caps.py +++ b/rdpy/core/pdu/caps.py @@ -16,16 +16,17 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # -from rdpy.core.error import InvalidExpectedDataException -import rdpy.core.log as log +from rdpy.model.error import InvalidExpectedDataException +import rdpy.model.log as log """ Definition of structure use for capabilities nego Use in PDU layer """ -from rdpy.core.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt32Le, sizeof, ArrayType, FactoryType - +from rdpy.model.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt32Le, sizeof, ArrayType, FactoryType + + class CapsType(object): """ @summary: Different type of capabilities diff --git a/rdpy/protocol/rdp/pdu/data.py b/rdpy/core/pdu/data.py similarity index 99% rename from rdpy/protocol/rdp/pdu/data.py rename to rdpy/core/pdu/data.py index 509cc6c..4fba42d 100644 --- a/rdpy/protocol/rdp/pdu/data.py +++ b/rdpy/core/pdu/data.py @@ -22,10 +22,10 @@ Implement the main graphic layer In this layer are managed all mains bitmap update orders end user inputs """ -from rdpy.core.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt32Le, sizeof, ArrayType, FactoryType -from rdpy.core.error import InvalidExpectedDataException -import rdpy.core.log as log -import caps, order +from rdpy.model.type import CompositeType, CallableValue, String, UInt8, UInt16Le, UInt32Le, sizeof, ArrayType, FactoryType +from rdpy.model.error import InvalidExpectedDataException +import rdpy.model.log as log +from rdpy.core.pdu import caps, order class PDUType(object): """ diff --git a/rdpy/protocol/rdp/pdu/layer.py b/rdpy/core/pdu/layer.py similarity index 99% rename from rdpy/protocol/rdp/pdu/layer.py rename to rdpy/core/pdu/layer.py index aebcd15..52cd4b9 100644 --- a/rdpy/protocol/rdp/pdu/layer.py +++ b/rdpy/core/pdu/layer.py @@ -23,12 +23,13 @@ Implement the main graphic layer In this layer are managed all mains bitmap update orders end user inputs """ -from rdpy.core.layer import LayerAutomata -from rdpy.core.error import CallPureVirtualFuntion -from rdpy.core.type import ArrayType -import rdpy.core.log as log -import rdpy.protocol.rdp.tpkt as tpkt -import data, caps +from rdpy.model.layer import LayerAutomata +from rdpy.model.error import CallPureVirtualFuntion +from rdpy.model.type import ArrayType +import rdpy.model.log as log +from rdpy.core import tpkt +from rdpy.core.pdu import data, caps + class PDUClientListener(object): """ diff --git a/rdpy/protocol/rdp/pdu/order.py b/rdpy/core/pdu/order.py similarity index 96% rename from rdpy/protocol/rdp/pdu/order.py rename to rdpy/core/pdu/order.py index 4885ea8..bd829bf 100644 --- a/rdpy/protocol/rdp/pdu/order.py +++ b/rdpy/core/pdu/order.py @@ -21,9 +21,9 @@ GDI order structure """ -from rdpy.core import log -from rdpy.core.error import InvalidExpectedDataException -from rdpy.core.type import CompositeType, UInt8, String, FactoryType, SInt8, SInt16Le +from rdpy.model import log +from rdpy.model.error import InvalidExpectedDataException +from rdpy.model.type import CompositeType, UInt8, String, FactoryType, SInt8, SInt16Le class ControlFlag(object): """ diff --git a/rdpy/protocol/rdp/rdp.py b/rdpy/core/rdp.py similarity index 91% rename from rdpy/protocol/rdp/rdp.py rename to rdpy/core/rdp.py index 3b48608..eb4575b 100644 --- a/rdpy/protocol/rdp/rdp.py +++ b/rdpy/core/rdp.py @@ -21,15 +21,19 @@ Use to manage RDP stack in twisted """ -from rdpy.core import layer -from rdpy.core.error import CallPureVirtualFuntion, InvalidValue -import pdu.layer -import pdu.data -import pdu.caps -import rdpy.core.log as log -import tpkt, x224, sec -from t125 import mcs, gcc -from nla import cssp, ntlm +from rdpy.model import layer +from rdpy.model.error import CallPureVirtualFuntion, InvalidValue +from rdpy.core.pdu.layer import PDUClientListener, PDUServerListener +from rdpy.core.pdu import data +from rdpy.core.pdu import caps +from rdpy.core.pdu import layer as pdu +import rdpy.model.log as log +import rdpy.core.tpkt as tpkt +import rdpy.core.x224 as x224 +import rdpy.core.sec as sec +from rdpy.core.t125 import mcs, gcc +from rdpy.core.nla import cssp, ntlm + class SecurityLevel(object): """ @@ -39,7 +43,8 @@ class SecurityLevel(object): RDP_LEVEL_SSL = 1 RDP_LEVEL_NLA = 2 -class RDPClientController(pdu.layer.PDUClientListener): + +class RDPClientController(PDUClientListener): """ Manage RDP stack as client """ @@ -47,7 +52,7 @@ class RDPClientController(pdu.layer.PDUClientListener): #list of observer self._clientObserver = [] #PDU layer - self._pduLayer = pdu.layer.Client(self) + self._pduLayer = pdu.Client(self) #secure layer self._secLayer = sec.Client(self._pduLayer) #multi channel service @@ -365,7 +370,8 @@ class RDPClientController(pdu.layer.PDUClientListener): """ self._pduLayer.close() -class RDPServerController(pdu.layer.PDUServerListener): + +class RDPServerController(PDUServerListener): """ @summary: Controller use in server side mode """ @@ -585,49 +591,50 @@ class ClientFactory(layer.RawLayerClientFactory): """ raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "buildObserver", "ClientFactory")) -class ServerFactory(layer.RawLayerServerFactory): - """ - @summary: Factory of Server RDP protocol - """ - def __init__(self, colorDepth, privateKeyFileName = None, certificateFileName = None): - """ - @param colorDepth: color depth of session - @param privateKeyFileName: file contain server private key (if none -> back to standard RDP security) - @param certficiateFileName: file that contain public key (if none -> back to standard RDP security) - """ - self._colorDepth = colorDepth - self._privateKeyFileName = privateKeyFileName - self._certificateFileName = certificateFileName - - def connectionLost(self, tpktLayer, reason): - """ - @param reason: twisted reason - """ - #retrieve controller - x224Layer = tpktLayer._presentation - mcsLayer = x224Layer._presentation - secLayer = mcsLayer._channels[mcs.Channel.MCS_GLOBAL_CHANNEL] - pduLayer = secLayer._presentation - controller = pduLayer._listener - controller.onClose() - - def buildRawLayer(self, addr): - """ - @summary: Function call from twisted and build rdp protocol stack - @param addr: destination address - """ - controller = RDPServerController(self._colorDepth, self._privateKeyFileName, self._certificateFileName) - self.buildObserver(controller, addr) - return controller.getProtocol() - - def buildObserver(self, controller, addr): - """ - @summary: Build observer use for connection - @param controller: RDP stack controller - @param addr: destination address - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "buildObserver", "ServerFactory")) - + +# class ServerFactory(RawLayerServerFactory): +# """ +# @summary: Factory of Server RDP protocol +# """ +# def __init__(self, colorDepth, privateKeyFileName = None, certificateFileName = None): +# """ +# @param colorDepth: color depth of session +# @param privateKeyFileName: file contain server private key (if none -> back to standard RDP security) +# @param certficiateFileName: file that contain public key (if none -> back to standard RDP security) +# """ +# self._colorDepth = colorDepth +# self._privateKeyFileName = privateKeyFileName +# self._certificateFileName = certificateFileName +# +# def connectionLost(self, tpktLayer, reason): +# """ +# @param reason: twisted reason +# """ +# #retrieve controller +# x224Layer = tpktLayer._presentation +# mcsLayer = x224Layer._presentation +# secLayer = mcsLayer._channels[mcs.Channel.MCS_GLOBAL_CHANNEL] +# pduLayer = secLayer._presentation +# controller = pduLayer._listener +# controller.onClose() +# +# def buildRawLayer(self, addr): +# """ +# @summary: Function call from twisted and build rdp protocol stack +# @param addr: destination address +# """ +# controller = RDPServerController(self._colorDepth, self._privateKeyFileName, self._certificateFileName) +# self.buildObserver(controller, addr) +# return controller.getProtocol() +# +# def buildObserver(self, controller, addr): +# """ +# @summary: Build observer use for connection +# @param controller: RDP stack controller +# @param addr: destination address +# """ +# raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "buildObserver", "ServerFactory")) +# class RDPClientObserver(object): """ @summary: Class use to inform all RDP event handle by RDPY diff --git a/rdpy/protocol/rdp/sec.py b/rdpy/core/sec.py similarity index 98% rename from rdpy/protocol/rdp/sec.py rename to rdpy/core/sec.py index 7a49b5a..9ce66db 100644 --- a/rdpy/protocol/rdp/sec.py +++ b/rdpy/core/sec.py @@ -21,13 +21,14 @@ RDP Standard security layer """ -import sha, md5 -import lic, tpkt -from t125 import gcc, mcs -from rdpy.core.type import CompositeType, CallableValue, Stream, UInt32Le, UInt16Le, String, sizeof, UInt8 -from rdpy.core.layer import LayerAutomata, IStreamSender -from rdpy.core.error import InvalidExpectedDataException -from rdpy.core import log +from hashlib import sha1 as sha +from hashlib import md5 +from rdpy.core import tpkt, lic +from rdpy.core.t125 import gcc, mcs +from rdpy.model.type import CompositeType, CallableValue, Stream, UInt32Le, UInt16Le, String, sizeof, UInt8 +from rdpy.model.layer import LayerAutomata, IStreamSender +from rdpy.model.error import InvalidExpectedDataException +from rdpy.model import log from rdpy.security import rc4 import rdpy.security.rsa_wrapper as rsa diff --git a/rdpy/protocol/rdp/nla/__init__.py b/rdpy/core/t125/__init__.py similarity index 100% rename from rdpy/protocol/rdp/nla/__init__.py rename to rdpy/core/t125/__init__.py diff --git a/rdpy/protocol/rdp/t125/ber.py b/rdpy/core/t125/ber.py similarity index 98% rename from rdpy/protocol/rdp/t125/ber.py rename to rdpy/core/t125/ber.py index 6afb9e2..3081236 100644 --- a/rdpy/protocol/rdp/t125/ber.py +++ b/rdpy/core/t125/ber.py @@ -22,8 +22,8 @@ Basic Encoding Rules use in RDP. ASN.1 standard """ -from rdpy.core.type import UInt8, UInt16Be, UInt32Be, String -from rdpy.core.error import InvalidExpectedDataException, InvalidSize +from rdpy.model.type import UInt8, UInt16Be, UInt32Be, String +from rdpy.model.error import InvalidExpectedDataException, InvalidSize class BerPc(object): BER_PC_MASK = 0x20 diff --git a/rdpy/protocol/rdp/t125/gcc.py b/rdpy/core/t125/gcc.py similarity index 98% rename from rdpy/protocol/rdp/t125/gcc.py rename to rdpy/core/t125/gcc.py index 1fa0716..20721bf 100644 --- a/rdpy/protocol/rdp/t125/gcc.py +++ b/rdpy/core/t125/gcc.py @@ -22,11 +22,11 @@ Implement GCC structure use in RDP protocol http://msdn.microsoft.com/en-us/library/cc240508.aspx """ -import md5 -from rdpy.core.type import UInt8, UInt16Le, UInt32Le, CompositeType, CallableValue, String, Stream, sizeof, FactoryType, ArrayType -import per, mcs -from rdpy.core.error import InvalidExpectedDataException -from rdpy.core import log +from hashlib import md5 +from rdpy.model.type import UInt8, UInt16Le, UInt32Le, CompositeType, CallableValue, String, Stream, sizeof, FactoryType, ArrayType +from rdpy.core.t125 import per, mcs +from rdpy.model.error import InvalidExpectedDataException +from rdpy.model import log from rdpy.security import x509 import rdpy.security.rsa_wrapper as rsa diff --git a/rdpy/protocol/rdp/t125/mcs.py b/rdpy/core/t125/mcs.py similarity index 98% rename from rdpy/protocol/rdp/t125/mcs.py rename to rdpy/core/t125/mcs.py index 78c604e..6837e90 100644 --- a/rdpy/protocol/rdp/t125/mcs.py +++ b/rdpy/core/t125/mcs.py @@ -24,13 +24,13 @@ Each channel have a particular role. The main channel is the graphical channel. It exist channel for file system order, audio channel, clipboard etc... """ -from rdpy.core.layer import LayerAutomata, IStreamSender, Layer -from rdpy.core.type import sizeof, Stream, UInt8, UInt16Le, String -from rdpy.core.error import InvalidExpectedDataException, InvalidValue, InvalidSize, CallPureVirtualFuntion -from ber import writeLength -import rdpy.core.log as log +from rdpy.model.layer import LayerAutomata, IStreamSender, Layer +from rdpy.model.type import sizeof, Stream, UInt8, UInt16Le, String +from rdpy.model.error import InvalidExpectedDataException, InvalidValue, InvalidSize, CallPureVirtualFuntion +from rdpy.core.t125.ber import writeLength +import rdpy.model.log as log -import ber, gcc, per +from rdpy.core.t125 import ber, gcc, per import rdpy.security.rsa_wrapper as rsa class Message(object): diff --git a/rdpy/protocol/rdp/t125/per.py b/rdpy/core/t125/per.py similarity index 98% rename from rdpy/protocol/rdp/t125/per.py rename to rdpy/core/t125/per.py index 6af2388..1f07295 100644 --- a/rdpy/protocol/rdp/t125/per.py +++ b/rdpy/core/t125/per.py @@ -21,8 +21,8 @@ Per encoded function """ -from rdpy.core.type import UInt8, UInt16Be, UInt32Be, String -from rdpy.core.error import InvalidValue, InvalidExpectedDataException +from rdpy.model.type import UInt8, UInt16Be, UInt32Be, String +from rdpy.model.error import InvalidValue, InvalidExpectedDataException def readLength(s): """ diff --git a/rdpy/protocol/rdp/tpkt.py b/rdpy/core/tpkt.py similarity index 98% rename from rdpy/protocol/rdp/tpkt.py rename to rdpy/core/tpkt.py index e7fa150..9207bbc 100644 --- a/rdpy/protocol/rdp/tpkt.py +++ b/rdpy/core/tpkt.py @@ -22,9 +22,10 @@ Transport packet layer implementation Use to build correct size packet and handle slow path and fast path mode """ -from rdpy.core.layer import RawLayer -from rdpy.core.type import UInt8, UInt16Be, sizeof -from rdpy.core.error import CallPureVirtualFuntion +from rdpy.model.layer import RawLayer +from rdpy.model.type import UInt8, UInt16Be, sizeof +from rdpy.model.error import CallPureVirtualFuntion + class Action(object): """ diff --git a/rdpy/protocol/rdp/x224.py b/rdpy/core/x224.py similarity index 88% rename from rdpy/protocol/rdp/x224.py rename to rdpy/core/x224.py index bd900ce..2e4a4f5 100644 --- a/rdpy/protocol/rdp/x224.py +++ b/rdpy/core/x224.py @@ -23,11 +23,11 @@ Implement transport PDU layer This layer have main goal to negociate SSL transport RDP basic security is supported only on client side """ -from rdpy.core import log +from rdpy.model import log -from rdpy.core.layer import LayerAutomata, IStreamSender -from rdpy.core.type import UInt8, UInt16Le, UInt16Be, UInt32Le, CompositeType, sizeof, String -from rdpy.core.error import InvalidExpectedDataException, RDPSecurityNegoFail +from rdpy.model.layer import LayerAutomata, IStreamSender +from rdpy.model.type import UInt8, UInt16Le, UInt16Be, UInt32Le, CompositeType, sizeof, String +from rdpy.model.error import InvalidExpectedDataException, RDPSecurityNegoFail class MessageType(object): """ @@ -303,38 +303,8 @@ class Server(X224Layer): if self._selectedProtocol == Protocols.PROTOCOL_SSL: log.debug("*" * 10 + " select SSL layer " + "*" * 10) #_transport is TPKT and transport is TCP layer of twisted - self._transport.startTLS(ServerTLSContext(self._serverPrivateKeyFileName, self._serverCertificateFileName)) + #self._transport.startTLS(ServerTLSContext(self._serverPrivateKeyFileName, self._serverCertificateFileName)) #connection is done send to presentation self.setNextState(self.recvData) self._presentation.connect() - -#open ssl needed -from twisted.internet import ssl -from OpenSSL import SSL - -class ClientTLSContext(ssl.ClientContextFactory): - """ - @summary: client context factory for open ssl - """ - def getContext(self): - context = SSL.Context(SSL.TLSv1_METHOD) - context.set_options(SSL.OP_DONT_INSERT_EMPTY_FRAGMENTS) - context.set_options(SSL.OP_TLS_BLOCK_PADDING_BUG) - return context - -class ServerTLSContext(ssl.DefaultOpenSSLContextFactory): - """ - @summary: Server context factory for open ssl - @param privateKeyFileName: Name of a file containing a private key - @param certificateFileName: Name of a file containing a certificate - """ - def __init__(self, privateKeyFileName, certificateFileName): - class TPDUSSLContext(SSL.Context): - def __init__(self, method): - SSL.Context.__init__(self, method) - self.set_options(SSL.OP_DONT_INSERT_EMPTY_FRAGMENTS) - self.set_options(SSL.OP_TLS_BLOCK_PADDING_BUG) - - ssl.DefaultOpenSSLContextFactory.__init__(self, privateKeyFileName, certificateFileName, SSL.SSLv23_METHOD, TPDUSSLContext) - \ No newline at end of file diff --git a/rdpy/protocol/rdp/pdu/__init__.py b/rdpy/model/__init__.py similarity index 100% rename from rdpy/protocol/rdp/pdu/__init__.py rename to rdpy/model/__init__.py diff --git a/rdpy/core/const.py b/rdpy/model/const.py similarity index 100% rename from rdpy/core/const.py rename to rdpy/model/const.py diff --git a/rdpy/core/error.py b/rdpy/model/error.py similarity index 100% rename from rdpy/core/error.py rename to rdpy/model/error.py diff --git a/rdpy/core/filetimes.py b/rdpy/model/filetimes.py similarity index 100% rename from rdpy/core/filetimes.py rename to rdpy/model/filetimes.py diff --git a/rdpy/core/layer.py b/rdpy/model/layer.py similarity index 83% rename from rdpy/core/layer.py rename to rdpy/model/layer.py index 7194495..89fab12 100644 --- a/rdpy/core/layer.py +++ b/rdpy/model/layer.py @@ -22,8 +22,9 @@ Join RDPY design with twisted design RDPY use Layer Protocol design (like twisted) """ +import asyncio +from rdpy.model.error import CallPureVirtualFuntion -from rdpy.core.error import CallPureVirtualFuntion class IStreamListener(object): """ @@ -35,7 +36,8 @@ class IStreamListener(object): @param s: Stream """ raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recv", "IStreamListener")) - + + class IStreamSender(object): """ @summary: Interface use to inform stream sender capability @@ -46,7 +48,8 @@ class IStreamSender(object): @param data: Type or tuple element handle by transport layer """ raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "send", "IStreamSender")) - + + class Layer(object): """ @summary: A simple double linked list with presentation and transport layer @@ -79,7 +82,8 @@ class Layer(object): """ if not self._transport is None: self._transport.close() - + + class LayerAutomata(Layer, IStreamListener): """ @summary: Layer with automata callback @@ -103,13 +107,8 @@ class LayerAutomata(Layer, IStreamListener): self.recv = callback -#twisted layer concept -from twisted.internet import protocol -from twisted.internet.abstract import FileDescriptor -#first that handle stream -from type import Stream -class RawLayerClientFactory(protocol.ClientFactory): +class RawLayerClientFactory(asyncio.Protocol): """ @summary: Abstract class for Raw layer client factory """ @@ -136,37 +135,38 @@ class RawLayerClientFactory(protocol.ClientFactory): @param reason: twisted reason """ raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "connectionLost", "RawLayerClientFactory")) - -class RawLayerServerFactory(protocol.ServerFactory): - """ - @summary: Abstract class for Raw layer server factory - """ - def buildProtocol(self, addr): - """ - @summary: Function call from twisted - @param addr: destination address - """ - rawLayer = self.buildRawLayer(addr) - rawLayer.setFactory(self) - return rawLayer - - def buildRawLayer(self, addr): - """ - @summary: Override this function to build raw layer - @param addr: destination address - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recv", "IStreamListener")) - - def connectionLost(self, rawlayer, reason): - """ - @summary: Override this method to handle connection lost - @param rawlayer: rawLayer that cause connectionLost event - @param reason: twisted reason - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recv", "IStreamListener")) - -class RawLayer(protocol.Protocol, LayerAutomata, IStreamSender): + +# class RawLayerServerFactory(protocol.ServerFactory): +# """ +# @summary: Abstract class for Raw layer server factory +# """ +# def buildProtocol(self, addr): +# """ +# @summary: Function call from twisted +# @param addr: destination address +# """ +# rawLayer = self.buildRawLayer(addr) +# rawLayer.setFactory(self) +# return rawLayer +# +# def buildRawLayer(self, addr): +# """ +# @summary: Override this function to build raw layer +# @param addr: destination address +# """ +# raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recv", "IStreamListener")) +# +# def connectionLost(self, rawlayer, reason): +# """ +# @summary: Override this method to handle connection lost +# @param rawlayer: rawLayer that cause connectionLost event +# @param reason: twisted reason +# """ +# raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recv", "IStreamListener")) +# +# +class RawLayer(asyncio.Protocol, LayerAutomata, IStreamSender): """ @summary: Wait event from twisted engine And format correct size packet @@ -183,14 +183,14 @@ class RawLayer(protocol.Protocol, LayerAutomata, IStreamSender): #len of next packet pass to next state function self._expectedLen = 0 self._factory = None - + def setFactory(self, factory): """ @summary: Call by RawLayer Factory @param param: RawLayerClientFactory or RawLayerFactory """ self._factory = factory - + def dataReceived(self, data): """ @summary: Inherit from twisted.protocol class @@ -207,27 +207,27 @@ class RawLayer(protocol.Protocol, LayerAutomata, IStreamSender): self._buffer = self._buffer[self._expectedLen:] #call recv function self.recv(expectedData) - + def connectionMade(self): """ @summary: inherit from twisted protocol """ #join two scheme self.connect() - + def connectionLost(self, reason): """ @summary: Call from twisted engine when protocol is closed @param reason: str represent reason of close connection """ self._factory.connectionLost(self, reason) - + def getDescriptor(self): """ @return: the twited file descriptor """ return self.transport - + def close(self): """ @summary: Close raw layer @@ -235,10 +235,10 @@ class RawLayer(protocol.Protocol, LayerAutomata, IStreamSender): Because is bugged """ FileDescriptor.loseConnection(self.getDescriptor()) - + def expect(self, expectedLen, callback = None): """ - @summary: Set next automata callback, + @summary: Set next automata callback, But this callback will be only called when data have expectedLen @param expectedLen: in bytes length use to call next state @@ -247,7 +247,7 @@ class RawLayer(protocol.Protocol, LayerAutomata, IStreamSender): self._expectedLen = expectedLen #default callback is recv from LayerAutomata self.setNextState(callback) - + def send(self, message): """ @summary: Send Stream on TCP layer diff --git a/rdpy/core/log.py b/rdpy/model/log.py similarity index 98% rename from rdpy/core/log.py rename to rdpy/model/log.py index cabd775..d8ebbb8 100644 --- a/rdpy/core/log.py +++ b/rdpy/model/log.py @@ -44,7 +44,7 @@ def log(message): f = open(_LOG_FILE, "a+") f.write("%s\n"%message) f.close() - print "[*] %s"%message + print("[*] %s"%message) def error(message): """ diff --git a/rdpy/core/rss.py b/rdpy/model/rss.py similarity index 98% rename from rdpy/core/rss.py rename to rdpy/model/rss.py index df1178f..543327d 100644 --- a/rdpy/core/rss.py +++ b/rdpy/model/rss.py @@ -22,8 +22,8 @@ Remote Session Scenario File format Private protocol format to save events """ -from rdpy.core.type import CompositeType, FactoryType, UInt8, UInt16Le, UInt32Le, String, sizeof, Stream -from rdpy.core import log, error +from rdpy.model.type import CompositeType, FactoryType, UInt8, UInt16Le, UInt32Le, String, sizeof, Stream +from rdpy.model import log, error import time class EventType(object): diff --git a/rdpy/core/scancode.py b/rdpy/model/scancode.py similarity index 100% rename from rdpy/core/scancode.py rename to rdpy/model/scancode.py diff --git a/rdpy/core/type.py b/rdpy/model/type.py similarity index 99% rename from rdpy/core/type.py rename to rdpy/model/type.py index 260c672..1cb85dc 100644 --- a/rdpy/core/type.py +++ b/rdpy/model/type.py @@ -26,9 +26,10 @@ We are in python! import struct from copy import deepcopy -from StringIO import StringIO -from rdpy.core.error import InvalidExpectedDataException, InvalidSize, CallPureVirtualFuntion, InvalidValue -import rdpy.core.log as log +from io import BytesIO +from rdpy.model.error import InvalidExpectedDataException, InvalidSize, CallPureVirtualFuntion, InvalidValue +import rdpy.model.log as log + def sizeof(element): """ @@ -852,7 +853,8 @@ def decodeUnicode(s): i += 1 return r -class Stream(StringIO): + +class Stream(BytesIO): """ @summary: Stream use to read all types """ diff --git a/rdpy/protocol/rdp/t125/__init__.py b/rdpy/protocol/rdp/t125/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/rdpy/protocol/rfb/__init__.py b/rdpy/protocol/rfb/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/rdpy/protocol/rfb/rfb.py b/rdpy/protocol/rfb/rfb.py deleted file mode 100644 index b43cfa0..0000000 --- a/rdpy/protocol/rfb/rfb.py +++ /dev/null @@ -1,765 +0,0 @@ -# -# Copyright (c) 2014-2015 Sylvain Peyrefitte -# -# This file is part of rdpy. -# -# rdpy is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . -# - -""" -Implement Remote FrameBuffer protocol use in VNC client and server -@see: http://www.realvnc.com/docs/rfbproto.pdf - -@todo: server side of protocol -@todo: more encoding rectangle -""" - -from rdpy.core.layer import RawLayer, RawLayerClientFactory -from rdpy.core.type import UInt8, UInt16Be, UInt32Be, SInt32Be, String, CompositeType -from rdpy.core.error import InvalidValue, CallPureVirtualFuntion -from rdpy.security.pyDes import des -import rdpy.core.log as log - -class ProtocolVersion(object): - """ - @summary: Different protocol version - """ - UNKNOWN = "" - RFB003003 = "RFB 003.003\n" - RFB003007 = "RFB 003.007\n" - RFB003008 = "RFB 003.008\n" - -class SecurityType(object): - """ - @summary: Security type supported - """ - INVALID = 0 - NONE = 1 - VNC = 2 - -class Pointer(object): - """ - @summary: Mouse event code (which button) - actually in RFB specification only - three buttons are supported - """ - BUTTON1 = 0x1 - BUTTON2 = 0x2 - BUTTON3 = 0x4 - -class Encoding(object): - """ - @summary: Encoding types of FrameBuffer update - """ - RAW = 0 - -class ClientToServerMessages(object): - """ - @summary: Client to server messages types - """ - PIXEL_FORMAT = 0 - ENCODING = 2 - FRAME_BUFFER_UPDATE_REQUEST = 3 - KEY_EVENT = 4 - POINTER_EVENT = 5 - CUT_TEXT = 6 - -class PixelFormat(CompositeType): - """ - @summary: Pixel format structure - """ - def __init__(self): - CompositeType.__init__(self) - self.BitsPerPixel = UInt8(32) - self.Depth = UInt8(24) - self.BigEndianFlag = UInt8(False) - self.TrueColorFlag = UInt8(True) - self.RedMax = UInt16Be(255) - self.GreenMax = UInt16Be(255) - self.BlueMax = UInt16Be(255) - self.RedShift = UInt8(16) - self.GreenShift = UInt8(8) - self.BlueShift = UInt8(0) - self.padding = (UInt16Be(), UInt8()) - -class ServerInit(CompositeType): - """ - @summary: Server init structure - FrameBuffer configuration - """ - def __init__(self): - CompositeType.__init__(self) - self.width = UInt16Be() - self.height = UInt16Be() - self.pixelFormat = PixelFormat() - -class FrameBufferUpdateRequest(CompositeType): - """ - @summary: FrameBuffer update request send from client to server - Incremental means that server send update with a specific - order, and client must draw orders in same order - """ - def __init__(self, incremental = False, x = 0, y = 0, width = 0, height = 0): - CompositeType.__init__(self) - self.incremental = UInt8(incremental) - self.x = UInt16Be(x) - self.y = UInt16Be(y) - self.width = UInt16Be(width) - self.height = UInt16Be(height) - - -class Rectangle(CompositeType): - """ - @summary: Header message of update rectangle - """ - def __init__(self): - CompositeType.__init__(self) - self.x = UInt16Be() - self.y = UInt16Be() - self.width = UInt16Be() - self.height = UInt16Be() - self.encoding = SInt32Be() - -class KeyEvent(CompositeType): - """ - @summary: Key event structure message - Use to send a keyboard event - """ - def __init__(self): - CompositeType.__init__(self) - self.downFlag = UInt8(False) - self.padding = UInt16Be() - self.key = UInt32Be() - -class PointerEvent(CompositeType): - """ - @summary: Pointer event structure message - Use to send mouse event - """ - def __init__(self): - CompositeType.__init__(self) - self.mask = UInt8() - self.x = UInt16Be() - self.y = UInt16Be() - -class ClientCutText(CompositeType): - """ - @summary: Client cut text message message - Use to simulate copy paste (ctrl-c ctrl-v) only for text - """ - def __init__(self, text = ""): - CompositeType.__init__(self) - self.padding = (UInt16Be(), UInt8()) - self.size = UInt32Be(len(text)) - self.message = String(text) - -class ServerCutTextHeader(CompositeType): - """ - @summary: Cut text header send from server to client - """ - def __init__(self): - CompositeType.__init__(self) - self.padding = (UInt16Be(), UInt8()) - self.size = UInt32Be() - -class RFB(RawLayer): - """ - @summary: Implement RFB protocol - """ - def __init__(self, listener): - """ - @param listener: listener use to inform new orders - """ - RawLayer.__init__(self) - #set client listener - self._clientListener = listener - #useful for RFB protocol - self._callbackBody = None - #protocol version negotiated - self._version = String(ProtocolVersion.RFB003008) - #number security launch by server - self._securityLevel = UInt8(SecurityType.INVALID) - #shared FrameBuffer client init message - self._sharedFlag = UInt8(False) - #server init message - #which contain FrameBuffer dim and pixel format - self._serverInit = ServerInit() - #client pixel format - self._pixelFormat = PixelFormat() - #server name - self._serverName = String() - #nb rectangle - self._nbRect = 0 - #current rectangle header - self._currentRect = Rectangle() - #for vnc security type - self._password = '\0' * 8 - - def expectWithHeader(self, expectedHeaderLen, callbackBody): - """ - 2nd level of waiting event - read expectedHeaderLen that contain body size - @param expectedHeaderLen: contains the number of bytes, which body length needs to be encoded - @param callbackBody: next state use when expected date from expectedHeaderLen - are received - """ - self._callbackBody = callbackBody - self.expect(expectedHeaderLen, self.expectedBody) - - def expectedBody(self, data): - """ - Read header and wait header value to call next state - @param data: Stream that length are to header length (1|2|4 bytes) - set next state to callBack body when length read from header - are received - """ - bodyLen = None - if data.len == 1: - bodyLen = UInt8() - elif data.len == 2: - bodyLen = UInt16Be() - elif data.len == 4: - bodyLen = UInt32Be() - else: - log.error("invalid header length") - return - data.readType(bodyLen) - self.expect(bodyLen.value, self._callbackBody) - - def connect(self): - """ - Call when transport layer connection is made - in Client mode -> wait protocol version - """ - self.expect(12, self.recvProtocolVersion) - - def readProtocolVersion(self, data): - """ - Read protocol version - @param data: Stream may contain protocol version string (ProtocolVersion) - """ - data.readType(self._version) - if not self._version.value in [ProtocolVersion.RFB003003, ProtocolVersion.RFB003007, ProtocolVersion.RFB003008]: - self._version.value = ProtocolVersion.UNKNOWN - - def recvProtocolVersion(self, data): - """ - Read handshake packet - If protocol receive from client is unknown - try best version of protocol version (ProtocolVersion.RFB003008) - @param data: Stream - """ - self.readProtocolVersion(data) - if self._version.value == ProtocolVersion.UNKNOWN: - log.info("Unknown protocol version %s send 003.008"%data.getvalue()) - #protocol version is unknown try best version we can handle - self._version.value = ProtocolVersion.RFB003008 - #send same version of - self.send(self._version) - - #next state read security - if self._version.value == ProtocolVersion.RFB003003: - self.expect(4, self.recvSecurityServer) - else: - self.expectWithHeader(1, self.recvSecurityList) - - def recvSecurityServer(self, data): - """ - Security handshake for 33 RFB version - Server imposed security level - @param data: well formed packet - """ - #TODO!!! - pass - - def recvSecurityList(self, data): - """ - Read security list packet send from server to client - @param data: Stream that contains well formed packet - """ - securityList = [] - while data.dataLen() > 0: - securityElement = UInt8() - data.readType(securityElement) - securityList.append(securityElement) - #select high security level - for s in securityList: - if s.value in [SecurityType.NONE, SecurityType.VNC] and s > self._securityLevel: - self._securityLevel = s - break - #send back security level choosen - self.send(self._securityLevel) - if self._securityLevel.value == SecurityType.VNC: - self.expect(16, self.recvVNCChallenge) - else: - self.expect(4, self.recvSecurityResult) - - def recvVNCChallenge(self, data): - """ - @summary: receive challenge in VNC authentication case - @param data: Stream that contain well formed packet - """ - key = (self._password + '\0' * 8)[:8] - newkey = [] - for ki in range(len(key)): - bsrc = ord(key[ki]) - btgt = 0 - for i in range(8): - if bsrc & (1 << i): - btgt = btgt | (1 << 7-i) - newkey.append(chr(btgt)) - - algo = des(newkey) - self.send(String(algo.encrypt(data.getvalue()))) - self.expect(4, self.recvSecurityResult) - - def recvSecurityResult(self, data): - """ - Read security result packet - Use by server to inform connection status of client - @param data: Stream that contain well formed packet - """ - result = UInt32Be() - data.readType(result) - if result == UInt32Be(1): - log.info("Authentification failed") - if self._version.value == ProtocolVersion.RFB003008: - self.expectWithHeader(4, self.recvSecurityFailed) - else: - log.debug("Authentification OK") - self.sendClientInit() - - def recvSecurityFailed(self, data): - """ - Send by server to inform reason of why it's refused client - @param data: Stream that contains well formed packet - """ - log.info("Security failed cause to %s"%data.getvalue()) - - def recvServerInit(self, data): - """ - Read server init packet - @param data: Stream that contains well formed packet - """ - data.readType(self._serverInit) - self.expectWithHeader(4, self.recvServerName) - - def recvServerName(self, data): - """ - @summary: Read server name - @param data: Stream that contains well formed packet - """ - data.readType(self._serverName) - log.info("Server name %s"%str(self._serverName)) - #end of handshake - #send pixel format - self.sendPixelFormat(self._pixelFormat) - #write encoding - self.sendSetEncoding() - #request entire zone - self.sendFramebufferUpdateRequest(False, 0, 0, self._serverInit.width.value, self._serverInit.height.value) - #now i'm ready to send event - self._clientListener.onReady() - self.expect(1, self.recvServerOrder) - - def recvServerOrder(self, data): - """ - @summary: Read order receive from server - Main function for bitmap update from server to client - @param data: Stream that contains well formed packet - """ - packetType = UInt8() - data.readType(packetType) - if packetType.value == 0: - self.expect(3, self.recvFrameBufferUpdateHeader) - elif packetType.value == 2: - self._clientListener.onBell() - elif packetType.value == 3: - self.expect(7, self.recvServerCutTextHeader) - else: - log.error("Unknown message type %s"%packetType.value) - - def recvFrameBufferUpdateHeader(self, data): - """ - @summary: Read frame buffer update packet header - @param data: Stream that contains well formed packet - """ - #padding - nbRect = UInt16Be() - self._nbRect = data.readType((UInt8(), nbRect)) - self._nbRect = nbRect.value - self.expect(12, self.recvRectHeader) - - def recvRectHeader(self, data): - """ - @summary: Read rectangle header - @param data: Stream that contains well formed packet - """ - data.readType(self._currentRect) - if self._currentRect.encoding.value == Encoding.RAW: - self.expect(self._currentRect.width.value * self._currentRect.height.value * (self._pixelFormat.BitsPerPixel.value / 8), self.recvRectBody) - - def recvRectBody(self, data): - """ - @summary: Read body of rectangle update - @param data: Stream that contains well formed packet - """ - self._clientListener.recvRectangle(self._currentRect, self._pixelFormat, data.getvalue()) - - self._nbRect -= 1 - #if there is another rect to read - if self._nbRect == 0: - #job is finish send a request - self.sendFramebufferUpdateRequest(True, 0, 0, self._serverInit.width.value, self._serverInit.height.value) - self.expect(1, self.recvServerOrder) - else: - self.expect(12, self.recvRectHeader) - - def recvServerCutTextHeader(self, data): - """ - @summary: callback when expect server cut text message - @param data: Stream that contains well formed packet - """ - header = ServerCutTextHeader() - data.readType(header) - self.expect(header.size.value, self.recvServerCutTextBody) - - def recvServerCutTextBody(self, data): - """ - @summary: Receive server cut text body - @param data: Stream that contains well formed packet - """ - self._clientListener.onCutText(data.getvalue()) - self.expect(1, self.recvServerOrder) - - def sendClientInit(self): - """ - @summary: Send client init packet - """ - self.send(self._sharedFlag) - self.expect(20, self.recvServerInit) - - def sendPixelFormat(self, pixelFormat): - """ - @summary: Send pixel format structure - Very important packet that inform the image struct supported by the client - @param pixelFormat: PixelFormat struct - """ - self.send((UInt8(ClientToServerMessages.PIXEL_FORMAT), UInt16Be(), UInt8(), pixelFormat)) - - def sendSetEncoding(self): - """ - @summary: Send set encoding packet - Actually only RAW bitmap encoding are used - """ - self.send((UInt8(ClientToServerMessages.ENCODING), UInt8(), UInt16Be(1), SInt32Be(Encoding.RAW))) - - def sendFramebufferUpdateRequest(self, incremental, x, y, width, height): - """ - @summary: Request server the specified zone - incremental means request only change before last update - """ - self.send((UInt8(ClientToServerMessages.FRAME_BUFFER_UPDATE_REQUEST), FrameBufferUpdateRequest(incremental, x, y, width, height))) - - def sendKeyEvent(self, keyEvent): - """ - @summary: Write key event packet - @param keyEvent: KeyEvent struct to send - """ - self.send((UInt8(ClientToServerMessages.KEY_EVENT), keyEvent)) - - def sendPointerEvent(self, pointerEvent): - """ - @summary: Write pointer event packet - @param pointerEvent: PointerEvent struct use - """ - self.send((UInt8(ClientToServerMessages.POINTER_EVENT), pointerEvent)) - - def sendClientCutText(self, text): - """ - @summary: write client cut text event packet - """ - self.send((UInt8(ClientToServerMessages.CUT_TEXT), ClientCutText(text))) - -class RFBClientListener(object): - """ - @summary: Interface use to expose event receive from RFB layer - """ - def recvRectangle(self, rectangle, pixelFormat, data): - """ - @summary: Receive rectangle order - Main update order type - @param rectangle: Rectangle type header of packet - @param pixelFormat: pixelFormat struct of current session - @param data: image data - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "recvRectangle", "RFBClientListener")) - - def onBell(self): - """ - @summary: receive bip from server - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onBell", "RFBClientListener")) - - def onCutText(self, text): - """ - @summary: Receive cut text from server - @param text: text inner cut text event - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onCutText", "RFBClientListener")) - - -class RFBClientController(RFBClientListener): - """ - @summary: Class use to manage RFB order and dispatch throw observers for client side - """ - def __init__(self): - self._clientObservers = [] - #rfb layer to send client orders - self._rfbLayer = RFB(self) - self._isReady = False - - def getProtocol(self): - """ - @return: RFB layer build by controller - """ - return self._rfbLayer - - def addClientObserver(self, observer): - """ - @summary: Add new observer for this protocol - @param observer: new observer - """ - self._clientObservers.append(observer) - observer._clientListener = self - - def getWidth(self): - """ - @return: width of framebuffer - """ - return self._rfbLayer._serverInit.width.value - - def getHeight(self): - """ - @return: height of framebuffer - """ - return self._rfbLayer._serverInit.height.value - - def getScreen(self): - """ - @return: (width, height) of screen - """ - return (self.getWidth(), self.getHeight()) - - def setPassword(self, password): - """ - @summary: set password for vnc authentication type - @param password: password for session - """ - self._rfbLayer._password = password - - def onReady(self): - """ - @summary: rfb stack is reday to send or receive event - """ - self._isReady = True - for observer in self._clientObservers: - observer.onReady() - - def recvRectangle(self, rectangle, pixelFormat, data): - """ - @summary: Receive rectangle order - Main update order type - @param rectangle: Rectangle type header of packet - @param pixelFormat: pixelFormat struct of current session - @param data: image data - """ - for observer in self._clientObservers: - observer.onUpdate(rectangle.width.value, rectangle.height.value, rectangle.x.value, rectangle.y.value, pixelFormat, rectangle.encoding, data) - - def onBell(self): - """ - @summary: biiiip event - """ - for observer in self._clientObservers: - observer.onBell() - - def onCutText(self, text): - """ - @summary: receive cut text event - @param text: text in cut text event - """ - for observer in self._clientObservers: - observer.onCutText(text) - - def onClose(self): - """ - @summary: handle on close events - """ - if not self._isReady: - log.debug("Close on non ready layer means authentication error") - return - for observer in self._clientObservers: - observer.onClose() - - def sendKeyEvent(self, isDown, key): - """ - @summary: Send a key event throw RFB protocol - @param isDown: boolean notify if key is pressed or not (True if key is pressed) - @param key: ASCII code of key - """ - if not self._isReady: - log.info("Try to send key event on non ready layer") - return - try: - event = KeyEvent() - event.downFlag.value = isDown - event.key.value = key - - self._rfbLayer.sendKeyEvent(event) - except InvalidValue: - log.debug("Try to send an invalid key event") - - def sendPointerEvent(self, mask, x, y): - """ - @summary: Send a pointer event throw RFB protocol - @param mask: mask of button if button 1 and 3 are pressed then mask is 00000101 - @param x: x coordinate of mouse pointer - @param y: y pointer of mouse pointer - """ - if not self._isReady: - log.info("Try to send pointer event on non ready layer") - return - try: - event = PointerEvent() - event.mask.value = mask - event.x.value = x - event.y.value = y - - self._rfbLayer.sendPointerEvent(event) - except InvalidValue: - log.debug("Try to send an invalid pointer event") - - def close(self): - """ - @summary: close rfb stack - """ - self._rfbLayer.close() - - -class ClientFactory(RawLayerClientFactory): - """ - @summary: Twisted Factory of RFB protocol - """ - def buildRawLayer(self, addr): - """ - @summary: Function call by twisted on connection - @param addr: address where client try to connect - """ - controller = RFBClientController() - self.buildObserver(controller, addr) - return controller.getProtocol() - - def connectionLost(self, rfblayer, reason): - """ - @summary: Override this method to handle connection lost - @param rfblayer: rfblayer that cause connectionLost event - @param reason: twisted reason - """ - #call controller - rfblayer._clientListener.onClose() - - def buildObserver(self, controller, addr): - """ - @summary: Build an RFB observer object - @param controller: controller use for rfb session - @param addr: destination - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "buildObserver", "ClientFactory")) - - -class RFBClientObserver(object): - """ - @summary: RFB client protocol observer - """ - def __init__(self, controller): - self._controller = controller - self._controller.addClientObserver(self) - - def getController(self): - """ - @return: RFB controller use by observer - """ - return self._controller - - def keyEvent(self, isPressed, key): - """ - @summary: Send a key event - @param isPressed: state of key - @param key: ASCII code of key - """ - self._controller.sendKeyEvent(isPressed, key) - - def mouseEvent(self, button, x, y): - """ - @summary: Send a mouse event to RFB Layer - @param button: button number which is pressed (0,1,2,3,4,5,6,7) - @param x: x coordinate of mouse pointer - @param y: y coordinate of mouse pointer - """ - mask = 0 - if button == 1: - mask = 1 - elif button > 1: - mask = 1 << button - 1 - - self._controller.sendPointerEvent(mask, x, y) - - def onReady(self): - """ - @summary: Event when network stack is ready to receive or send event - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onReady", "RFBClientObserver")) - - def onClose(self): - """ - @summary: On close event - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onClose", "RFBClientObserver")) - - def onUpdate(self, width, height, x, y, pixelFormat, encoding, data): - """ - @summary: Receive FrameBuffer update - @param width : width of image - @param height : height of image - @param x : x position - @param y : y position - @param pixelFormat : pixel format struct from rfb.types - @param encoding : encoding struct from rfb.types - @param data : in respect of dataFormat and pixelFormat - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onUpdate", "RFBClientObserver")) - - def onCutText(self, text): - """ - @summary: event when server send cut text event - @param text: text received - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onCutText", "RFBClientObserver")) - - def onBell(self): - """ - @summary: event when server send biiip - """ - raise CallPureVirtualFuntion("%s:%s defined by interface %s"%(self.__class__, "onBell", "RFBClientObserver")) diff --git a/rdpy/ui/qt4.py b/rdpy/ui/qt4.py index 237f974..8ca7d0e 100644 --- a/rdpy/ui/qt4.py +++ b/rdpy/ui/qt4.py @@ -23,13 +23,12 @@ Qt specific code QRemoteDesktop is a widget use for render in rdpy """ -from PyQt4 import QtGui, QtCore -from rdpy.protocol.rfb.rfb import RFBClientObserver -from rdpy.protocol.rdp.rdp import RDPClientObserver -from rdpy.core.error import CallPureVirtualFuntion +from PyQt5 import QtWidgets +from rdpy.core.rdp import RDPClientObserver +from rdpy.model.error import CallPureVirtualFuntion import sys -import rdpy.core.log as log +import rdpy.model.log as log import rle class QAdaptor(object): @@ -72,112 +71,10 @@ def qtImageFormatFromRFBPixelFormat(pixelFormat): @summary: convert RFB pixel format to QtGui.QImage format """ if pixelFormat.BitsPerPixel.value == 32: - return QtGui.QImage.Format_RGB32 + return QtWidgets.QImage.Format_RGB32 elif pixelFormat.BitsPerPixel.value == 16: - return QtGui.QImage.Format_RGB16 + return QtWidgets.QImage.Format_RGB16 -class RFBClientQt(RFBClientObserver, QAdaptor): - """ - @summary: QAdaptor for specific RFB protocol stack - is to an RFB observer - """ - def __init__(self, controller): - """ - @param controller: controller for observer - @param width: width of widget - @param height: height of widget - """ - RFBClientObserver.__init__(self, controller) - self._widget = QRemoteDesktop(1024, 800, self) - - def getWidget(self): - """ - @return: widget use for render - """ - return self._widget - - 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 - """ - imageFormat = qtImageFormatFromRFBPixelFormat(pixelFormat) - if imageFormat is None: - log.error("Receive image in bad format") - return - - image = QtGui.QImage(data, width, height, imageFormat) - self._widget.notifyImage(x, y, image, width, height) - - 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 onReady(self): - """ - @summary: Event when network stack is ready to receive or send event - """ - (width, height) = self._controller.getScreen() - self._widget.resize(width, height) - - def sendMouseEvent(self, e, isPressed): - """ - @summary: Convert Qt mouse event to RFB mouse event - @param e: qMouseEvent - @param isPressed: event come from press or release action - """ - button = e.button() - buttonNumber = 0 - if button == QtCore.Qt.LeftButton: - buttonNumber = 1 - elif button == QtCore.Qt.MidButton: - buttonNumber = 2 - elif button == QtCore.Qt.RightButton: - buttonNumber = 3 - self.mouseEvent(buttonNumber, e.pos().x(), e.pos().y()) - - def sendKeyEvent(self, e, isPressed): - """ - @summary: Convert Qt key press event to RFB press event - @param e: qKeyEvent - @param isPressed: event come from press or release action - """ - self.keyEvent(isPressed, e.nativeVirtualKey()) - - def sendWheelEvent(self, e): - """ - @summary: Convert Qt wheel event to RFB Wheel event - @param e: QKeyEvent - @param isPressed: event come from press or release action - """ - pass - - def closeEvent(self, e): - """ - @summary: Call when you want to close connection - @param: QCloseEvent - """ - self._controller.close() - - def onClose(self): - """ - @summary: Call when stack is close - """ - #do something maybe a message - pass def RDPBitmapToQtImage(width, height, bitsPerPixel, isCompress, data): """ @@ -195,36 +92,36 @@ def RDPBitmapToQtImage(width, height, bitsPerPixel, isCompress, data): if isCompress: buf = bytearray(width * height * 2) rle.bitmap_decompress(buf, width, height, data, 2) - image = QtGui.QImage(buf, width, height, QtGui.QImage.Format_RGB555) + image = QtWidgets.QImage(buf, width, height, QtWidgets.QImage.Format_RGB555) else: - image = QtGui.QImage(data, width, height, QtGui.QImage.Format_RGB555).transformed(QtGui.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) + image = QtWidgets.QImage(data, width, height, QtWidgets.QImage.Format_RGB555).transformed(QtWidgets.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) elif bitsPerPixel == 16: if isCompress: buf = bytearray(width * height * 2) rle.bitmap_decompress(buf, width, height, data, 2) - image = QtGui.QImage(buf, width, height, QtGui.QImage.Format_RGB16) + image = QtWidgets.QImage(buf, width, height, QtWidgets.QImage.Format_RGB16) else: - image = QtGui.QImage(data, width, height, QtGui.QImage.Format_RGB16).transformed(QtGui.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) + image = QtWidgets.QImage(data, width, height, QtWidgets.QImage.Format_RGB16).transformed(QtWidgets.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) elif bitsPerPixel == 24: if isCompress: buf = bytearray(width * height * 3) rle.bitmap_decompress(buf, width, height, data, 3) - image = QtGui.QImage(buf, width, height, QtGui.QImage.Format_RGB888) + image = QtWidgets.QImage(buf, width, height, QtWidgets.QImage.Format_RGB888) else: - image = QtGui.QImage(data, width, height, QtGui.QImage.Format_RGB888).transformed(QtGui.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) + image = QtWidgets.QImage(data, width, height, QtWidgets.QImage.Format_RGB888).transformed(QtWidgets.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) elif bitsPerPixel == 32: if isCompress: buf = bytearray(width * height * 4) rle.bitmap_decompress(buf, width, height, data, 4) - image = QtGui.QImage(buf, width, height, QtGui.QImage.Format_RGB32) + image = QtWidgets.QImage(buf, width, height, QtWidgets.QImage.Format_RGB32) else: - image = QtGui.QImage(data, width, height, QtGui.QImage.Format_RGB32).transformed(QtGui.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) + image = QtWidgets.QImage(data, width, height, QtWidgets.QImage.Format_RGB32).transformed(QtWidgets.QMatrix(1.0, 0.0, 0.0, -1.0, 0.0, 0.0)) else: log.error("Receive image in bad format") - image = QtGui.QImage(width, height, QtGui.QImage.Format_RGB32) + image = QtWidgets.QImage(width, height, QtWidgets.QImage.Format_RGB32) return image class RDPClientQt(RDPClientObserver, QAdaptor): @@ -330,7 +227,7 @@ class RDPClientQt(RDPClientObserver, QAdaptor): #do something maybe a message -class QRemoteDesktop(QtGui.QWidget): +class QRemoteDesktop(QtWidgets.QWidget): """ @summary: Qt display widget """ @@ -348,7 +245,7 @@ class QRemoteDesktop(QtGui.QWidget): #bind mouse event self.setMouseTracking(True) #buffer image - self._buffer = QtGui.QImage(width, height, QtGui.QImage.Format_RGB32) + self._buffer = QtWidgets.QImage(width, height, QtWidgets.QImage.Format_RGB32) def notifyImage(self, x, y, qimage, width, height): """ @@ -358,7 +255,7 @@ class QRemoteDesktop(QtGui.QWidget): @param qimage: new QImage """ #fill buffer image - with QtGui.QPainter(self._buffer) as qp: + with QtWidgets.QPainter(self._buffer) as qp: qp.drawImage(x, y, qimage, 0, 0, width, height) #force update self.update() @@ -369,8 +266,8 @@ class QRemoteDesktop(QtGui.QWidget): @param width: {int} width of widget @param height: {int} height of widget """ - self._buffer = QtGui.QImage(width, height, QtGui.QImage.Format_RGB32) - QtGui.QWidget.resize(self, width, height) + self._buffer = QtWidgets.QImage(width, height, QtWidgets.QImage.Format_RGB32) + QtWidgets.QWidget.resize(self, width, height) def paintEvent(self, e): """ @@ -378,7 +275,7 @@ class QRemoteDesktop(QtGui.QWidget): @param e: QEvent """ #draw in widget - with QtGui.QPainter(self) as qp: + with QtWidgets.QPainter(self) as qp: qp.drawImage(0, 0, self._buffer) def mouseMoveEvent(self, event): diff --git a/setup.py b/setup.py index ed31090..3b6f7e5 100644 --- a/setup.py +++ b/setup.py @@ -4,7 +4,7 @@ import setuptools from distutils.core import setup, Extension setup(name='rdpy', - version='1.3.2', + version='2.0.0', description='Remote Desktop Protocol in Python', long_description=""" RDPY is a pure Python implementation of the Microsoft RDP (Remote Desktop Protocol) protocol (Client and Server side). RDPY is built over the event driven network engine Twisted. @@ -16,14 +16,11 @@ setup(name='rdpy', url='https://github.com/citronneur/rdpy', packages=[ 'rdpy', - 'rdpy.core', - 'rdpy.security', - 'rdpy.protocol', - 'rdpy.protocol.rdp', - 'rdpy.protocol.rdp.pdu', - 'rdpy.protocol.rdp.nla', - 'rdpy.protocol.rdp.t125', - 'rdpy.protocol.rfb', + 'rdpy.model', + 'rdpy.security', + 'rdpy.core.pdu', + 'rdpy.core.nla', + 'rdpy.core.t125', 'rdpy.ui' ], ext_modules=[Extension('rle', ['ext/rle.c'])], @@ -37,10 +34,9 @@ setup(name='rdpy', 'bin/rdpy-vncscreenshot.py' ], install_requires=[ - 'twisted', - 'pyopenssl', + 'PyQt5', + 'PyQt5-sip', 'service_identity', - 'qt4reactor', 'rsa', 'pyasn1' ], diff --git a/test/test_protocol_rdp_ber.py b/test/test_protocol_rdp_ber.py index 4b062a5..7e13b1f 100644 --- a/test/test_protocol_rdp_ber.py +++ b/test/test_protocol_rdp_ber.py @@ -26,9 +26,9 @@ import os, sys sys.path.insert(1, os.path.join(sys.path[0], '..')) import unittest -import rdpy.protocol.rdp.t125.ber as ber +import rdpy.core.t125.ber as ber import rdpy.core.type as type -import rdpy.core.error as error + class BERTest(unittest.TestCase): """ diff --git a/test/test_protocol_rdp_cssp_ntlm.py b/test/test_protocol_rdp_cssp_ntlm.py index 5987273..263b2f8 100644 --- a/test/test_protocol_rdp_cssp_ntlm.py +++ b/test/test_protocol_rdp_cssp_ntlm.py @@ -25,7 +25,7 @@ import os, sys # Change path so we find rdpy sys.path.insert(1, os.path.join(sys.path[0], '..')) -from rdpy.protocol.rdp.nla import cssp, ntlm +from rdpy.core.nla import ntlm, cssp from rdpy.security import rc4 pubKeyHex = """ diff --git a/test/test_protocol_rdp_lic.py b/test/test_protocol_rdp_lic.py index 9627d80..e48850f 100644 --- a/test/test_protocol_rdp_lic.py +++ b/test/test_protocol_rdp_lic.py @@ -26,7 +26,7 @@ import os, sys sys.path.insert(1, os.path.join(sys.path[0], '..')) import unittest -from rdpy.protocol.rdp import lic, sec +from rdpy.core import lic, sec import rdpy.core.type as type #dump of server request diff --git a/test/test_protocol_rdp_per.py b/test/test_protocol_rdp_per.py index ad3f7a0..9b336fb 100644 --- a/test/test_protocol_rdp_per.py +++ b/test/test_protocol_rdp_per.py @@ -26,7 +26,7 @@ import os, sys sys.path.insert(1, os.path.join(sys.path[0], '..')) import unittest -import rdpy.protocol.rdp.t125.per as per +import rdpy.core.t125.per as per import rdpy.core.type as type import rdpy.core.error as error @@ -81,7 +81,7 @@ class PERTest(unittest.TestCase): s.writeType((per.writeLength(type.sizeof(v)), v)) s.pos = 0 - self.assertTrue(per.readInteger(s) == 3, "invalid readLength for type %s"%t) + self.assertTrue(per.readInteger(s) == 3, "invalid readLength for type %s" % t) #error case for l in [0, 3, 5]: diff --git a/test/test_protocol_rdp_tpkt.py b/test/test_protocol_rdp_tpkt.py index 9e27792..ab5fe76 100644 --- a/test/test_protocol_rdp_tpkt.py +++ b/test/test_protocol_rdp_tpkt.py @@ -26,9 +26,9 @@ import os, sys sys.path.insert(1, os.path.join(sys.path[0], '..')) import unittest -import rdpy.protocol.rdp.tpkt as tpkt +import rdpy.core.tpkt as tpkt import rdpy.core.type as type -import rdpy.core.error as error + class TPKTTest(unittest.TestCase): """ diff --git a/test/test_protocol_rdp_x224.py b/test/test_protocol_rdp_x224.py index e396e06..d6e33db 100644 --- a/test/test_protocol_rdp_x224.py +++ b/test/test_protocol_rdp_x224.py @@ -26,7 +26,7 @@ import os, sys sys.path.insert(1, os.path.join(sys.path[0], '..')) import unittest -import rdpy.protocol.rdp.x224 as x224 +import rdpy.core.x224 as x224 import rdpy.core.type as type import rdpy.core.error as error