Merge branch 'main' into feat/619-store-pubkey-peerid-peerstore

libp2p/security/base_session.py

@@ -1,7 +1,3 @@
-from typing import (
-    Optional,
-)
-
 from libp2p.abc import (
     ISecureConn,
 )
@@ -49,5 +45,5 @@ class BaseSession(ISecureConn):
     def get_remote_peer(self) -> ID:
         return self.remote_peer
 
-    def get_remote_public_key(self) -> Optional[PublicKey]:
+    def get_remote_public_key(self) -> PublicKey:
         return self.remote_permanent_pubkey

libp2p/security/base_transport.py

@@ -1,7 +1,7 @@
-import secrets
-from typing import (
+from collections.abc import (
     Callable,
 )
+import secrets
 
 from libp2p.abc import (
     ISecureTransport,

libp2p/security/insecure/transport.py

@@ -93,13 +93,13 @@ class InsecureSession(BaseSession):
     async def write(self, data: bytes) -> None:
         await self.conn.write(data)
 
-    async def read(self, n: int = None) -> bytes:
+    async def read(self, n: int | None = None) -> bytes:
         return await self.conn.read(n)
 
     async def close(self) -> None:
         await self.conn.close()
 
-    def get_remote_address(self) -> Optional[tuple[str, int]]:
+    def get_remote_address(self) -> tuple[str, int] | None:
         """
         Delegate to the underlying connection's get_remote_address method.
         """
@@ -131,6 +131,15 @@ async def run_handshake(
     remote_msg.ParseFromString(remote_msg_bytes)
     received_peer_id = ID(remote_msg.id)
 
+    # Verify that `remote_peer_id` isn't `None`
+    # That is the only condition that `remote_peer_id` would not need to be checked
+    # against the `recieved_peer_id` gotten from the outbound/recieved `msg`.
+    # The check against `received_peer_id` happens in the next if-block
+    if is_initiator and remote_peer_id is None:
+        raise HandshakeFailure(
+            "remote peer ID cannot be None if `is_initiator` is set to `True`"
+        )
+
     # Verify if the receive `ID` matches the one we originally initialize the session.
     # We only need to check it when we are the initiator, because only in that condition
     # we possibly knows the `ID` of the remote.

libp2p/security/noise/io.py

@@ -1,5 +1,4 @@
 from typing import (
-    Optional,
     cast,
 )
 
@@ -10,7 +9,6 @@ from libp2p.abc import (
 )
 from libp2p.io.abc import (
     EncryptedMsgReadWriter,
-    MsgReadWriteCloser,
     ReadWriteCloser,
 )
 from libp2p.io.msgio import (
@@ -40,7 +38,7 @@ class BaseNoiseMsgReadWriter(EncryptedMsgReadWriter):
     implemented by the subclasses.
     """
 
-    read_writer: MsgReadWriteCloser
+    read_writer: NoisePacketReadWriter
     noise_state: NoiseState
 
     # FIXME: This prefix is added in msg#3 in Go. Check whether it's a desired behavior.
@@ -50,12 +48,12 @@ class BaseNoiseMsgReadWriter(EncryptedMsgReadWriter):
         self.read_writer = NoisePacketReadWriter(cast(ReadWriteCloser, conn))
         self.noise_state = noise_state
 
-    async def write_msg(self, data: bytes, prefix_encoded: bool = False) -> None:
-        data_encrypted = self.encrypt(data)
+    async def write_msg(self, msg: bytes, prefix_encoded: bool = False) -> None:
+        data_encrypted = self.encrypt(msg)
         if prefix_encoded:
-            await self.read_writer.write_msg(self.prefix + data_encrypted)
-        else:
-            await self.read_writer.write_msg(data_encrypted)
+            # Manually add the prefix if needed
+            data_encrypted = self.prefix + data_encrypted
+        await self.read_writer.write_msg(data_encrypted)
 
     async def read_msg(self, prefix_encoded: bool = False) -> bytes:
         noise_msg_encrypted = await self.read_writer.read_msg()
@@ -67,10 +65,11 @@ class BaseNoiseMsgReadWriter(EncryptedMsgReadWriter):
     async def close(self) -> None:
         await self.read_writer.close()
 
-    def get_remote_address(self) -> Optional[tuple[str, int]]:
+    def get_remote_address(self) -> tuple[str, int] | None:
         # Delegate to the underlying connection if possible
         if hasattr(self.read_writer, "read_write_closer") and hasattr(
-            self.read_writer.read_write_closer, "get_remote_address"
+            self.read_writer.read_write_closer,
+            "get_remote_address",
         ):
             return self.read_writer.read_write_closer.get_remote_address()
         return None
@@ -78,7 +77,7 @@ class BaseNoiseMsgReadWriter(EncryptedMsgReadWriter):
 
 class NoiseHandshakeReadWriter(BaseNoiseMsgReadWriter):
     def encrypt(self, data: bytes) -> bytes:
-        return self.noise_state.write_message(data)
+        return bytes(self.noise_state.write_message(data))
 
     def decrypt(self, data: bytes) -> bytes:
         return bytes(self.noise_state.read_message(data))

libp2p/security/noise/messages.py

@@ -19,7 +19,7 @@ SIGNED_DATA_PREFIX = "noise-libp2p-static-key:"
 class NoiseHandshakePayload:
     id_pubkey: PublicKey
     id_sig: bytes
-    early_data: bytes = None
+    early_data: bytes | None = None
 
     def serialize(self) -> bytes:
         msg = noise_pb.NoiseHandshakePayload(

libp2p/security/noise/patterns.py

@@ -7,8 +7,10 @@ from cryptography.hazmat.primitives import (
     serialization,
 )
 from noise.backends.default.keypairs import KeyPair as NoiseKeyPair
-from noise.connection import Keypair as NoiseKeypairEnum
-from noise.connection import NoiseConnection as NoiseState
+from noise.connection import (
+    Keypair as NoiseKeypairEnum,
+    NoiseConnection as NoiseState,
+)
 
 from libp2p.abc import (
     IRawConnection,
@@ -47,14 +49,12 @@ from .messages import (
 
 class IPattern(ABC):
     @abstractmethod
-    async def handshake_inbound(self, conn: IRawConnection) -> ISecureConn:
-        ...
+    async def handshake_inbound(self, conn: IRawConnection) -> ISecureConn: ...
 
     @abstractmethod
     async def handshake_outbound(
         self, conn: IRawConnection, remote_peer: ID
-    ) -> ISecureConn:
-        ...
+    ) -> ISecureConn: ...
 
 
 class BasePattern(IPattern):
@@ -62,13 +62,15 @@ class BasePattern(IPattern):
     noise_static_key: PrivateKey
     local_peer: ID
     libp2p_privkey: PrivateKey
-    early_data: bytes
+    early_data: bytes | None
 
     def create_noise_state(self) -> NoiseState:
         noise_state = NoiseState.from_name(self.protocol_name)
         noise_state.set_keypair_from_private_bytes(
             NoiseKeypairEnum.STATIC, self.noise_static_key.to_bytes()
         )
+        if noise_state.noise_protocol is None:
+            raise NoiseStateError("noise_protocol is not initialized")
         return noise_state
 
     def make_handshake_payload(self) -> NoiseHandshakePayload:
@@ -84,7 +86,7 @@ class PatternXX(BasePattern):
         local_peer: ID,
         libp2p_privkey: PrivateKey,
         noise_static_key: PrivateKey,
-        early_data: bytes = None,
+        early_data: bytes | None = None,
     ) -> None:
         self.protocol_name = b"Noise_XX_25519_ChaChaPoly_SHA256"
         self.local_peer = local_peer
@@ -96,7 +98,12 @@ class PatternXX(BasePattern):
         noise_state = self.create_noise_state()
         noise_state.set_as_responder()
         noise_state.start_handshake()
+        if noise_state.noise_protocol is None:
+            raise NoiseStateError("noise_protocol is not initialized")
         handshake_state = noise_state.noise_protocol.handshake_state
+        if handshake_state is None:
+            raise NoiseStateError("Handshake state is not initialized")
+
         read_writer = NoiseHandshakeReadWriter(conn, noise_state)
 
         # Consume msg#1.
@@ -145,7 +152,11 @@ class PatternXX(BasePattern):
         read_writer = NoiseHandshakeReadWriter(conn, noise_state)
         noise_state.set_as_initiator()
         noise_state.start_handshake()
+        if noise_state.noise_protocol is None:
+            raise NoiseStateError("noise_protocol is not initialized")
         handshake_state = noise_state.noise_protocol.handshake_state
+        if handshake_state is None:
+            raise NoiseStateError("Handshake state is not initialized")
 
         # Send msg#1, which is *not* encrypted.
         msg_1 = b""
@@ -195,6 +206,8 @@ class PatternXX(BasePattern):
     @staticmethod
     def _get_pubkey_from_noise_keypair(key_pair: NoiseKeyPair) -> PublicKey:
         # Use `Ed25519PublicKey` since 25519 is used in our pattern.
+        if key_pair.public is None:
+            raise NoiseStateError("public key is not initialized")
         raw_bytes = key_pair.public.public_bytes(
             serialization.Encoding.Raw, serialization.PublicFormat.Raw
         )

libp2p/security/noise/transport.py

@@ -26,7 +26,7 @@ class Transport(ISecureTransport):
     libp2p_privkey: PrivateKey
     noise_privkey: PrivateKey
     local_peer: ID
-    early_data: bytes
+    early_data: bytes | None
     with_noise_pipes: bool
 
     # NOTE: Implementations that support Noise Pipes must decide whether to use
@@ -37,8 +37,8 @@ class Transport(ISecureTransport):
     def __init__(
         self,
         libp2p_keypair: KeyPair,
-        noise_privkey: PrivateKey = None,
-        early_data: bytes = None,
+        noise_privkey: PrivateKey,
+        early_data: bytes | None = None,
         with_noise_pipes: bool = False,
     ) -> None:
         self.libp2p_privkey = libp2p_keypair.private_key

libp2p/security/secio/transport.py

@@ -2,9 +2,6 @@ from dataclasses import (
     dataclass,
 )
 import itertools
-from typing import (
-    Optional,
-)
 
 import multihash
 
@@ -14,14 +11,10 @@ from libp2p.abc import (
 )
 from libp2p.crypto.authenticated_encryption import (
     EncryptionParameters as AuthenticatedEncryptionParameters,
-)
-from libp2p.crypto.authenticated_encryption import (
     InvalidMACException,
-)
-from libp2p.crypto.authenticated_encryption import (
+    MacAndCipher as Encrypter,
     initialize_pair as initialize_pair_for_encryption,
 )
-from libp2p.crypto.authenticated_encryption import MacAndCipher as Encrypter
 from libp2p.crypto.ecc import (
     ECCPublicKey,
 )
@@ -91,6 +84,8 @@ class SecioPacketReadWriter(FixedSizeLenMsgReadWriter):
 
 class SecioMsgReadWriter(EncryptedMsgReadWriter):
     read_writer: SecioPacketReadWriter
+    local_encrypter: Encrypter
+    remote_encrypter: Encrypter
 
     def __init__(
         self,
@@ -213,7 +208,8 @@ async def _response_to_msg(read_writer: SecioPacketReadWriter, msg: bytes) -> by
 
 
 def _mk_multihash_sha256(data: bytes) -> bytes:
-    return multihash.digest(data, "sha2-256")
+    mh = multihash.digest(data, "sha2-256")
+    return mh.encode()
 
 
 def _mk_score(public_key: PublicKey, nonce: bytes) -> bytes:
@@ -270,7 +266,7 @@ def _select_encryption_parameters(
 async def _establish_session_parameters(
     local_peer: PeerID,
     local_private_key: PrivateKey,
-    remote_peer: Optional[PeerID],
+    remote_peer: PeerID | None,
     conn: SecioPacketReadWriter,
     nonce: bytes,
 ) -> tuple[SessionParameters, bytes]:
@@ -399,7 +395,7 @@ async def create_secure_session(
     local_peer: PeerID,
     local_private_key: PrivateKey,
     conn: IRawConnection,
-    remote_peer: PeerID = None,
+    remote_peer: PeerID | None = None,
 ) -> ISecureConn:
     """
     Attempt the initial `secio` handshake with the remote peer.

libp2p/security/secure_session.py

@@ -1,7 +1,4 @@
 import io
-from typing import (
-    Optional,
-)
 
 from libp2p.crypto.keys import (
     PrivateKey,
@@ -44,7 +41,7 @@ class SecureSession(BaseSession):
 
         self._reset_internal_buffer()
 
-    def get_remote_address(self) -> Optional[tuple[str, int]]:
+    def get_remote_address(self) -> tuple[str, int] | None:
         """Delegate to the underlying connection's get_remote_address method."""
         return self.conn.get_remote_address()
 
@@ -53,7 +50,7 @@ class SecureSession(BaseSession):
         self.low_watermark = 0
         self.high_watermark = 0
 
-    def _drain(self, n: int) -> bytes:
+    def _drain(self, n: int | None) -> bytes:
         if self.low_watermark == self.high_watermark:
             return b""
 
@@ -75,7 +72,7 @@ class SecureSession(BaseSession):
         self.low_watermark = 0
         self.high_watermark = len(msg)
 
-    async def read(self, n: int = None) -> bytes:
+    async def read(self, n: int | None = None) -> bytes:
         if n == 0:
             return b""
 
@@ -85,6 +82,9 @@ class SecureSession(BaseSession):
 
         msg = await self.conn.read_msg()
 
+        if n is None:
+            return msg
+
         if n < len(msg):
             self._fill(msg)
             return self._drain(n)