Struct DualLayerHandshake 

pub struct DualLayerHandshake<Outer, Inner, C, H, const BUF: usize>
where
    Inner: Handshaker<C, H>,
    Outer: Handshaker<C, H>,
    C: Cipher,
    H: Hash,
{ /* private fields */ }

Dual layer handshake

An “outer-encrypts-inner” dual layer handshake with fully independent layers. The outer handshake is completed first, after which the inner handshake starts and all the related handshake messages are encrypted using the outer layers resulting transport encryption.

Warning: this is a naive approach which does NOT cryptographically bind the layers together. Use this handshake type only if you know what you are doing and absolutely require the handshake layers to remain independent.

Dual layer handshakes require an additional intermediate buffer for decrypting outer layer handshake messages. The buffer size is controlled by the generic parameter BUF.

Message Sequences

With dual layer handshakes it is possible to construct handshake pattern combinations which result in one party having to send two handshake messages in a row. Take care when implementing your handshaking logic and always use Self::is_write_turn to check who should send next.

Implementations

impl<Outer, Inner, C, H, const BUF: usize> DualLayerHandshake<Outer, Inner, C, H, BUF>

where Inner: Handshaker<C, H>, Outer: Handshaker<C, H>, C: Cipher, H: Hash,

pub fn new(outer: Outer, inner: Inner) -> Self

Initialize a new dual layer handshake

Arguments

• outer - Outer handshake, which is completed first
• innter - Inner handshake, which benefits from the security of the outer layer

Generic parameters

• const BUF - Intermediate decrypt buffer size - Must be large enough to fit all inner handshake messages

Panics

• If outer and inner aren’t both either initiators or responders
• If outer handshake is a one-way pattern

pub fn outer_completed(&self) -> bool

Check if outer handshake is completed

pub fn inner(&self) -> &Inner

Get reference to inner handshake

pub fn inner_mut(&mut self) -> &mut Inner

Get mutable reference to inner handshake

pub fn outer(&self) -> Option<&Outer>

Get reference to outer handshake

pub fn outer_mut(&mut self) -> Option<&mut Outer>

Get mutable reference to outer handshake

Trait Implementations

impl<Outer, Inner, C, H, const BUF: usize> Handshaker<C, H> for DualLayerHandshake<Outer, Inner, C, H, BUF>

where Inner: Handshaker<C, H>, Outer: Handshaker<C, H>, C: Cipher, H: Hash,

fn get_remote_static(&self) -> Option<Self::S>

Get remote static key of the inner handshake (if available)

fn get_remote_ephemeral(&self) -> Option<Self::E>

Get remote ephemeral key of the inner handshake (if available)

fn get_state(&self) -> SymmetricState<C, H>

Get a copy of the inner handshakers current SymmetricState

fn get_state_mut(&mut self) -> &mut SymmetricState<C, H>

Get a mutable reference of the inner handshakers current SymmetricState

type E = <Inner as Handshaker<C, H>>::E

Ephemeral public key type

type S = <Inner as Handshaker<C, H>>::S

Static public key type

fn push_psk(&mut self, _psk: &[u8])

Push a PSK to the PSK queue

fn is_write_turn(&self) -> bool

Is it our turn to send

fn is_initiator(&self) -> bool

Are we the initiator

fn get_next_message_overhead(&self) -> HandshakeResult<usize>

Get next message overhead in bytes

fn build_name(_: &HandshakePattern) -> ArrayString<128>

Build full name of the protocol with the given pattern

fn write_message( &mut self, payload: &[u8], out: &mut [u8], ) -> HandshakeResult<usize>

Write next handshake message to the given buffer

fn read_message( &mut self, message: &[u8], out: &mut [u8], ) -> HandshakeResult<usize>

Read and process next handshake message from given buffer

fn is_finished(&self) -> bool

Is the handshake finished

fn get_name(&self) -> ArrayString<128>

Get full name of the selected protocol

fn finalize(self) -> HandshakeResult<TransportState<C, H>>

where Self: Sized,

Transition into transport mode