WIP: Progress on py-libp2p and rust-libp2p interop for Noise and Yamux

Author: paschal533

examples/ping/ping.py

@@ -1,20 +1,53 @@
 import argparse
+import logging
+from typing import (
+    cast,
+)
 
 import multiaddr
 import trio
 
-from libp2p import (
-    new_host,
+from libp2p.crypto.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+    KeyPair,
 )
 from libp2p.custom_types import (
     TProtocol,
 )
+from libp2p.host.basic_host import (
+    BasicHost,
+)
 from libp2p.network.stream.net_stream import (
     INetStream,
 )
+from libp2p.network.swarm import (
+    Swarm,
+)
+from libp2p.peer.id import (
+    ID,
+)
 from libp2p.peer.peerinfo import (
     info_from_p2p_addr,
 )
+from libp2p.peer.peerstore import (
+    PeerStore,
+)
+from libp2p.security.noise.transport import (
+    PROTOCOL_ID,
+    Transport,
+)
+from libp2p.stream_muxer.yamux.yamux import (
+    Yamux,
+)
+from libp2p.transport.tcp.tcp import (
+    TCP,
+)
+from libp2p.transport.upgrader import (
+    TransportUpgrader,
+)
+
+logging.basicConfig(level=logging.DEBUG)
 
 PING_PROTOCOL_ID = TProtocol("/ipfs/ping/1.0.0")
 PING_LENGTH = 32
@@ -28,10 +61,8 @@ async def handle_ping(stream: INetStream) -> None:
             peer_id = stream.muxed_conn.peer_id
             if payload is not None:
                 print(f"received ping from {peer_id}")
-
                 await stream.write(payload)
                 print(f"responded with pong to {peer_id}")
-
         except Exception:
             await stream.reset()
             break
@@ -41,45 +72,61 @@ async def send_ping(stream: INetStream) -> None:
     try:
         payload = b"\x01" * PING_LENGTH
         print(f"sending ping to {stream.muxed_conn.peer_id}")
-
         await stream.write(payload)
-
         with trio.fail_after(RESP_TIMEOUT):
             response = await stream.read(PING_LENGTH)
-
         if response == payload:
             print(f"received pong from {stream.muxed_conn.peer_id}")
-
     except Exception as e:
         print(f"error occurred : {e}")
 
 
 async def run(port: int, destination: str) -> None:
     localhost_ip = "127.0.0.1"
     listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
-    host = new_host()
+
+    rust_privkey_bytes = bytes.fromhex(
+        "6866d018650288fef506b818f04e6aafeadd96d70752fb16ac4b7f0a5f88f18d"
+    )
+    rust_pubkey_bytes = bytes.fromhex(
+        "0d3fb3dc6cc19c6e58d6f61829fd56af9bbd28aa28d76ccb519f56a79bdace2a"
+    )
+    private_key = Ed25519PrivateKey.from_bytes(rust_privkey_bytes)
+    public_key = Ed25519PublicKey.from_bytes(rust_pubkey_bytes)
+    key_pair = KeyPair(private_key, public_key)
+    peer_id = ID.from_pubkey(key_pair.public_key)
+    logging.debug(f"Local Peer ID: {peer_id.pretty()}")
+    logging.debug(f"Public Key from Private: {key_pair.public_key.to_bytes().hex()}")
+
+    noise_transport = Transport(key_pair, noise_privkey=key_pair.private_key)
+    tcp_transport = TCP()
+    peerstore = PeerStore()
+    upgrader = TransportUpgrader(
+        secure_transports_by_protocol={PROTOCOL_ID: noise_transport},
+        muxer_transports_by_protocol={cast(TProtocol, "/yamux/1.0.0"): Yamux},
+    )
+    swarm = Swarm(
+        peer_id=peer_id, peerstore=peerstore, upgrader=upgrader, transport=tcp_transport
+    )
+    host = BasicHost(network=swarm)
 
     async with host.run(listen_addrs=[listen_addr]), trio.open_nursery() as nursery:
         if not destination:
             host.set_stream_handler(PING_PROTOCOL_ID, handle_ping)
