ForHosting KIT · Outils pour développeurs

Signature HMAC

Le HMAC combine un message et une clé secrète pour produire une signature : seul celui qui connaît la clé peut la recalculer, ce qui prouve l’authenticité et l’intégrité du message. Cet outil génère et vérifie une signature HMAC en SHA-256, SHA-1 ou SHA-512, indispensable pour valider un webhook. Le calcul reste sur votre appareil.

● StableGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailApp bientôtTelegram bientôt

Signer, c’est prouver qui parle

Un webhook arrive sur votre serveur : comment être sûr qu’il vient bien du service annoncé et non d’un imposteur ? L’émetteur calcule un HMAC du corps du message avec une clé partagée, et le joint dans un en-tête. Vous recalculez le même HMAC de votre côté ; si les deux coïncident, le message est authentique et n’a pas été modifié en route. Sinon, vous le rejetez sans hésiter.

Vérifier une signature reçue

Collez le corps exact du message, la clé secrète et l’algorithme indiqué par l’émetteur — souvent SHA-256. L’outil recalcule la signature et vous la comparez à celle reçue. Attention au détail qui piège : la signature porte sur le corps brut, avant toute reformulation. Un espace ou un saut de ligne ajouté suffit à faire diverger le résultat, et à faire échouer la vérification.

HMAC ou simple hash ?

Un hash seul prouve qu’un contenu n’a pas changé, mais n’importe qui peut le recalculer. Le HMAC ajoute une clé secrète : sans elle, impossible de forger une signature valide. C’est la différence entre constater une modification accidentelle et authentifier réellement l’expéditeur. Pour un webhook exposé sur Internet, seul le HMAC offre cette garantie d’origine. Concrètement, un imposteur peut recopier un hash, jamais un HMAC valide, faute de connaître le secret partagé.

La clé ne quitte pas la page

La signature se calcule dans votre navigateur : ni le message, ni surtout la clé secrète ne sont transmis à nos serveurs. C’est essentiel, car une clé HMAC divulguée annule toute la sécurité du dispositif. Pour automatiser la vérification côté serveur, l’appel programmable revient à $0.002 la requête, en dollars US ; l’usage manuel de test reste gratuit et illimité. Le web demeure le canal principal ; l’API n’est qu’une option pour l’automatisation.

Cas d’usage

Valider un webhook de paiement

Le Studio Lumen SAS reçoit une notification de paiement ; en recalculant le HMAC SHA-256 avec sa clé, l’équipe confirme que l’appel vient bien du prestataire et non d’un tiers.

Déboguer une signature qui échoue

La signature d’un webhook est systématiquement rejetée : Nadia Benali rejoue le calcul à la main et découvre qu’elle signait le corps reformaté plutôt que le corps brut.

Préparer une intégration

Avant de coder, Julien Lefèvre reproduit dans l’outil la signature attendue par un partenaire, pour vérifier qu’il a compris l’algorithme et l’encodage exigés.

Questions fréquentes

Quelle différence entre un hash et un HMAC ?

Un hash se calcule sans secret : tout le monde peut le reproduire. Le HMAC mêle le message à une clé secrète, si bien que seul celui qui la détient peut produire une signature valide. Il authentifie l’expéditeur, pas seulement le contenu.

Pourquoi ma signature ne correspond-elle jamais ?

Le plus souvent, vous ne signez pas exactement le même contenu que l’émetteur. La signature porte sur le corps brut du message : un espace, un saut de ligne ou un ré-encodage change tout. Vérifiez aussi l’algorithme et l’encodage de sortie, hexadécimal ou Base64.

Quel algorithme choisir ?

SHA-256 est le standard actuel pour un HMAC et convient à la quasi-totalité des webhooks. SHA-512 offre une empreinte plus longue ; SHA-1 ne subsiste que pour des systèmes anciens. Suivez ce qu’impose le service que vous intégrez.

Ma clé secrète est-elle envoyée quelque part ?

Non. Le message comme la clé restent dans votre navigateur ; rien n’est transmis ni journalisé. C’est capital : une clé HMAC exposée ruinerait la sécurité de vos webhooks.

Puis-je vérifier une signature, pas seulement en générer une ?

Oui. Générez la signature à partir du message et de la clé, puis comparez-la à celle reçue. Si elles coïncident, le message est authentique ; sinon, écartez-le.

Combien coûte l’automatisation ?

Le test manuel est gratuit et illimité dans le navigateur. Pour vérifier des signatures en continu côté serveur via l’API, comptez $0.002 par requête, en dollars US, sans abonnement.

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

POSThttps://api.kit.forhosting.com/dev/hmac

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/dev/hmac \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

const res = await fetch("https://api.kit.forhosting.com/dev/hmac", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/hmac",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/hmac", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/hmac", 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

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.hmac",
  "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

par requête$0.002

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.

Consulter la documentation complète du KIT →

Lancer gratuitement