Générateur HMAC & vérificateur de signature

Qu'est-ce qu'un HMAC ?

const crypto = require('crypto');

// HMAC-SHA256 with a UTF-8 text key, hex output
const hmac = crypto
  .createHmac('sha256', 'my-secret-key')
  .update('Hello, World!')
  .digest('hex');

console.log(hmac);
// → 'cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699'

// Verify a signature in constant time
function verify(message, key, expectedHex) {
  const actual = crypto.createHmac('sha256', key).update(message).digest();
  const expected = Buffer.from(expectedHex, 'hex');
  return actual.length === expected.length &&
    crypto.timingSafeEqual(actual, expected);
}

Fonctionnalités clés

Exemples HMAC

Hello, World!

cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699

{"id":42,"event":"user.created"}

Cd2f7zTKaJFeG6k+t1FcvDPn51OAZ2f4GrxkCUgMhGs=

what do ya want for nothing?

5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843

The quick brown fox

36f44b125a8a90639dc46733039571792e081e0fd8685ff746784b02ed14aa35629d562c7117cde4a701570551faa5a5e1b7ef1eb5c3bcd4cc1fdb8923fcf14e

Comment générer & vérifier un HMAC

1. 1

   Choisir l'algorithme

   Choisissez HMAC-SHA256 (la valeur par défaut et le bon choix pour presque tous les webhooks, API et JWT), ou passez à SHA-1, SHA-384 ou SHA-512 pour correspondre à un système qui l'exige. Les quatre s'exécutent nativement dans votre navigateur via l'API Web Crypto.

2. 2

   Saisir la clé secrète et définir son encodage

   Tapez ou collez votre clé secrète, puis réglez l'encodage de clé pour correspondre à la façon dont le serveur l'interprète : Texte (UTF-8) pour une chaîne ordinaire, Hex pour un bloc hexadécimal, ou Base64 pour un secret en base64. Se tromper ici est la première cause de désaccords HMAC, alors en cas de doute, essayez les trois.

3. 3

   Saisir le message

   Collez les octets exacts que vous voulez signer — pour un webhook, c'est le corps brut de la requête, octet pour octet, sans re-sérialisation ni modification d'espaces. Le HMAC se recalcule en direct au fil de votre édition, sans rien envoyer à un serveur.

4. 4

   Choisir le format de sortie et copier

   Sélectionnez Hex (façon GitHub), Base64 (façon Stripe/AWS) ou Base64URL (façon JWT) pour correspondre à ce qu'attend votre intégration, puis cliquez sur Copier pour récupérer la signature.

5. 5

   Vérifier une signature existante

   Passez à l'onglet Vérifier, collez le HMAC attendu provenant d'un en-tête ou d'un jeton, et l'outil confirme en temps constant si votre signature calculée correspond — vous pouvez ainsi authentifier une charge utile avant d'agir.

Erreurs HMAC courantes

// Server stored a base64 secret but you sign the literal string
createHmac('sha256', 'c2VjcmV0LWtleQ==').update(msg)

// Decode the base64 secret to raw bytes first
createHmac('sha256', Buffer.from('c2VjcmV0LWtleQ==', 'base64')).update(msg)

// Provider sends base64, you compare hex
expected = 'Cd2f7z...=' // base64
actual   = digest('hex') // hex — never matches

// Produce the same encoding the provider uses
actual = digest('base64')

// Re-serialization changes the bytes
body = JSON.stringify(JSON.parse(rawBody))
verify(hmac(body))

// Sign the raw bytes exactly as received
verify(hmac(rawBody))

if (received === computed) { /* trust */ }

if (crypto.timingSafeEqual(receivedBuf, computedBuf)) { /* trust */ }

À quoi sert HMAC

Vérifier les signatures de webhook

Des fournisseurs comme GitHub, Stripe, Slack et Twilio signent chaque webhook avec un HMAC sur le corps de la requête et un secret que vous seul partagez. Recalculez l'étiquette et comparez-la à l'en-tête (par exemple X-Hub-Signature-256) pour confirmer que l'événement est authentique avant d'agir. Utilisez l'onglet Vérifier pour le faire sans écrire de code jetable.

Signer des requêtes d'API

Les API authentifiées exigent souvent que le client signe la requête par HMAC (méthode, chemin, horodatage, corps) avec un secret partagé plutôt que d'envoyer le secret lui-même. AWS Signature Version 4 en est l'exemple canonique. Cet outil vous permet de reproduire et déboguer ces signatures étape par étape.

Garantir l'intégrité des messages

Lorsque vous passez un jeton, un cookie ou un message entre des services, y attacher un HMAC permet au destinataire de détecter toute falsification. Comme l'étiquette dépend d'un secret, un attaquant ne peut pas la recalculer après avoir modifié les données — contrairement à une simple somme de contrôle.

Comprendre la signature HS256 des JWT

Un JWT signé avec HS256 est simplement base64url(en-tête) + '.' + base64url(charge utile), signé avec HMAC-SHA256 et le résultat émis en Base64URL. Réglez l'algorithme sur SHA-256 et la sortie sur Base64URL ici pour voir exactement comment cette signature est produite, puis vérifiez-la dans l'encodeur JWT.