-
-            print(
-                "Run this from the same folder in another console:\n\n"
+            cmd = (
+                f"Run this from the same folder in another console:\n\n"
                 f"ping-demo -p {int(port) + 1} "
                 f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
             )
+            print(cmd)
             print("Waiting for incoming connection...")
-
         else:
             maddr = multiaddr.Multiaddr(destination)
             info = info_from_p2p_addr(maddr)
             await host.connect(info)
             stream = await host.new_stream(info.peer_id, [PING_PROTOCOL_ID])
-
             nursery.start_soon(send_ping, stream)
-
             return
-
         await trio.sleep_forever()
 
 
@@ -90,13 +137,10 @@ def main() -> None:
     Then, run another instance with 'python ping.py -p <ANOTHER_PORT> -d <DESTINATION>',
     where <DESTINATION> is the multiaddress of the previous listener host.
     """
-
     example_maddr = (
         "/ip4/127.0.0.1/tcp/8000/p2p/QmQn4SwGkDZKkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
     )
-
     parser = argparse.ArgumentParser(description=description)
-
     parser.add_argument(
         "-p", "--port", default=8000, type=int, help="source port number"
     )
@@ -107,10 +151,8 @@ def main() -> None:
         help=f"destination multiaddr string, e.g. {example_maddr}",
     )
     args = parser.parse_args()
-
     if not args.port:
         raise RuntimeError("failed to determine local port")
-
     try:
         trio.run(run, *(args.port, args.destination))
     except KeyboardInterrupt:

libp2p/__init__.py

@@ -1,11 +1,21 @@
+from collections.abc import (
+    Mapping,
+)
 from importlib.metadata import version as __version
+from typing import (
+    Type,
+    cast,
+)
 
 from libp2p.abc import (
     IHost,
+    IMuxedConn,
     INetworkService,
     IPeerRouting,
     IPeerStore,
+    ISecureTransport,
 )
+from libp2p.crypto.ed25519 import create_new_key_pair as create_ed25519_key_pair
 from libp2p.crypto.keys import (
     KeyPair,
 )
@@ -36,11 +46,18 @@
     PLAINTEXT_PROTOCOL_ID,
     InsecureTransport,
 )
+from libp2p.security.noise.transport import (
+    PROTOCOL_ID,
+    Transport,
+)
 import libp2p.security.secio.transport as secio
 from libp2p.stream_muxer.mplex.mplex import (
     MPLEX_PROTOCOL_ID,
     Mplex,
 )
+from libp2p.stream_muxer.yamux.yamux import (
+    Yamux,
+)
 from libp2p.transport.tcp.tcp import (
     TCP,
 )
@@ -74,24 +91,25 @@ def new_swarm(
     :return: return a default swarm instance
     """
     if key_pair is None:
-        key_pair = generate_new_rsa_identity()
+        key_pair = create_ed25519_key_pair()  # Use Ed25519 instead of RSA
 
     id_opt = generate_peer_id_from(key_pair)
-
-    # TODO: Parse `listen_addrs` to determine transport
     transport = TCP()
+    # noise_key_pair = key_pair  # Alternatively: create_ed25519_key_pair()
 
-    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),
+    secure_transports_by_protocol: Mapping[TProtocol, ISecureTransport] = {
+        PROTOCOL_ID: Transport(key_pair, noise_privkey=key_pair.private_key)
+    }
+    muxer_transports_by_protocol: Mapping[TProtocol, type[IMuxedConn]] = {
+        cast(TProtocol, "/yamux/1.0.0"): Yamux
     }
+
     upgrader = TransportUpgrader(
-        security_transports_by_protocol, muxer_transports_by_protocol
+        secure_transports_by_protocol=secure_transports_by_protocol,
+        muxer_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)

libp2p/crypto/ed25519.py

