def test_connect_socks_illegal_packet(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
def dataReceived(self, data):
self._buffer += data
if len(self._buffer) == 3:
assert self._buffer == b'\x05\x01\x00'
self._buffer = b''
self.transport.write(b'\x05\x01\x01')
factory = socks._TorSocksFactory(u'meejah.ca', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
pump = yield connect(
server_proto,
server_transport,
client_proto,
client_transport,
)
self.assertTrue(server_proto.transport.disconnected)
self.assertTrue(client_proto.transport.disconnected)
pump.flush()
def test_connect_socks_unknown_version(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\xff'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'1.2.3.4', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
# returns IOPump
yield connect(
server_proto, server_transport,
client_proto, client_transport,
)
self.assertTrue(server_proto.transport.disconnected)
self.assertTrue(client_proto.transport.disconnected)
def test_connect_socks_illegal_packet(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
def dataReceived(self, data):
self._buffer += data
if len(self._buffer) == 3:
assert self._buffer == b'\x05\x01\x00'
self._buffer = b''
self.transport.write(b'\x05\x01\x01')
factory = socks._TorSocksFactory(u'meejah.ca', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
pump = yield connect(
server_proto, server_transport,
client_proto, client_transport,
)
self.assertTrue(server_proto.transport.disconnected)
self.assertTrue(client_proto.transport.disconnected)
pump.flush()
def test_socks_ipv6(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
(b'\x05\x01\x00\x04\x20\x02\x44\x93\x04\xd2',
b'\x05\x00\x00\x04%s\xbe\xef' % (b'\x00' * 16)),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(
repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(
repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(
u'2002:4493:5105::a299:9bff:fe0e:4471', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
expected_address = object()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol(u'ignored')
client_transport = FakeTransport(client_proto,
isServer=False,
hostAddress=expected_address)
pump = yield connect(
server_proto,
server_transport,
client_proto,
client_transport,
)
# should be relaying now, try sending some datas
client_proto.transport.write(b'abcdef')
addr = yield factory._get_address()
# FIXME how shall we test for IPv6-ness?
assert addr is expected_address
pump.flush()
self.assertEqual(b'abcdef', server_proto._buffer)
def test_get_address(self):
# normally, ._get_address is only called via the
# attach_stream() method on Circuit
addr = object()
factory = socks._TorSocksFactory()
d = factory._get_address()
self.assertFalse(d.called)
factory._did_connect(addr)
maybe_addr = yield d
self.assertEqual(addr, maybe_addr)
# if we do it a second time, should be immediate
d = factory._get_address()
self.assertTrue(d.called)
self.assertEqual(d.result, addr)
def test_get_address(self):
# normally, ._get_address is only called via the
# attach_stream() method on Circuit
addr = object()
factory = socks._TorSocksFactory()
d = factory._get_address()
self.assertFalse(d.called)
factory._did_connect(addr)
maybe_addr = yield d
self.assertEqual(addr, maybe_addr)
# if we do it a second time, should be immediate
d = factory._get_address()
self.assertTrue(d.called)
self.assertEqual(d.result, addr)
def test_socks_ipv6(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
(b'\x05\x01\x00\x04\x20\x02\x44\x93\x04\xd2',
b'\x05\x00\x00\x04' + (b'\x00' * 16) + b'\xbe\xef'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'2002:4493:5105::a299:9bff:fe0e:4471', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
expected_address = object()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol(u'ignored')
client_transport = FakeTransport(client_proto, isServer=False, hostAddress=expected_address)
pump = yield connect(
server_proto, server_transport,
client_proto, client_transport,
)
# should be relaying now, try sending some datas
client_proto.transport.write(b'abcdef')
addr = yield factory._get_address()
# FIXME how shall we test for IPv6-ness?
assert addr is expected_address
pump.flush()
self.assertEqual(b'abcdef', server_proto._buffer)
def test_connect_socks_unknown_reply_code(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
# the \xff is an invalid reply-code
(b'\x05\x01\x00\x01\x01\x02\x03\x04\x04\xd2',
b'\x05\xff\x00\x04\x01\x01\x01\x01'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(
repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(
repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'1.2.3.4', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
d = client_proto._machine.when_done()
# returns IOPump
yield connect(
server_proto,
server_transport,
client_proto,
client_transport,
)
with self.assertRaises(Exception) as ctx:
yield d
self.assertIn('Unknown SOCKS error-code', str(ctx.exception))
def test_socks_relay_data(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
(b'\x05\x01\x00\x01\x01\x02\x03\x04\x04\xd2',
b'\x05\x00\x00\x01\x01\x02\x03\x04\x12\x34'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(
repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(
repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'1.2.3.4', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
pump = yield connect(
server_proto,
server_transport,
client_proto,
client_transport,
)
# should be relaying now, try sending some datas
client_proto.transport.write(b'abcdef')
pump.flush()
self.assertEqual(b'abcdef', server_proto._buffer)
def test_connect_socks_unknown_reply_code(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
# the \xff is an invalid reply-code
(b'\x05\x01\x00\x01\x01\x02\x03\x04\x04\xd2', b'\x05\xff\x00\x04\x01\x01\x01\x01'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'1.2.3.4', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
d = client_proto._machine.when_done()
# returns IOPump
yield connect(
server_proto, server_transport,
client_proto, client_transport,
)
with self.assertRaises(Exception) as ctx:
yield d
self.assertIn('Unknown SOCKS error-code', str(ctx.exception))
def test_socks_relay_data(self):
class BadSocksServer(Protocol):
def __init__(self):
self._buffer = b''
self._recv_stack = [
(b'\x05\x01\x00', b'\x05\x00'),
(b'\x05\x01\x00\x01\x01\x02\x03\x04\x04\xd2', b'\x05\x00\x00\x01\x01\x02\x03\x04\x12\x34'),
]
def dataReceived(self, data):
self._buffer += data
if len(self._recv_stack) == 0:
assert "not expecting any more data, got {}".format(repr(self._buffer))
return
expecting, to_send = self._recv_stack.pop(0)
got = self._buffer[:len(expecting)]
self._buffer = self._buffer[len(expecting):]
assert got == expecting, "wanted {} but got {}".format(repr(expecting), repr(got))
self.transport.write(to_send)
factory = socks._TorSocksFactory(u'1.2.3.4', 1234, 'CONNECT', Mock())
server_proto = BadSocksServer()
server_transport = FakeTransport(server_proto, isServer=True)
client_proto = factory.buildProtocol('ignored')
client_transport = FakeTransport(client_proto, isServer=False)
pump = yield connect(
server_proto, server_transport,
client_proto, client_transport,
)
# should be relaying now, try sending some datas
client_proto.transport.write(b'abcdef')
pump.flush()
self.assertEqual(b'abcdef', server_proto._buffer)
