def test_default_protocols(): key_pair = create_new_key_pair() swarm = initialize_default_swarm(key_pair) host = BasicHost(swarm) mux = host.get_mux() handlers = mux.handlers assert handlers == get_default_protocols()
def test_default_protocols(): key_pair = create_new_key_pair() swarm = initialize_default_swarm(key_pair) host = BasicHost(swarm) mux = host.get_mux() handlers = mux.handlers # NOTE: comparing keys for equality as handlers may be closures that do not compare in the way # this test is concerned with assert handlers.keys() == get_default_protocols(host).keys()
def test_id_from_public_key(): key_pair = create_new_key_pair() public_key = key_pair.public_key key_bin = public_key.serialize() algo = multihash.Func.sha2_256 mh_digest = multihash.digest(key_bin, algo) expected = ID(mh_digest.encode()) actual = ID.from_pubkey(public_key) assert actual == expected
def generate_keypair(print_key: bool, key_path: Optional[str]): """Generate an key pair and exit.""" keypair = create_new_key_pair() if print_key: # Print the armored key pair for archiving print(keypair.private_key.impl.export_key().decode("utf-8")) if key_path: # Save the armored key pair in a file with open(key_path, "wb") as key_file: key_file.write(keypair.private_key.impl.export_key()) return keypair
from libp2p import new_node from libp2p.crypto.rsa import create_new_key_pair from libp2p.security.insecure.transport import InsecureSession, InsecureTransport from tests.configs import LISTEN_MADDR from tests.utils import cleanup, connect # TODO: Add tests for multiple streams being opened on different # protocols through the same connection def peer_id_for_node(node): return node.get_id() initiator_key_pair = create_new_key_pair() noninitiator_key_pair = create_new_key_pair() async def perform_simple_test( assertion_func, transports_for_initiator, transports_for_noninitiator ): # Create libp2p nodes and connect them, then secure the connection, then check # the proper security was chosen # TODO: implement -- note we need to introduce the notion of communicating over a raw connection # for testing, we do NOT want to communicate over a stream so we can't just create two nodes # and use their conn because our mplex will internally relay messages to a stream node1 = await new_node(
async def test_one_notifier_on_two_nodes_with_listen(): events_b = [] messages = ["hello", "hello"] node_a_key_pair = create_new_key_pair() node_a_transport_opt = ["/ip4/127.0.0.1/tcp/0"] node_a = await new_node(node_a_key_pair, transport_opt=node_a_transport_opt) await node_a.get_network().listen( multiaddr.Multiaddr(node_a_transport_opt[0])) # Set up node_b swarm to pass into host node_b_key_pair = create_new_key_pair() node_b_transport_opt = ["/ip4/127.0.0.1/tcp/0"] node_b_multiaddr = multiaddr.Multiaddr(node_b_transport_opt[0]) node_b_swarm = initialize_default_swarm(node_b_key_pair, transport_opt=node_b_transport_opt) node_b = BasicHost(node_b_swarm) async def my_stream_handler(stream): # Ensure the listened, connected and opened_stream events were hit in Notifee obj # and that the stream passed into opened_stream matches the stream created on # node_b assert events_b == [ ["listenedb", node_b_multiaddr], ["connectedb", stream.mplex_conn], ["opened_streamb", stream], ] for message in messages: read_string = (await stream.read(len(message))).decode() resp = ACK + read_string await stream.write(resp.encode()) # Add notifee for node_a events_a = [] assert node_a.get_network().notify(MyNotifee(events_a, "a")) # Add notifee for node_b assert node_b.get_network().notify(MyNotifee(events_b, "b")) # start listen on node_b_swarm await node_b.get_network().listen(node_b_multiaddr) node_b.set_stream_handler("/echo/1.0.0", my_stream_handler) # Associate the peer with local ip address (see default parameters of Libp2p()) node_a.get_peerstore().add_addrs(node_b.get_id(), node_b.get_addrs(), 10) stream = await node_a.new_stream(node_b.get_id(), ["/echo/1.0.0"]) # Ensure the connected and opened_stream events were hit in MyNotifee obj # and that stream passed into opened_stream matches the stream created on # node_a assert events_a == [["connecteda", stream.mplex_conn], ["opened_streama", stream]] for message in messages: expected_resp = ACK + message await stream.write(message.encode()) response = (await stream.read(len(expected_resp))).decode() assert response == expected_resp # Success, terminate pending tasks. await cleanup()
def generate_new_rsa_identity() -> KeyPair: return create_new_key_pair()
def generate_keypair(print_info=False): keypair = create_new_key_pair() if print_info: LOGGER.info("Generating new key, please save it to keep same host id.") LOGGER.info(keypair.private_key.impl.export_key().decode('utf-8')) return keypair