def test_server_side_invalid_2(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
self.assertEquals(t.value(), '')
ver_pkt = struct.pack('B', self.protocol_version)
invalid_hs_data = (('abcdefg' * int(self.handshake_length * 2 / 7)) +
'abcdefg'[:int(self.handshake_length * 2 % 7)])
# version is ok
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
# ... but the rest is just (the right amount of) rubbish
err = p.dataReceived(invalid_hs_data)
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(t.disconnecting, 'should not be disconnecting')
self.assertEquals(p.handshake_status, 'fail')
def test_server_side_invalid_2(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
self.assertEquals(t.value(), '')
ver_pkt = struct.pack('B', self.protocol_version)
invalid_hs_data = (('abcdefg' * int(self.handshake_length * 2 / 7)) +
'abcdefg'[:int(self.handshake_length * 2 % 7)])
# version is ok
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
# ... but the rest is just (the right amount of) rubbish
err = p.dataReceived(invalid_hs_data)
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(t.disconnecting, 'should not be disconnecting')
self.assertEquals(p.handshake_status, 'fail')
def test_server_side_ok_plus(self):
# similar as with test_complete_exchange_plus() - feeding some
# additional data immediately following handshake data
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
# server shouldn't respond before spoken to
self.assertEquals(t.value(), '')
ver_pkt = struct.pack('B', self.protocol_version)
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
# server may wait until it receives handshake packet before
# responding, so not testing here
hs_rand_data = '.' * (self.handshake_length - 8)
timestamp = 42
hs_pkt = struct.pack('>LL', timestamp, 0) + hs_rand_data
err = p.dataReceived(hs_pkt)
self.assertIdentical(err, None)
# ... and here the server might send all the packets already,
# and our implementation should do so, so that's what we test
self.assert_(
len(t.value()) == 1 + self.handshake_length * 2,
'Response too short (%d)' % len(t.value()))
self.assertEquals(
struct.unpack_from('B', t.value(), 0)[0], self.protocol_version)
srv_hs_pkt = t.value()[1:1 + self.handshake_length]
hs_pkt_echo = t.value()[1 + self.handshake_length:1 +
self.handshake_length * 2]
self.assertEquals(
struct.unpack_from('>L', hs_pkt_echo, 0)[0], timestamp)
self.assertEquals(hs_pkt_echo[8:], hs_rand_data)
# server response ok, let's finish the server side, and
# pretend client starts sending more data
err = p.dataReceived(srv_hs_pkt + '\x00')
self.assertIdentical(err, None)
self.assertFalse(t.disconnecting, 'disconnecting')
self.assertEquals(p.handshake_status, 'ok')
def test_server_side_ok_plus(self):
# similar as with test_complete_exchange_plus() - feeding some
# additional data immediately following handshake data
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
# server shouldn't respond before spoken to
self.assertEquals(t.value(), '')
ver_pkt = struct.pack('B', self.protocol_version)
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
# server may wait until it receives handshake packet before
# responding, so not testing here
hs_rand_data = '.' * (self.handshake_length - 8)
timestamp = 42
hs_pkt = struct.pack('>LL', timestamp, 0) + hs_rand_data
err = p.dataReceived(hs_pkt)
self.assertIdentical(err, None)
# ... and here the server might send all the packets already,
# and our implementation should do so, so that's what we test
self.assert_(len(t.value()) == 1 + self.handshake_length * 2,
'Response too short (%d)' % len(t.value()))
self.assertEquals(struct.unpack_from('B', t.value(), 0)[0],
self.protocol_version)
srv_hs_pkt = t.value()[1:1+self.handshake_length]
hs_pkt_echo = t.value()[1+self.handshake_length:
1+self.handshake_length*2]
self.assertEquals(struct.unpack_from('>L', hs_pkt_echo, 0)[0],
timestamp)
self.assertEquals(hs_pkt_echo[8:], hs_rand_data)
# server response ok, let's finish the server side, and
# pretend client starts sending more data
err = p.dataReceived(srv_hs_pkt + '\x00')
self.assertIdentical(err, None)
self.assertFalse(t.disconnecting, 'disconnecting')
self.assertEquals(p.handshake_status, 'ok')
def test_client_side_ok(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now, is_client=True)
# can't initiate client handler before making connection
p.init_handler(hs.gen_handler(), do_init=False)
p.makeConnection(t)
# client side is the active one
self.assertEquals(t.value(), '')
# ... once initiated
p.init_handler()
# after that the handling is almost identical to the server side...
ver_pkt = struct.pack('B', self.protocol_version)
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
hs_rand_data = '.' * (self.handshake_length - 8)
timestamp = 42
hs_pkt = struct.pack('>LL', timestamp, 0) + hs_rand_data
err = p.dataReceived(hs_pkt)
self.assertIdentical(err, None)
self.assert_(len(t.value()) == 1 + self.handshake_length * 2,
'Response too short (%d)' % len(t.value()))
self.assertEquals(struct.unpack_from('B', t.value(), 0)[0],
self.protocol_version)
cli_hs_pkt = t.value()[1:1+self.handshake_length]
hs_pkt_echo = t.value()[1+self.handshake_length:
1+self.handshake_length*2]
self.assertEquals(struct.unpack_from('>L', hs_pkt_echo, 0)[0],
timestamp)
self.assertEquals(hs_pkt_echo[8:], hs_rand_data)
err = p.dataReceived(cli_hs_pkt)
self.assertIdentical(err, None)
self.assertFalse(t.disconnecting, 'disconnecting')
self.assertEquals(p.handshake_status, 'ok')
def test_client_side_ok(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now, is_client=True)
# can't initiate client handler before making connection
p.init_handler(hs.gen_handler(), do_init=False)
p.makeConnection(t)
# client side is the active one
self.assertEquals(t.value(), '')
# ... once initiated
p.init_handler()
# after that the handling is almost identical to the server side...
ver_pkt = struct.pack('B', self.protocol_version)
err = p.dataReceived(ver_pkt)
self.assertIdentical(err, None)
hs_rand_data = '.' * (self.handshake_length - 8)
timestamp = 42
hs_pkt = struct.pack('>LL', timestamp, 0) + hs_rand_data
err = p.dataReceived(hs_pkt)
self.assertIdentical(err, None)
self.assert_(
len(t.value()) == 1 + self.handshake_length * 2,
'Response too short (%d)' % len(t.value()))
self.assertEquals(
struct.unpack_from('B', t.value(), 0)[0], self.protocol_version)
cli_hs_pkt = t.value()[1:1 + self.handshake_length]
hs_pkt_echo = t.value()[1 + self.handshake_length:1 +
self.handshake_length * 2]
self.assertEquals(
struct.unpack_from('>L', hs_pkt_echo, 0)[0], timestamp)
self.assertEquals(hs_pkt_echo[8:], hs_rand_data)
err = p.dataReceived(cli_hs_pkt)
self.assertIdentical(err, None)
self.assertFalse(t.disconnecting, 'disconnecting')
self.assertEquals(p.handshake_status, 'ok')
def test_complete_exchange_plus(self):
# almost exactly the same test as above except writing some
# additional (garbage) data immediately (as in the same
# "socket.read()") after the handshake data
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def __init__(self, protocol, epoch_base, is_client=False):
Handshaker.__init__(self, protocol, epoch_base, is_client=is_client)
self._digest_offset_extractor = None
if self.is_client:
self.compat_version = self.client_compat_version
# find a scheme matching our client version
scheme = find_client_offset_scheme(self.compat_version)
if scheme is not None:
self._digest_offset_extractor = schemes[scheme][0]
else:
# otherwise we'll do non-crypto handshake
self.compat_version = NO_VERSION
else:
self.compat_version = self.server_compat_version
def __init__(self, protocol, epoch_base, is_client=False):
Handshaker.__init__(self, protocol, epoch_base, is_client=is_client)
self._digest_offset_extractor = None
if self.is_client:
self.compat_version = self.client_compat_version
# find a scheme matching our client version
scheme = find_client_offset_scheme(self.compat_version)
if scheme is not None:
self._digest_offset_extractor = schemes[scheme][0]
else:
# otherwise we'll do non-crypto handshake
self.compat_version = NO_VERSION
else:
self.compat_version = self.server_compat_version
def test_complete_exchange(self):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value())
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_server_side_invalid_1(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
self.assertEquals(t.value(), '')
# sending version different from the server's version
ver_pkt = struct.pack('B', self.protocol_version + 1)
err = p.dataReceived(ver_pkt)
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(t.disconnecting, 'should not be disconnecting')
self.assertEquals(p.handshake_status, 'fail')
def test_server_side_invalid_1(self):
t = StringTransport()
p = TestHandshakeProtocol()
now = time.time()
hs = Handshaker(p, now)
p.init_handler(hs.gen_handler())
p.makeConnection(t)
self.assertEquals(t.value(), '')
# sending version different from the server's version
ver_pkt = struct.pack('B', self.protocol_version + 1)
err = p.dataReceived(ver_pkt)
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(t.disconnecting, 'should not be disconnecting')
self.assertEquals(p.handshake_status, 'fail')
def test_complete_exchange_plus(self):
# almost exactly the same test as above except writing some
# additional (garbage) data immediately (as in the same
# "socket.read()") after the handshake data
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_complete_exchange(self):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value())
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
