Authentification HMAC
HMAC(K, m) = H((K' XOR opad) || H((K' XOR ipad) || m)), où K' est la clé secrète ajustée à la taille de bloc de la fonction de hachage H
Calculez le HMAC d’un message avec une clé secrète, en hexadécimal ou en Base64, et comparez-le à une signature attendue (préfixe sha256= accepté) pour vérifier un webhook GitHub, Stripe ou Shopify.
Hexadécimal ou Base64, avec ou sans préfixe comme sha256=.
Cet outil calcule le HMAC d’un message avec une clé secrète, en SHA-1, SHA-256, SHA-384 ou SHA-512, et le compare à une signature attendue. Il s’adresse surtout aux développeurs qui intègrent ou déboguent des webhooks GitHub, Stripe ou Shopify et veulent savoir si l’échec vient du secret, du corps du message ou de leur code.
Un HMAC (RFC 2104, FIPS 198-1) combine une fonction de hachage et une clé secrète : HMAC(K, m) = H((K ⊕ opad) ‖ H((K ⊕ ipad) ‖ m)). Cette double passe rend la valeur impossible à produire sans la clé et évite l’attaque par extension de longueur qui touche un simple SHA-256(clé ‖ message). Avec la clé « key » et le message « The quick brown fox jumps over the lazy dog », HMAC-SHA-256 donne f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8 en hexadécimal, soit 97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg= en Base64. La clé est utilisée telle que saisie, le message et la clé sont encodés en UTF-8, et le calcul passe par l’API Web Crypto du navigateur.
La plupart des fournisseurs signent le corps brut de la requête. GitHub envoie X-Hub-Signature-256: sha256=<hex>, Shopify envoie X-Shopify-Hmac-Sha256 en Base64, et Stripe signe la chaîne « horodatage.corps » et place la valeur hexadécimale après v1= dans l’en-tête Stripe-Signature. Choisissez donc la sortie hexadécimale ou Base64 selon le fournisseur, puis collez la signature reçue dans le champ facultatif : les préfixes comme « sha256= » sont acceptés et le verdict se met à jour à chaque frappe. La comparaison est effectuée en temps constant, comme GitHub le recommande pour le code serveur.
Collez le message exact à signer, par exemple le corps brut d’un webhook, puis la clé secrète partagée.
Sélectionnez SHA-1, SHA-256, SHA-384 ou SHA-512 et une sortie hexadécimale ou Base64 selon ce qu’attend le service.
Collez si besoin la signature attendue, avec ou sans préfixe comme sha256= : le HMAC et le résultat de la vérification se mettent à jour pendant la saisie.
HMAC(K, m) = H((K' XOR opad) || H((K' XOR ipad) || m)), où K' est la clé secrète ajustée à la taille de bloc de la fonction de hachage H
Copiez le payload brut et l’en-tête X-Hub-Signature-256 depuis l’onglet Recent Deliveries du webhook, saisissez le secret et comparez. Si la valeur correspond ici mais pas sur votre serveur, c’est votre framework qui modifie le corps avant la vérification.
Reconstituez la chaîne signée « t.corps » à partir de l’en-tête Stripe-Signature et du corps brut, calculez le HMAC-SHA-256 avec votre secret whsec_… et comparez-le à la valeur v1 pour isoler l’origine d’un échec de vérification.
Shopify signe le corps brut en HMAC-SHA-256 et transmet le résultat en Base64 dans X-Shopify-Hmac-Sha256. Choisissez la sortie Base64 et collez l’en-tête pour confirmer que vous utilisez le bon secret d’application.
Entrée
Message : The quick brown fox jumps over the lazy dog ; Clé secrète : key ; Algorithme : SHA-256 ; Encodage : HexadécimalRésultat
Signature calculée : f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8Un hash comme SHA-256 peut être calculé par n’importe qui : il prouve l’intégrité, pas l’origine. Un HMAC ajoute une clé secrète, si bien que seul un détenteur de cette clé peut produire la bonne valeur. Il authentifie donc l’expéditeur en plus de détecter toute modification.
Le plus souvent, le corps a été modifié avant le calcul : JSON analysé puis resérialisé par le framework, encodage changé ou espaces ajoutés. Les autres causes fréquentes sont un mauvais secret (celui de test au lieu de celui de production), un mauvais format de sortie (hex au lieu de Base64) ou, pour Stripe, l’oubli de l’horodatage dans la chaîne signée.
Pour authentifier des messages, oui : les collisions de SHA-1 ne permettent pas de forger un HMAC-SHA-1 sans la clé, et il reste utilisé, par exemple par TOTP. Pour tout nouveau système, préférez néanmoins HMAC-SHA-256, devenu le standard des webhooks. GitHub ne conserve l’en-tête X-Hub-Signature en SHA-1 que pour la compatibilité.
La RFC 2104 recommande une clé au moins aussi longue que la sortie du hash, soit 32 octets pour HMAC-SHA-256. Une clé plus longue que le bloc (64 octets pour SHA-256) est d’abord hachée et n’apporte donc pas de sécurité supplémentaire. Générez-la aléatoirement plutôt que de choisir un mot de passe.
Non, un HMAC n’est pas un chiffrement : il ne contient pas le message et ne permet pas de le reconstituer. Le message est d’ailleurs généralement envoyé en clair à côté de la signature. Pour rendre un contenu illisible, il faut un chiffrement comme AES-GCM.
Le calcul se fait uniquement dans votre navigateur avec Web Crypto : ni la clé ni le message ne sont transmis. Par principe, utilisez plutôt un secret de test, ou renouvelez le secret après une session de débogage sur un ordinateur partagé.
Outils associés
Des outils similaires ou complémentaires à celui-ci.
Calculez en une fois les empreintes MD5, SHA-1, SHA-256, SHA-384 et SHA-512 d’un texte ou d’un fichier.
Vérifiez si deux hash ou sommes de contrôle correspondent, quels que soient la casse, les espaces ou les deux-points.
Générez des jetons aléatoires sûrs de 8 à 256 octets en hexadécimal, Base64 ou Base64URL, avec préfixe optionnel.
Distinguez hash, chiffrement et signature, puis utilisez les empreintes pour vérifier une égalité ou l’intégrité de données sans leur attribuer de fausses garanties.
Distinguez chiffrement, hachage, HMAC et dérivation de clé pour choisir le bon mécanisme selon le besoin : confidentialité, intégrité, authentification ou stockage de mots de passe.
Comprenez comment OAuth 2.0, PKCE, JWT, JWK et JWKS s’articulent sans les confondre : autorisation, jetons, clés publiques et vérification.
Comprenez comment SRI utilise une empreinte cryptographique pour vérifier qu’un script ou une feuille de style externe correspond au fichier attendu.