Struct Nonce

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

A random nonce (“number used once”).

A Nonce is a cryptographic primitive consisting of a random or pseudo-random number that is used only once in a cryptographic communication. Nonces are often used in authentication protocols, encryption algorithms, and digital signatures to prevent replay attacks and ensure the uniqueness of encrypted messages.

In this implementation, a Nonce is a 12-byte random value. The size is chosen to be sufficiently large to prevent collisions while remaining efficient for storage and transmission.

CBOR Serialization

Nonce implements the CBORTaggedCodable trait, which means it can be serialized to and deserialized from CBOR with a specific tag. The tag used is TAG_NONCE defined in the tags module.

UR Serialization

When serialized as a Uniform Resource (UR), a Nonce is represented as a binary blob with the type “nonce”.

Common Uses

• In authenticated encryption schemes like AES-GCM
• For initializing counters in counter-mode block ciphers
• In challenge-response authentication protocols
• To prevent replay attacks in secure communications

Examples

Creating a new random nonce:

use bc_components::Nonce;

// Generate a new random nonce
let nonce = Nonce::new();

Creating a nonce from existing data:

use bc_components::Nonce;

// Create a nonce from a byte array
let data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
let nonce = Nonce::from_data(data);

// Access the nonce data
let nonce_data = nonce.data();

Converting to and from hexadecimal representation:

use bc_components::Nonce;

// Create a nonce and convert to hex
let nonce = Nonce::new();
let hex_string = nonce.hex();

// Create a nonce from hex
let nonce_from_hex = Nonce::from_hex(&hex_string);
assert_eq!(nonce, nonce_from_hex);

Implementations

impl Nonce

pub const NONCE_SIZE: usize = 12usize

pub fn new() -> Self

Create a new random nonce.

pub const fn from_data(data: [u8; 12]) -> Self

Restores a nonce from data.

pub fn from_data_ref(data: impl AsRef<[u8]>) -> Result<Self>

Restores a nonce from data.

pub fn data(&self) -> &[u8; 12]

Get the data of the nonce.

pub fn from_hex(hex: impl AsRef<str>) -> Self

Create a new nonce from the given hexadecimal string.

Panics

Panics if the string is not exactly 24 hexadecimal digits.

pub fn hex(&self) -> String

The data as a hexadecimal string.

Trait Implementations

impl AsRef<Nonce> for Nonce

Provides a self-reference, enabling API consistency with other types.

fn as_ref(&self) -> &Self

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

impl CBORTagged for Nonce

Identifies the CBOR tags used for Nonce serialization.

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags associated with this type.

impl CBORTaggedDecodable for Nonce

Defines how a Nonce is decoded from CBOR.

fn from_untagged_cbor(untagged_cbor: CBOR) -> Result<Self>

Creates an instance of this type by decoding it from untagged CBOR.

fn from_tagged_cbor(cbor: CBOR) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from tagged CBOR.

fn from_tagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded tagged CBOR.

fn from_untagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded untagged CBOR.

impl CBORTaggedEncodable for Nonce

Defines how a Nonce is encoded as CBOR (as a byte string).

fn untagged_cbor(&self) -> CBOR

Returns the untagged CBOR encoding of this instance.

fn tagged_cbor(&self) -> CBOR

Returns the tagged CBOR encoding of this instance.

fn tagged_cbor_data(&self) -> Vec<u8>

Returns the tagged value in CBOR binary representation.

impl Clone for Nonce

fn clone(&self) -> Nonce

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Nonce

Provides a debug representation showing the nonce’s hexadecimal value.

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

Formats the value using the given formatter.

impl Default for Nonce

Provides a default implementation that creates a new random nonce.

fn default() -> Self

Returns the “default value” for a type.

impl<'a> From<&'a Nonce> for &'a [u8; 12]

Allows accessing the underlying data as a fixed-size byte array reference.

fn from(value: &'a Nonce) -> Self

Converts to this type from the input type.

impl From<&Nonce> for Nonce

Enables cloning a Nonce from a reference using From trait.

fn from(nonce: &Nonce) -> Self

Converts to this type from the input type.

impl From<&Nonce> for Vec<u8>

Converts a Nonce reference into a Vec<u8> containing the nonce bytes.

fn from(nonce: &Nonce) -> Self

Converts to this type from the input type.

impl From<Nonce> for CBOR

Enables conversion of a Nonce into a tagged CBOR value.

fn from(value: Nonce) -> Self

Converts to this type from the input type.

impl From<Nonce> for Vec<u8>

Converts a Nonce into a Vec<u8> containing the nonce bytes.

fn from(nonce: Nonce) -> Self

Converts to this type from the input type.

impl From<Rc<Nonce>> for Nonce

Converts an Rc-wrapped Nonce into a Nonce by cloning the inner value.

fn from(value: Rc<Nonce>) -> Self

Converts to this type from the input type.

impl PartialEq for Nonce

fn eq(&self, other: &Nonce) -> 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 TryFrom<CBOR> for Nonce

Enables conversion from CBOR to Nonce, with proper error handling.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(cbor: CBOR) -> Result<Self>

Performs the conversion.

impl Eq for Nonce

impl StructuralPartialEq for Nonce