Generatore HMAC

Cos'è HMAC?

HMAC (Hash-based Message Authentication Code) è una costruzione crittografica definita nell'RFC 2104 che combina una funzione hash con una chiave segreta per produrre un tag di autenticazione di dimensione fissa. A differenza di un hash semplice, che chiunque può calcolare, un HMAC può essere generato e verificato solo dalle parti che condividono la chiave segreta. HMAC è il meccanismo standard per verificare sia l'integrità che l'autenticità di un messaggio — confermando che i dati non sono stati alterati e che provengono da un mittente affidabile.

L'algoritmo HMAC funziona con qualsiasi funzione hash iterativa: SHA-256, SHA-384, SHA-512 e persino funzioni legacy come SHA-1 o MD5. Il risultato viene identificato dalla funzione sottostante — HMAC-SHA256, HMAC-SHA384 o HMAC-SHA512. Poiché la sicurezza di HMAC dipende dalla resistenza alle collisioni della funzione hash e da certe proprietà pseudocasuali, gli algoritmi della famiglia SHA-2 sono la scelta raccomandata per i nuovi sistemi. HMAC-SHA256 è la variante più diffusa, usata in AWS Signature V4, i webhook di Stripe, i segreti webhook di GitHub, la firma delle richieste di Slack e i JSON Web Token (HS256).

Il design di HMAC offre una proprietà critica che il semplice hashing non ha: la resistenza agli attacchi di estensione della lunghezza. Con SHA-256 da solo, un attaccante che conosce H(messaggio) può calcolare H(messaggio || dati_attaccante) senza conoscere il messaggio originale. La struttura a doppio hashing di HMAC (hash interno e hash esterno con chiavi con padding differenti) previene completamente questo attacco. Ecco perché gli schemi di firma API usano HMAC invece di concatenare una chiave segreta al messaggio e calcolarne l'hash.

Perché usare un generatore HMAC online?

Il calcolo delle firme HMAC richiede normalmente di scrivere codice o usare strumenti da riga di comando. Questo generatore HMAC basato su browser ti consente di creare firme HMAC-SHA256, HMAC-SHA384 e HMAC-SHA512 immediatamente, senza installare software o passare al terminale.

Casi d'uso del Generatore HMAC

HMAC vs Hash Semplice vs Cifratura

HMAC, l'hashing semplice e la cifratura servono a scopi diversi. HMAC fornisce autenticazione dei messaggi — la prova che il messaggio è stato creato da qualcuno con la chiave segreta e non è stato modificato. Un hash semplice fornisce integrità ma non autenticazione. La cifratura fornisce riservatezza. La tabella seguente chiarisce le distinzioni.

Confronto degli Algoritmi HMAC

HMAC può usare qualsiasi funzione hash, ma la scelta dell'algoritmo sottostante determina la dimensione dell'output, il livello di sicurezza e la compatibilità con il browser. HMAC-SHA256 è la scelta più comune per i nuovi sistemi. La tabella seguente confronta le varianti che probabilmente incontrerai.

Come Funziona HMAC Internamente

HMAC applica la funzione hash sottostante due volte con due padding derivati dalla chiave diversi. La costruzione è definita nell'RFC 2104 ed è dimostrata essere una PRF (funzione pseudocasuale) in base alle ipotesi crittografiche standard. La chiave viene prima riempita con padding o hashata per corrispondere alla dimensione del blocco della funzione hash (64 byte per SHA-256, 128 byte per SHA-512).

L'algoritmo esegue l'XOR della chiave con padding con una costante di padding interno (ipad, 0x36 ripetuto), la concatena con il messaggio e ne calcola l'hash. Poi esegue l'XOR della chiave con padding con una costante di padding esterno (opad, 0x5C ripetuto), la concatena con l'output dell'hash interno e calcola nuovamente l'hash. Questa struttura a doppio hashing è ciò che previene gli attacchi di estensione della lunghezza e garantisce che l'output HMAC non possa essere calcolato senza conoscere la chiave segreta.

Esempi di Codice HMAC

HMAC è supportato nativamente in tutti i principali linguaggi e runtime. La Web Crypto API fornisce HMAC-SHA256, HMAC-SHA384 e HMAC-SHA512 nei browser senza alcuna libreria. Gli esempi seguenti mostrano pattern di utilizzo reali, inclusa la verifica dei webhook e il confronto a tempo costante.

async function hmacSHA256(message, secret) {
  const enc = new TextEncoder()
  const key = await crypto.subtle.importKey(
    'raw', enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false, ['sign']
  )
  const sig = await crypto.subtle.sign('HMAC', key, enc.encode(message))
  return Array.from(new Uint8Array(sig))
    .map(b => b.toString(16).padStart(2, '0')).join('')
}

await hmacSHA256('hello world', 'my-secret-key')
// → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHmac('sha256', 'my-secret-key')
  .update('hello world').digest('hex')
// → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

import hmac
import hashlib

# HMAC-SHA256
sig = hmac.new(
    b'my-secret-key',
    b'hello world',
    hashlib.sha256
).hexdigest()
print(sig)
# → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

# Verify a webhook signature (constant-time comparison)
expected = "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"
received = hmac.new(b'my-secret-key', b'hello world', hashlib.sha256).hexdigest()
if hmac.compare_digest(expected, received):
    print("Signature valid")

# HMAC-SHA512
hmac.new(b'key', b'data', hashlib.sha512).hexdigest()

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "fmt"
)

func main() {
    mac := hmac.New(sha256.New, []byte("my-secret-key"))
    mac.Write([]byte("hello world"))
    sig := mac.Sum(nil)
    fmt.Printf("%x\n", sig)
    // → 90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad

    // Verify: use hmac.Equal for constant-time comparison
    expected := mac.Sum(nil)
    fmt.Println(hmac.Equal(sig, expected)) // true
}

# HMAC-SHA256
echo -n "hello world" | openssl dgst -sha256 -hmac "my-secret-key"
# → SHA2-256(stdin)= 90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad

# HMAC-SHA512
echo -n "hello world" | openssl dgst -sha512 -hmac "my-secret-key"

# Verify a file signature
openssl dgst -sha256 -hmac "my-secret-key" release.tar.gz

# HMAC with hex key (e.g. from a webhook secret)
echo -n "payload" | openssl dgst -sha256 -hmac "$(echo -n '736563726574' | xxd -r -p)"

Domande Frequenti