Struct ProtectionData

pub struct ProtectionData {
    pub timestamp: u64,
    pub nonce: String,
    pub signature: String,
}

Authentication data for nonce-based request verification.

This structure contains the cryptographic authentication information that is embedded within or sent alongside application requests. It is specifically designed for nonce-based authentication and replay attack prevention, not as a complete request structure.

Purpose

ProtectionData represents only the authentication portion of a request:

• It does not contain application payload or business logic data
• It focuses solely on cryptographic verification and replay prevention
• It can be embedded in larger request structures or sent as headers

Fields

• timestamp: Unix timestamp (seconds since epoch) when the auth data was created
• nonce: A unique identifier (typically UUID) that prevents request reuse
• signature: HMAC-SHA256 signature that can include various data fields

Serialization

This struct implements Serialize and Deserialize for easy JSON/binary serialization when sending authentication data over the network.

Example

use nonce_auth::{NonceClient, ProtectionData};
use hmac::Mac;

let client = NonceClient::new(b"secret");
let protection_data: ProtectionData = client.create_protection_data(|mac, timestamp, nonce| {
    mac.update(timestamp.as_bytes());
    mac.update(nonce.as_bytes());
}).unwrap();

// Embed in a larger request structure
#[derive(serde::Serialize)]
struct ApiRequest {
    payload: String,
    auth: ProtectionData,
}

let request = ApiRequest {
    payload: "application data".to_string(),
    auth: protection_data,
};

Security Notes

• The timestamp prevents very old authentication attempts from being replayed
• The nonce ensures each authentication attempt is unique and can only be used once
• The signature proves the authentication data hasn’t been tampered with
• The signature algorithm is flexible and can include additional request data

Fields

timestamp: u64

Unix timestamp (seconds since epoch) when this authentication data was created.

Used by the server to validate that the authentication attempt is within the acceptable time window and not too old.

nonce: String

A unique nonce value, typically a UUID string.

This value must be unique and is used to prevent the same authentication data from being processed multiple times.

signature: String

HMAC-SHA256 signature that can include various data fields.

The signature algorithm is flexible and can be customized to include timestamp, nonce, payload, HTTP method, path, or any other relevant data. This proves that the authentication data was created by someone who knows the shared secret and that the included data hasn’t been tampered with.

Trait Implementations

impl Clone for ProtectionData

fn clone(&self) -> ProtectionData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProtectionData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProtectionData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ProtectionData

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

where __S: Serializer,

Serialize this value into the given Serde serializer.