HMAC Generator

Vad är HMAC?

HMAC (Hash-based Message Authentication Code) är en kryptografisk konstruktion definierad i RFC 2104 som kombinerar en hashfunktion med en hemlig nyckel för att producera en autentiseringstagg av fast storlek. Till skillnad från en vanlig hash, som vem som helst kan beräkna, kan ett HMAC bara genereras och verifieras av parter som delar den hemliga nyckeln. HMAC är standardmekanismen för att verifiera både integritet och äkthet hos ett meddelande — det bekräftar att data inte har ändrats och att det producerats av en betrodd avsändare.

HMAC-algoritmen fungerar med vilken iterativ hashfunktion som helst: SHA-256, SHA-384, SHA-512 och även äldre funktioner som SHA-1 eller MD5. Den resulterande konstruktionen refereras till med dess underliggande hash — HMAC-SHA256, HMAC-SHA384 eller HMAC-SHA512. Eftersom HMAC:s säkerhetsbevis förlitar sig på att hashfunktionen är kollisionsresistent och har vissa pseudoslumpmässiga egenskaper är SHA-2-familjen det rekommenderade valet för nya system. HMAC-SHA256 är den mest utbredda varianten och används i AWS Signature V4, Stripe-webhooks, GitHubs webhook-hemligheter, Slacks begäransignering och JSON Web Tokens (HS256).

HMAC:s design ger en kritisk egenskap som vanlig hashning saknar: motstånd mot längdutvidgningsattacker. Med SHA-256 ensamt kan en angripare som känner till H(meddelande) beräkna H(meddelande || angripardata) utan att känna till det ursprungliga meddelandet. HMAC:s dubbelhasningsstruktur (inre hash och yttre hash med olika vadderade nycklar) förhindrar den här attacken helt. Det är därför API-signeringsscheman använder HMAC i stället för att lägga till en hemlig nyckel till meddelandet och hasha resultatet.

Varför använda en online HMAC-generator?

Att beräkna HMAC-signaturer kräver normalt att man skriver kod eller använder CLI-verktyg. Den här webbläsarbaserade HMAC-generatorn låter dig skapa HMAC-SHA256-, HMAC-SHA384- och HMAC-SHA512-signaturer direkt utan att installera programvara eller byta till en terminal.

Användningsfall för HMAC-generatorn

HMAC vs vanlig hash vs kryptering

HMAC, vanlig hashning och kryptering tjänar olika syften. HMAC ger meddelandeautentisering — bevis på att meddelandet skapades av någon med den hemliga nyckeln och inte har ändrats. En vanlig hash ger integritet men inte autentisering. Kryptering ger konfidentialitet. Tabellen nedan klargör skillnaderna.

Jämförelse av HMAC-algoritmer

HMAC kan använda vilken hashfunktion som helst, men valet av underliggande algoritm avgör utdatastorleken, säkerhetsnivån och webbläsarkompatibiliteten. HMAC-SHA256 är det vanligaste valet för nya system. Tabellen nedan jämför de varianter du troligtvis kommer att stöta på.

Hur HMAC fungerar internt

HMAC tillämpar den underliggande hashfunktionen två gånger med två olika nyckelbaserade vadderings. Konstruktionen är definierad i RFC 2104 och bevisad vara en PRF (pseudoslumpmässig funktion) under standard kryptografiska antaganden. Nyckeln vadderas först eller hashas för att matcha hashfunktionens blockstorlek (64 byte för SHA-256, 128 byte för SHA-512).

Algoritmen XOR:ar den vadderade nyckeln med en inre vadderingskonstant (ipad, 0x36 upprepat), sammanfogar den med meddelandet och hashar resultatet. Den XOR:ar sedan den vadderade nyckeln med en yttre vadderingskonstant (opad, 0x5C upprepat), sammanfogar med det inre hashvärdet och hashar igen. Den här dubbelhasningsstrukturen är det som förhindrar längdutvidgningsattacker och säkerställer att HMAC-utdata inte kan beräknas utan kännedom om den hemliga nyckeln.

HMAC-kodexempel

HMAC stöds internt i alla större språk och körtidsmiljöer. Web Crypto API tillhandahåller HMAC-SHA256, HMAC-SHA384 och HMAC-SHA512 i webbläsare utan något bibliotek. Exemplen nedan visar verkliga användningsmönster inklusive webhook-verifiering och jämförelse med konstant tidskomplexitet.

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

Vanliga frågor