Replay Attack in Buffalo with Hmac Signatures

A replay attack in a Buffalo application that uses Hmac Signatures occurs when an attacker intercepts a valid request—typically including a signature, timestamp, and possibly a nonce—and re-sends it to the server to perform an unintended action. Because Hmac Signatures rely on a shared secret to sign a canonical string of the request (often including method, path, parameters, and timestamp), replayed requests can appear valid if the server does not enforce strict freshness controls.

Buffalo does not provide built-in replay protection; it relies on the developer to design safeguards when using Hmac Signatures. If the server validates the signature and timestamp with a loose or missing tolerance window, an attacker can reuse a captured request within the allowed time drift. For example, an API endpoint that accepts a payment or changes state without ensuring one-time use of a nonce or a strict timestamp window is susceptible.

The vulnerability is amplified when the signature covers only static parts of the request (e.g., path and static headers) and omits a nonce or request-specific random value. An attacker can repeatedly present the same signed payload, and if the server processes it multiple times, the operation is replayed. This is especially dangerous for idempotency-unsafe actions when the signature scheme does not incorporate a server-side or distributed cache of recently seen nonces or digests.

Because Hmac Signatures require the server to recompute the signature using the shared secret, any deviation in the canonicalization process can lead to inconsistent validation that either rejects valid requests or, worse, accepts tampered ones. If the server does not explicitly reject requests with timestamps outside a tight window (for example, five minutes) or does not track used nonces, the attack surface remains open. MiddleBrick scans can detect such design weaknesses by analyzing the API specification and runtime behavior, highlighting missing replay mitigations in the context of authentication and input validation checks.

To remediate replay attacks in Buffalo when using Hmac Signatures, you must enforce timestamp freshness, include a unique nonce per request, and ensure signature validation logic is strict and side-channel resistant. Below are concrete Go examples that demonstrate a secure pattern using the net/http package and crypto/hmac.

1. Canonicalization and Signature Verification

Create a function that builds the string to sign from the request components and verifies the Hmac signature. This example includes method, path, timestamp, nonce, and a sorted query string to ensure a consistent canonical form.

// buildStringToSign constructs the canonical string used for signing.
// It includes method, path, timestamp, nonce, and sorted query parameters.
func buildStringToSign(r *http.Request, timestamp, nonce string) string {
    var buf bytes.Buffer
    buf.WriteString(r.Method + "\n")
    buf.WriteString(r.URL.Path + "\n")
    buf.WriteString(timestamp + "\n")
    buf.WriteString(nonce + "\n")

    // Collect and sort query keys to ensure deterministic ordering.
    keys := make([]string, 0, len(r.URL.Query()))
    for k := range r.URL.Query() {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        buf.WriteString(k + "=" + r.URL.Query().Get(k) + "&")
    }
    // Remove trailing "&" if any query params exist.
    qs := strings.TrimSuffix(buf.String(), "&\n")
    return qs
}

// verifySignature returns true if the provided signature matches HMAC-SHA256 of the canonical string.
func verifySignature(r *http.Request, timestamp, nonce, receivedSig, secret string) bool {
    const tolerance = 5 * 60 // 5 minutes in seconds
    ts, err := strconv.ParseInt(timestamp, 10, 64)
    if err != nil {
        return false
    }
    // Reject requests too far in the past or future.
    now := time.Now().Unix()
    if math.Abs(float64(now-ts)) > tolerance {
        return false
    }
    expected := computeHmac(buildStringToSign(r, timestamp, nonce), secret)
    return hmac.Equal([]byte(expected), []byte(receivedSig))
}

func computeHmac(msg, secret string) string {
    key := []byte(secret)
    h := hmac.New(sha256.New, key)
    h.Write([]byte(msg))
    return hex.EncodeToString(h.Sum(nil))
}

2. Middleware to Enforce Nonce and Timestamp Validation

Add a Buffalo middleware that checks for nonce reuse (e.g., using a short-lived in-memory cache or a distributed store in clustered deployments) and validates the timestamp window. This prevents replayed requests with valid signatures but stale or duplicate nonces from being processed.

func HmacReplayProtection(next http.Handler) http.Handler {
    seenNonces := cache.New(5*time.Minute, 10*time.Minute) // TTL-based cache for nonces.
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        timestamp := r.Header.Get("X-Request-Timestamp")
        nonce := r.Header.Get("X-Request-Nonce")
        sig := r.Header.Get("X-Request-Signature")
        if timestamp == "" || nonce == "" || sig == "" {
            http.Error(w, "missing security headers", http.StatusBadRequest)
            return
        }
        // Reject duplicate nonces.
        if seenNonces.Exists(nonce) {
            http.Error(w, "replay detected", http.StatusForbidden)
            return
        }
        // Verify signature using a shared secret retrieved securely.
        secret := os.Getenv("HMAC_SHARED_SECRET")
        if !verifySignature(r, timestamp, nonce, sig, secret) {
            http.Error(w, "invalid signature", http.StatusForbidden)
            return
        }
        seenNonces.Set(nonce, "used", cache.DefaultExpiration)
        next.ServeHTTP(w, r)
    })
}

3. Example Request with Headers

Clients should include timestamp, nonce, and signature headers. The server uses these to validate authenticity and freshness.

// Example client request headers:
// X-Request-Timestamp: 1700000000
// X-Request-Nonce: 7b3d9f2a-8c1e-4f6a-bc72-1a2b3c4d5e6f
// X-Request-Signature: 3a7d4e1f8c45b96d1024a67e5f8d9c0b2a1c4d7e8f9a0b1c2d3e4f5a6b7c8d9e

By combining strict timestamp windows, unique nonces, and canonicalization that includes all relevant request components, you significantly reduce the risk of replay attacks in Buffalo applications using Hmac Signatures. MiddleBrick can help surface missing protections by scanning your API spec and runtime behavior, ensuring your authentication and input validation checks cover replay scenarios.