dash/rdpy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix build issue

Browse Source
This commit is contained in:
speyrefitte
2014-12-16 18:03:12 +01:00
parent f2481149d9
commit a0ae3d97ec
5 changed files with 41 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
rdpy/protocol/rdp/rdp.py
View File

@@ -324,10 +324,11 @@ class RDPServerController(pdu.layer.PDUServerListener):
""" """
@summary: Controller use in server side mode @summary: Controller use in server side mode
""" """
def __init__(self, privateKeyFileName, certificateFileName, colorDepth): def __init__(self, colorDepth, privateKeyFileName = None, certificateFileName = None, rsaKeys = None):
""" """
@param privateKeyFileName: file contain server private key @param privateKeyFileName: file contain server private key
@param certficiateFileName: file that contain public key @param certficiateFileName: file that contain public key
@param rsaKeys: {Tuple(rsa.PublicKey, rsa.PrivateKey)} rsa crypto
@param colorDepth: 15, 16, 24 @param colorDepth: 15, 16, 24
""" """
self._isReady = False self._isReady = False
@@ -336,11 +337,11 @@ class RDPServerController(pdu.layer.PDUServerListener):
#build RDP protocol stack #build RDP protocol stack
self._pduLayer = pdu.layer.Server(self) self._pduLayer = pdu.layer.Server(self)
#secure layer #secure layer
self._secLayer = sec.Server(self._pduLayer) self._secLayer = sec.Server(self._pduLayer, rsaKeys)
#multi channel service #multi channel service
self._mcsLayer = mcs.Server(self._secLayer) self._mcsLayer = mcs.Server(self._secLayer)
#transport pdu layer #transport pdu layer
self._x224Layer = x224.Server(self._mcsLayer, privateKeyFileName, certificateFileName) self._x224Layer = x224.Server(self._mcsLayer, privateKeyFileName, certificateFileName, False)
#transport packet (protocol layer) #transport packet (protocol layer)
self._tpktLayer = tpkt.TPKT(self._x224Layer) self._tpktLayer = tpkt.TPKT(self._x224Layer)
#fastpath stack #fastpath stack
@@ -553,7 +554,7 @@ class ServerFactory(layer.RawLayerServerFactory):
@summary: Function call from twisted and build rdp protocol stack @summary: Function call from twisted and build rdp protocol stack
@param addr: destination address @param addr: destination address
""" """
controller = RDPServerController(self._privateKeyFileName, self._certificateFileName, self._colorDepth) controller = RDPServerController(self._colorDepth, self._privateKeyFileName, self._certificateFileName)
self.buildObserver(controller, addr) self.buildObserver(controller, addr)
return controller.getProtocol() return controller.getProtocol()

8
rdpy/protocol/rdp/sec.py
View File

@@ -586,8 +586,14 @@ class Server(SecLayer):
""" """
@summary: Client side of security layer @summary: Client side of security layer
""" """
def __init__(self, presentation): def __init__(self, presentation, rsaKeys = None):
"""
@param rsaKeys: {Tuple(rsa.PublicKey, rsa.PrivateKey)} rsa crypto
"""
SecLayer.__init__(self, presentation) SecLayer.__init__(self, presentation)
self._rsaPublicKey, self._rsaPrivateKey = None, None
if not rsaKeys is None:
self._rsaPublicKey, self._rsaPrivateKey = rsaKeys
def connect(self): def connect(self):
""" """

37
rdpy/protocol/rdp/x224.py
View File