Déboguer une signature qui ne correspond pas

Quand votre HMAC refuse de correspondre à celui du serveur, cet outil est le moyen le plus rapide d'isoler la cause : essayez la clé en Texte, Hex et Base64, basculez la sortie entre Hex et Base64, et confirmez que vous signez exactement les octets bruts — le tout sans redéployer de code.

Comment fonctionne HMAC

Construction RFC 2104

HMAC est défini par H((K ⊕ opad) ‖ H((K ⊕ ipad) ‖ m)), où ipad est l'octet 0x36 répété et opad l'octet 0x5c répété, tous deux à la taille de bloc du hash. Une clé plus longue que la taille de bloc est d'abord hachée ; une clé plus courte est complétée par des zéros. Cette imbrication à deux passes est ce qui confère à HMAC sa preuve de sécurité, laquelle tient même si le hash sous-jacent n'est pas résistant aux collisions.

Pourquoi un hash à clé l'emporte sur un hash simple

Un hash simple ne prouve que l'absence de corruption accidentelle des données, car n'importe qui peut le recalculer pour n'importe quel message — y compris un message falsifié. HMAC y mêle un secret, de sorte que seuls les détenteurs de la clé peuvent produire une étiquette valide. Cela transforme la simple intégrité en intégrité plus authenticité, qui est la propriété dont les webhooks et les requêtes signées ont réellement besoin.

Résistance à l'extension de longueur

Les SHA-1, SHA-256 et SHA-512 nus sont des hashs Merkle–Damgård vulnérables à l'extension de longueur : à partir de H(secret ‖ msg), un attaquant peut calculer H(secret ‖ msg ‖ extra) sans connaître le secret. Les schémas naïfs de « MAC à préfixe secret » sont cassés par cette attaque. Le hachage externe de HMAC neutralise l'attaque, ce qui est la principale raison d'utiliser HMAC plutôt que de hacher ensemble un secret et un message.

Choisir SHA-256 ou SHA-512

HMAC-SHA256 produit une étiquette de 256 bits (64 caractères hex) et constitue la valeur par défaut pour l'interopérabilité — rapide, omniprésente et prise en charge partout. HMAC-SHA512 produit une étiquette de 512 bits (128 caractères hex) et est souvent plus rapide sur les processeurs 64 bits, car SHA-512 utilise des mots de 64 bits. Choisissez SHA-256 sauf si une spécification ou un système pair exige SHA-512 ; les deux sont sûrs pour l'authentification.

Implémentation Web Crypto

Cet outil appelle crypto.subtle.importKey pour charger votre clé (décodée depuis Texte, Hex ou Base64) et crypto.subtle.sign('HMAC', ...) pour calculer l'étiquette, puis encode les octets bruts en Hex, Base64 ou Base64URL. C'est la même implémentation native et auditée que le navigateur utilise pour TLS, exécutée en dehors du moteur JavaScript pour plus de rapidité.

Bonnes pratiques HMAC

Utiliser une clé au moins aussi longue que la sortie du hash

Pour HMAC-SHA256, utilisez un secret d'au moins 32 octets aléatoires (256 bits) ; pour SHA-512, utilisez-en 64. Une clé courte ou à faible entropie est le maillon faible. Générez les clés depuis une source aléatoire cryptographiquement sûre — jamais un mot de passe ou une chaîne prévisible.

Toujours comparer les étiquettes en temps constant

Vérifiez les signatures avec une comparaison en temps constant (crypto.timingSafeEqual en Node, hmac.compare_digest en Python) plutôt qu'avec == ou l'égalité de chaînes. Une comparaison naïve s'arrête dès le premier octet différent, révélant un timing qui peut permettre à un attaquant de retrouver une étiquette valide octet par octet. L'onglet Vérifier de cet outil compare déjà en temps constant.

Ne jamais journaliser ni exposer la clé secrète

Tenez les secrets de signature hors des logs, des messages d'erreur, des URL et du code côté client. Stockez-les dans un gestionnaire de secrets ou des variables d'environnement, faites-les tourner périodiquement, et limitez chaque intégration à sa propre clé pour qu'une seule fuite ne compromette pas tout.

Préférer HMAC-SHA256 ou plus fort

Optez par défaut pour HMAC-SHA256 ; montez à SHA-384 ou SHA-512 quand un pair l'exige. Évitez HMAC-SHA1 pour les nouveaux systèmes et n'utilisez jamais HMAC-MD5. Même si HMAC tolère mieux un hash plus faible qu'une signature brute, partir d'un hash moderne vous donne la plus grande marge.

Signer les octets exacts, horodatage inclus

Signez la charge utile brute et non modifiée — re-sérialiser le JSON ou rogner les espaces change les octets et casse la vérification. Pour la signature de requêtes, incluez un horodatage ou un nonce dans les données signées et rejetez les signatures périmées pour prévenir les attaques par rejeu.

FAQ HMAC