Struct NoiseSession 

pub struct NoiseSession<S> { /* private fields */ }

A Noise-XX session over a stream.

Payloads are exchanged with NoiseSession::send and NoiseSession::recv; the session moves from the handshake phase to the transport phase via NoiseSession::into_transport_mode, which may only be called once the pattern’s three messages have been exchanged.

Implementations

impl<S: AsyncRead + AsyncWrite + Unpin> NoiseSession<S>

pub fn new(stream: S, role: Role) -> Result<Self>

Creates a Noise session over the given stream.

The caller is responsible for the NOISE_MAGIC prefix: the initiator must have sent it with write_noise_magic, and the responder must have consumed it with detect_handshake_protocol. Note that a responder should generally use PendingSession::accept instead, so that it can inspect the initiator’s cleartext payload before committing to any key derivation.

pub async fn send(&mut self, payload: &[u8]) -> Result<()>

Encrypts the given payload and sends it to the peer.

pub async fn recv(&mut self) -> Result<Vec<u8>>

Receives a message from the peer and returns its decrypted payload.

pub fn handshake_hash(&self) -> Result<[u8; 32]>

Returns the current handshake hash, which commits to every key and payload exchanged so far; see binding_message.

Both sides derive the same value after processing the same number of messages. It can only be read during the handshake phase, so callers that need it must capture it before calling NoiseSession::into_transport_mode.

pub fn into_transport_mode(self) -> Result<Self>

Transitions the session from the handshake phase to the transport phase, which the pattern only permits once its three messages have been exchanged.

pub fn into_inner(self) -> S

Recovers the underlying stream.

Nothing is lost in the process: the session reads its messages exactly, so anything the peer sent past the end of the handshake is still on the stream for whoever takes it next.