@@ -220,16 +220,18 @@ class Server(X224Layer):
""" """
@summary: Server automata of X224 layer @summary: Server automata of X224 layer
""" """
def __init__(self, presentation, privateKeyFileName, certificateFileName): def __init__(self, presentation, privateKeyFileName = None, certificateFileName = None, forceSSL = False):
""" """
@param presentation: upper layer, MCS layer in RDP case @param presentation: {layer} upper layer, MCS layer in RDP case
@param privateKeyFileName: file contain server private key @param privateKeyFileName: {str} file contain server private key
@param certficiateFileName: file that contain public key @param certficiateFileName: {str} file that contain public key
@param forceSSL: {boolean} reject old client that doerasn't support SSL
""" """
X224Layer.__init__(self, presentation) X224Layer.__init__(self, presentation)
#Server mode informations for TLS connection #Server mode informations for TLS connection
self._serverPrivateKeyFileName = privateKeyFileName self._serverPrivateKeyFileName = privateKeyFileName
self._serverCertificateFileName = certificateFileName self._serverCertificateFileName = certificateFileName
self._forceSSL = forceSSL and not self._serverPrivateKeyFileName is None and not self._serverCertificateFileName is None
def connect(self): def connect(self):
""" """
@@ -241,26 +243,33 @@ class Server(X224Layer):
""" """
@summary: Read connection confirm packet @summary: Read connection confirm packet
Next state is send connection confirm Next state is send connection confirm
@param data: Stream @param data: {Stream}
@see : http://msdn.microsoft.com/en-us/library/cc240470.aspx @see : http://msdn.microsoft.com/en-us/library/cc240470.aspx
""" """
message = ClientConnectionRequestPDU() message = ClientConnectionRequestPDU()
data.readType(message) data.readType(message)
if not message.protocolNeg._is_readed or message.protocolNeg.failureCode._is_readed: if not message.protocolNeg._is_readed:
raise InvalidExpectedDataException("Too older RDP client") self._requestedProtocol = Protocols.PROTOCOL_RDP
else:
self._requestedProtocol = message.protocolNeg.selectedProtocol.value
self._requestedProtocol = message.protocolNeg.selectedProtocol.value #match best security layer available
if not self._serverPrivateKeyFileName is None and not self._serverCertificateFileName is None:
self._selectedProtocol = self._requestedProtocol & Protocols.PROTOCOL_SSL
else:
self._selectedProtocol = self._requestedProtocol & Protocols.PROTOCOL_RDP
if not self._requestedProtocol & Protocols.PROTOCOL_SSL: #if force ssl is enable
if not self._selectedProtocol & Protocols.PROTOCOL_SSL and self._forceSSL:
#send error message and quit #send error message and quit
message = ServerConnectionConfirm() message = ServerConnectionConfirm()
message.protocolNeg.code.value = NegociationType.TYPE_RDP_NEG_FAILURE message.protocolNeg.code.value = NegociationType.TYPE_RDP_NEG_FAILURE
message.protocolNeg.failureCode.value = NegotiationFailureCode.SSL_REQUIRED_BY_SERVER message.protocolNeg.failureCode.value = NegotiationFailureCode.SSL_REQUIRED_BY_SERVER
self._transport.send(message) self._transport.send(message)
raise InvalidExpectedDataException("rdpy needs ssl client compliant") self.close()
return
self._selectedProtocol = Protocols.PROTOCOL_SSL
self.sendConnectionConfirm() self.sendConnectionConfirm()
def sendConnectionConfirm(self): def sendConnectionConfirm(self):
@@ -274,8 +283,10 @@ class Server(X224Layer):
message.protocolNeg.code.value = NegociationType.TYPE_RDP_NEG_RSP message.protocolNeg.code.value = NegociationType.TYPE_RDP_NEG_RSP
message.protocolNeg.selectedProtocol.value = self._selectedProtocol message.protocolNeg.selectedProtocol.value = self._selectedProtocol
self._transport.send(message) self._transport.send(message)
#_transport is TPKT and transport is TCP layer of twisted if self._selectedProtocol == Protocols.PROTOCOL_SSL:
self._transport.transport.startTLS(ServerTLSContext(self._serverPrivateKeyFileName, self._serverCertificateFileName)) #_transport is TPKT and transport is TCP layer of twisted
self._transport.transport.startTLS(ServerTLSContext(self._serverPrivateKeyFileName, self._serverCertificateFileName))
#connection is done send to presentation #connection is done send to presentation
self.setNextState(self.recvData) self.setNextState(self.recvData)
self._presentation.connect() self._presentation.connect()

