Struct snow::HandshakeState

pub struct HandshakeState { /* private fields */ }

A state machine encompassing the handshake phase of a Noise session.

Note: you are probably looking for Builder to get started.

See: http://noiseprotocol.org/noise.html#the-handshakestate-object

Implementations

impl HandshakeState

pub fn was_write_payload_encrypted(&self) -> bool

This method will return true if the previous write payload was encrypted.

See Payload Security Properties for more information on the specific properties of your chosen handshake pattern.

Examples

let mut session = Builder::new("Noise_NN_25519_AESGCM_SHA256".parse()?)
    .build_initiator()?;

// write message...

assert!(session.was_write_payload_encrypted());

pub fn write_message(
    &mut self,
    payload: &[u8],
    message: &mut [u8]
) -> Result<usize, Error>

Construct a message from payload (and pending handshake tokens if in handshake state), and writes it to the message buffer.

Returns the size of the written payload.

Errors

Will result in Error::Input if the size of the output exceeds the max message length in the Noise Protocol (65535 bytes).

pub fn read_message(
    &mut self,
    message: &[u8],
    payload: &mut [u8]
) -> Result<usize, Error>

Reads a noise message from input

Returns the size of the payload written to payload.

Errors

Will result in Error::Decrypt if the contents couldn’t be decrypted and/or the authentication tag didn’t verify.

Panics

This function will panic if there is no key, or if there is a nonce overflow.

pub fn set_psk(&mut self, location: usize, key: &[u8]) -> Result<(), Error>

Set the preshared key at the specified location. It is up to the caller to correctly set the location based on the specified handshake - Snow won’t stop you from placing a PSK in an unused slot.

Errors

Will result in Error::Input if the PSK is not the right length or the location is out of bounds.

pub fn get_remote_static(&self) -> Option<&[u8]>

Get the remote party’s static public key, if available.

Note: will return None if either the chosen Noise pattern doesn’t necessitate a remote static key, or if the remote static key is not yet known (as can be the case in the XX pattern, for example).

pub fn get_handshake_hash(&self) -> &[u8]

Get the handshake hash.

Returns a slice of length Hasher.hash_len() (i.e. HASHLEN for the chosen Hash function).

pub fn is_initiator(&self) -> bool

Check if this session was started with the “initiator” role.

pub fn is_handshake_finished(&self) -> bool

Check if the handshake is finished and into_transport_mode() can now be called.

pub fn is_my_turn(&self) -> bool

Check whether it is our turn to send in the handshake state machine

pub fn into_transport_mode(self) -> Result<TransportState, Error>

Convert this HandshakeState into a TransportState with an internally stored nonce.

pub fn into_stateless_transport_mode(
    self
) -> Result<StatelessTransportState, Error>

Convert this HandshakeState into a StatelessTransportState without an internally stored nonce.

Trait Implementations

impl Debug for HandshakeState

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl TryFrom<HandshakeState> for StatelessTransportState

type Error = Error

The type returned in the event of a conversion error.

fn try_from(old: HandshakeState) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<HandshakeState> for TransportState

type Error = Error

The type returned in the event of a conversion error.

fn try_from(old: HandshakeState) -> Result<Self, Self::Error>

Performs the conversion.