Struct MessageAuthenticator 

pub struct MessageAuthenticator { /* private fields */ }

Production-quality message authenticator with:

• HMAC-FNV64 signing / verification (three algorithm variants).
• Replay attack prevention via a bounded nonce window.
• Key expiry and atomic key rotation.
• Configurable AuthPolicy enforcement.
• Monotonic per-key sequence numbers.
• Cumulative statistics and drainable audit log.

Example

use ipfrs_network::message_authenticator::{
    AuthAlgorithm, AuthKey, AuthPolicy, MessageAuthenticator,
};

let mut auth = MessageAuthenticator::new(vec![AuthPolicy::RequireAll], 256);
let key = AuthKey::new("k1", b"super-secret".to_vec(), 0, None, AuthAlgorithm::HmacFnv64);
auth.add_key(key).unwrap();
let msg = auth.sign(b"hello world".to_vec(), "k1", 1_000_000).unwrap();
auth.verify(&msg, 1_000_000).unwrap();

Implementations

impl MessageAuthenticator

pub fn new(policies: Vec<AuthPolicy>, replay_window_size: usize) -> Self

Create a new MessageAuthenticator.

• policies — list of AuthPolicy variants to enforce.
• replay_window_size — maximum number of nonces retained for replay detection.

Panics

Does not panic; replay_window_size == 0 is accepted but provides no replay protection.

pub fn add_key(&mut self, key: AuthKey) -> Result<(), AuthError>

Add a new key to the keystore.

Fails with AuthError::KeyNotFound if a key with the same ID already exists (use rotate_key for atomic replacement).

pub fn remove_key(&mut self, key_id: &str) -> Result<(), AuthError>

Remove a key from the keystore.

Returns AuthError::KeyNotFound if no such key exists.

pub fn rotate_key( &mut self, old_id: &str, new_key: AuthKey, ) -> Result<(), AuthError>

Atomically replace the key identified by old_id with new_key.

The sequence counter is reset to 1 for the new key. Returns AuthError::KeyNotFound if old_id is not in the keystore.

pub fn sign( &mut self, payload: Vec<u8>, key_id: &str, current_ts: u64, ) -> Result<SignedMessage, AuthError>

Sign payload using the key identified by key_id.

• A fresh nonce is generated via xorshift64.
• The signature is computed per the key’s AuthAlgorithm.
• The per-key sequence counter is incremented atomically.

Errors

• AuthError::KeyNotFound — unknown key.
• AuthError::KeyExpired — key has passed its expiry.
• AuthError::NonceExhausted — PRNG state wrapped to zero (extremely unlikely in practice).
• AuthError::KeyRotationRequired — (via policy check) key age exceeds the rotation threshold.

pub fn verify( &mut self, msg: &SignedMessage, current_ts: u64, ) -> Result<(), AuthError>

Verify the authenticity of msg at time current_ts.

Checks (in order):

1. Key exists in the keystore.
2. Key has not expired.
3. Nonce has not been replayed.
4. Sequence number is valid (when SequentialNonce policy is active).
5. Signature matches the recomputed value.

On success the nonce is recorded and statistics are updated.

pub fn check_replay(&self, nonce: u64) -> bool

Return true if nonce is present in the current replay window.

pub fn record_nonce(&mut self, nonce: u64)

Add nonce to the replay window, evicting the oldest entry if full.

pub fn expire_keys(&mut self, current_ts: u64) -> Vec<String>

Remove all keys whose expires_at is ≤ current_ts.

Returns the IDs of all removed keys.

pub fn stats(&self) -> AuthStats

Return a snapshot of the current cumulative statistics.

pub fn drain_events(&mut self) -> Vec<String>

Drain the internal audit log, returning all accumulated events.

The log is cleared after this call.

pub fn key_count(&self) -> usize

Return the number of keys currently in the keystore.

pub fn has_key(&self, key_id: &str) -> bool

Return true if a key with key_id is currently registered.

Trait Implementations

impl Debug for MessageAuthenticator

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

Formats the value using the given formatter.