Struct keynesis::noise::TransportState

pub struct TransportState<H: Hash> { /* fields omitted */ }

Noise transport session between 2 participant. Communication is Asymmetric. So it is possible to send messages independently from the messages to receive. This allows to continue sending our current messages without having to make sure we are in sync with the remote messages.

All messages are authenticated and because we are rekeying after each messages we have strong forward secrecy.

Implementations

impl<H: Hash> TransportState<H>

pub fn split(self) -> (TransportSendHalf<H>, TransportReceiveHalf<H>)

split the transport state into a sending half and receiving half

this is to make it easier to handle bidirectional connections asynchronously.

pub fn noise_session(&self) -> &H::HASH

unique identifier of the noise session

pub fn remote_public_identity(&self) -> &PublicKey

get the remote's public identity

pub fn count_received(&self) -> u64

get the number of message received from the remote peer

this function will be a little tainted by the handshake state it also account for the number of times either encrypt or decrypt has been used during the handshake. This is because during the handshake the exchange is symmetrical while in the transport era the exchanges are asymmetrical.

pub fn count_sent(&self) -> u64

get the number of message sent to the remote peer

this function will be a little tainted by the handshake state it also account for the number of times either encrypt or decrypt has been used during the handshake. This is because during the handshake the exchange is symmetrical while in the transport era the exchanges are asymmetrical.

pub fn send(
    &mut self,
    input: impl AsRef<[u8]>,
    output: &mut [u8]
) -> Result<(), CipherStateError>

send message to the remote peer

The output must be at least 16 bytes longer than the input this is in order to add the MAC, this will be use to authenticate the message has not been tempered with.

pub fn receive(
    &mut self,
    input: impl AsRef<[u8]>,
    output: &mut [u8]
) -> Result<(), CipherStateError>

receive message from the remote peer

The output can have 16 bytes less than the input. This is because the MAC is appended in the input message so we can verify the message has not been tempered with.