def open(self): """open the connection to the lircd socket""" def gotProtocol(result): """now we have a connection""" self.protocol = result self.protocol.wrapper = self print 'got lirc protocol' def gotNoProtocol(result): """something went wrong""" print "got no connection to lirc: %s" % result point = UNIXClientEndpoint(reactor, self.irwSocket, timeout=2) factory = ClientFactory() factory.protocol = LircProtocol point.connect(factory).addCallback(gotProtocol).addErrback(gotNoProtocol)
def main(): address = FilePath(sys.argv[1]) startLogging(sys.stdout) factory = Factory() factory.protocol = ReceiveFDProtocol factory.quiet = True endpoint = UNIXClientEndpoint(reactor, address.path) connected = endpoint.connect(factory) def succeeded(client): return client.whenDisconnected def failed(reason): print("Could not connect:", reason.getErrorMessage()) def disconnected(ignored): reactor.stop() connected.addCallbacks(succeeded, failed) connected.addCallback(disconnected) reactor.run()
def sign(self, challenge): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") factory = Factory() factory.noisy = False factory.protocol = SSHAgentClient endpoint = UNIXClientEndpoint(self._reactor, os.environ["SSH_AUTH_SOCK"]) d = endpoint.connect(factory) @inlineCallbacks def on_connect(agent): # we are now connected to the locally running ssh-agent # that agent might be the openssh-agent, or eg on Ubuntu 14.04 by # default the gnome-keyring / ssh-askpass-gnome application blob = pack(['ssh-ed25519', self.public_key(binary=True)]) # now ask the agent signature_blob = yield agent.signData(blob, challenge) algo, signature = unpack(signature_blob) agent.transport.loseConnection() returnValue(signature) return d.addCallback(on_connect)
def sign(self, challenge): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") factory = Factory() factory.noisy = False factory.protocol = SSHAgentClient endpoint = UNIXClientEndpoint(self._reactor, os.environ["SSH_AUTH_SOCK"]) d = endpoint.connect(factory) @inlineCallbacks def on_connect(agent): # we are now connected to the locally running ssh-agent # that agent might be the openssh-agent, or eg on Ubuntu 14.04 by # default the gnome-keyring / ssh-askpass-gnome application blob = _pack(['ssh-ed25519', self.public_key(binary=True)]) # now ask the agent signature_blob = yield agent.signData(blob, challenge) algo, signature = _unpack(signature_blob) agent.transport.loseConnection() returnValue(signature) return d.addCallback(on_connect)
class Client: def __init__(self, addr, reactor, callback, plant, name, pid, wait_result): self.addr = addr self.reactor = reactor self.protocol = None self.deferred = defer.Deferred() self.deferred.addCallback(self.connected) self.factory = ClientFactory(callback, plant, name, pid, wait_result, self.deferred) self.endpoint = UNIXClientEndpoint(reactor, addr) def connect(self): return self.endpoint.connect(self.factory) def disconnect(self): if self.protocol is not None: self.protocol.disconnect() def connected(self, protocol): self.protocol = protocol def notify_death(self, wait_result): """Returns true if death ceritificate has been sent, false otherwise """ if self.protocol is None: logging.error("Cannot report exit status because not connected") return False elif self.protocol.state == ACCEPTED: self.protocol.notify_death(wait_result) else: logging.info("Not notifying server of death because connection is not in ACCEPTED state (state = {})".format(self.protocol.state)) return self.protocol.state >= ACCEPTED
def open(self): """open the connection to the lircd socket""" def gotProtocol(result): """now we have a connection""" self.protocol = result self.protocol.wrapper = self logDebug(self, None, 'got lirc protocol') def gotNoProtocol(result): """something went wrong""" print "got no connection to lirc: %s" % result point = UNIXClientEndpoint(reactor, self.irwSocket, timeout=2) factory = ClientFactory() factory.protocol = LircProtocol point.connect(factory).addCallback(gotProtocol).addErrback( gotNoProtocol)
def __init__(self, args=None): '''Args must be an object with the following attributes: socketpath, verbose Suitable defaults will be supplied.''' # Pass command line args to ProtocolIVSHMSG, then open logging. if args is None: args = argparse.Namespace() for arg, default in self._required_arg_defaults.items(): setattr(args, arg, getattr(args, arg, default)) self.args = args # checkPID looks for <socketpath>.lock which the server sets up # as a symlink to file named <PID> E = UNIXClientEndpoint(TIreactor, args.socketpath, timeout=1, checkPID=False) E.connect(self)
def new(cls, pubkey=None, reactor=None): """ Create a proxy for a key held in SSH agent. :param pubkey: A string with a public Ed25519 key in SSH format. :type pubkey: unicode """ pubkey = _read_ssh_ed25519_pubkey(pubkey) if not reactor: from twisted.internet import reactor from twisted.internet.defer import inlineCallbacks, returnValue from twisted.internet.protocol import Factory from twisted.internet.endpoints import UNIXClientEndpoint from twisted.conch.ssh.agent import SSHAgentClient if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") factory = Factory() factory.noisy = False factory.protocol = SSHAgentClient endpoint = UNIXClientEndpoint(reactor, os.environ["SSH_AUTH_SOCK"]) d = endpoint.connect(factory) @inlineCallbacks def on_connect(agent): keys = yield agent.requestIdentities() # if the key is found in ssh-agent, the raw public key (32 bytes), and the # key comment as returned from ssh-agent key_data = None key_comment = None for blob, comment in keys: raw = unpack(blob) algo = raw[0] if algo == u'ssh-ed25519': algo, _pubkey = raw if _pubkey == pubkey: key_data = _pubkey key_comment = comment.decode('utf8') break agent.transport.loseConnection() if key_data: key = signing.VerifyKey(key_data) returnValue(cls(key, key_comment, reactor)) else: raise Exception("Ed25519 key not held in ssh-agent") return d.addCallback(on_connect)
def passTo(self, host, protocol): orig_socket = protocol.transport.socket if not host: host = b'default' try: for vhost in self.vhosts: if vhost.hostname.match(host): dest_socket = vhost.socket endpoint = UNIXClientEndpoint(reactor, dest_socket) connected = endpoint.connect(Factory.forProtocol(Protocol)) connected.addCallback( partial(self.passClientTo, orig_socket)) connected.addBoth(partial(self.disconnect, protocol)) return finally: pass
def main(reactor, *argv): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") factory = Factory() factory.protocol = SSHAgentClient endpoint = UNIXClientEndpoint(reactor, os.environ["SSH_AUTH_SOCK"]) d = endpoint.connect(factory) @inlineCallbacks def on_connect(proto): print("connected to agent. keys held currently:") keys = yield proto.requestIdentities() for blob, comment in keys: print("Key: {}".format(comment)) proto.transport.loseConnection() return d.addCallback(on_connect)
def query(ctx): """" Execute subcommand through UNIX domain socket client. """ if not ctx.opts.argv: print("No command %s" % ctx.opts.argv[0], file=ctx.err) return 1 address = FilePath(ctx.opts.flags.address) factory = Factory() factory.ctx = ctx ctx.rs = 0 factory.protocol = QueryProtocol factory.quiet = True factory.cmd = ' '.join(ctx.opts.argv) # DEBUG: # print('Passthrough command to backend via socket: %r' % factory.cmd, file=sys.stderr) endpoint = UNIXClientEndpoint(reactor, address.path) connected = endpoint.connect(factory) def succeeded(client): return client.whenDisconnected def failed(reason): print("Could not connect:", reason.getErrorMessage(), file=ctx.err) def disconnected(ignored): reactor.stop() connected.addCallbacks(succeeded, failed) connected.addCallback(disconnected) reactor.run() return factory.ctx.rs
def main(): address = FilePath(sys.argv[1]) startLogging(sys.stdout) factory = Factory() factory.protocol = ReceiveFDProtocol factory.quiet = True endpoint = UNIXClientEndpoint(reactor, address.path) connected = endpoint.connect(factory) def succeeded(client): return client.whenDisconnected def failed(reason): print("Could not connect:", reason.getErrorMessage()) def disconnected(ignored): reactor.stop() connected.addCallbacks(succeeded, failed) connected.addCallback(disconnected) reactor.run()
def main(reactor, *argv): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") endpoint = UNIXClientEndpoint(reactor, os.environ["SSH_AUTH_SOCK"]) proto = yield endpoint.connect(Factory.forProtocol(SSHAgentClient)) print("connected to agent. keys held currently:") for blob, comment in (yield proto.requestIdentities()): raw = unpack(blob) algo = raw[0] if algo == u'ssh-rsa': algo, exponent, modulus = raw print("RSA key: {} {} 0x{} {}: 0x{} ..".format( comment, algo, b2a_hex(exponent), len(modulus), b2a_hex(modulus)[:16])) print(b2a_base64(blob)) elif algo == u'ssh-ed25519': algo, pubkey = raw print("Ed25519 key: {} {} {}".format(comment, algo, b2a_hex(pubkey))) else: print("Key of unknown type {}".format(algo)) proto.transport.loseConnection()
def main(reactor, *argv): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") endpoint = UNIXClientEndpoint(reactor, os.environ["SSH_AUTH_SOCK"]) proto = yield endpoint.connect(Factory.forProtocol(SSHAgentClient)) print("connected to agent. keys held currently:") for blob, comment in (yield proto.requestIdentities()): raw = unpack(blob) algo = raw[0] if algo == u"ssh-rsa": algo, exponent, modulus = raw print( "RSA key: {} {} 0x{} {}: 0x{} ..".format( comment, algo, b2a_hex(exponent), len(modulus), b2a_hex(modulus)[:16] ) ) print(b2a_base64(blob)) elif algo == u"ssh-ed25519": algo, pubkey = raw print("Ed25519 key: {} {} {}".format(comment, algo, b2a_hex(pubkey))) else: print("Key of unknown type {}".format(algo)) proto.transport.loseConnection()
def main(reactor): ep = UNIXClientEndpoint(reactor, '/var/run/postgresql/.s.PGSQL.5432') fact = ClientFactory.forProtocol(PostgresProtocol) proto = yield ep.connect(fact) # for i in range(5000): res = yield proto.runQuery('SELECT * from entries limit 5')
def build_tor_connection(connection, build_state=True, wait_for_proto=True, password_function=lambda: None): """ This is used to build a valid TorState (which has .protocol for the TorControlProtocol). For example:: from twisted.internet import reactor from twisted.internet.endpoints import TCP4ClientEndpoint import txtorcon def example(state): print "Fully bootstrapped state:",state print " with bootstrapped protocol:",state.protocol d = txtorcon.build_tor_connection(TCP4ClientEndpoint(reactor, "localhost", 9051)) d.addCallback(example) reactor.run() :param password_function: See :class:`txtorcon.TorControlProtocol` :param build_state: If True (the default) a TorState object will be built as well. If False, just a TorControlProtocol will be returned via the Deferred. :return: a Deferred that fires with a TorControlProtocol or, if you specified build_state=True, a TorState. In both cases, the object has finished bootstrapping (i.e. TorControlProtocol.post_bootstrap or TorState.post_bootstap has fired, as needed) """ if IStreamClientEndpoint.providedBy(connection): endpoint = connection elif isinstance(connection, tuple): if len(connection) == 2: reactor, socket = connection if (os.path.exists(socket) and os.stat(socket).st_mode & (stat.S_IRGRP | stat.S_IRUSR | stat.S_IROTH)): endpoint = UNIXClientEndpoint(reactor, socket) else: raise ValueError('Can\'t use "%s" as a socket' % (socket, )) elif len(connection) == 3: endpoint = TCP4ClientEndpoint(*connection) else: raise TypeError('Expected either a (reactor, socket)- or a ' '(reactor, host, port)-tuple for argument ' '"connection", got %s' % (connection, )) else: raise TypeError('Expected a (reactor, socket)- or a (reactor, host, ' 'port)-tuple or an object implementing IStreamClient' 'Endpoint for argument "connection", got %s' % (connection, )) d = endpoint.connect( TorProtocolFactory(password_function=password_function)) if build_state: d.addCallback(build_state if isinstance(build_state, collections. Callable) else _build_state) elif wait_for_proto: d.addCallback(wait_for_proto if isinstance( wait_for_proto, collections.Callable) else _wait_for_proto) return d
def build_tor_connection(connection, build_state=True, wait_for_proto=True, password_function=lambda: None): """ This is used to build a valid TorState (which has .protocol for the TorControlProtocol). For example:: from twisted.internet import reactor from twisted.internet.endpoints import TCP4ClientEndpoint import txtorcon def example(state): print "Fully bootstrapped state:",state print " with bootstrapped protocol:",state.protocol d = txtorcon.build_tor_connection(TCP4ClientEndpoint(reactor, "localhost", 9051)) d.addCallback(example) reactor.run() :param password_function: See :class:`txtorcon.TorControlProtocol` :param build_state: If True (the default) a TorState object will be built as well. If False, just a TorControlProtocol will be returned via the Deferred. :return: a Deferred that fires with a TorControlProtocol or, if you specified build_state=True, a TorState. In both cases, the object has finished bootstrapping (i.e. TorControlProtocol.post_bootstrap or TorState.post_bootstap has fired, as needed) """ if IStreamClientEndpoint.providedBy(connection): endpoint = connection elif isinstance(connection, tuple): if len(connection) == 2: reactor, socket = connection if (os.path.exists(socket) and os.stat(socket).st_mode & (stat.S_IRGRP | stat.S_IRUSR | stat.S_IROTH)): endpoint = UNIXClientEndpoint(reactor, socket) else: raise ValueError('Can\'t use "%s" as a socket' % (socket, )) elif len(connection) == 3: endpoint = TCP4ClientEndpoint(*connection) else: raise TypeError('Expected either a (reactor, socket)- or a ' '(reactor, host, port)-tuple for argument ' '"connection", got %s' % (connection, )) else: raise TypeError('Expected a (reactor, socket)- or a (reactor, host, ' 'port)-tuple or an object implementing IStreamClient' 'Endpoint for argument "connection", got %s' % (connection, )) d = endpoint.connect(TorProtocolFactory(password_function=password_function)) if build_state: d.addCallback(build_state if callable(build_state) else _build_state) elif wait_for_proto: d.addCallback(wait_for_proto if callable(wait_for_proto) else _wait_for_proto) return d
class ContainerModule: """ The ComponentModule creates component hosts in a Worker process. Component hosts can dynamically load, reload and unload Python application classes and components (WAMPlets). """ def __init__(self, cbdir, debug = False): self._cbdir = cbdir self.debug = debug self._client = None self._session = None def connect(self, session): assert(self._session is None) self._session = session self._pid = session._pid self._node_name = session._node_name dl = [] procs = [ 'start_component', ] for proc in procs: uri = 'crossbar.node.{}.worker.{}.container.{}'.format(self._node_name, self._pid, proc) dl.append(self._session.register(getattr(self, proc), uri)) d = DeferredList(dl) return d def start_component(self, component, router): """ Starts a Class or WAMPlet in this component container. """ if component['type'] == 'wamplet': try: dist = component['dist'] name = component['entry'] if self.debug: log.msg("Worker {}: starting WAMPlet '{}/{}' in realm '{}' ..".format(self._pid, dist, name, router['realm'])) ## make is supposed to make instances of ApplicationSession make = pkg_resources.load_entry_point(dist, 'autobahn.twisted.wamplet', name) except Exception as e: log.msg("Worker {}: failed to import class - {}".format(e)) raise ApplicationError("crossbar.error.class_import_failed", str(e)) elif component['type'] == 'class': try: klassname = component['name'] if self.debug: log.msg("Worker {}: starting class '{}' in realm '{}' ..".format(self._pid, klassname, router['realm'])) import importlib c = klassname.split('.') mod, kls = '.'.join(c[:-1]), c[-1] app = importlib.import_module(mod) ## make is supposed to be of class ApplicationSession make = getattr(app, kls) except Exception as e: log.msg("Worker {}: failed to import class - {}".format(e)) raise ApplicationError("crossbar.error.class_import_failed", str(e)) else: raise ApplicationError("crossbar.error.invalid_configuration", "unknown component type '{}'".format(component['type'])) def create(): cfg = ComponentConfig(realm = router['realm'], extra = component.get('extra', None)) c = make(cfg) return c ## create a WAMP-over-WebSocket transport client factory ## from autobahn.twisted.websocket import WampWebSocketClientFactory transport_factory = WampWebSocketClientFactory(create, router['url'], debug = self.debug) transport_factory.setProtocolOptions(failByDrop = False) ## start a WebSocket client from an endpoint ## from twisted.internet import reactor from twisted.internet.endpoints import TCP4ClientEndpoint, SSL4ClientEndpoint, UNIXClientEndpoint from twisted.internet.endpoints import clientFromString from crossbar.twisted.tlsctx import TlsClientContextFactory if False: self._client = clientFromString(reactor, router['endpoint']) else: try: endpoint_config = router.get('endpoint') ## a TCP4 endpoint ## if endpoint_config['type'] == 'tcp': ## the host to connect ot ## host = str(endpoint_config['host']) ## the port to connect to ## port = int(endpoint_config['port']) ## connection timeout in seconds ## timeout = int(endpoint_config.get('timeout', 10)) if 'tls' in endpoint_config: ctx = TlsClientContextFactory() ## create a TLS client endpoint ## self._client = SSL4ClientEndpoint(reactor, host, port, ctx, timeout = timeout) else: ## create a non-TLS client endpoint ## self._client = TCP4ClientEndpoint(reactor, host, port, timeout = timeout) ## a Unix Domain Socket endpoint ## elif endpoint_config['type'] == 'unix': ## the path ## path = os.path.abspath(os.path.join(self._cbdir, endpoint_config['path'])) ## connection timeout in seconds ## timeout = int(endpoint_config['type'].get('timeout', 10)) ## create the endpoint ## self._client = UNIXClientEndpoint(reactor, path, timeout = timeout) else: raise ApplicationError("crossbar.error.invalid_configuration", "invalid endpoint type '{}'".format(endpoint_config['type'])) except Exception as e: log.msg("endpoint creation failed: {}".format(e)) raise e retry = True retryDelay = 1000 def try_connect(): if self.debug: log.msg("Worker {}: connecting to router ..".format(self._pid)) d = self._client.connect(transport_factory) def success(res): if self.debug: log.msg("Worker {}: client connected to router".format(self._pid)) def error(err): log.msg("Worker {}: client failed to connect to router - {}".format(self._pid, err)) if retry: log.msg("Worker {}: retrying in {} ms".format(self._pid, retryDelay)) reactor.callLater(float(retryDelay) / 1000., try_connect) else: log.msg("Worker {}: giving up.".format(seld._pid)) d.addCallbacks(success, error) try_connect()
def main(reactor): ep = UNIXClientEndpoint(reactor, '/var/run/postgresql/.s.PGSQL.5432') fact = ClientFactory.forProtocol(PostgresProtocol) proto = yield ep.connect(fact) # for i in range(5000): res = yield proto.runQuery('SELECT * from entries limit 5')
class XmppService(xmppim.MessageProtocol): def __init__(self, cfg): self.cfg = cfg self.active = {} self.redis = None self.core = UNIXClientEndpoint(reactor, self.cfg.get("xmpp", "dmproc")) self.pooling = task.LoopingCall(self.redis_pooling) @defer.inlineCallbacks def redis_pooling(self): data0 = yield self.redis.hgetall("leela.xmpp") for (key, conn) in list(self.active.iteritems()): if (key not in data0): logger.warn("reaping connection: %s" % (key,)) conn.shutdown() for (key, data1) in data0.iteritems(): data = parser.parse_json(data1) if (key not in self.active): logger.debug("spawning connection: %s: %s" % (key, data["sender"])) conn = Connection(key, xmppim.JID(data["sender"]), data["request"]["select"], self) self.core.connect(conn.factory()) @defer.inlineCallbacks def handle_select(self, request, sender, cc): try: if ((request["select"]["regex"] == "leela.xmpp") and (request["select"]["proc"] == "*")): data0 = yield self.redis.hgetall("leela.xmpp") tmp = [] for (key, data1) in data0.iteritems(): data = parser.parse_json(data1) sql = pp.render_select(data["request"]["select"]["proc"], data["request"]["select"]["regex"]) if (data["sender"] == sender.userhost()): tmp.append({"key": key, "cmd": sql }) cc(200, {"results": tmp}) else: hcode = hashlib.sha512() hcode.update(sender.userhost()) hcode.update(request["select"]["proc"]) hcode.update(request["select"]["regex"]) key = hcode.hexdigest() self.redis.hsetnx("leela.xmpp", key, pp.render_json({"request": request, "sender": sender.userhost()})) except: logger.exception() cc(500, {"reason": "internal server error"}) @defer.inlineCallbacks def handle_delete_all(self, sender, cc): data0 = yield self.redis.hgetall("leela.xmpp") keys = [] for (key, data1) in data0.iteritems(): data = parser.parse_json(data1) if (data["sender"] == sender.userhost()): keys.append({"key": key}) self.redis.hdel("leela.xmpp", key) cc(200, {"results": keys}) @defer.inlineCallbacks def handle_delete_one(self, key, sender, cc): data0 = yield self.redis.hget("leela.xmpp", key) if (data0 is not None): data = parser.parse_json(data0) if (data["sender"] == sender.userhost()): yield self.redis.hdel("leela.xmpp", key) cc(200, {"results": {"key": key}}) else: cc(403, {"reason": "forbidden"}) else: cc(404, {"reason": "not found"}) def handle_delete(self, request, sender, cc): try: key = request["delete"]["key"] if (key is None): self.handle_delete_all(sender, cc) else: self.handle_delete_one(key, sender, cc) except: logger.exception() cc(500, {"reason": "internal server error"}) def handle_request(self, request, sender, cc): if ("select" in request): self.handle_select(request, sender, cc) elif ("delete" in request): self.handle_delete(request, sender, cc) else: cc(400, {"reason": "unknow command"}) def mkcc(self, envelope, debug={}): def f(status, results=None): if (results is None): envelope.addElement("body", content=pp.render_json({"status": status, "debug": debug})) else: msg = dict(results) msg.update({"status": status, "debug": debug}) envelope.addElement("body", content=pp.render_json(msg)) self.send(envelope) return(f) def onMessage(self, message): if (message.body is None): return sender = xmppim.JID(message.getAttribute("from")) req = parser.parse_sql_(unicode(message.body)) debug = {"request": unicode(message.body)} resp = xmppim.Message(recipient = sender).toElement() cc = self.mkcc(resp, debug) if (req in [{}, None]): logger.debug("message [%s] - 400" % message.body) cc(400, {"reason": "parse error"}) else: logger.debug("message [%s] %s - 200" % (message.getAttribute("from"), message.body)) self.handle_request(req, sender, cc) @defer.inlineCallbacks def connectionMade(self): try: self.redis = yield redis.ConnectionPool(self.cfg.get("redis", "host"), self.cfg.getint("redis", "port"), self.cfg.getint("redis", "db"), True) self.pooling.start(5) xmppim.MessageProtocol.connectionMade(self) except: logger.exception() def connectionLost(self, reason): xmppim.MessageProtocol.connectionLost(self, reason) funcs.suppress(self.pooling.stop)() funcs.suppress(self.redis.disconnect)()
class ComponentModule: """ """ def __init__(self, session, pid): self._session = session self._pid = pid self._client = None self.debug = self._session.factory.options.debug session.register(self.start, 'crossbar.node.module.{}.component.start'.format(self._pid)) def start(self, transport, klassname, realm): """ Dynamically start an application component to run next to the router in "embedded mode". """ ## dynamically load the application component .. ## try: if self.debug: log.msg("Worker {}: starting class '{}' in realm '{}' ..".format(self._pid, klassname, realm)) import importlib c = klassname.split('.') mod, klass = '.'.join(c[:-1]), c[-1] app = importlib.import_module(mod) SessionKlass = getattr(app, klass) except Exception as e: if self.debug: log.msg("Worker {}: failed to import class - {}".format(e)) raise ApplicationError("crossbar.error.class_import_failed", str(e)) else: ## create a WAMP application session factory ## #from autobahn.twisted.wamp import ApplicationSessionFactory #session_factory = ApplicationSessionFactory() session_factory = ComponentSessionFactory(realm) session_factory.session = SessionKlass ## create a WAMP-over-WebSocket transport client factory ## from autobahn.twisted.websocket import WampWebSocketClientFactory transport_factory = WampWebSocketClientFactory(session_factory, transport['url'], debug = self.debug) transport_factory.setProtocolOptions(failByDrop = False) ## start a WebSocket client from an endpoint ## from twisted.internet import reactor from twisted.internet.endpoints import TCP4ClientEndpoint, SSL4ClientEndpoint, UNIXClientEndpoint from twisted.internet.endpoints import clientFromString from tlsctx import TlsClientContextFactory if False: self._client = clientFromString(reactor, transport['endpoint']) else: try: endpoint_config = transport.get('endpoint') ## a TCP4 endpoint ## if endpoint_config['type'] == 'tcp': ## the host to connect ot ## host = str(endpoint_config['host']) ## the port to connect to ## port = int(endpoint_config['port']) ## connection timeout in seconds ## timeout = int(endpoint_config.get('timeout', 10)) if 'tls' in endpoint_config: ctx = TlsClientContextFactory() ## create a TLS client endpoint ## self._client = SSL4ClientEndpoint(reactor, host, port, ctx, timeout = timeout) else: ## create a non-TLS client endpoint ## self._client = TCP4ClientEndpoint(reactor, host, port, timeout = timeout) ## a Unix Domain Socket endpoint ## elif endpoint_config['type'] == 'unix': ## the path ## path = str(endpoint_config['path']) ## connection timeout in seconds ## timeout = int(endpoint_config['type'].get('timeout', 10)) ## create the endpoint ## self._client = UNIXClientEndpoint(reactor, path, timeout = timeout) else: raise ApplicationError("crossbar.error.invalid_configuration", "invalid endpoint type '{}'".format(endpoint_config['type'])) except Exception as e: log.msg("endpoint creation failed: {}".format(e)) raise e retry = True retryDelay = 1000 def try_connect(): print "Trying to connect .." d = self._client.connect(transport_factory) def success(res): if True or self.debug: log.msg("Worker {}: client connected to router".format(self._pid)) def error(err): log.msg("Worker {}: client failed to connect to router - {}".format(self._pid, err)) if retry: log.msg("Worker {}: retrying in {} ms".format(self._pid, retryDelay)) reactor.callLater(float(retryDelay) / 1000., try_connect) else: log.msg("Worker {}: giving up.".format(seld._pid)) d.addCallbacks(success, error) try_connect()
def main(reactor, *argv): if "SSH_AUTH_SOCK" not in os.environ: raise Exception("no ssh-agent is running!") factory = Factory() factory.protocol = SSHAgentClient endpoint = UNIXClientEndpoint(reactor, os.environ["SSH_AUTH_SOCK"]) d = endpoint.connect(factory) @inlineCallbacks def on_connect(agent): # we are now connected to the locally running ssh-agent # that agent might be the openssh-agent, or eg on Ubuntu 14.04 by # default the gnome-keyring / ssh-askpass-gnome application print("connected to ssh-agent!") print("keys currently held in ssh-agent:\n") keys = yield agent.requestIdentities() for blob, comment in keys: print(comment) raw = unpack(blob) algo = raw[0] if algo == u'ssh-rsa': algo, exponent, modulus = raw print("RSA key: {} {} 0x{} {}: 0x{} ..".format(comment, algo, b2a_hex(exponent), len(modulus), b2a_hex(modulus)[:16])) print(b2a_base64(blob)) elif algo == u'ssh-ed25519': algo, pubkey = raw print("Ed25519 key: {} {} {}".format(comment, algo, b2a_hex(pubkey))) # we will now ask the ssh-agent to sign some data using the private # key that corresponds to the public key that we selected print("sign some data:\n") # message to sign message = 'Hello, world!' # the public key that corrsponds to the private key we ask the agent to sign with key_blob, key_comment = keys[-1] # now ask the agent signature_blob = yield agent.signData(key_blob, message) algo, signature = unpack(signature_blob) print(algo) print(b2a_base64(signature)) # we now verify the signature using cryptography. # https://cryptography.io/en/latest/hazmat/primitives/asymmetric/serialization/#cryptography.hazmat.primitives.serialization.load_ssh_public_key public_key = load_ssh_public_key("ssh-rsa {} {}".format(b2a_base64(key_blob), key_comment), backend=default_backend()) isinstance(public_key, rsa.RSAPublicKey) verifier = public_key.verifier(signature, padding.PKCS1v15(), hashes.SHA1()) verifier.update(message) # here we can provoke a failing signature to check that it actually works provoke_signature_failure = False if provoke_signature_failure: verifier.update('make the sig fail') try: verifier.verify() except InvalidSignature: print("** Signature is invalid!! **") else: print("Signature looks good.") # that's it. say goodbye. print("disconnecting ..") agent.transport.loseConnection() return d.addCallback(on_connect)
from twisted.internet import reactor from twisted.internet.protocol import Factory, Protocol from twisted.internet.endpoints import UNIXClientEndpoint class Greeter(Protocol): def sendMessage(self, msg): print "Sending message" self.transport.write("MESSAGE %s\r\n" % msg) def gotProtocol(p): print "gotProtocol" p.sendMessage("Hello \r\n") reactor.callLater(1, p.sendMessage, "This is sent in a second") reactor.callLater(2, p.transport.loseConnection) factory = Factory() factory.protocol = Greeter point = UNIXClientEndpoint(reactor, "tmpSoc") d = point.connect(factory) d.addCallback(gotProtocol) print "point = ", point
else: print k,v if 'defaults' in sys.argv: print "Set to default value:" for k in defaults: print "# %s" % k reactor.stop() def setup_failed(arg): print "SETUP FAILED",arg reactor.stop() def bootstrap(c): conf = TorConfig(c) conf.post_bootstrap.addCallback(setup_complete).addErrback(setup_failed) print "Connection is live, bootstrapping state..." if os.stat('/var/run/tor/control').st_mode & (stat.S_IRGRP | stat.S_IRUSR | stat.S_IROTH): print "using control socket" point = UNIXClientEndpoint(reactor, "/var/run/tor/control") else: point = TCP4ClientEndpoint(reactor, "localhost", 9051) d = point.connect(TorProtocolFactory()) # do not use addCallbacks() here, in case bootstrap has an error d.addCallback(bootstrap).addErrback(setup_failed) reactor.run()