JWT Encoder
Skapa och signera JSON Web Tokens med HS256, HS384, HS512
Rubrik
Nyttolast
Hemlig nyckel
Kodad JWT
Din hemliga nyckel lämnar aldrig din webbläsare. All signering sker på klientsidan.
Vad är JWT-kodning?
JWT-kodning är processen för att skapa en JSON Web Token — en kompakt, URL-säker sträng som bär en uppsättning anspråk signerade med en kryptografisk nyckel. Resultatet är en tredelig token (header.payload.signature) definierad av RFC 7519 som servrar kan verifiera utan att upprätthålla sessionstillståndet.
Header deklarerar signeringsalgoritmen (t.ex. HS256) och tokentypen. Payload innehåller claims — nyckel-värde-par som subjektet (sub), utgångstid (exp) och anpassad data som din applikation behöver. Båda delarna serialiseras som JSON och base64url-kodas sedan. Signaturen beräknas över den kodade headern och payloaden med hjälp av en hemlig nyckel, vilket binder alla tre segment samman.
Till skillnad från sessionscookies är JWT självinnehållande: verifieraren behöver inte fråga en databas eller anropa en extern tjänst. Detta gör JWT-baserad autentisering populär i REST API:er, mikrotjänster och single-page-applikationer där tillståndslös auktorisering minskar latens och förenklar horisontell skalning.
Varför använda en JWT-kodare?
Att generera JWT manuellt kräver base64url-kodning, JSON-serialisering och HMAC-beräkning. Det här verktyget hanterar alla tre stegen omedelbart så att du kan fokusera på att få claims rätt.
Användningsfall för JWT-kodare
HS256 vs HS384 vs HS512: Jämförelse av HMAC-algoritmer
Alla tre algoritmer använder HMAC (Hash-based Message Authentication Code) med en delad hemlighet. Skillnaden är den underliggande hashfunktionen, vilket påverkar signaturlängd och säkerhetsmarginal. För de flesta applikationer ger HS256 tillräcklig säkerhet. Välj HS384 eller HS512 när efterlevnadskrav (t.ex. FIPS-140) kräver en starkare hash eller när dina tokens bär högt värderade auktoriseringsbeslut.
| Algoritm | Hash | Signatur | Hastighet | Typisk användning |
|---|---|---|---|---|
| HS256 | SHA-256 | 32 B | Fastest | General purpose, default for most libraries |
| HS384 | SHA-384 | 48 B | Fast | Higher security margin, FIPS-140 compliant |
| HS512 | SHA-512 | 64 B | Fast | Maximum HMAC security, large payloads |
Referens för standard-JWT-claims
RFC 7519 definierar sju registrerade claims. Ingen är obligatorisk, men att använda dem korrekt förbättrar interoperabilitet och säkerhet. Claim exp är särskilt viktig — tokens utan utgångsdatum är giltiga på obestämd tid om hemligheten inte roteras.
| Claim | Namn | Beskrivning | Exempel |
|---|---|---|---|
| iss | Issuer | Who issued the token | "auth.example.com" |
| sub | Subject | Who the token represents | "user-123" |
| aud | Audience | Intended recipient service | "api.example.com" |
| exp | Expiration | Unix timestamp — token invalid after this time | 1717203600 |
| nbf | Not Before | Unix timestamp — token invalid before this time | 1717200000 |
| iat | Issued At | Unix timestamp when the token was created | 1717200000 |
| jti | JWT ID | Unique token identifier for revocation tracking | "a1b2c3d4" |
JWT-kodning i kod
Dessa exempel visar hur man skapar och signerar JWT programmatiskt. Varje kodavsnitt producerar ett giltigt HS256-signerat token. För produktionssystem, ange alltid exp-claimet och använd en kryptografiskt slumpmässig hemlighet på minst 256 bitar.
async function signJWT(payload, secret, alg = 'HS256') {
const header = { alg, typ: 'JWT' }
const enc = new TextEncoder()
// Base64url encode header and payload
const b64url = (obj) =>
btoa(JSON.stringify(obj)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
const h = b64url(header)
const p = b64url(payload)
// Sign with HMAC-SHA256
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(`${h}.${p}`))
const s = btoa(String.fromCharCode(...new Uint8Array(sig)))
.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
return `${h}.${p}.${s}`
}
// Usage
const token = await signJWT(
{ sub: 'user-123', name: 'Alice', iat: Math.floor(Date.now() / 1000) },
'your-256-bit-secret'
)
// → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."import jwt
import time
payload = {
"sub": "user-123",
"name": "Alice",
"iat": int(time.time()),
"exp": int(time.time()) + 3600, # expires in 1 hour
}
# Sign with HS256 (default)
token = jwt.encode(payload, "your-256-bit-secret", algorithm="HS256")
# → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."
# Verify and decode
decoded = jwt.decode(token, "your-256-bit-secret", algorithms=["HS256"])
# → {"sub": "user-123", "name": "Alice", "iat": 1717200000, "exp": 1717203600}const jwt = require('jsonwebtoken')
const payload = {
sub: 'user-123',
name: 'Alice',
role: 'admin',
}
// Sign — iat is added automatically
const token = jwt.sign(payload, 'your-256-bit-secret', {
algorithm: 'HS256',
expiresIn: '1h', // sets exp claim
issuer: 'auth.example.com', // sets iss claim
})
// Verify
const decoded = jwt.verify(token, 'your-256-bit-secret')
// → { sub: 'user-123', name: 'Alice', role: 'admin', iat: ..., exp: ... }package main
import (
"fmt"
"time"
"github.com/golang-jwt/jwt/v5"
)
func main() {
claims := jwt.MapClaims{
"sub": "user-123",
"name": "Alice",
"iat": time.Now().Unix(),
"exp": time.Now().Add(time.Hour).Unix(),
}
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
signed, _ := token.SignedString([]byte("your-256-bit-secret"))
fmt.Println(signed)
// → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi...
}