Struct Chacha20Key

pub struct Chacha20Key<T: Chacha20Type>(/* private fields */);

Available on crate feature chacha only.

A ChaCha20 symmetric encryption key

Implementations

impl<T: Chacha20Type> Chacha20Key<T>

pub const KEY_LENGTH: usize = KeyType<T>::SIZE

The length of the secret key in bytes

pub const NONCE_LENGTH: usize = NonceSize<T>::USIZE

The length of the AEAD encryption nonce

pub const TAG_LENGTH: usize = TagSize<T>::USIZE

The length of the AEAD encryption tag

Trait Implementations

impl<T: Chacha20Type> Clone for Chacha20Key<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Chacha20Type> Debug for Chacha20Key<T>

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

Formats the value using the given formatter.

impl<'de, T: Chacha20Type> Deserialize<'de> for Chacha20Key<T>

where ArrayKey<<<T as Chacha20Type>::Aead as KeySizeUser>::KeySize>: for<'a> Deserialize<'a>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Chacha20Type> FromJwk for Chacha20Key<T>

fn from_jwk_parts(jwk: JwkParts<'_>) -> Result<Self, Error>

Import the key from a pre-parsed JWK

fn from_jwk(jwk: &str) -> Result<Self, Error>

Import the key from a JWK string reference

fn from_jwk_slice(jwk: &[u8]) -> Result<Self, Error>

Import the key from a JWK byte slice

impl<T: Chacha20Type> FromKeyDerivation for Chacha20Key<T>

fn from_key_derivation<D: KeyDerivation>(derive: D) -> Result<Self, Error>

where Self: Sized,

Create a new instance of a key from a key derivation

impl<Lhs, Rhs, T> FromKeyExchange<Lhs, Rhs> for Chacha20Key<T>

where Lhs: KeyExchange<Rhs> + ?Sized, Rhs: ?Sized, T: Chacha20Type,

fn from_key_exchange(lhs: &Lhs, rhs: &Rhs) -> Result<Self, Error>

Derive an instance of this key directly from a supported key exchange

impl<T: Chacha20Type> HasKeyAlg for Chacha20Key<T>

fn algorithm(&self) -> KeyAlg

Get the corresponding key algorithm.

impl<T: Chacha20Type> HasKeyBackend for Chacha20Key<T>

fn key_backend(&self) -> KeyBackend

Get the corresponding key backend.

impl<T: Chacha20Type> KeyAeadInPlace for Chacha20Key<T>

fn encrypt_in_place( &self, buffer: &mut dyn ResizeBuffer, nonce: &[u8], aad: &[u8], ) -> Result<usize, Error>

Encrypt a secret value in place, appending the verification tag

fn decrypt_in_place( &self, buffer: &mut dyn ResizeBuffer, nonce: &[u8], aad: &[u8], ) -> Result<(), Error>

Decrypt an encrypted (verification tag appended) value in place

fn aead_params(&self) -> KeyAeadParams

Get the nonce and tag length for encryption

fn aead_padding(&self, _msg_len: usize) -> usize

Get the ciphertext padding required

impl<T: Chacha20Type> KeyAeadMeta for Chacha20Key<T>

type NonceSize = <<T as Chacha20Type>::Aead as AeadCore>::NonceSize

The size of the AEAD nonce

type TagSize = <<T as Chacha20Type>::Aead as AeadCore>::TagSize

The size of the AEAD tag

fn random_nonce() -> GenericArray<u8, Self::NonceSize>

Generate a new random nonce

impl<T: Chacha20Type> KeyGen for Chacha20Key<T>

fn generate(rng: impl KeyMaterial) -> Result<Self, Error>

Create a new key from a key material generator.

fn random() -> Result<Self, Error>

Generate a new random key.

impl<T: Chacha20Type> KeyMeta for Chacha20Key<T>

type KeySize = <<T as Chacha20Type>::Aead as KeySizeUser>::KeySize

The size of the key secret bytes

impl<T: Chacha20Type> KeySecretBytes for Chacha20Key<T>

fn from_secret_bytes(key: &[u8]) -> Result<Self, Error>

Create a new key instance from a slice of key secret bytes.

fn with_secret_bytes<O>(&self, f: impl FnOnce(Option<&[u8]>) -> O) -> O

Access a temporary slice of the key secret bytes, if any.

impl<T: Chacha20Type> PartialEq for Chacha20Key<T>

fn eq(&self, other: &Self) -> 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<T: Chacha20Type> Serialize for Chacha20Key<T>

where ArrayKey<<<T as Chacha20Type>::Aead as KeySizeUser>::KeySize>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Chacha20Type> ToJwk for Chacha20Key<T>

fn encode_jwk(&self, enc: &mut dyn JwkEncoder) -> Result<(), Error>

Write the JWK representation to an encoder

fn to_jwk_thumbprint(&self, alg: Option<KeyAlg>) -> Result<String, Error>

Available on crate feature alloc only.

Create the JWK thumbprint of the key

fn to_jwk_public(&self, alg: Option<KeyAlg>) -> Result<String, Error>

Available on crate feature alloc only.

Create a JWK of the public key

fn to_jwk_secret(&self, alg: Option<KeyAlg>) -> Result<SecretBytes, Error>

Available on crate feature alloc only.

Create a JWK of the secret key

impl<T: Chacha20Type> Zeroize for Chacha20Key<T>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<T: Chacha20Type> Eq for Chacha20Key<T>