Struct SecureMeshTransport 

pub struct SecureMeshTransport<T: MeshTransport, A: AuthenticationChannel> { /* private fields */ }

Secure mesh transport that requires authentication before sync.

This wrapper adds Ed25519-based challenge-response authentication to any MeshTransport implementation. Peers must complete mutual authentication before the connection is considered established.

Implementations

impl<T: MeshTransport, A: AuthenticationChannel> SecureMeshTransport<T, A>

pub fn new(keypair: DeviceKeypair, inner: Arc<T>, auth_channel: Arc<A>) -> Self

Create a new secure transport wrapper.

Arguments

• keypair - This device’s keypair for authentication
• inner - The underlying transport to wrap
• auth_channel - Channel for exchanging authentication messages

pub fn device_id(&self) -> DeviceId

Get this device’s ID.

pub fn is_authenticated(&self, peer_id: &NodeId) -> bool

Check if a peer is authenticated.

pub fn get_peer_device_id(&self, peer_id: &NodeId) -> Option<DeviceId>

Get the DeviceId for an authenticated peer.

pub async fn authenticate_peer( &self, peer_id: &NodeId, ) -> Result<DeviceId, SecurityError>

Authenticate a peer using challenge-response.

This performs mutual authentication:

1. We send a challenge to the peer
2. Peer responds with signed challenge
3. We verify the response
4. Peer sends us a challenge
5. We respond with signed challenge
6. Both sides are now authenticated

pub fn remove_authenticated_peer(&self, peer_id: &NodeId)

Remove a peer from the authenticated cache.

pub fn authenticated_peer_count(&self) -> usize

Get the number of authenticated peers.

pub fn authenticator(&self) -> &DeviceAuthenticator

Get the underlying authenticator (for testing or advanced use).

Trait Implementations

impl<T: MeshTransport + 'static, A: AuthenticationChannel + 'static> MeshTransport for SecureMeshTransport<T, A>

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start the transport layer

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop the transport layer

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, peer_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = TransportResult<Box<dyn MeshConnection>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Connect to a peer by node ID

fn disconnect<'life0, 'life1, 'async_trait>( &'life0 self, peer_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = TransportResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Disconnect from a peer

fn get_connection(&self, peer_id: &NodeId) -> Option<Box<dyn MeshConnection>>

Get an existing connection to a peer

fn peer_count(&self) -> usize

Get the number of connected peers

fn connected_peers(&self) -> Vec<NodeId>

Get list of connected peer IDs

fn is_connected(&self, peer_id: &NodeId) -> bool

Check if connected to a specific peer

fn subscribe_peer_events(&self) -> PeerEventReceiver

Subscribe to peer connection events

fn send_to<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, peer_id: &'life1 NodeId, data: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<usize, TransportError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Send data to a connected peer.

fn get_peer_health(&self, peer_id: &NodeId) -> Option<ConnectionHealth>

Get connection health for a specific peer