Struct Key 

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

A key for Poly1305 one-time authentication

This key is used for computing and verifying Poly1305 authentication tags. It must be exactly 32 bytes long.

Security Warning

This key should be used only once for a single message. Reusing the same key for multiple messages completely compromises security. This is why Poly1305 is called a “one-time” authenticator.

Key Generation

Keys should be generated using a cryptographically secure random number generator. The generate() method provides a convenient way to create a secure random key.

Usage Pattern

1. Generate a new key for each message to be authenticated
2. Use the key to compute an authentication tag
3. Never reuse the key for another message
4. Store or transmit the key securely alongside the message and tag

Implementations

impl Key

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Generate a new key from bytes

Arguments

• bytes - The bytes to create the key from

Returns

• Result<Self> - The key or an error if the input is invalid

Errors

Returns an error if the input is not exactly KEYBYTES bytes long

pub fn generate() -> Self

Generate a new random key

Returns

• Self - A randomly generated key

Panics

This function will panic if the random number generator fails, which should never happen

pub fn as_bytes(&self) -> &[u8]

Get the bytes of the key

Returns

• &[u8] - A reference to the key bytes

Trait Implementations

impl AsRef<[u8]> for Key

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

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Drop for Key

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Key

impl From<Key> for [u8; 32]

fn from(key: Key) -> Self

Converts to this type from the input type.

impl From<[u8; 32]> for Key

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

Converts to this type from the input type.

impl PartialEq for Key

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

impl TryFrom<&[u8]> for Key

type Error = SodiumError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

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.