Enum Key 

pub enum Key {
    Aes256([u8; 32]),
    Aes192([u8; 24]),
    Aes128([u8; 16]),
}

Represents different AES key sizes.

AES (Advanced Encryption Standard) supports three key sizes:

• 128-bit (16 bytes)
• 192-bit (24 bytes)
• 256-bit (32 bytes)

This enum allows for type-safe handling of these different key sizes.

Variants

Aes256([u8; 32])

256-bit AES key (32 bytes)

Aes192([u8; 24])

192-bit AES key (24 bytes)

Aes128([u8; 16])

128-bit AES key (16 bytes)

Implementations

impl Key

pub const fn capacity(&self) -> usize

Returns the capacity (size in bytes) of the key.

Returns

• 32 for Aes256
• 24 for Aes192
• 16 for Aes128

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

Returns a reference to the key as a byte slice.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns a mutable reference to the key as a byte slice.

pub fn zero(&mut self)

Zeros out the key for security purposes.

This method uses the zeroize crate to ensure that the key material is securely erased from memory.

This is called in the Key drop implementation.

Trait Implementations

impl Drop for Key

fn drop(&mut self)

Zeroes the underlying key material.

impl From<[u8; 16]> for Key

fn from(value: [u8; 16]) -> Self

Converts to this type from the input type.

impl From<[u8; 24]> for Key

fn from(value: [u8; 24]) -> Self

Converts to this type from the input type.

impl From<[u8; 32]> for Key

fn from(value: [u8; 32]) -> Self

Converts to this type from the input type.

impl Zeroize for Key

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.