def build_irc(self):
"""The main starting method that creates a protocol object
according to the config variables, ready for whenever
the reactor starts running.
"""
wlog('building irc')
if self.tx_irc_client:
raise Exception('irc already built')
if self.usessl.lower() == 'true' and not self.socks5.lower() == 'true':
factory = TxIRCFactory(self)
ctx = ClientContextFactory()
reactor.connectSSL(self.serverport[0], self.serverport[1], factory,
ctx)
elif self.socks5.lower() == 'true':
factory = TxIRCFactory(self)
#str() casts needed else unicode error
torEndpoint = TCP4ClientEndpoint(reactor, str(self.socks5_host),
self.socks5_port)
ircEndpoint = SOCKS5ClientEndpoint(str(self.serverport[0]),
self.serverport[1], torEndpoint)
if self.usessl.lower() == 'true':
ctx = ClientContextFactory()
tlsEndpoint = TLSWrapClientEndpoint(ctx, ircEndpoint)
tlsEndpoint.connect(factory)
else:
ircEndpoint.connect(factory)
else:
try:
factory = TxIRCFactory(self)
wlog('build_irc: ', self.serverport[0], self.serverport[1],
self.channel)
self.tcp_connector = reactor.connectTCP(
self.serverport[0], self.serverport[1], factory)
except Exception as e:
wlog('error in buildirc: ' + repr(e))
def make_proxied_connection(protocol_factory,
target_host,
target_port,
use_ssl,
socks_config=None,
log_id=None,
http_error_transport=None):
from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
from txsocksx.client import SOCKS5ClientEndpoint
from txsocksx.tls import TLSWrapClientEndpoint
from pappyproxy.pappy import session
if socks_config is not None:
log("Connecting to socks proxy", id=log_id)
sock_host = socks_config['host']
sock_port = int(socks_config['port'])
methods = {'anonymous': ()}
if 'username' in socks_config and 'password' in socks_config:
methods['login'] = (socks_config['username'],
socks_config['password'])
tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
socks_endpoint = SOCKS5ClientEndpoint(target_host,
target_port,
tcp_endpoint,
methods=methods)
if use_ssl:
log("Using SSL over proxy to connect to %s:%d ssl=%s" %
(target_host, target_port, use_ssl),
id=log_id)
endpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(),
socks_endpoint)
else:
log("Using TCP over proxy to connect to %s:%d ssl=%s" %
(target_host, target_port, use_ssl),
id=log_id)
endpoint = socks_endpoint
else:
log("Connecting directly to host", id=log_id)
if use_ssl:
log("Using SSL to connect to %s:%d ssl=%s" %
(target_host, target_port, use_ssl),
id=log_id)
#context = BrowserLikePolicyForHTTPS().creatorForNetloc(target_host, target_port)
context = ssl.ClientContextFactory()
endpoint = SSL4ClientEndpoint(reactor, target_host, target_port,
context)
else:
log("Using TCP to connect to %s:%d ssl=%s" %
(target_host, target_port, use_ssl),
id=log_id)
endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
connection_deferred = endpoint.connect(protocol_factory)
if http_error_transport:
connection_deferred.addErrback(connection_error_http_response,
http_error_transport, log_id)
def main(reactor):
torEndpoint = TCP4ClientEndpoint(reactor, '127.0.0.1', 9050)
ircEndpoint = SOCKS5ClientEndpoint('CHANGE_THIS', 6697, torEndpoint)
host = 'CHANGE_THIS'
options_ = optionsForClientTLS(hostname=host.decode('\
utf-8'), trustRoot=ssl.Certificate.loadPEM(FilePath('\
CHANGE_THIS').getContent()), clientCertificate=None)
tlsEndpoint = TLSWrapClientEndpoint(options_, ircEndpoint)
d = tlsEndpoint.connect(SpewingFactory(TorIRCFactory()))
d.addCallback(lambda proto: proto.wrappedProtocol.deferred)
return d
class TLSWrapClientEndpointTestCase(SyncDeferredsTestCase):
def setUp(self):
self.endpoint = FakeEndpoint()
self.context = object()
self.wrapper = TLSWrapClientEndpoint(self.context, self.endpoint)
self.wrapper._wrapper = UppercaseWrapperFactory
self.factory = NetstringFactory()
def test_wrappingBehavior(self):
"""
Any modifications performed by the underlying ProtocolWrapper
propagate through to the wrapped Protocol.
"""
proto = self.successResultOf(self.wrapper.connect(self.factory))
self.endpoint.proto.dataReceived('5:hello,')
self.assertEqual(proto.strings, ['HELLO'])
def test_methodsAvailable(self):
"""
Methods defined on the Protocol are accessible from the Protocol
returned from connect's Deferred.
"""
proto = self.successResultOf(self.wrapper.connect(self.factory))
proto.sendString('spam')
self.assertEqual(self.endpoint.transport.value(), '4:SPAM,')
def test_connectionFailure(self):
"""
Connection failures propagate upward to connect's Deferred.
"""
self.endpoint.deferred = defer.Deferred()
d = self.wrapper.connect(self.factory)
self.assertNoResult(d)
self.endpoint.deferred.errback(FakeError())
self.failureResultOf(d, FakeError)
def test_connectionCancellation(self):
"""
Cancellation propagates upward to connect's Deferred.
"""
canceled = []
self.endpoint.deferred = defer.Deferred(canceled.append)
d = self.wrapper.connect(self.factory)
self.assertNoResult(d)
d.cancel()
self.assert_(canceled)
self.failureResultOf(d, defer.CancelledError)
def test_contextPassing(self):
"""
The SSL context object is passed along to the wrapper.
"""
self.successResultOf(self.wrapper.connect(self.factory))
self.assertIdentical(self.context, self.endpoint.factory.context)
class TLSWrapClientEndpointTestCase(SyncDeferredsTestCase):
def setUp(self):
self.endpoint = FakeEndpoint()
self.context = object()
self.wrapper = TLSWrapClientEndpoint(self.context, self.endpoint)
self.wrapper._wrapper = UppercaseWrapperFactory
self.factory = NetstringFactory()
def test_wrappingBehavior(self):
"""
Any modifications performed by the underlying ProtocolWrapper
propagate through to the wrapped Protocol.
"""
proto = self.successResultOf(self.wrapper.connect(self.factory))
self.endpoint.proto.dataReceived('5:hello,')
self.assertEqual(proto.strings, [six.b('HELLO')])
def test_methodsAvailable(self):
"""
Methods defined on the Protocol are accessible from the Protocol
returned from connect's Deferred.
"""
proto = self.successResultOf(self.wrapper.connect(self.factory))
proto.sendString('spam')
self.assertEqual(self.endpoint.transport.value(), six.b('4:SPAM,'))
def test_connectionFailure(self):
"""
Connection failures propagate upward to connect's Deferred.
"""
self.endpoint.deferred = defer.Deferred()
d = self.wrapper.connect(self.factory)
self.assertNoResult(d)
self.endpoint.deferred.errback(FakeError())
self.failureResultOf(d, FakeError)
def test_connectionCancellation(self):
"""
Cancellation propagates upward to connect's Deferred.
"""
canceled = []
self.endpoint.deferred = defer.Deferred(canceled.append)
d = self.wrapper.connect(self.factory)
self.assertNoResult(d)
d.cancel()
self.assert_(canceled)
self.failureResultOf(d, defer.CancelledError)
def test_contextPassing(self):
"""
The SSL context object is passed along to the wrapper.
"""
self.successResultOf(self.wrapper.connect(self.factory))
self.assertIdentical(self.context, self.endpoint.factory.context)
def main(reactor):
factory = protocol.Factory.forProtocol(other_proto.DecisionProtocol)
ca_data = FilePath(b'ca_cert.pem').getContent()
client_data = FilePath(b'a.client.pem').getContent()
ca_cert = ssl.Certificate.loadPEM(ca_data)
client_key = ssl.PrivateCertificate.loadPEM(client_data)
options = ssl.optionsForClientTLS(u'the-authority', ca_cert, client_key)
exampleEndpoint = txtorcon.TorClientEndpoint(ip, 8966, socks_hostname="127.0.0.1")
tlsEndpoint = TLSWrapClientEndpoint(options, exampleEndpoint)
deferred = yield tlsEndpoint.connect(factory)
done = defer.Deferred()
deferred.connectionLost = lambda reason: done.callback(None)
yield done
def get_endpoint(target_host, target_port, target_ssl, socks_config=None):
# Imports go here to allow mocking for tests
from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
from txsocksx.client import SOCKS5ClientEndpoint
from txsocksx.tls import TLSWrapClientEndpoint
from twisted.internet.interfaces import IOpenSSLClientConnectionCreator
if socks_config is not None:
sock_host = socks_config['host']
sock_port = int(socks_config['port'])
methods = {'anonymous': ()}
if 'username' in socks_config and 'password' in socks_config:
methods['login'] = (socks_config['username'],
socks_config['password'])
tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
socks_endpoint = SOCKS5ClientEndpoint(target_host,
target_port,
tcp_endpoint,
methods=methods)
if target_ssl:
endpoint = TLSWrapClientEndpoint(ClientTLSContext(),
socks_endpoint)
else:
endpoint = socks_endpoint
else:
if target_ssl:
endpoint = SSL4ClientEndpoint(reactor, target_host, target_port,
ClientTLSContext())
else:
endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
return endpoint
def TLS_TOR_conn(self, bar_server, bar_port):
# Connect to TOR network
torServerEndpoint = TCP4ClientEndpoint(reactor, "127.0.0.1", 9050)
torEndpoint = SOCKS5ClientEndpoint(bar_server, bar_port,
torServerEndpoint)
#Use SSL - TLS to encrypt the connection between You and the server
tlsEndpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(),
torEndpoint)
return tlsEndpoint
def test_no_tcp():
from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
from txsocksx.client import SOCKS5ClientEndpoint
from txsocksx.tls import TLSWrapClientEndpoint
with pytest.raises(NotImplementedError):
SSL4ClientEndpoint('aasdfasdf.sdfwerqwer')
with pytest.raises(NotImplementedError):
TCP4ClientEndpoint('aasdfasdf.sdfwerqwer')
with pytest.raises(NotImplementedError):
SOCKS5ClientEndpoint('aasdfasdf.sdfwerqwer')
with pytest.raises(NotImplementedError):
TLSWrapClientEndpoint('asdf.2341')
def get_endpoint(target_host,
target_port,
target_ssl,
socks_config=None,
use_http_proxy=False,
debugid=None):
# Imports go here to allow mocking for tests
from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
from txsocksx.client import SOCKS5ClientEndpoint
from txsocksx.tls import TLSWrapClientEndpoint
from pappyproxy.pappy import session
log("Getting endpoint for host '%s' on port %d ssl=%s, socks_config=%s, use_http_proxy=%s"
% (target_host, target_port, target_ssl, str(socks_config),
use_http_proxy),
id=debugid,
verbosity_level=3)
if session.config.http_proxy and use_http_proxy:
target_host = session.config.http_proxy['host']
target_port = session.config.http_proxy['port']
target_ssl = False # We turn on ssl after CONNECT request if needed
log("Connecting to http proxy at %s:%d" % (target_host, target_port),
id=debugid,
verbosity_level=3)
if socks_config is not None:
sock_host = socks_config['host']
sock_port = int(socks_config['port'])
methods = {'anonymous': ()}
if 'username' in socks_config and 'password' in socks_config:
methods['login'] = (socks_config['username'],
socks_config['password'])
tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
socks_endpoint = SOCKS5ClientEndpoint(target_host,
target_port,
tcp_endpoint,
methods=methods)
if target_ssl:
endpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(),
socks_endpoint)
else:
endpoint = socks_endpoint
else:
if target_ssl:
endpoint = SSL4ClientEndpoint(reactor, target_host, target_port,
ssl.ClientContextFactory())
else:
endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
return endpoint
def make_proxied_connection(protocol_factory, target_host, target_port, use_ssl,
socks_config=None, log_id=None, http_error_transport=None):
from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
from txsocksx.client import SOCKS5ClientEndpoint
from txsocksx.tls import TLSWrapClientEndpoint
from pappyproxy.pappy import session
if socks_config is not None:
log("Connecting to socks proxy", id=log_id)
sock_host = socks_config['host']
sock_port = int(socks_config['port'])
methods = {'anonymous': ()}
if 'username' in socks_config and 'password' in socks_config:
methods['login'] = (socks_config['username'], socks_config['password'])
tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
socks_endpoint = SOCKS5ClientEndpoint(target_host, target_port, tcp_endpoint, methods=methods)
if use_ssl:
log("Using SSL over proxy to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
endpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(), socks_endpoint)
else:
log("Using TCP over proxy to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
endpoint = socks_endpoint
else:
log("Connecting directly to host", id=log_id)
if use_ssl:
log("Using SSL to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
#context = BrowserLikePolicyForHTTPS().creatorForNetloc(target_host, target_port)
context = ssl.ClientContextFactory()
endpoint = SSL4ClientEndpoint(reactor, target_host, target_port, context)
else:
log("Using TCP to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
connection_deferred = endpoint.connect(protocol_factory)
if http_error_transport:
connection_deferred.addErrback(connection_error_http_response,
http_error_transport, log_id)
def connect(self, protocolfactory):
last_error = None
kwargs = dict()
if self.socks_username is not None and self.socks_password is not None:
kwargs['methods'] = dict(
login=(self.socks_username, self.socks_password),
)
if self.socks_endpoint is not None:
args = (self.host, self.port, self.socks_endpoint)
socks_ep = SOCKS5ClientEndpoint(*args, **kwargs)
if self.tls:
context = optionsForClientTLS(unicode(self.host))
socks_ep = TLSWrapClientEndpoint(context, socks_ep)
proto = yield socks_ep.connect(protocolfactory)
defer.returnValue(proto)
else:
for socks_port in self._socks_port_iter:
tor_ep = TCP4ClientEndpoint(
reactor,
"127.0.0.1",
socks_port,
)
args = (self.host, self.port, tor_ep)
socks_ep = SOCKS5ClientEndpoint(*args, **kwargs)
if self.tls:
# XXX only twisted 14+
context = optionsForClientTLS(unicode(self.host))
socks_ep = TLSWrapClientEndpoint(context, socks_ep)
try:
proto = yield socks_ep.connect(protocolfactory)
defer.returnValue(proto)
except error.ConnectError as e0:
last_error = e0
if last_error is not None:
raise last_error
def _tlsWrapper(self, *a):
wrapper = TLSWrapClientEndpoint(*a)
wrapper._wrapper = UppercaseWrapperFactory
return wrapper
def setUp(self):
self.endpoint = FakeEndpoint()
self.context = object()
self.wrapper = TLSWrapClientEndpoint(self.context, self.endpoint)
self.wrapper._wrapper = UppercaseWrapperFactory
self.factory = NetstringFactory()
def setUp(self):
self.endpoint = FakeEndpoint()
self.context = object()
self.wrapper = TLSWrapClientEndpoint(self.context, self.endpoint)
self.wrapper._wrapper = UppercaseWrapperFactory
self.factory = NetstringFactory()
def _tlsWrapper(self, *a):
wrapper = TLSWrapClientEndpoint(*a)
wrapper._wrapper = UppercaseWrapperFactory
return wrapper