2
test/test_protocol_rdp_rc4.py
View File

@@ -26,7 +26,7 @@ import os, sys
sys.path.insert(1, os.path.join(sys.path[0], '..')) sys.path.insert(1, os.path.join(sys.path[0], '..'))
import unittest import unittest
import rdpy.protocol.rdp.rc4 as rc4 import rdpy.core.rc4 as rc4
class RC4Test(unittest.TestCase): class RC4Test(unittest.TestCase):

37
test/test_protocol_rdp_x224.py
View File

@@ -172,37 +172,6 @@ class X224Test(unittest.TestCase):
self.assertTrue(presentation_connect, "connect event is not forwarded") self.assertTrue(presentation_connect, "connect event is not forwarded")
self.assertRaises(X224Test.X224_PASS, layer.recv, type.String('\x01\x02')) self.assertRaises(X224Test.X224_PASS, layer.recv, type.String('\x01\x02'))
def test_x224_server_recvConnectionRequest_invalid_old_client(self):
"""
@summary: unit test for X224Server.recvConnectionRequest function
old client with non protocol neg
"""
message = x224.ClientConnectionRequestPDU()
del message._typeName[message._typeName.index("protocolNeg")]
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Server(None, "key", "cert")
layer.connect()
self.assertRaises(error.InvalidExpectedDataException, layer.recv, s)
def test_x224_server_recvConnectionRequest_invalid_protocol_neg_failure(self):
"""
@summary: unit test for X224Server.recvConnectionRequest function
"""
message = x224.ClientConnectionRequestPDU()
message.protocolNeg.code.value = x224.NegociationType.TYPE_RDP_NEG_FAILURE
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Server(None, "key", "cert")
layer.connect()
self.assertRaises(error.InvalidExpectedDataException, layer.recv, s)
def test_x224_server_recvConnectionRequest_client_accept_ssl(self): def test_x224_server_recvConnectionRequest_client_accept_ssl(self):
""" """
@summary: unit test for X224Server.recvConnectionRequest function @summary: unit test for X224Server.recvConnectionRequest function
@@ -215,6 +184,8 @@ class X224Test(unittest.TestCase):
raise X224Test.X224_FAIL() raise X224Test.X224_FAIL()
if data.protocolNeg.code.value != x224.NegociationType.TYPE_RDP_NEG_FAILURE or data.protocolNeg.failureCode.value != x224.NegotiationFailureCode.SSL_REQUIRED_BY_SERVER: if data.protocolNeg.code.value != x224.NegociationType.TYPE_RDP_NEG_FAILURE or data.protocolNeg.failureCode.value != x224.NegotiationFailureCode.SSL_REQUIRED_BY_SERVER:
raise X224Test.X224_FAIL() raise X224Test.X224_FAIL()
def close(self):
raise X224Test.X224_PASS()
message = x224.ClientConnectionRequestPDU() message = x224.ClientConnectionRequestPDU()
message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_HYBRID message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_HYBRID
@@ -222,11 +193,11 @@ class X224Test(unittest.TestCase):
s.writeType(message) s.writeType(message)
s.pos = 0 s.pos = 0
layer = x224.Server(None, "key", "cert") layer = x224.Server(None, "key", "cert", True)
layer._transport = Transport() layer._transport = Transport()
layer.connect() layer.connect()
self.assertRaises(error.InvalidExpectedDataException, layer.recv, s) self.assertRaises(X224Test.X224_PASS, layer.recv, s)
def test_x224_server_recvConnectionRequest_valid(self): def test_x224_server_recvConnectionRequest_valid(self):
""" """