def test_registerProducers(self): """ The proxy client registers itself as a producer of the proxy server and vice versa. """ # create a ProxyServer instance addr = address.IPv4Address('TCP', '127.0.0.1', 0) server = portforward.ProxyFactory('127.0.0.1', 0).buildProtocol(addr) # set the reactor for this test reactor = proto_helpers.MemoryReactor() server.reactor = reactor # make the connection serverTransport = proto_helpers.StringTransport() server.makeConnection(serverTransport) # check that the ProxyClientFactory is connecting to the backend self.assertEqual(len(reactor.tcpClients), 1) # get the factory instance and check it's the one we expect host, port, clientFactory, timeout, _ = reactor.tcpClients[0] self.assertIsInstance(clientFactory, portforward.ProxyClientFactory) # Connect it client = clientFactory.buildProtocol(addr) clientTransport = proto_helpers.StringTransport() client.makeConnection(clientTransport) # check that the producers are registered self.assertIs(clientTransport.producer, serverTransport) self.assertIs(serverTransport.producer, clientTransport) # check the streaming attribute in both transports self.assertTrue(clientTransport.streaming) self.assertTrue(serverTransport.streaming)
def sslToTcp(localhost, localport, remotehost, remoteport, serverContextFactory): #log.msg("SSL on {}:{} forwarding to TCP {}:{}".format(localhost, localport, remotehost, remoteport)) return reactor.listenSSL(localport, portforward.ProxyFactory(remotehost, remoteport), serverContextFactory, interface=localhost)
def testPortforward(self): serverProtocol = wire.Echo() realServerFactory = protocol.ServerFactory() realServerFactory.protocol = lambda: serverProtocol realServerPort = reactor.listenTCP(0, realServerFactory, interface='127.0.0.1') proxyServerFactory = portforward.ProxyFactory('127.0.0.1', realServerPort.getHost().port) proxyServerPort = reactor.listenTCP(0, proxyServerFactory, interface='127.0.0.1') nBytes = 1000 received = [] clientProtocol = protocol.Protocol() clientProtocol.dataReceived = received.extend clientProtocol.connectionMade = lambda: clientProtocol.transport.write('x' * nBytes) clientFactory = protocol.ClientFactory() clientFactory.protocol = lambda: clientProtocol reactor.connectTCP('127.0.0.1', proxyServerPort.getHost().port, clientFactory) c = 0 while len(received) < nBytes and c < 100: reactor.iterate(0.01) c += 1 self.assertEquals(''.join(received), 'x' * nBytes) clientProtocol.transport.loseConnection() serverProtocol.transport.loseConnection() return defer.gatherResults([ defer.maybeDeferred(realServerPort.stopListening), defer.maybeDeferred(proxyServerPort.stopListening)])
def testPortforward(self): """ Test port forwarding through Echo protocol. """ realServerFactory = protocol.ServerFactory() realServerFactory.protocol = lambda: self.serverProtocol realServerPort = reactor.listenTCP(0, realServerFactory, interface='127.0.0.1') self.openPorts.append(realServerPort) proxyServerFactory = portforward.ProxyFactory( '127.0.0.1', realServerPort.getHost().port) proxyServerPort = reactor.listenTCP(0, proxyServerFactory, interface='127.0.0.1') self.openPorts.append(proxyServerPort) nBytes = 1000 received = [] d = defer.Deferred() def testDataReceived(data): received.extend(data) if len(received) >= nBytes: self.assertEquals(''.join(received), 'x' * nBytes) d.callback(None) self.clientProtocol.dataReceived = testDataReceived def testConnectionMade(): self.clientProtocol.transport.write('x' * nBytes) self.clientProtocol.connectionMade = testConnectionMade clientFactory = protocol.ClientFactory() clientFactory.protocol = lambda: self.clientProtocol reactor.connectTCP('127.0.0.1', proxyServerPort.getHost().port, clientFactory) return d
def start_proxy(local_port, remote_host, remote_port, protocol): if protocol == "SMTP": portforward.ProxyServer.dataReceived = server_receive_data_generic portforward.ProxyClient.dataReceived = client_receive_data_smtp elif protocol == "IMAP": portforward.ProxyServer.dataReceived = server_receive_data_generic portforward.ProxyClient.dataReceived = client_receive_data_imap else: portforward.ProxyServer.dataReceived = server_receive_data_generic portforward.ProxyClient.dataReceived = client_receive_data_generic portforward.ProxyServer.connectionLost = connection_lost #portforward.ProxyClient.connectionLost = connection_lost reactor.listenTCP( local_port, portforward.ProxyFactory( remote_host, remote_port)) reactor.run()
def makeService(config): f = portforward.ProxyFactory(config['host'], int(config['dest_port'])) return strports.service(config['port'], f)
def starttcpproxy(): reactor.listenTCP(localport, portforward.ProxyFactory(desthost, destport)) reactor.run()
def sslToTcp(localport, remotehost, remoteport, serverContextFactory): print "SSL on localhost:%i forwarding to %s:%i" % (localport, remotehost, remoteport) return reactor.listenSSL(localport, portforward.ProxyFactory(remotehost, remoteport), serverContextFactory)
def tcpToTcp(localport, remotehost, remoteport): print "TCP on localhost:%i forwarding to %s:%i" % (localport, remotehost, remoteport) return reactor.listenTCP(localport, portforward.ProxyFactory(remotehost, remoteport))
def tcpToTcp(localhost, localport, remotehost, remoteport): #log.msg("TCP on {}:{} forwarding to TCP {}:{}".format(localhost, localport, remotehost, remoteport)) return reactor.listenTCP(localport, portforward.ProxyFactory(remotehost, remoteport), interface=localhost)
def makeService(config): f = portforward.ProxyFactory(config["host"], int(config["dest_port"])) return strports.service(config["port"], f)