Unicode Normalization in Buffalo with Hmac Signatures

Buffalo is a Go web framework commonly used to build APIs. When HMAC signatures are used for request authentication, relying on raw, unnormalized input can lead to signature validation bypasses due to Unicode equivalence. An attacker can provide semantically identical but differently encoded Unicode characters in paths, query parameters, or headers, causing the server to compute a different HMAC than the expected value while the application logic treats the request as valid.

For example, the character é can be represented as a single code point U+00E9 (LATIN SMALL LETTER E WITH ACUTE) or as the two-code-point sequence U+0065 (LATIN SMALL LETTER E) followed by U+0301 (COMBINING ACUTE ACCENT). These are canonically equivalent but produce different byte representations. If the signature is computed over the raw, unnormalized request target (path + query) or over selected headers without normalization, two requests that resolve to the same logical resource may carry different HMACs. The server may fail to normalize before signing or verification, enabling an attacker to forge requests that pass signature checks while bypassing intended access controls or integrity checks.

In the context of an API security scan, this manifests as a BOLA/IDOR or Authentication finding when canonicalization differences allow unauthorized access across equivalent resource identifiers. Because the signature does not protect against these alternate representations, the integrity guarantee of HMAC is weakened. MiddleBrick tests for such inconsistencies by correlating OpenAPI/Swagger spec definitions with runtime behavior, including checks for input validation and authentication weaknesses that can be exploited through encoding variations.

Remediation requires normalizing the signed data to a canonical Unicode form before computing or verifying HMAC signatures. Use a consistent form, such as NFC or NFD, across all signature operations. For Buffalo applications, this typically means normalizing any user-controlled input that participates in signature generation, including path parameters, query strings, and selected headers.

Below are concrete, working examples in Go using the golang.org/x/text/unicode/norm package to apply NFC normalization before HMAC signing and verification.

Example 1: Normalizing the request path + query before signing

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "golang.org/x/text/unicode/norm"
    "strings"
)

func computeSignature(secret, method, path, query string) string {
    // Normalize path and query separately to NFC
    normPath := norm.String(norm.NFC, path)
    normQuery := norm.String(norm.NFC, query)
    message := method + ":" + normPath + "?" + normQuery
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(message))
    return hex.EncodeToString(mac.Sum(nil))
}

func verifySignature(secret, method, path, query, receivedSig string) bool {
    expected := computeSignature(secret, method, path, query)
    return hmac.Equal([]byte(expected), []byte(receivedSig))
}

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "golang.org/x/text/unicode/norm"
)

func signatureBaseString(secret, contentType, payload string) string {
    normContentType := norm.String(norm.NFC, contentType)
    normPayload := norm.String(norm.NFC, payload)
    return "content-type:" + normContentType + ":" + normPayload
}

func signRequest(secret, contentType, payload string) string {
    base := signatureBaseString(secret, contentType, payload)
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(base))
    return hex.EncodeToString(mac.Sum(nil))
}