JWT Encoder
Vytvářejte a podepisujte JSON Web Tokens s HS256, HS384, HS512
Záhlaví
Datová část
Tajný klíč
Zakódovaný JWT
Váš tajný klíč nikdy neopustí váš prohlížeč. Veškeré podepisování probíhá na straně klienta.
Co je kódování JWT?
Kódování JWT je proces vytváření JSON Web Token — kompaktního řetězce bezpečného pro URL, který nese sadu tvrzení podepsaných kryptografickým klíčem. Výsledkem je token se třemi částmi (záhlaví.data.podpis) definovaný RFC 7519, který mohou servery ověřit bez zachování stavu relace.
Header deklaruje podpisový algoritmus (např. HS256) a typ tokenu. Payload obsahuje claims — páry klíč-hodnota jako subjekt (sub), čas expirace (exp) a libovolná vlastní data, která vaše aplikace potřebuje. Obě části jsou serializovány jako JSON a poté zakódovány v base64url. Podpis je vypočítán nad zakódovaným headerem a payloadem pomocí tajného klíče, čímž jsou všechny tři segmenty svázány dohromady.
Na rozdíl od session cookies jsou JWTs soběstačné: ověřovatel nepotřebuje dotazovat databázi ani volat externí službu. To dělá autentizaci na bázi JWT oblíbenou v REST API, mikroslužbách a jednostránkových aplikacích, kde bezstavová autorizace snižuje latenci a zjednodušuje horizontální škálování.
Proč používat JWT Encoder?
Ruční generování JWTs vyžaduje kódování base64url, serializaci JSON a výpočet HMAC. Tento nástroj zvládne všechny tři kroky okamžitě, takže se můžete soustředit na správné nastavení claims.
Případy použití JWT Encoderu
HS256 vs HS384 vs HS512: Srovnání HMAC algoritmů
Všechny tři algoritmy používají HMAC (Hash-based Message Authentication Code) se sdíleným tajemstvím. Rozdíl spočívá v použité hashovací funkci, která ovlivňuje délku podpisu a bezpečnostní rezervu. Pro většinu aplikací poskytuje HS256 dostatečnou bezpečnost. Zvolte HS384 nebo HS512, pokud to vyžadují compliance požadavky (např. FIPS-140) nebo pokud vaše tokeny nesou autorizační rozhodnutí s vysokou hodnotou.
| Algoritmus | Hash | Podpis | Rychlost | Typické použití |
|---|---|---|---|---|
| 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 |
Referenční přehled standardních JWT claims
RFC 7519 definuje sedm registrovaných claims. Žádný není povinný, ale jejich správné použití zlepšuje interoperabilitu a bezpečnost. Claim exp je obzvláště důležitý — tokeny bez expirace jsou platné donekonečna, pokud není tajný klíč obměněn.
| Claim | Název | Popis | Příklad |
|---|---|---|---|
| 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" |
Kódování JWT v kódu
Tyto příklady ukazují, jak programově vytvářet a podepisovat JWTs. Každý úryvek vytvoří platný token podepsaný HS256. V produkčních systémech vždy nastavte claim exp a použijte kryptograficky náhodný tajný klíč o délce alespoň 256 bitů.
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...
}