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 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()