@@ -1,16 +1,12 @@
-from Crypto.Hash import (
-    SHA256,
+from cryptography.exceptions import (
+    InvalidSignature,
 )
-from nacl.exceptions import (
-    BadSignatureError,
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey as CryptoEd25519PrivateKey,
 )
-from nacl.public import PrivateKey as PrivateKeyImpl
-from nacl.public import PublicKey as PublicKeyImpl
-from nacl.signing import (
-    SigningKey,
-    VerifyKey,
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PublicKey as CryptoEd25519PublicKey,
 )
-import nacl.utils as utils
 
 from libp2p.crypto.keys import (
     KeyPair,
@@ -21,58 +17,52 @@
 
 
 class Ed25519PublicKey(PublicKey):
-    def __init__(self, impl: PublicKeyImpl) -> None:
+    def __init__(self, impl: CryptoEd25519PublicKey) -> None:
         self.impl = impl
 
     def to_bytes(self) -> bytes:
-        return bytes(self.impl)
+        return self.impl.public_bytes_raw()
 
     @classmethod
     def from_bytes(cls, key_bytes: bytes) -> "Ed25519PublicKey":
-        return cls(PublicKeyImpl(key_bytes))
+        return cls(CryptoEd25519PublicKey.from_public_bytes(key_bytes))
 
     def get_type(self) -> KeyType:
         return KeyType.Ed25519
 
     def verify(self, data: bytes, signature: bytes) -> bool:
-        verify_key = VerifyKey(self.to_bytes())
         try:
-            verify_key.verify(data, signature)
-        except BadSignatureError:
+            self.impl.verify(signature, data)
+            return True
+        except InvalidSignature:
             return False
-        return True
 
 
 class Ed25519PrivateKey(PrivateKey):
-    def __init__(self, impl: PrivateKeyImpl) -> None:
+    def __init__(self, impl: CryptoEd25519PrivateKey) -> None:
         self.impl = impl
 
     @classmethod
     def new(cls, seed: bytes = None) -> "Ed25519PrivateKey":
         if not seed:
-            seed = utils.random()
-
-        private_key_impl = PrivateKeyImpl.from_seed(seed)
-        return cls(private_key_impl)
+            return cls(CryptoEd25519PrivateKey.generate())
+        return cls(CryptoEd25519PrivateKey.from_private_bytes(seed[:32]))
 
     def to_bytes(self) -> bytes:
-        return bytes(self.impl)
+        return self.impl.private_bytes_raw()
 
     @classmethod
     def from_bytes(cls, data: bytes) -> "Ed25519PrivateKey":
-        impl = PrivateKeyImpl(data)
-        return cls(impl)
+        return cls(CryptoEd25519PrivateKey.from_private_bytes(data))
 
     def get_type(self) -> KeyType:
         return KeyType.Ed25519
 
     def sign(self, data: bytes) -> bytes:
-        h = SHA256.new(data)
-        signing_key = SigningKey(self.to_bytes())
-        return signing_key.sign(h.digest())
+        return self.impl.sign(data)
 
     def get_public_key(self) -> PublicKey:
-        return Ed25519PublicKey(self.impl.public_key)
+        return Ed25519PublicKey(self.impl.public_key())
 
 
 def create_new_key_pair(seed: bytes = None) -> KeyPair:

libp2p/security/noise/io.py

@@ -1,3 +1,4 @@
+import logging
 from typing import (
     cast,
 )
@@ -68,6 +69,20 @@ async def close(self) -> None:
 
 
 class NoiseHandshakeReadWriter(BaseNoiseMsgReadWriter):
+    def __init__(self, read_writer: IRawConnection, noise_state: NoiseState) -> None:
+        self.read_writer = NoisePacketReadWriter(cast(ReadWriteCloser, read_writer))
+        self.noise_state = noise_state
+        self.last_written_data = b""
+
+    async def write_msg(self, data: bytes, prefix_encoded: bool = False) -> None:
+        data_encrypted = self.encrypt(data)
+        if prefix_encoded:
+            await self.read_writer.write_msg(self.prefix + data_encrypted)
+        else:
+            await self.read_writer.write_msg(data_encrypted)
+        self.last_written_data = data_encrypted
+        logging.debug(f"Wrote encrypted message: {data_encrypted.hex()}")
+
     def encrypt(self, data: bytes) -> bytes:
         return self.noise_state.write_message(data)