Enum noise::NoiseState

pub enum NoiseState<E: Ecdh, D: Digest> {
    AwaitWrite(HandshakeState<E, D>),
    Handshake(HandshakeState<E, D>),
    Active {
        sending_cipher: CipherState,
        receiving_cipher: CipherState,
        handshake_hash: HandshakeHash<D>,
        remote_static_pubkey: Option<E::Pk>,
    },
}

Variants

AwaitWrite(HandshakeState<E, D>)

Handshake(HandshakeState<E, D>)

Active

Fields

sending_cipher: CipherState

receiving_cipher: CipherState

handshake_hash: HandshakeHash<D>

remote_static_pubkey: Option<E::Pk>

Implementations

impl<E: Ecdh, D: Digest> NoiseState<E, D>

pub fn initialize<const HASHLEN: usize>( handshake_pattern: HandshakePattern, is_initiator: bool, prologue: &[u8], keyset: Keyset<E> ) -> Self

pub fn advance(&mut self, input: &[u8]) -> Result<Vec<u8>, NoiseError>

Takes incoming data from the remote peer, advances internal state machine and returns a data to be sent to the remote peer for the next handshake act. If the handshake is over, returns an empty vector. On subsequent calls return NoiseError::HandshakeComplete error.

pub fn advance_with_payload( &mut self, input: &[u8], payload: &[u8] ) -> Result<(Vec<u8>, Vec<u8>), NoiseError>

pub fn next_read_len(&self) -> usize

Provides information about next message length which should be read from a network stream.

pub fn get_handshake_hash(&self) -> Option<HandshakeHash<D>>

pub fn get_remote_static_key(&self) -> Option<E::Pk>

Trait Implementations

impl<E: Clone + Ecdh, D: Clone + Digest> Clone for NoiseState<E, D>

where E::Pk: Clone,

fn clone(&self) -> NoiseState<E, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Debug + Ecdh, D: Debug + Digest> Debug for NoiseState<E, D>

where E::Pk: Debug,

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

Formats the value using the given formatter.

impl<E: PartialEq + Ecdh, D: PartialEq + Digest> PartialEq for NoiseState<E, D>

where E::Pk: PartialEq,

fn eq(&self, other: &NoiseState<E, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Eq + Ecdh, D: Eq + Digest> Eq for NoiseState<E, D>

where E::Pk: Eq,

impl<E: Ecdh, D: Digest> StructuralPartialEq for NoiseState<E, D>