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>>

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<NoiseState<E, D>> 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> StructuralEq for NoiseState<E, D>

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