Générateur HMAC

Qu'est-ce que HMAC ?

HMAC (Hash-based Message Authentication Code) est une construction cryptographique définie dans la RFC 2104 qui combine une fonction de hachage avec une clé secrète pour produire une étiquette d'authentification de taille fixe. Contrairement à un simple hachage que n'importe qui peut calculer, un HMAC ne peut être généré et vérifié que par des parties partageant la clé secrète. HMAC est le mécanisme standard pour vérifier à la fois l'intégrité et l'authenticité d'un message — confirmant que les données n'ont pas été altérées et qu'elles ont été produites par un expéditeur de confiance.

L'algorithme HMAC fonctionne avec n'importe quelle fonction de hachage itérative : SHA-256, SHA-384, SHA-512, et même des fonctions héritées comme SHA-1 ou MD5. La construction résultante est désignée par son hachage sous-jacent — HMAC-SHA256, HMAC-SHA384 ou HMAC-SHA512. La preuve de sécurité de HMAC reposant sur la résistance aux collisions et certaines propriétés pseudo-aléatoires de la fonction de hachage, les algorithmes de la famille SHA-2 sont le choix recommandé pour les nouveaux systèmes. HMAC-SHA256 est la variante la plus déployée, utilisée dans AWS Signature V4, les webhooks Stripe, les secrets de webhook GitHub, la signature de requêtes Slack et les JSON Web Tokens (HS256).

La conception de HMAC offre une propriété critique absente du simple hachage : la résistance aux attaques par extension de longueur. Avec SHA-256 seul, un attaquant connaissant H(message) peut calculer H(message || données_attaquant) sans connaître le message original. La structure de double hachage de HMAC (hachage interne et hachage externe avec des clés rembourrées différentes) prévient entièrement cette attaque. C'est pourquoi les schémas de signature d'API utilisent HMAC plutôt que de concaténer une clé secrète au message et d'en hacher le résultat.

Pourquoi utiliser un générateur HMAC en ligne ?

Calculer des signatures HMAC nécessite généralement d'écrire du code ou d'utiliser des outils CLI. Ce générateur HMAC fonctionnant dans le navigateur vous permet de créer des signatures HMAC-SHA256, HMAC-SHA384 et HMAC-SHA512 instantanément, sans installer de logiciel ni ouvrir un terminal.

Cas d'usage du générateur HMAC

HMAC vs Hachage simple vs Chiffrement

HMAC, le hachage simple et le chiffrement servent des objectifs différents. HMAC fournit l'authentification du message — la preuve qu'il a été créé par quelqu'un possédant la clé secrète et n'a pas été modifié. Un hachage simple garantit l'intégrité mais pas l'authenticité. Le chiffrement assure la confidentialité. Le tableau ci-dessous clarifie ces distinctions.

Comparaison des algorithmes HMAC

HMAC peut utiliser n'importe quelle fonction de hachage, mais le choix de l'algorithme sous-jacent détermine la taille de la sortie, le niveau de sécurité et la compatibilité avec le navigateur. HMAC-SHA256 est le choix le plus courant pour les nouveaux systèmes. Le tableau ci-dessous compare les variantes que vous êtes susceptible de rencontrer.

Fonctionnement interne de HMAC

HMAC applique la fonction de hachage sous-jacente deux fois avec deux remplissages dérivés de la clé. La construction est définie dans la RFC 2104 et s'avère être une PRF (fonction pseudo-aléatoire) sous les hypothèses cryptographiques standard. La clé est d'abord rembourrée ou hachée pour correspondre à la taille de bloc de la fonction de hachage (64 octets pour SHA-256, 128 octets pour SHA-512).

L'algorithme effectue un XOR de la clé rembourrée avec une constante de remplissage interne (ipad, 0x36 répété), la concatène avec le message et hache le résultat. Il effectue ensuite un XOR de la clé rembourrée avec une constante de remplissage externe (opad, 0x5C répété), la concatène avec la sortie du hachage interne et hache à nouveau. Cette structure de double hachage est ce qui empêche les attaques par extension de longueur et garantit que la sortie HMAC ne peut pas être calculée sans connaissance de la clé secrète.

Exemples de code HMAC

HMAC est supporté nativement dans tous les langages et runtimes majeurs. L'API Web Crypto fournit HMAC-SHA256, HMAC-SHA384 et HMAC-SHA512 dans les navigateurs sans aucune bibliothèque. Les exemples ci-dessous montrent des patterns d'utilisation réels, notamment la vérification de webhook et la comparaison en temps constant.

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)"

Foire aux questions