Noise: add PatternXX

libp2p/security/noise/patterns.py

@@ -0,0 +1,116 @@
+from abc import ABC, abstractmethod
+
+from noise.connection import Keypair as NoiseKeypair
+from noise.connection import NoiseConnection as NoiseState
+
+from libp2p.crypto.keys import PrivateKey
+from libp2p.network.connection.raw_connection_interface import IRawConnection
+from libp2p.peer.id import ID
+from libp2p.security.secure_conn_interface import ISecureConn
+
+from .connection import NoiseConnection
+
+# FIXME: Choose a serious bound number.
+NUM_BYTES_TO_READ = 2048
+
+
+# TODO: Merged into `BasePattern`?
+class PreHandshakeConnection:
+    conn: IRawConnection
+
+    def __init__(self, conn: IRawConnection) -> None:
+        self.conn = conn
+
+    async def write_msg(self, data: bytes) -> None:
+        # TODO:
+        await self.conn.write(data)
+
+    async def read_msg(self) -> bytes:
+        return await self.conn.read(NUM_BYTES_TO_READ)
+
+
+class IPattern(ABC):
+    @abstractmethod
+    async def handshake_inbound(self, conn: IRawConnection) -> ISecureConn:
+        ...
+
+    @abstractmethod
+    async def handshake_outbound(
+        self, conn: IRawConnection, remote_peer: ID
+    ) -> ISecureConn:
+        ...
+
+
+class BasePattern(IPattern):
+    protocol_name: bytes
+    noise_static_key: PrivateKey
+    local_peer: ID
+    libp2p_privkey: PrivateKey
+
+    def create_noise_state(self) -> NoiseState:
+        noise_state = NoiseState.from_name(self.protocol_name)
+        noise_state.set_keypair_from_private_bytes(
+            NoiseKeypair.STATIC, self.noise_static_key.to_bytes()
+        )
+        return noise_state
+
+
+class PatternXX(BasePattern):
+    def __init__(
+        self, local_peer: ID, libp2p_privkey: PrivateKey, noise_static_key: PrivateKey
+    ) -> None:
+        self.protocol_name = b"Noise_XX_25519_ChaChaPoly_SHA256"
+        self.local_peer = local_peer
+        self.libp2p_privkey = libp2p_privkey
+        self.noise_static_key = noise_static_key
+
+    async def handshake_inbound(self, conn: IRawConnection) -> ISecureConn:
+        noise_state = self.create_noise_state()
+        handshake_conn = PreHandshakeConnection(conn)
+        noise_state.set_as_responder()
+        noise_state.start_handshake()
+        msg_0_encrypted = await handshake_conn.read_msg()
+        msg_0 = noise_state.read_message(msg_0_encrypted)
+        # TODO: Parse and save the payload from the other side.
+
+        # TODO: Send our payload.
+        our_payload = b"server"
+        msg_1_encrypted = noise_state.write_message(our_payload)
+        await handshake_conn.write_msg(msg_1_encrypted)
+
+        msg_2_encrypted = await handshake_conn.read_msg()
+        msg_2 = noise_state.read_message(msg_2_encrypted)
+        # TODO: Parse and save another payload from the other side.
+
+        # TODO: Add a specific exception
+        if not noise_state.handshake_finished:
+            raise Exception
+
+        # FIXME: `remote_peer` should be derived from the messages.
+        return NoiseConnection(self.local_peer, self.libp2p_privkey, None, conn, False)
+
+    async def handshake_outbound(
+        self, conn: IRawConnection, remote_peer: ID
+    ) -> ISecureConn:
+        noise_state = self.create_noise_state()
+        handshake_conn = PreHandshakeConnection(conn)
+        noise_state.set_as_initiator()
+        noise_state.start_handshake()
+        msg_0 = noise_state.write_message()
+        await handshake_conn.write_msg(msg_0)
+        msg_1_encrypted = await handshake_conn.read_msg()
+        msg_1 = noise_state.read_message(msg_1_encrypted)
+        # TODO: Parse and save the payload from the other side.
+
+        # TODO: Send our payload.
+        our_payload = b"client"
+        msg_2_encrypted = noise_state.write_message(our_payload)
+        await handshake_conn.write_msg(msg_2_encrypted)
+
+        # TODO: Add a specific exception
+        if not noise_state.handshake_finished:
+            raise Exception
+
+        return NoiseConnection(
+            self.local_peer, self.libp2p_privkey, remote_peer, conn, False
+        )