Struct ConsensusKeyAuthentication

pub struct ConsensusKeyAuthentication<T: Transport, S: SignatureKey + 'static, C: StreamMuxer + Unpin> {
    pub inner: T,
    pub auth_message: Arc<Option<Vec<u8>>>,
    pub consensus_key_to_pid_map: Arc<Mutex<BiMap<S, PeerId>>>,
    pd: PhantomData<(C, S)>,
}

A wrapper for a Transport that bidirectionally associates (and verifies) the corresponding consensus keys.

Fields

inner: T

The underlying transport we are wrapping

auth_message: Arc<Option<Vec<u8>>>

A pre-signed message that we (depending on if it’s specified or not) send to the remote peer for authentication

consensus_key_to_pid_map: Arc<Mutex<BiMap<S, PeerId>>>

The (verified) map of consensus keys to peer IDs

pd: PhantomData<(C, S)>

Phantom data for the connection type

Implementations

impl<T: Transport, S: SignatureKey + 'static, C: StreamMuxer + Unpin> ConsensusKeyAuthentication<T, S, C>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __ConsensusKeyAuthenticationProjection<'pin, T, S, C>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __ConsensusKeyAuthenticationProjectionRef<'pin, T, S, C>

impl<T: Transport, S: SignatureKey + 'static, C: StreamMuxer + Unpin> ConsensusKeyAuthentication<T, S, C>

pub fn new( inner: T, auth_message: Option<Vec<u8>>, consensus_key_to_pid_map: Arc<Mutex<BiMap<S, PeerId>>>, ) -> Self

Create a new ConsensusKeyAuthentication transport that wraps the given transport and authenticates connections against the stake table. If the auth message is None, the authentication is disabled.

pub async fn authenticate_with_remote_peer<W: AsyncWrite + Unpin>( stream: &mut W, auth_message: &[u8], ) -> AnyhowResult<()>

Prove to the remote peer that we are in the stake table by sending them our authentication message.

Errors

• If we fail to write the message to the stream

pub async fn verify_peer_authentication<R: AsyncReadExt + Unpin>( stream: &mut R, required_peer_id: &PeerId, consensus_key_to_pid_map: Arc<Mutex<BiMap<S, PeerId>>>, ) -> AnyhowResult<()>

Verify that the remote peer is:

• In the stake table
• Sending us a valid authentication message
• Sending us a valid signature
• Matching the peer ID we expect

Errors

If the peer fails verification. This can happen if:

• We fail to read the message from the stream
• The message is too large
• The message is invalid
• The peer is not in the stake table
• The signature is invalid

fn gen_handshake<F: Future<Output = Result<T::Output, T::Error>> + Send + 'static>( original_future: F, outgoing: bool, auth_message: Arc<Option<Vec<u8>>>, consensus_key_to_pid_map: Arc<Mutex<BiMap<S, PeerId>>>, ) -> Pin<Box<dyn Future<Output = Result<<T as Transport>::Output, <T as Transport>::Error>> + Send>>

where T::Error: From<<C as StreamMuxer>::Error> + From<IoError>, T::Output: AsOutput<C> + Send, C::Substream: Unpin + Send,

Wrap the supplied future in an upgrade that performs the authentication handshake.

outgoing is a boolean that indicates if the connection is incoming or outgoing. This is needed because the flow of the handshake is different for each.

Trait Implementations

impl<T: Transport, S: SignatureKey + 'static, C: StreamMuxer + Unpin> Transport for ConsensusKeyAuthentication<T, S, C>

where T::Dial: Future<Output = Result<T::Output, T::Error>> + Send + 'static, T::ListenerUpgrade: Send + 'static, T::Output: AsOutput<C> + Send, T::Error: From<<C as StreamMuxer>::Error> + From<Error>, C::Substream: Unpin + Send,

fn dial( &mut self, addr: Multiaddr, opts: DialOpts, ) -> Result<Self::Dial, TransportError<Self::Error>>

Dial a remote peer. This function is changed to perform an authentication handshake on top.

fn poll( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<TransportEvent<Self::ListenerUpgrade, Self::Error>>

This function is where we perform the authentication handshake for incoming connections. The flow in this case is the reverse of the dial function: we first verify the remote peer’s authentication, and then authenticate with them.

fn remove_listener(&mut self, id: ListenerId) -> bool

The below functions just pass through to the inner transport, but we had to define them

type Dial = Pin<Box<dyn Future<Output = Result<<T as Transport>::Output, <T as Transport>::Error>> + Send>>

A pending Output for an outbound connection, obtained from dialing.

type ListenerUpgrade = Pin<Box<dyn Future<Output = Result<<T as Transport>::Output, <T as Transport>::Error>> + Send>>

A pending Output for an inbound connection, obtained from the [Transport] stream.

type Output = <T as Transport>::Output

The result of a connection setup process, including protocol upgrades.

type Error = <T as Transport>::Error

An error that occurred during connection setup.

fn listen_on( &mut self, id: ListenerId, addr: Multiaddr, ) -> Result<(), TransportError<Self::Error>>

Listens on the given Multiaddr for inbound connections with a provided [ListenerId].

fn boxed(self) -> Boxed<Self::Output>

where Self: Sized + Send + Unpin + 'static, Self::Dial: Send + 'static, Self::ListenerUpgrade: Send + 'static, Self::Error: Send + Sync,

Boxes the transport, including custom transport errors.

fn map<F, O>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnOnce(Self::Output, ConnectedPoint) -> O,

Applies a function on the connections created by the transport.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F>

where Self: Sized, F: FnOnce(Self::Error) -> E,

Applies a function on the errors generated by the futures of the transport.

fn or_transport<U>(self, other: U) -> OrTransport<Self, U>

where Self: Sized, U: Transport, <U as Transport>::Error: 'static,

Adds a fallback transport that is used when encountering errors while establishing inbound or outbound connections.

fn and_then<C, F, O>(self, f: C) -> AndThen<Self, C>

where Self: Sized, C: FnOnce(Self::Output, ConnectedPoint) -> F, F: TryFuture<Ok = O>, <F as TryFuture>::Error: Error + 'static,

Applies a function producing an asynchronous result to every connection created by this transport.

fn upgrade(self, version: Version) -> Builder<Self>

where Self: Sized, Self::Error: 'static,

Begins a series of protocol upgrades via an [upgrade::Builder].

impl<'pin, T: Transport, S: SignatureKey + 'static, C: StreamMuxer + Unpin> Unpin for ConsensusKeyAuthentication<T, S, C>

where PinnedFieldsOf<__ConsensusKeyAuthentication<'pin, T, S, C>>: Unpin,