Struct SharedKey 

pub struct SharedKey(/* private fields */);

32-byte key shared among sender and receiver secretly.

It is a good practice to use SerdeEncryptPublicKey to exchange this shared key.

Implementations

impl SharedKey

pub const fn new_const(data: [u8; 32]) -> Self

Build SharedKey from static [u8; 32] data at compile time.

pub fn new(data: [u8; 32]) -> Self

Build SharedKey from [u8; 32] data.

Trait Implementations

impl AsSharedKey for SharedKey

type R = RngSingletonImpl

RNG singleton

fn from_array(key: [u8; 32]) -> Self

Constructor from secret bytes.

fn as_slice(&self) -> &[u8]

Ref to 32-byte slice

fn generate() -> Self

where Self: Sized,

Generates secure random key.

fn to_chacha_key( &self, ) -> &GenericArray<u8, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>

Makes chacha20poly1305::Key

impl Clone for SharedKey

fn clone(&self) -> SharedKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SharedKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SharedKey

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SharedKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SharedKey

fn eq(&self, other: &SharedKey) -> 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 SerdeEncryptPublicKey for SharedKey

type S = BincodeSerializer<SharedKey>

Serializer implementation

fn encrypt( &self, combined_key: &SenderCombinedKey<'_, '_>, ) -> Result<EncryptedMessage, Error>

where Self: Serialize,

Serialize and encrypt.

fn decrypt_owned( encrypted_message: &EncryptedMessage, combined_key: &ReceiverCombinedKey<'_, '_>, ) -> Result<Self, Error>

where Self: DeserializeOwned,

Decrypt and deserialize into DeserializeOwned type.

fn decrypt_ref<'de>( encrypted_message: &EncryptedMessage, combined_key: &ReceiverCombinedKey<'_, '_>, ) -> Result<Self::S, Error>

where Self: Deserialize<'de>,

Just decrypts cipher-text. Returned data must be deserialized later. Types implementing serde::Deserialize<'de> (not serde::de::DeserializeOwned) should use this function to resolve lifetime.

impl Serialize for SharedKey

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SharedKey

impl StructuralPartialEq for SharedKey