Struct Hello 

pub struct Hello<P: PublicKey> { /* private fields */ }

A signed hello message.

Allows recipient to verify that the sender has the private key of public key before sending any data.

By requiring the server to have their public key signed, they prevent a malicious peer from forwarding a handshake message from a previous connection with public key (which could be used to convince the server to start a useless handshake). Alternatively, we could require the dialer to sign some random bytes provided by the server but this would require the server to send a message to a peer before authorizing that it should connect to them.

Implementations

impl<P: PublicKey> Hello<P>

pub fn sign<Sk: Signer<PublicKey = P, Signature = P::Signature>>( crypto: &mut Sk, namespace: &[u8], info: Info<P>, ) -> Self

Sign a hello message.

pub fn signer(&self) -> P

Get the public key of the signer.

pub fn ephemeral(&self) -> PublicKey

Get the ephemeral public key of the signer.

pub fn verify<E: Clock>( &self, context: &E, crypto: &P, namespace: &[u8], synchrony_bound: Duration, max_handshake_age: Duration, tag_data: Option<&[u8]>, ) -> Result<(), Error>

Verify a signed hello message.

Trait Implementations

impl<P: PublicKey> EncodeSize for Hello<P>

fn encode_size(&self) -> usize

Returns the encoded size of this value (in bytes).

impl<P: PublicKey> Read for Hello<P>

type Cfg = ()

The Cfg type parameter allows passing configuration during the read process. This is crucial for safely decoding untrusted data, for example, by providing size limits for collections or strings.

fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError>

Reads a value from the buffer using the provided configuration cfg.

impl<P: PublicKey> Write for Hello<P>

fn write(&self, buf: &mut impl BufMut)

Writes the binary representation of self to the provided buffer buf.