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)
