Struct libp2p_networking::network::transport::StakeTableAuthentication

pub struct StakeTableAuthentication<T: Transport, Types: NodeType, C: StreamMuxer + Unpin> {
    pub inner: T,
    pub stake_table: Arc<Option<Arc<RwLock<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<Arc<RwLock<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<Arc<RwLock<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<Arc<RwLock<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<Arc<RwLock<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, 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 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,