Vérifier une signature webhook HMAC étape par étape
Indiquez l’algorithme HMAC, par exemple HMAC-SHA256, et l’en-tête qui porte la signature : vous obtenez 8 étapes ordonnées, de la conservation du corps brut à la comparaison en temps constant, puis au contrôle des rejeux. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Cette capacité convertit l’algorithme HMAC et l’en-tête du fournisseur en liste précise et ordonnée. Elle ne demande ni charge utile, ni secret, ni signature.
Ce que prouve une signature HMAC
L’expéditeur calcule un HMAC avec un secret partagé sur les octets exacts du message et place le résultat dans un en-tête. À la réception, votre système refait le même calcul : il reprend le corps brut tel qu’il est arrivé, y ajoute l’horodatage ou le préfixe exigé par le fournisseur, applique l’algorithme indiqué et encode le résultat comme le prévoit sa documentation, souvent en hexadécimal ou en Base64. Si les deux signatures concordent, quelqu’un qui détient le secret a bien produit ce message. Cela ne prouve ni qu’il est récent ni qu’il n’a pas déjà été traité : d’où la fenêtre de tolérance sur l’horodatage et la conservation des identifiants d’événements acceptés.
Erreurs fréquentes et cas d’usage
L’échec le plus courant survient avant le calcul : le système lit et réorganise le corps, modifie des espaces, l’ordre ou les fins de ligne, et la bonne signature ne correspond plus. Autres erreurs classiques : accepter un en-tête vide ou en double, comparer avec une égalité ordinaire, ou tronquer et compléter des valeurs de longueurs différentes au lieu de les rejeter. Servez-vous de ces étapes pour mettre en place ou relire un récepteur, et pour préparer un plan de contrôle avec corps modifiés, horodatages périmés, mauvais secrets et événements rejoués. La documentation du fournisseur reste la référence pour le format de l’en-tête.
Commencez par les octets signés par le fournisseur
Conservez exactement les octets reçus avant toute analyse. Lisez l’en-tête indiqué sans tenir compte de la casse de son nom, mais validez strictement sa valeur. Le fournisseur peut transmettre un condensé seul ou inclure version, date et plusieurs signatures.
Suivez sa grammaire, refusez toute valeur absente, vide, dupliquée ou mal formée et gardez le secret dans un gestionnaire protégé.
Reconstruisez, calculez et comparez dans le bon ordre
Reconstituez exactement le message signé : corps brut seul, ou date suivie d’un séparateur et du corps. Respectez l’ordre et l’encodage documentés. Calculez le HMAC avec le secret et l’algorithme normalisé, puis encodez le résultat comme demandé.
Décodez les deux signatures en tableaux d’octets de même longueur et employez une comparaison en temps constant. Un encodage incorrect ou une longueur différente entraîne un rejet, jamais un rognage ou un remplissage.
Intégrez la cryptographie au processus d’acceptation
Un HMAC identique prouve la connaissance du secret, mais pas la fraîcheur ni l’unicité du message. Appliquez la tolérance horodatée recommandée, mémorisez les identifiants acceptés et rendez le traitement idempotent. Faites tourner les secrets selon la période de chevauchement prévue.
Refusez avant toute mise en file, renvoyez une erreur générique et journalisez seulement des codes sûrs. Testez corps modifiés, dates périmées, en-têtes invalides, mauvais secrets et événements rejoués.
Cas d’usage
Auditer une intégration existante
Vérifiez l’ordre de capture, calcul HMAC, comparaison sûre et défense antirejeu.
Préparer des tests de sécurité
Déduisez des tests négatifs pour en-têtes absents, corps modifiés, signatures invalides, dates périmées et rejeux.
Questions fréquentes
Quels algorithmes sont reconnus ?
HMAC-SHA1, HMAC-SHA256, HMAC-SHA384 et HMAC-SHA512. Tout autre algorithme provoque une erreur d’entrée.
Pourquoi conserver le corps brut ?
L’analyse et la resérialisation peuvent modifier ses octets et invalider une signature correcte.
Un HMAC valide empêche-t-il les rejeux ?
Non. Contrôlez la date signée et dédupliquez les identifiants fournis.
Pourquoi comparer la signature en temps constant ?
Parce qu’une comparaison ordinaire peut révéler, par le temps de réponse, quelle part de la signature correspondait. Convertissez les deux valeurs en octets de même longueur et utilisez une comparaison résistante à la mesure du temps ; un écart de longueur ou de décodage vaut échec.
Dois-je saisir mon secret ou le message reçu ?
Non. La liste d’étapes n’a besoin que de l’algorithme HMAC et du nom de l’en-tête de signature : le secret, le message et la signature restent dans votre propre récepteur.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/security/webhook-signature-verify-steps \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"algorithm":"HMAC-SHA256","header_name":"X-Webhook-Signature"}'const res = await fetch("https://api.kit.forhosting.com/security/webhook-signature-verify-steps", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"algorithm": "HMAC-SHA256",
"header_name": "X-Webhook-Signature"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/webhook-signature-verify-steps",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"algorithm": "HMAC-SHA256",
"header_name": "X-Webhook-Signature"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/webhook-signature-verify-steps", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"algorithm":"HMAC-SHA256","header_name":"X-Webhook-Signature"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"algorithm":"HMAC-SHA256","header_name":"X-Webhook-Signature"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/webhook-signature-verify-steps", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"algorithm": "HMAC-SHA256",
"header_name": "X-Webhook-Signature"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.webhook_signature_verify_steps",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
La vérification des signatures webhook échoue souvent aux interfaces : le framework modifie le corps, l’en-tête est analysé sans rigueur ou une comparaison ordinaire divulgue des informations temporelles. Utilisez le résultat pour créer ou auditer votre endpoint, puis vérifiez le format horodaté, l’encodage et la tolérance aux rejeux dans la documentation officielle.
Commencez par les octets signés par le fournisseur
Analyser puis sérialiser JSON peut modifier espaces, ordre, échappements, Unicode ou fins de ligne.
Cas d'intégration
Créer un nouvel endpoint webhook
Convertissez l’algorithme et l’en-tête en liste contrôlable avant de programmer.
Questions techniques
Cet outil vérifie-t-il un vrai webhook ?
Non. Il produit des étapes et ne demande jamais de charge utile, secret ou signature.
Dois-je transmettre le secret webhook ?
Non. Seuls l’algorithme et l’en-tête sont requis ; gardez le secret dans votre environnement protégé.
Quel est le prix d’une requête API ?
Chaque requête coûte $0.002. L’implémentation déterministe s’exécute dans le navigateur sans transmettre de secrets.