Enum Handshake 

pub enum Handshake {
    N,
    K,
    X,
    Npsk0,
    Kpsk0,
    Xpsk1,
    NN,
    KK,
    XX,
    IK,
    IX,
    NK,
    NX,
    XK1,
    KK1,
    NNpsk2,
}

The handshake patterns we support for now

Variants

N

One-way, no static key for initiator

K

One-way, static key for initiator known to responder

X

One-way, static key for initiator is transmitted to responder

Npsk0

One-way, no static key for initiator, pre-shared key (i.e. passphrase, biometric, etc)

Kpsk0

One-way, static key for initiator known to responder, pre-shared key (i.e. passphrase, biometric, etc)

Xpsk1

One-way, static key for initiator is transmitted to responder, pre-shared key (i.e. passphrase, biometric, etc)

NN

No static keys for either the initiator or responder

KK

Both sides know each other’s static public keys

XX

Both sides transmit their keys

IK

Initiator transmits their static public key immediately

IX

Initiator transmits their ephemeral and static public key immediately

NK

No static key for the initiator, reponder key known

NX

No static key for the initiator, responder transmits key

XK1

Initiator transmits key and knows responders key, deferred

KK1

Initiator and responder know each other’s keys, deferred

NNpsk2

Initiator and responder know a pre-shared key

Implementations

impl Handshake

pub fn get_pattern(&self, role: &ChannelRole) -> &[HandshakeOp]

Return the appropriate HandshakeState

pub fn needs_local_static_key(&self, role: &ChannelRole) -> bool

True if handshake pattern requires local static key

pub fn needs_remote_static_key(&self, role: &ChannelRole) -> bool

True if handshake pattern requires remote static public key before the handshake

pub fn mix_local_static_key(&self, role: &ChannelRole) -> bool

True if the handshake pattern and my role requires me to mix my static pub key

pub fn mix_remote_static_key(&self, role: &ChannelRole) -> bool

True if the handshake pattern and my role requires me to mix the remote static pub key

pub fn needs_pre_shared_key(&self, _role: &ChannelRole) -> bool

True if the handshake pattern requires a pre-shared key before the handshake

pub fn local_dh_is_deferred(&self, role: &ChannelRole) -> bool

True if handshake pattern defers the local DH operation

pub fn remote_dh_is_deferred(&self, role: &ChannelRole) -> bool

True if handshake pattern defers the remote DH operation

Trait Implementations

impl Clone for Handshake

fn clone(&self) -> Handshake

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Handshake

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Handshake

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Handshake

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

Formats the value using the given formatter.

impl FromStr for Handshake

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Handshake

fn eq(&self, other: &Handshake) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Handshake

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Handshake

impl StructuralPartialEq for Handshake