def test_ber_readLength(self):
"""
@summary: test readLength function in ber module
"""
s1 = type.Stream()
s1.writeType(type.UInt8(0x1a))
s1.pos = 0
l1 = ber.readLength(s1)
self.assertTrue(l1 == 0x1a, "readLength fail in small format")
s2 = type.Stream()
s2.writeType((type.UInt8(0x81), type.UInt8(0xab)))
s2.pos = 0
l2 = ber.readLength(s2)
self.assertTrue(l2 == 0xab, "readLength fail in big format of size 1")
s3 = type.Stream()
s3.writeType((type.UInt8(0x82), type.UInt16Be(0xabab)))
s3.pos = 0
l3 = ber.readLength(s3)
self.assertTrue(l3 == 0xabab,
"readLength fail in big format of size 2")
def test_x224_server_recvConnectionRequest_client_accept_ssl(self):
"""
@summary: unit test for X224Server.recvConnectionRequest function
test client doesn't support TLS case
"""
class Transport(object):
def send(self, data):
if not isinstance(data, x224.ServerConnectionConfirm):
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:
raise X224Test.X224_FAIL()
def close(self):
raise X224Test.X224_PASS()
message = x224.ClientConnectionRequestPDU()
message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_HYBRID
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Server(None, "key", "cert", True)
layer._transport = Transport()
layer.connect()
self.assertRaises(X224Test.X224_PASS, layer.recv, s)
def send(self, data):
s = type.Stream()
s.writeType(data)
s.pos = 0
s.readType(x224.X224DataHeader())
s.readType(type.String('test_x224_layer_send', constant=True))
raise X224Test.X224_PASS()
def test_tpkt_layer_recv_fastpath_ext_length(self):
"""
@summary: test receive in fastpath case with extended length
"""
class FastPathLayer(tpkt.IFastPathListener):
def setFastPathSender(self, fastPathSender):
pass
def recvFastPath(self, secflag, fastPathS):
fastPathS.readType(
type.String("test_tpkt_layer_recv_fastpath_ext_length",
constant=True))
raise TPKTTest.TPKT_PASS()
message = type.String("test_tpkt_layer_recv_fastpath_ext_length")
s = type.Stream()
s.writeType(
(type.UInt8(tpkt.Action.FASTPATH_ACTION_FASTPATH),
type.UInt16Be((type.sizeof(message) + 3) | 0x8000), message))
layer = tpkt.TPKT(None)
layer.initFastPath(FastPathLayer())
layer.connect()
self.assertRaises(TPKTTest.TPKT_PASS, layer.dataReceived, s.getvalue())
def test_valid_client_licensing_error_message(self):
l = lic.LicenseManager(None)
s = type.Stream()
s.writeType(lic.createValidClientLicensingErrorMessage())
#reinit position
s.pos = 0
self.assertTrue(l.recv(s), "Manager can retrieve valid case")
def sendFlagged(self, flag, message):
if flag != sec.SecurityFlag.SEC_LICENSE_PKT:
return
s = type.Stream()
s.writeType(message)
s.pos = 0
s.readType(lic.LicPacket(lic.ClientNewLicenseRequest()))
self._state = True
def send(self, data):
s = type.Stream()
s.writeType(data)
s.pos = 0
t = x224.ClientConnectionRequestPDU()
s.readType(t)
if t.protocolNeg.code != x224.NegociationType.TYPE_RDP_NEG_REQ:
raise X224Test.X224_FAIL()
def test_per_readLength(self):
"""
@summary: test readLength function in per module
"""
s1 = type.Stream()
s1.writeType(type.UInt8(0x1a))
s1.pos = 0
l1 = per.readLength(s1)
self.assertTrue(l1 == 0x1a, "readLength fail in small format")
s2 = type.Stream()
s2.writeType(type.UInt16Be(0x1abc | 0x8000))
s2.pos = 0
l2 = per.readLength(s2)
self.assertTrue(l2 == 0x1abc, "readLength fail in big format")
def test_per_readInteger(self):
"""
@summary: test readInteger function in per module
"""
for t in [type.UInt8, type.UInt16Be, type.UInt32Be]:
v = t(3)
s = type.Stream()
s.writeType((per.writeLength(type.sizeof(v)), v))
s.pos = 0
self.assertTrue(
per.readInteger(s) == 3, "invalid readLength for type %s" % t)
#error case
for l in [0, 3, 5]:
s = type.Stream()
s.writeType(per.writeLength(l))
s.pos = 0
self.assertRaises(error.InvalidValue, per.readInteger, s)
def test_x224_client_recvConnectionConfirm_negotiation_failure(self):
"""
@summary: unit test for X224Client.recvConnectionConfirm and sendConnectionRequest function
check negotiation failure
"""
message = x224.ServerConnectionConfirm()
message.protocolNeg.code.value = x224.NegociationType.TYPE_RDP_NEG_FAILURE
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Client(None)
self.assertRaises(error.RDPSecurityNegoFail, layer.recvConnectionConfirm, s)
def test_x224_client_recvConnectionConfirm_negotiation_bad_protocol(self):
"""
@summary: unit test for X224Client.recvConnectionConfirm and sendConnectionRequest function
Server ask another protocol than SSL or RDP
"""
message = x224.ServerConnectionConfirm()
message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_HYBRID
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Client(None)
self.assertRaises(error.InvalidExpectedDataException,
layer.recvConnectionConfirm, s)
def test_x224_layer_recvData(self):
"""
@summary: unit test for X224Layer.recvData function
"""
class Presentation(object):
def recv(self, data):
data.readType(type.String('test_x224_layer_recvData', constant = True))
raise X224Test.X224_PASS()
layer = x224.X224Layer(Presentation())
s = type.Stream()
s.writeType((x224.X224DataHeader(), type.String('test_x224_layer_recvData')))
#reinit position
s.pos = 0
self.assertRaises(X224Test.X224_PASS, layer.recvData, s)
def test_x224_server_recvConnectionRequest_valid(self):
"""
@summary: unit test for X224Server.recvConnectionRequest function
"""
global tls, connect_event
tls = False
connect_event = False
class ServerTLSContext(object):
def __init__(self, key, cert):
pass
x224.ServerTLSContext = ServerTLSContext
class Transport(object):
def __init__(self):
class TLS(object):
def startTLS(self, context):
global tls
tls = True
self.transport = TLS()
def send(self, data):
if not isinstance(data, x224.ServerConnectionConfirm):
raise X224Test.X224_FAIL()
if data.protocolNeg.code.value != x224.NegociationType.TYPE_RDP_NEG_RSP or data.protocolNeg.selectedProtocol.value != x224.Protocols.PROTOCOL_SSL:
raise X224Test.X224_FAIL()
class Presentation(object):
def connect(self):
global connect_event
connect_event = True
message = x224.ClientConnectionRequestPDU()
message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_SSL | x224.Protocols.PROTOCOL_RDP
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Server(Presentation(), "key", "cert")
layer._transport = Transport()
layer.connect()
layer.recvConnectionRequest(s)
self.assertTrue(tls, "TLS not started")
self.assertTrue(connect_event, "connect event not forwarded")
def test_x224_client_recvConnectionConfirm_ok(self):
"""
@summary: nominal case of protocol negotiation
"""
global tls_begin, presentation_connect
tls_begin = False
presentation_connect = False
class Transport(object):
def __init__(self):
class TLSTransport(object):
def startTLS(self, context):
global tls_begin
tls_begin = True
self.transport = TLSTransport()
class Presentation(object):
def connect(self):
global presentation_connect
presentation_connect = True
def recvData(data):
raise X224Test.X224_PASS()
message = x224.ServerConnectionConfirm()
message.protocolNeg.selectedProtocol.value = x224.Protocols.PROTOCOL_SSL
s = type.Stream()
s.writeType(message)
s.pos = 0
layer = x224.Client(Presentation())
layer._transport = Transport()
layer.recvData = recvData
layer.recvConnectionConfirm(s)
self.assertTrue(tls_begin, "TLS is not started")
self.assertTrue(presentation_connect, "connect event is not forwarded")
self.assertRaises(X224Test.X224_PASS, layer.recv,
type.String('\x01\x02'))
def test_new_license(self):
class Transport(object):
def __init__(self):
self._state = False
def sendFlagged(self, flag, message):
if flag != sec.SecurityFlag.SEC_LICENSE_PKT:
return
s = type.Stream()
s.writeType(message)
s.pos = 0
s.readType(lic.LicPacket(lic.ClientNewLicenseRequest()))
self._state = True
t = Transport()
l = lic.LicenseManager(t)
s = type.Stream(SERVERREQUEST.decode("base64"))
self.assertFalse(
l.recv(s) and t._state, "Bad message after license request")
def test_tpkt_layer_recv(self):
"""
@summary: test receive in classic case
"""
class Presentation(object):
def connect(self):
pass
def recv(self, data):
data.readType(
type.String("test_tpkt_layer_recv", constant=True))
raise TPKTTest.TPKT_PASS()
message = type.String("test_tpkt_layer_recv")
s = type.Stream()
s.writeType(
(type.UInt8(tpkt.Action.FASTPATH_ACTION_X224), type.UInt8(),
type.UInt16Be(type.sizeof(message) + 4), message))
layer = tpkt.TPKT(Presentation())
layer.connect()
self.assertRaises(TPKTTest.TPKT_PASS, layer.dataReceived, s.getvalue())
def test_new_license(self):
class Transport(object):
def __init__(self):
self._state = False
def sendFlagged(self, flag, message):
if flag != sec.SecurityFlag.SEC_LICENSE_PKT:
return
s = type.Stream()
s.writeType(message)
s.pos = 0
s.readType(lic.LicPacket(lic.ClientNewLicenseRequest()))
self._state = True
def getGCCServerSettings(self):
class A:
def __init__(self):
self._is_readed = False
class B:
def __init__(self):
self.serverCertificate = A()
class C:
def __init__(self):
self.SC_SECURITY = B()
return C()
t = Transport()
l = lic.LicenseManager(t)
s = type.Stream(SERVERREQUEST.decode("base64"))
self.assertFalse(
l.recv(s) and t._state, "Bad message after license request")
