Integer Overflow in Gorilla Mux with Hmac Signatures

When an API uses Gorilla Mux for routing and HMAC signatures for request authentication, integer overflow can arise during signature length or timestamp arithmetic, creating a path to bypass or weaken authentication. This typically occurs when user-controlled numeric values (e.g., timestamps, counters, or payload-size fields) are used in hash computation or comparison without proper bounds checking.

Consider an endpoint that signs a request using a timestamp parameter parsed from the query string with Gorilla Mux variables. If the timestamp is stored in a small integer type and an attacker provides a very large value, an integer overflow can wrap the value, causing it to appear valid and within an acceptable time window. Because HMAC verification depends on consistent inputs, the wrapped timestamp may still produce a valid signature match, leading to authentication bypass or time-based replay windows expanding far beyond intended limits.

Another scenario involves signature length or key-derivation iterations. If the code computes a buffer size based on an integer that can overflow before allocation, an attacker may trigger unexpected behavior or information leaks indirectly through error handling or memory layout changes. While HMAC itself does not overflow, the surrounding logic that parses, truncates, or compares numeric fields tied to the signed payload becomes vulnerable when integer types cannot hold attacker-controlled values.

In the context of Gorilla Mux, route variables and query parameters are often bound directly into handler functions. If these values participate in HMAC input construction or time-window checks without sanitization or use of safe arithmetic, the attack surface expands. For example, an integer used to compute a rolling window for signature validity may wrap and accept an expired timestamp, undermining replay protection. This is an implementation flaw in how numeric values are handled around HMAC, not a flaw in HMAC itself, but it can compromise the integrity guarantees the signature scheme is meant to provide.

Real-world parallels include classes in the OWASP API Top 10 addressing security misconfigures and insufficient logging/monitoring, where unchecked numeric inputs lead to authentication weaknesses. Patterns resembling CVE-type issues involving integer overflow in routing and signature verification have been observed in frameworks when bounds validation is omitted. The risk is especially relevant when combined with time-sensitive replay checks, where an overflow can extend acceptable windows dramatically.

Remediation focuses on validating and sanitizing all numeric inputs before they influence HMAC computation or time-based checks, using constant-time comparison for signatures, and avoiding integer types that can overflow.

Example 1: Safe timestamp parsing and HMAC verification in Gorilla Mux

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"math"
	"net/http"
	"strconv"
	"time"

	"github.com/gorilla/mux"
)

func verifyHMAC(secret, message, receivedSig string) bool {
	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(message))
	expected := hex.EncodeToString(h.Sum(nil))
	return hmac.Equal([]byte(expected), []byte(receivedSig))
}

func handler(secret string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		tsStr := vars["ts"]
		receivedSig := r.Header.Get("X-Signature")

		ts, err := strconv.ParseInt(tsStr, 10, 64)
		if err != nil {
			http.Error(w, "invalid timestamp", http.StatusBadRequest)
			return
		}

		// Prevent negative timestamps and unreasonable far-future values
		now := time.Now().Unix()
		if ts < 0 || ts > now+300 {
			http.Error(w, "timestamp out of range", http.StatusForbidden)
			return
		}

		// Use int64 safely; ensure no overflow in concatenation
		message := fmt.Sprintf("ts=%d", ts)
		if !verifyHMAC(secret, message, receivedSig) {
			http.Error(w, "invalid signature", http.StatusForbidden)
			return
		}

		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	}
}

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/api/endpoint/{ts}", handler("my-32-byte-secret-key-123456789012")).Methods("GET
		http.ListenAndServe(":8080", r)
}

Example 2: Using uint64 with explicit checks to avoid overflow in size-derived values

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"net/http"

	"github.com/gorilla/mux"
)

func safeHash(data []byte) []byte {
	h := sha256.New()
	h.Write(data)
	return h.Sum(nil)
}

func verifyHMACFixed(secret, payload, receivedSig string) bool {
	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(payload))
	expected := hex.EncodeToString(h.Sum(nil))
	return hmac.Equal([]byte(expected), []byte(receivedSig))
}

func handlerFixed(secret string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		lengthStr := vars["length"]
		receivedSig := r.Header.Get("X-Signature")

		length, err := strconv.ParseUint(lengthStr, 10, 32)
		if err != nil || length == 0 || length > 1024*1024 {
			http.Error(w, "invalid length", http.StatusBadRequest)
			return
		}

		// Build payload safely without integer overflow in sizing
		payload := fmt.Sprintf("fixed=data&len=%d", length)
		if !verifyHMACFixed(secret, payload, receivedSig) {
			http.Error(w, "invalid signature", http.StatusForbidden)
			return
		}

		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	}
}

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/api/safe/{length}", handlerFixed("another-secure-key-abcdef")).Methods("GET")
	http.ListenAndServe(":8081", r)
}

Key remediation practices

• Parse numeric route/query values into int64 or uint64 with explicit range checks; reject negatives or unreasonably large values.
• Avoid using unsigned types for values that may be used in arithmetic with signed inputs; prefer explicit casts and overflow checks.
• Use constant-time comparison (hmac.Equal) for signature verification to prevent timing attacks.
• Limit maximum sizes for length-derived buffers to prevent resource exhaustion even if integer math is safe.
• Validate and sanitize all inputs before they participate in HMAC construction, regardless of routing framework.