def _testStreamingProducer(self, mode): """ Connect a couple protocol/transport pairs to an L{IOPump} and then pump it. Verify that a streaming producer registered with one of the transports does not receive invalid L{IPushProducer} method calls and ends in the right state. @param mode: C{u"server"} to test a producer registered with the server transport. C{u"client"} to test a producer registered with the client transport. """ serverProto = Protocol() serverTransport = FakeTransport(serverProto, isServer=True) clientProto = Protocol() clientTransport = FakeTransport(clientProto, isServer=False) pump = connect( serverProto, serverTransport, clientProto, clientTransport, greet=False, ) producer = StrictPushProducer() victim = { u"server": serverTransport, u"client": clientTransport, }[mode] victim.registerProducer(producer, streaming=True) pump.pump() self.assertEqual(u"running", producer._state)
def connect_application_session(server_factory, MyApplicationSession, component_config=None): """ Connect an ApplicationSession class to the given server factory. """ application_session_factory = ApplicationSessionFactory(component_config) application_session_factory.session = MyApplicationSession client_factory = WampRawSocketClientFactory(application_session_factory) # client_factory = WampWebSocketClientFactory(application_session_factory) server_protocol = server_factory.buildProtocol(None) client_protocol = client_factory.buildProtocol(None) server_transport = FakeTransport(server_protocol, True) client_transport = FakeTransport(client_protocol, False) pump = connect(server_protocol, server_transport, client_protocol, client_transport, debug=False) return client_protocol._session, pump
def connectedServerAndClient(self, serverFactory, clientFactory): """ Set up an in-memory connection between protocols created by C{serverFactory} and C{clientFactory}. @return: A three-tuple. The first element is the protocol created by C{serverFactory}. The second element is the protocol created by C{clientFactory}. The third element is the L{IOPump} connecting them. """ clientProtocol = clientFactory.buildProtocol(None) serverProtocol = serverFactory.buildProtocol(None) clientTransport = FakeTransport(clientProtocol, isServer=False, hostAddress=self.clientAddress, peerAddress=self.serverAddress) serverTransport = FakeTransport(serverProtocol, isServer=True, hostAddress=self.serverAddress, peerAddress=self.clientAddress) pump = connect(serverProtocol, serverTransport, clientProtocol, clientTransport) return serverProtocol, clientProtocol, pump
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_connectionSerial(self): """ Each L{FakeTransport} receives a serial number that uniquely identifies it. """ a = FakeTransport(object(), True) b = FakeTransport(object(), False) self.assertIsInstance(a.serial, int) self.assertIsInstance(b.serial, int) self.assertNotEqual(a.serial, b.serial)
def connect_mqtt_server(server_factory): server_protocol = server_factory.buildProtocol(None) server_transport = FakeTransport(server_protocol, True) client_protocol = AccumulatingProtocol() client_transport = FakeTransport(client_protocol, False) mqtt_pump = connect(server_protocol, server_transport, client_protocol, client_transport, debug=False) return client_transport, client_protocol, mqtt_pump
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 connect(self, factory): if self.pump is not None: raise Exception("SingleUseMemoryEndpoint was already used") try: protocol = factory.buildProtocol(MemoryAddress()) except: return fail() else: self.pump = connect(self._server, FakeTransport(self._server, isServer=True), protocol, FakeTransport(protocol, isServer=False)) return succeed(protocol)
def test_connectWaitsForConnection(self): """ Calling L{gConnectTCP} blocks until a connection is made and returns a L{GreenletTransport}. """ transports = [] def connect(): transports.append( gConnectTCP("whatever", 9090, reactor=fakeReactor)) class FakeReactor(object): def __init__(self): self.connections = [] def connectTCP(self, host, port, factory): self.connections.append((host, port, factory)) fakeReactor = FakeReactor() greenlet(connect).switch() self.assertEquals(transports, []) self.assertEquals(len(fakeReactor.connections), 1) self.assertEquals(fakeReactor.connections[0][0], "whatever") self.assertEquals(fakeReactor.connections[0][1], 9090) proto = fakeReactor.connections[0][2].buildProtocol(None) proto.makeConnection(FakeTransport()) # This is gonna switch back! self.assertEquals(transports, [proto.gtransport])
def setUp(self): self.peer = IPv4Address('TCP', 'kafka', 9072) self.protocol = KafkaBootstrapProtocol() self.transport = FakeTransport(self.protocol, isServer=False, peerAddress=self.peer) self.protocol.makeConnection(self.transport)
def unconnected_proxyserver(mocker): mocker.patch("twisted.test.iosim.FakeTransport.startTLS") mocker.patch("pappyproxy.proxy.load_certs_from_dir", new=mock_generate_cert) factory = ProxyServerFactory() protocol = factory.buildProtocol(('127.0.0.1', 0)) protocol.makeConnection(FakeTransport(protocol, True)) return protocol
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_writeAfterClose(self): """ L{FakeTransport.write} will accept writes after transport was closed, but the data will be silently discarded. """ a = FakeTransport(object(), False) a.write(b"before") a.loseConnection() a.write(b"after") self.assertEqual(b"".join(a.stream), b"before")
def test_writeSequence(self): """ L{FakeTransport.writeSequence} will write a sequence of L{bytes} to the transport. """ a = FakeTransport(object(), False) a.write(b"a") a.writeSequence([b"b", b"c", b"d"]) self.assertEqual(b"".join(a.stream), b"abcd")
def proxyserver(mocker): mocker.patch("twisted.test.iosim.FakeTransport.startTLS") mocker.patch("pappyproxy.proxy.load_certs_from_dir", new=mock_generate_cert) factory = ProxyServerFactory() protocol = factory.buildProtocol(('127.0.0.1', 0)) protocol.makeConnection(FakeTransport(protocol, True)) protocol.lineReceived('CONNECT https://www.AAAA.BBBB:443 HTTP/1.1') protocol.lineReceived('') protocol.transport.getOutBuffer() return protocol
def getTransportAndProtocol(self, function): """ Construct a L{GreenletProtocol} with the given C{function} and create a L{FakeTransport} to go along with it. @param function: Function to pass to L{GreenletProtocol} @rtype: Two-tuple of L{FakeTransport}, L{GreenletProtocol}. """ twistedTransport = FakeTransport() factory = _GreenletFactory(function) protocol = factory.buildProtocol(None) twistedTransport.protocol = protocol return twistedTransport, protocol
def gen_connection(send_data, new_req=False, new_rsp=False, drop_req=False, drop_rsp=False): factory = ProxyClientFactory(http.Request(send_data)) macro = gen_mangle_macro(new_req, new_rsp, drop_req, drop_rsp) factory.intercepting_macros['pappy_mangle'] = macro protocol = factory.buildProtocol(None) tr = FakeTransport(protocol, True) protocol.makeConnection(tr) sent = yield protocol.data_defer print sent defer.returnValue((protocol, sent, factory.data_defer))