Noise: add noise option in the factories and tests

tests/conftest.py

@@ -4,8 +4,8 @@ from libp2p.tools.factories import HostFactory
 
 
 @pytest.fixture
-def is_host_secure():
-    return False
+def security_protocol():
+    return None
 
 
 @pytest.fixture
@@ -14,6 +14,8 @@ def num_hosts():
 
 
 @pytest.fixture
-async def hosts(num_hosts, is_host_secure, nursery):
-    async with HostFactory.create_batch_and_listen(is_host_secure, num_hosts) as _hosts:
+async def hosts(num_hosts, security_protocol, nursery):
+    async with HostFactory.create_batch_and_listen(
+        num_hosts, security_protocol=security_protocol
+    ) as _hosts:
         yield _hosts

tests/examples/test_examples.py

@@ -92,8 +92,11 @@ async def no_common_protocol(host_a, host_b):
     "test", [(hello_world), (connect_write), (connect_read), (no_common_protocol)]
 )
 @pytest.mark.trio
-async def test_chat(test, is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_chat(test, security_protocol):
+    print("!@# ", security_protocol)
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         addr = hosts[0].get_addrs()[0]
         info = info_from_p2p_addr(addr)
         await hosts[1].connect(info)

tests/host/test_ping.py

@@ -8,8 +8,11 @@ from libp2p.tools.factories import host_pair_factory
 
 
 @pytest.mark.trio
-async def test_ping_once(is_host_secure):
-    async with host_pair_factory(is_host_secure) as (host_a, host_b):
+async def test_ping_once(security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as (
+        host_a,
+        host_b,
+    ):
         stream = await host_b.new_stream(host_a.get_id(), (ID,))
         some_ping = secrets.token_bytes(PING_LENGTH)
         await stream.write(some_ping)
@@ -23,8 +26,11 @@ SOME_PING_COUNT = 3
 
 
 @pytest.mark.trio
-async def test_ping_several(is_host_secure):
-    async with host_pair_factory(is_host_secure) as (host_a, host_b):
+async def test_ping_several(security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as (
+        host_a,
+        host_b,
+    ):
         stream = await host_b.new_stream(host_a.get_id(), (ID,))
         for _ in range(SOME_PING_COUNT):
             some_ping = secrets.token_bytes(PING_LENGTH)

tests/host/test_routed_host.py

@@ -7,7 +7,7 @@ from libp2p.tools.factories import HostFactory, RoutedHostFactory
 
 @pytest.mark.trio
 async def test_host_routing_success():
-    async with RoutedHostFactory.create_batch_and_listen(False, 2) as hosts:
+    async with RoutedHostFactory.create_batch_and_listen(2) as hosts:
         # forces to use routing as no addrs are provided
         await hosts[0].connect(PeerInfo(hosts[1].get_id(), []))
         await hosts[1].connect(PeerInfo(hosts[0].get_id(), []))
@@ -15,10 +15,9 @@ async def test_host_routing_success():
 
 @pytest.mark.trio
 async def test_host_routing_fail():
-    is_secure = False
     async with RoutedHostFactory.create_batch_and_listen(
-        is_secure, 2
-    ) as routed_hosts, HostFactory.create_batch_and_listen(is_secure, 1) as basic_hosts:
+        2
+    ) as routed_hosts, HostFactory.create_batch_and_listen(1) as basic_hosts:
         # routing fails because host_c does not use routing
         with pytest.raises(ConnectionFailure):
             await routed_hosts[0].connect(PeerInfo(basic_hosts[0].get_id(), []))

tests/identity/identify/test_protocol.py

@@ -6,8 +6,11 @@ from libp2p.tools.factories import host_pair_factory
 
 
 @pytest.mark.trio
-async def test_identify_protocol(is_host_secure):
-    async with host_pair_factory(is_host_secure) as (host_a, host_b):
+async def test_identify_protocol(security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as (
+        host_a,
+        host_b,
+    ):
         stream = await host_b.new_stream(host_a.get_id(), (ID,))
         response = await stream.read()
         await stream.close()

tests/libp2p/test_libp2p.py

@@ -19,8 +19,10 @@ ACK_STR_3 = "ack_3:"
 
 
 @pytest.mark.trio
-async def test_simple_messages(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_simple_messages(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         hosts[1].set_stream_handler(
             PROTOCOL_ID_0, create_echo_stream_handler(ACK_STR_0)
         )
@@ -38,8 +40,10 @@ async def test_simple_messages(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_double_response(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_double_response(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
 
         async def double_response_stream_handler(stream):
             while True:
@@ -78,11 +82,13 @@ async def test_double_response(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_multiple_streams(is_host_secure):
+async def test_multiple_streams(security_protocol):
     # hosts[0] should be able to open a stream with hosts[1] and then vice versa.
     # Stream IDs should be generated uniquely so that the stream state is not overwritten
 
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         hosts[0].set_stream_handler(
             PROTOCOL_ID_0, create_echo_stream_handler(ACK_STR_0)
         )
@@ -115,8 +121,10 @@ async def test_multiple_streams(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_multiple_streams_same_initiator_different_protocols(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_multiple_streams_same_initiator_different_protocols(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
 
         hosts[1].set_stream_handler(
             PROTOCOL_ID_0, create_echo_stream_handler(ACK_STR_0)
@@ -161,8 +169,10 @@ async def test_multiple_streams_same_initiator_different_protocols(is_host_secur
 
 
 @pytest.mark.trio
-async def test_multiple_streams_two_initiators(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_multiple_streams_two_initiators(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         hosts[0].set_stream_handler(
             PROTOCOL_ID_2, create_echo_stream_handler(ACK_STR_2)
         )
@@ -217,8 +227,10 @@ async def test_multiple_streams_two_initiators(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_triangle_nodes_connection(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 3) as hosts:
+async def test_triangle_nodes_connection(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        3, security_protocol=security_protocol
+    ) as hosts:
 
         hosts[0].set_stream_handler(
             PROTOCOL_ID_0, create_echo_stream_handler(ACK_STR_0)
@@ -268,8 +280,10 @@ async def test_triangle_nodes_connection(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_host_connect(is_host_secure):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+async def test_host_connect(security_protocol):
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         assert len(hosts[0].get_peerstore().peer_ids()) == 1
 
         await connect(hosts[0], hosts[1])

tests/network/conftest.py

@@ -8,18 +8,22 @@ from libp2p.tools.factories import (
 
 
 @pytest.fixture
-async def net_stream_pair(is_host_secure):
-    async with net_stream_pair_factory(is_host_secure) as net_stream_pair:
+async def net_stream_pair(security_protocol):
+    async with net_stream_pair_factory(
+        security_protocol=security_protocol
+    ) as net_stream_pair:
         yield net_stream_pair
 
 
 @pytest.fixture
-async def swarm_pair(is_host_secure):
-    async with swarm_pair_factory(is_host_secure) as swarms:
+async def swarm_pair(security_protocol):
+    async with swarm_pair_factory(security_protocol=security_protocol) as swarms:
         yield swarms
 
 
 @pytest.fixture
-async def swarm_conn_pair(is_host_secure):
-    async with swarm_conn_pair_factory(is_host_secure) as swarm_conn_pair:
+async def swarm_conn_pair(security_protocol):
+    async with swarm_conn_pair_factory(
+        security_protocol=security_protocol
+    ) as swarm_conn_pair:
         yield swarm_conn_pair

tests/network/test_notify.py

@@ -55,8 +55,8 @@ class MyNotifee(INotifee):
 
 
 @pytest.mark.trio
-async def test_notify(is_host_secure):
-    swarms = [SwarmFactory(is_secure=is_host_secure) for _ in range(2)]
+async def test_notify(security_protocol):
+    swarms = [SwarmFactory(security_protocol=security_protocol) for _ in range(2)]
 
     events_0_0 = []
     events_1_0 = []

tests/network/test_swarm.py

@@ -9,8 +9,10 @@ from libp2p.tools.utils import connect_swarm
 
 
 @pytest.mark.trio
-async def test_swarm_dial_peer(is_host_secure):
-    async with SwarmFactory.create_batch_and_listen(is_host_secure, 3) as swarms:
+async def test_swarm_dial_peer(security_protocol):
+    async with SwarmFactory.create_batch_and_listen(
+        3, security_protocol=security_protocol
+    ) as swarms:
         # Test: No addr found.
         with pytest.raises(SwarmException):
             await swarms[0].dial_peer(swarms[1].get_peer_id())
@@ -38,8 +40,10 @@ async def test_swarm_dial_peer(is_host_secure):
 
 
 @pytest.mark.trio
-async def test_swarm_close_peer(is_host_secure):
-    async with SwarmFactory.create_batch_and_listen(is_host_secure, 3) as swarms:
+async def test_swarm_close_peer(security_protocol):
+    async with SwarmFactory.create_batch_and_listen(
+        3, security_protocol=security_protocol
+    ) as swarms:
         # 0 <> 1 <> 2
         await connect_swarm(swarms[0], swarms[1])
         await connect_swarm(swarms[1], swarms[2])
@@ -90,8 +94,10 @@ async def test_swarm_remove_conn(swarm_pair):
 
 
 @pytest.mark.trio
-async def test_swarm_multiaddr(is_host_secure):
-    async with SwarmFactory.create_batch_and_listen(is_host_secure, 3) as swarms:
+async def test_swarm_multiaddr(security_protocol):
+    async with SwarmFactory.create_batch_and_listen(
+        3, security_protocol=security_protocol
+    ) as swarms:
 
         def clear():
             swarms[0].peerstore.clear_addrs(swarms[1].get_peer_id())

tests/protocol_muxer/test_protocol_muxer.py

@@ -16,9 +16,11 @@ async def perform_simple_test(
     expected_selected_protocol,
     protocols_for_client,
     protocols_with_handlers,
-    is_host_secure,
+    security_protocol,
 ):
-    async with HostFactory.create_batch_and_listen(is_host_secure, 2) as hosts:
+    async with HostFactory.create_batch_and_listen(
+        2, security_protocol=security_protocol
+    ) as hosts:
         for protocol in protocols_with_handlers:
             hosts[1].set_stream_handler(
                 protocol, create_echo_stream_handler(ACK_PREFIX)
@@ -38,28 +40,28 @@ async def perform_simple_test(
 
 
 @pytest.mark.trio
-async def test_single_protocol_succeeds(is_host_secure):
+async def test_single_protocol_succeeds(security_protocol):
     expected_selected_protocol = PROTOCOL_ECHO
     await perform_simple_test(
         expected_selected_protocol,
         [expected_selected_protocol],
         [expected_selected_protocol],
-        is_host_secure,
+        security_protocol,
     )
 
 
 @pytest.mark.trio
-async def test_single_protocol_fails(is_host_secure):
+async def test_single_protocol_fails(security_protocol):
     with pytest.raises(StreamFailure):
         await perform_simple_test(
-            "", [PROTOCOL_ECHO], [PROTOCOL_POTATO], is_host_secure
+            "", [PROTOCOL_ECHO], [PROTOCOL_POTATO], security_protocol
         )
 
     # Cleanup not reached on error
 
 
 @pytest.mark.trio
-async def test_multiple_protocol_first_is_valid_succeeds(is_host_secure):
+async def test_multiple_protocol_first_is_valid_succeeds(security_protocol):
     expected_selected_protocol = PROTOCOL_ECHO
     protocols_for_client = [PROTOCOL_ECHO, PROTOCOL_POTATO]
     protocols_for_listener = [PROTOCOL_FOO, PROTOCOL_ECHO]
@@ -67,12 +69,12 @@ async def test_multiple_protocol_first_is_valid_succeeds(is_host_secure):
         expected_selected_protocol,
         protocols_for_client,
         protocols_for_listener,
-        is_host_secure,
+        security_protocol,
     )
 
 
 @pytest.mark.trio
-async def test_multiple_protocol_second_is_valid_succeeds(is_host_secure):
+async def test_multiple_protocol_second_is_valid_succeeds(security_protocol):
     expected_selected_protocol = PROTOCOL_FOO
     protocols_for_client = [PROTOCOL_ROCK, PROTOCOL_FOO]
     protocols_for_listener = [PROTOCOL_FOO, PROTOCOL_ECHO]
@@ -80,15 +82,15 @@ async def test_multiple_protocol_second_is_valid_succeeds(is_host_secure):
         expected_selected_protocol,
         protocols_for_client,
         protocols_for_listener,
-        is_host_secure,
+        security_protocol,
     )
 
 
 @pytest.mark.trio
-async def test_multiple_protocol_fails(is_host_secure):
+async def test_multiple_protocol_fails(security_protocol):
     protocols_for_client = [PROTOCOL_ROCK, PROTOCOL_FOO, "/bar/1.0.0"]
     protocols_for_listener = ["/aspyn/1.0.0", "/rob/1.0.0", "/zx/1.0.0", "/alex/1.0.0"]
     with pytest.raises(StreamFailure):
         await perform_simple_test(
-            "", protocols_for_client, protocols_for_listener, is_host_secure
+            "", protocols_for_client, protocols_for_listener, security_protocol
         )

tests/pubsub/test_floodsub.py

@@ -82,10 +82,11 @@ async def test_lru_cache_two_nodes(monkeypatch):
 @pytest.mark.parametrize("test_case_obj", floodsub_protocol_pytest_params)
 @pytest.mark.trio
 @pytest.mark.slow
-async def test_gossipsub_run_with_floodsub_tests(test_case_obj, is_host_secure):
+async def test_gossipsub_run_with_floodsub_tests(test_case_obj, security_protocol):
     await perform_test_from_obj(
         test_case_obj,
         functools.partial(
-            PubsubFactory.create_batch_with_floodsub, is_secure=is_host_secure
+            PubsubFactory.create_batch_with_floodsub,
+            security_protocol=security_protocol,
         ),
     )

tests/pubsub/test_pubsub.py

@@ -236,7 +236,7 @@ async def test_validate_msg(is_topic_1_val_passed, is_topic_2_val_passed):
 
 
 @pytest.mark.trio
-async def test_continuously_read_stream(monkeypatch, nursery, is_host_secure):
+async def test_continuously_read_stream(monkeypatch, nursery, security_protocol):
     async def wait_for_event_occurring(event):
         await trio.hazmat.checkpoint()
         with trio.fail_after(0.1):
@@ -271,8 +271,10 @@ async def test_continuously_read_stream(monkeypatch, nursery, is_host_secure):
             yield Events(event_push_msg, event_handle_subscription, event_handle_rpc)
 
     async with PubsubFactory.create_batch_with_floodsub(
-        1, is_secure=is_host_secure
-    ) as pubsubs_fsub, net_stream_pair_factory(is_secure=is_host_secure) as stream_pair:
+        1, security_protocol=security_protocol
+    ) as pubsubs_fsub, net_stream_pair_factory(
+        security_protocol=security_protocol
+    ) as stream_pair:
         await pubsubs_fsub[0].subscribe(TESTING_TOPIC)
         # Kick off the task `continuously_read_stream`
         nursery.start_soon(pubsubs_fsub[0].continuously_read_stream, stream_pair[0])
@@ -394,10 +396,12 @@ async def test_handle_talk():
 
 
 @pytest.mark.trio
-async def test_message_all_peers(monkeypatch, is_host_secure):
+async def test_message_all_peers(monkeypatch, security_protocol):
     async with PubsubFactory.create_batch_with_floodsub(
-        1, is_secure=is_host_secure
-    ) as pubsubs_fsub, net_stream_pair_factory(is_secure=is_host_secure) as stream_pair:
+        1, security_protocol=security_protocol
+    ) as pubsubs_fsub, net_stream_pair_factory(
+        security_protocol=security_protocol
+    ) as stream_pair:
         peer_id = IDFactory()
         mock_peers = {peer_id: stream_pair[0]}
         with monkeypatch.context() as m:

tests/security/test_security_multistream.py

@@ -1,88 +1,49 @@
 import pytest
-import trio
 
-from libp2p import new_host
 from libp2p.crypto.rsa import create_new_key_pair
-from libp2p.security.insecure.transport import InsecureSession, InsecureTransport
-from libp2p.tools.constants import LISTEN_MADDR
-from libp2p.tools.utils import 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()
-
+from libp2p.security.insecure.transport import PLAINTEXT_PROTOCOL_ID, InsecureSession
+from libp2p.security.noise.transport import PROTOCOL_ID as NOISE_PROTOCOL_ID
+from libp2p.security.secio.transport import ID as SECIO_PROTOCOL_ID
+from libp2p.security.secure_session import SecureSession
+from libp2p.tools.factories import host_pair_factory
 
 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 = new_host(key_pair=initiator_key_pair, sec_opt=transports_for_initiator)
-    node2 = new_host(
-        key_pair=noninitiator_key_pair, sec_opt=transports_for_noninitiator
-    )
-    async with node1.run(listen_addrs=[LISTEN_MADDR]), node2.run(
-        listen_addrs=[LISTEN_MADDR]
-    ):
-        await connect(node1, node2)
-
-        # Wait a very short period to allow conns to be stored (since the functions
-        # storing the conns are async, they may happen at slightly different times
-        # on each node)
-        await trio.sleep(0.1)
-
-        # Get conns
-        node1_conn = node1.get_network().connections[peer_id_for_node(node2)]
-        node2_conn = node2.get_network().connections[peer_id_for_node(node1)]
+async def perform_simple_test(assertion_func, security_protocol):
+    async with host_pair_factory(security_protocol=security_protocol) as hosts:
+        conn_0 = hosts[0].get_network().connections[hosts[1].get_id()]
+        conn_1 = hosts[1].get_network().connections[hosts[0].get_id()]
 
         # Perform assertion
-        assertion_func(node1_conn.muxed_conn.secured_conn)
-        assertion_func(node2_conn.muxed_conn.secured_conn)
+        assertion_func(conn_0.muxed_conn.secured_conn)
+        assertion_func(conn_1.muxed_conn.secured_conn)
 
 
 @pytest.mark.trio
-async def test_single_insecure_security_transport_succeeds():
-    transports_for_initiator = {"foo": InsecureTransport(initiator_key_pair)}
-    transports_for_noninitiator = {"foo": InsecureTransport(noninitiator_key_pair)}
-
+@pytest.mark.parametrize(
+    "security_protocol, transport_type",
+    (
+        (PLAINTEXT_PROTOCOL_ID, InsecureSession),
+        (SECIO_PROTOCOL_ID, SecureSession),
+        (NOISE_PROTOCOL_ID, SecureSession),
+    ),
+)
+@pytest.mark.trio
+async def test_single_insecure_security_transport_succeeds(
+    security_protocol, transport_type
+):
     def assertion_func(conn):
-        assert isinstance(conn, InsecureSession)
+        assert isinstance(conn, transport_type)
 
-    await perform_simple_test(
-        assertion_func, transports_for_initiator, transports_for_noninitiator
-    )
+    await perform_simple_test(assertion_func, security_protocol)
 
 
 @pytest.mark.trio
 async def test_default_insecure_security():
-    transports_for_initiator = None
-    transports_for_noninitiator = None
-
-    conn1 = None
-    conn2 = None
-
     def assertion_func(conn):
-        nonlocal conn1
-        nonlocal conn2
-        if not conn1:
-            conn1 = conn
-        elif not conn2:
-            conn2 = conn
-        else:
-            assert conn1 == conn2
+        assert isinstance(conn, InsecureSession)
 
-    await perform_simple_test(
-        assertion_func, transports_for_initiator, transports_for_noninitiator
-    )
+    await perform_simple_test(assertion_func, None)

tests/stream_muxer/conftest.py

@@ -4,14 +4,18 @@ from libp2p.tools.factories import mplex_conn_pair_factory, mplex_stream_pair_fa
 
 
 @pytest.fixture
-async def mplex_conn_pair(is_host_secure):
-    async with mplex_conn_pair_factory(is_host_secure) as mplex_conn_pair:
+async def mplex_conn_pair(security_protocol):
+    async with mplex_conn_pair_factory(
+        security_protocol=security_protocol
+    ) as mplex_conn_pair:
         assert mplex_conn_pair[0].is_initiator
         assert not mplex_conn_pair[1].is_initiator
         yield mplex_conn_pair[0], mplex_conn_pair[1]
 
 
 @pytest.fixture
-async def mplex_stream_pair(is_host_secure):
-    async with mplex_stream_pair_factory(is_host_secure) as mplex_stream_pair:
+async def mplex_stream_pair(security_protocol):
+    async with mplex_stream_pair_factory(
+        security_protocol=security_protocol
+    ) as mplex_stream_pair:
         yield mplex_stream_pair