Struct libp2p_networking::network::transport::StakeTableAuthentication

pub struct StakeTableAuthentication<T: Transport, Types: NodeType, C: StreamMuxer + Unpin> {
    pub inner: T,
    pub stake_table: Arc<Option<Types::Membership>>,
    pub auth_message: Arc<Option<Vec<u8>>>,
    pd: PhantomData<C>,
}

A wrapper for a Transport that bidirectionally authenticates connections by performing a handshake that checks if the remote peer is present in the stake table.

Fields

inner: T

The underlying transport we are wrapping

stake_table: Arc<Option<Types::Membership>>

The stake table we check against to authenticate connections

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

A pre-signed message that we send to the remote peer for authentication

pd: PhantomData<C>

Phantom data for the connection type

Implementations

impl<T: Transport, Types: NodeType, C: StreamMuxer + Unpin> StakeTableAuthentication<T, Types, C>

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

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

impl<T: Transport, Types: NodeType, C: StreamMuxer + Unpin> StakeTableAuthentication<T, Types, C>

pub fn new( inner: T, stake_table: Option<Types::Membership>, auth_message: Option<Vec<u8>>, ) -> Self

Create a new StakeTableAuthentication transport that wraps the given transport and authenticates connections against the stake table.

pub async fn authenticate_with_remote_peer<W: AsyncWrite + Unpin>( stream: &mut W, auth_message: Arc<Option<Vec<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, stake_table: Arc<Option<Types::Membership>>, required_peer_id: &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, stake_table: Arc<Option<Types::Membership>>, auth_message: Arc<Option<Vec<u8>>>, ) -> 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, Types: NodeType, C: StreamMuxer + Unpin> Transport for StakeTableAuthentication<T, Types, 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, ) -> Result<Self::Dial, TransportError<Self::Error>>

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

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

Dial a remote peer as a listener. This function is changed to perform an authentication handshake on top. The flow should be the reverse of the dial function and the same as the poll function.

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 address_translation( &self, listen: &Multiaddr, observed: &Multiaddr, ) -> Option<Multiaddr>

Performs a transport-specific mapping of an address observed by a remote onto a local listen address to yield an address for the local node that may be reachable for other peers.

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 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, Types: NodeType, C: StreamMuxer + Unpin> Unpin for StakeTableAuthentication<T, Types, C>

where PinnedFieldsOf<__StakeTableAuthentication<'pin, T, Types, C>>: Unpin,