async def test_single_insecure_security_transport_succeeds(): transports_for_initiator = {"foo": InsecureTransport(initiator_key_pair)} transports_for_noninitiator = {"foo": InsecureTransport(noninitiator_key_pair)} def assertion_func(conn): assert isinstance(conn, InsecureSession) await perform_simple_test( assertion_func, transports_for_initiator, transports_for_noninitiator )
def security_transport_factory( is_secure: bool, key_pair: KeyPair ) -> Dict[TProtocol, BaseSecureTransport]: if not is_secure: return {PLAINTEXT_PROTOCOL_ID: InsecureTransport(key_pair)} else: return {secio.ID: secio.Transport(key_pair)}
def __init__( self, key_pair: KeyPair, listen_ip: str, listen_port: int, chain: BaseBeaconChain, security_protocol_ops: Dict[TProtocol, BaseSecureTransport] = None, muxer_protocol_ops: Dict[TProtocol, IMuxedConn] = None, gossipsub_params: Optional[GossipsubParams] = None, cancel_token: CancelToken = None, bootstrap_nodes: Tuple[Multiaddr, ...] = None, preferred_nodes: Tuple[Multiaddr, ...] = None) -> None: super().__init__(cancel_token) self.listen_ip = listen_ip self.listen_port = listen_port self.key_pair = key_pair self.bootstrap_nodes = bootstrap_nodes self.preferred_nodes = preferred_nodes # TODO: Add key and peer_id to the peerstore if security_protocol_ops is None: security_protocol_ops = { PLAINTEXT_PROTOCOL_ID: InsecureTransport(key_pair) } if muxer_protocol_ops is None: muxer_protocol_ops = {MPLEX_PROTOCOL_ID: Mplex} network: INetwork = initialize_default_swarm( key_pair=key_pair, transport_opt=[self.listen_maddr], muxer_opt=muxer_protocol_ops, sec_opt=security_protocol_ops, peerstore_opt=None, # let the function initialize it disc_opt=None, # no routing required here ) self.host = BasicHost(network=network, router=None) if gossipsub_params is None: gossipsub_params = GossipsubParams() gossipsub_router = GossipSub( protocols=[GOSSIPSUB_PROTOCOL_ID], degree=gossipsub_params.DEGREE, degree_low=gossipsub_params.DEGREE_LOW, degree_high=gossipsub_params.DEGREE_HIGH, time_to_live=gossipsub_params.FANOUT_TTL, gossip_window=gossipsub_params.GOSSIP_WINDOW, gossip_history=gossipsub_params.GOSSIP_HISTORY, heartbeat_interval=gossipsub_params.HEARTBEAT_INTERVAL, ) self.pubsub = Pubsub( host=self.host, router=gossipsub_router, my_id=self.peer_id, ) self.chain = chain self.handshaked_peers = PeerPool() self.run_task(self.start())
def initialize_default_swarm( key_pair: KeyPair, id_opt: ID = None, transport_opt: Sequence[str] = None, muxer_opt: TMuxerOptions = None, sec_opt: TSecurityOptions = None, peerstore_opt: IPeerStore = None, ) -> Swarm: """ initialize swarm when no swarm is passed in. :param id_opt: optional id for host :param transport_opt: optional choice of transport upgrade :param muxer_opt: optional choice of stream muxer :param sec_opt: optional choice of security upgrade :param peerstore_opt: optional peerstore :return: return a default swarm instance """ if not id_opt: id_opt = generate_peer_id_from(key_pair) # TODO: Parse `transport_opt` to determine transport transport = TCP() muxer_transports_by_protocol = muxer_opt or {MPLEX_PROTOCOL_ID: Mplex} security_transports_by_protocol = sec_opt or { TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair), TProtocol(secio.ID): secio.Transport(key_pair), } upgrader = TransportUpgrader(security_transports_by_protocol, muxer_transports_by_protocol) peerstore = peerstore_opt or PeerStore() # Store our key pair in peerstore peerstore.add_key_pair(id_opt, key_pair) # TODO: Initialize discovery if not presented return Swarm(id_opt, peerstore, upgrader, transport)
def new_swarm( key_pair: KeyPair = None, muxer_opt: TMuxerOptions = None, sec_opt: TSecurityOptions = None, peerstore_opt: IPeerStore = None, ) -> INetworkService: """ Create a swarm instance based on the parameters. :param key_pair: optional choice of the ``KeyPair`` :param muxer_opt: optional choice of stream muxer :param sec_opt: optional choice of security upgrade :param peerstore_opt: optional peerstore :return: return a default swarm instance """ if key_pair is None: key_pair = generate_new_rsa_identity() id_opt = generate_peer_id_from(key_pair) # TODO: Parse `listen_addrs` to determine transport transport = TCP() muxer_transports_by_protocol = muxer_opt or {MPLEX_PROTOCOL_ID: Mplex} security_transports_by_protocol = sec_opt or { TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair), TProtocol(secio.ID): secio.Transport(key_pair), } upgrader = TransportUpgrader(security_transports_by_protocol, muxer_transports_by_protocol) peerstore = peerstore_opt or PeerStore() # Store our key pair in peerstore peerstore.add_key_pair(id_opt, key_pair) return Swarm(id_opt, peerstore, upgrader, transport)
def plaintext_transport_factory(key_pair: KeyPair) -> ISecureTransport: return InsecureTransport(key_pair)