Replay Attack in Actix with Hmac Signatures

A replay attack occurs when an adversary intercepts a valid request and retransmits it to reproduce the intended effect without going through the authentication logic. In Actix-based services that rely on Hmac Signatures for request integrity, a common pattern is to sign a canonical string that includes a timestamp and a nonce. If the server only validates the Hmac correctly but does not enforce strict freshness constraints on the timestamp and does not enforce global nonce uniqueness, an attacker can capture a legitimately signed request and replay it later. The signature remains valid because the Hmac over the same canonical data and shared secret does not change, and the server may accept the request as long as the timestamp is within a loosely configured window.

Actix web applications often implement Hmac Signatures by concatenating a timestamp, a nonce, and the request payload, then computing a SHA-256 Hmac with a shared secret. The server then recomputes the Hmac and compares it in constant time. The vulnerability arises when the implementation treats a matching Hmac as sufficient proof of authenticity without ensuring that the same timestamp-nonce combination has not been seen recently. For example, if the server accepts timestamps with a generous skew window (e.g., five minutes) and does not track previously used nonces, an attacker can record a request signed at time T and replay it within that window. Because the server will accept T as fresh, the request is processed as intended by the original sender, potentially leading to duplicate transactions, unauthorized state changes, or privilege escalation.

Real-world impacts include unauthorized fund transfers, repeated API calls that consume resources, and circumvention of rate-limiting mechanisms. This pattern is especially problematic when the Hmac scheme does not incorporate a server-side nonce or when the server’s nonce cache is too small or improperly invalidated. Even with proper timestamp validation, an attacker can exploit weak entropy in nonce generation or predictable nonce values to mount replay attempts. Because Actix middleware typically validates signatures early in the request pipeline, a replayed request may proceed to business logic handlers before being rejected, amplifying the risk.

To mitigate replay attacks in Actix when using Hmac Signatures, you must enforce timestamp freshness with a tight tolerance and maintain a server-side cache of recently used nonces. Below are concrete, realistic code examples that demonstrate a secure approach using Actix web and the hmac and sha2 crates.

First, define your shared secret and a structure for validated claims:

use hmac::{Hmac, Mac};
use sha2::Sha256;
use std::collections::HashSet;
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};

type HmacSha256 = Hmac<Sha256>;

struct NonceCache {
    seen: HashSet<String>,
}

struct AppState {
    mac_key: Vec<u8>,
    nonces: Arc<Mutex<NonceCache>>,
    timestamp_window_secs: u64,
}

Next, implement request validation that checks both timestamp and nonce uniqueness. This handler demonstrates how to parse headers, verify the Hmac, and reject replays:

use actix_web::{web, HttpRequest, HttpResponse, Error};
use serde::Deserialize;

#[derive(Deserialize)]
struct SignedRequest {
    timestamp: u64,
    nonce: String,
    payload: String,
    signature: String,
}

async fn handle_signed_request(
    req: HttpRequest,
    body: web::Json<SignedRequest>,
    data: web::Data<Arc<AppState>>,
) -> Result<HttpResponse, Error> {
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs();

    // 1) Check timestamp freshness
    if data.timestamp_window_secs == 0 {
        return Ok(HttpResponse::BadRequest().body("clock skew not allowed"));
    }
    if (body.timestamp as i64 - now as i64).abs() > data.timestamp_window_secs as i64 {
        return Ok(HttpResponse::Unauthorized().body("timestamp outside tolerance"));
    }

    // 2) Ensure nonce has not been used recently
    let mut nonces = data.nonces.lock().unwrap();
    if nonces.seen.contains(&body.nonce) {
        return Ok(HttpResponse::Unauthorized().body("replay detected: nonce used"));
    }
    nonces.seen.insert(body.nonce.clone());

    // 3) Recompute Hmac and verify
    let mut mac = HmacSha256::new_from_slice(&data.mac_key)
        .map_err(|_| actix_web::error::ErrorInternalServerError("hmac init failed"))?;
    let canonical = format!(