JWT-tokengenerator

Bouw en onderteken RFC 7519 JSON Web Tokens lokaal in je browser met Web Crypto HMAC (HS256, HS384, HS512) en geregistreerde of aangepaste JSON-claims.

Geen uploadsGeen registratieDirect resultaat
HS256 · HS384 · HS512 · noneSnelle claims (iat / exp / jti)100% Lokaal • Geen Uploads
JWT maken & ondertekenen
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis JWT-tokengenerator gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

In-browser Web Crypto HMAC-ondertekening

Berekent HS256-, HS384- en HS512-JWS-handtekeningen lokaal via SubtleCrypto, zodat test-secrets en claim-payloads je machine nooit verlaten.

RFC 7519 geregistreerde & aangepaste claims

Configureer standaardvelden zoals iss, sub, aud, exp, nbf, iat en jti naast geneste aangepaste JSON-claims, RBAC-rol-arrays en OAuth2-scopes.

Strikte Base64URL-serialisatie zonder padding

Serialiseert UTF-8 JSON-headers, payloads en binaire MAC-tags met het URL-veilige alfabet uit RFC 4648 waarbij afsluitende padding wordt verwijderd volgens RFC 7515.

Deterministische auth- & edge-case testdata

Genereer direct actieve, geantedateerde, verlopen of toekomstige nbf-tokens om API-gateway-middleware, clock-skew-marges en autorisatieregels te testen.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
In-browser Web Crypto HMAC-ondertekening Berekent HS256-, HS384- en HS512-JWS-handtekeningen lokaal via SubtleCrypto, zodat test-secrets en claim-payloads je machine nooit verlaten. Beperkte opties zonder geavanceerde aanpassing
RFC 7519 geregistreerde & aangepaste claims Configureer standaardvelden zoals iss, sub, aud, exp, nbf, iat en jti naast geneste aangepaste JSON-claims, RBAC-rol-arrays en OAuth2-scopes. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe JWT-tokengenerator te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Kies HMAC-algoritme & JOSE-header

Selecteer HS256, HS384 of HS512 om de beveiligde JOSE-header (alg en typ: JWT) in te vullen, samen met eventuele optionele headerparameters zoals kid.

2

Configureer geregistreerde & eigen claims

Stel Unix NumericDate-tijdstempels (iat, nbf, exp) en standaard identiteitsvelden (iss, sub, aud, jti) in, of plak en upload aangepaste JSON-claims.

3

Onderteken met secret key & kopieer token

Voer je gedeelde HMAC-secret in om de cryptografische handtekening in de browser te genereren en kopieer de compacte JWT voor Authorization Bearer-headers.

Hoe je een RFC 7519 JSON Web Token opbouwt en ondertekent

Kort antwoord: Serialiseer de JOSE-header en JSON-claims-payload als geminificeerde UTF-8-strings, codeer elk segment met Base64URL zonder padding, voeg ze samen met een punt tot de ASCII-signing-input, bereken de HMAC-SHA2-digest met je geheime sleutel en voeg de Base64URL-gecodeerde handtekening toe.

Het genereren van een standaardconforme JWT in JWS Compact Serialization (RFC 7515 Sectie 3.1) zet een JOSE-header, een JSON-claimset en een symmetrische geheime sleutel om in een driedelige string met het formaat <header>.<payload>.<signature>.

1. Stel de JOSE-header en API-claims-payload samen

Begin met een beveiligde HS256-header en een JSON-payload die geregistreerde RFC 7519-claims (iss, sub, aud, iat, exp) combineert met aangepaste applicatie-claims (role):

{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "aud": "api.example.com",
  "iat": 1767225600,
  "exp": 1767229200,
  "role": "admin"
}

Hier staat 1767225600 voor 2026-01-01T00:00:00Z en 1767229200 voor 2026-01-01T01:00:00Z (een tokenlevensduur van 1 uur).

2. Bouw de Base64URL-signing-input zonder padding

Elk JSON-object wordt geminificeerd naar UTF-8-bytes zonder extra witruimte, gecodeerd met Base64URL (-- en _-alfabet, =-padding verwijderd) en samengevoegd met een ASCII-punt (.):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Reproduceerbare HMAC-SHA256-testvector

Web Crypto importeert je secret-bytes via crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) en ondertekent de exacte ASCII-bytes van <base64url-header>.<base64url-payload>. Je kunt de deterministische gelijkheid tussen OpenSSL, Node.js crypto, Python PyJWT en deze generator verifiëren met de canonieke HS256-testvector en het UTF-8-secret your-256-bit-secret:

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Het ondertekenen van de {"alg":"HS256","typ":"JWT"}-header en bovenstaande payload met your-256-bit-secret levert altijd exact dit token van 147 tekens op, direct klaar voor een HTTP Authorization: Bearer <token>-header of round-trip verificatie in de JWT-decoder & -inspecteur:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

JWS HMAC-ondertekeningspipeline, claim-semantiek en sleutel-entropieregels

Kort antwoord: RFC 7518 vereist dat HMAC-ondertekeningssleutels minstens zo lang zijn als de hash-outputlengte: minimaal 256 bits (32 bytes) voor HS256, 384 bits (48 bytes) voor HS384 en 512 bits (64 bytes) voor HS512. Zwakke ASCII-wachtwoordzinnen maken symmetrische JWT's kwetsbaar voor offline brute-force woordenboekaanvallen.

Het implementeren of testen van JWT-uitgifte vereist strikte naleving van de regels op byteniveau uit RFC 7515 (JWS), RFC 7518 (JWA) en RFC 7519 (JWT).

Exacte JWS-signing-input en binaire digest-codering

Volgens RFC 7515 Sectie 5.1 wordt de JWS-handtekening berekend over de ASCII-bytes van de Base64URL-gecodeerde segmenten, nooit over ruwe JSON-strings:

SigningInput = ASCII(BASE64URL(UTF8(Header))) || '.' || ASCII(BASE64URL(UTF8(Payload)))
Signature    = BASE64URL(HMAC_SHA2(SecretKeyBytes, SigningInput))

Twee serialisatiedetails zijn bepalend voor de interoperabiliteit tussen programmeertalen:

  1. Binaire digest vs. hex-string: HMAC_SHA2 retourneert ruwe binaire bytes (32 bytes voor HS256, 48 bytes voor HS384, 64 bytes voor HS512). Je moet die ruwe bytes rechtstreeks Base64URL-coderen (wat respectievelijk 43, 64 of 86 tekens oplevert), en niet eerst omzetten naar een hexadecimale string in kleine letters.
  2. Determinisme van JSON-serialisatie: Hoewel JSON-objecten volgens RFC 8259 ongeordende sleutel-waardeparen zijn, ondertekent JWS de exacte UTF-8-bytereeks zoals die bij het aanmaken is geserialiseerd. Het herschikken van sleutels of toevoegen van witruimte (pretty-printing) verandert de Base64URL-payload en produceert een compleet andere handtekening.

Formaat van HMAC-algoritmen & brute-force-bestendigheid (RFC 7518 Sectie 3.2)

  • HS256 (SHA-256, 512-bit intern blok): 256-bit (32-byte) digest, 43-teken Base64URL-handtekening. Minimaal 32-byte CSPRNG-secret.
  • HS384 (SHA-384, 1024-bit intern blok): 384-bit (48-byte) digest, 64-teken Base64URL-handtekening. Minimaal 48-byte CSPRNG-secret.
  • HS512 (SHA-512, 1024-bit intern blok): 512-bit (64-byte) digest, 86-teken Base64URL-handtekening. Minimaal 64-byte CSPRNG-secret.

Omdat elke client met een JWT zowel over de plaintext signing-input (<header>.<payload>) als over de resulterende MAC-tag beschikt, kan een aanvaller kandidaat-secrets volledig offline testen met miljoenen hashes per seconde zonder API-ratelimieten te raken. Genereer secrets daarom altijd met een cryptografisch veilige random number generator in plaats van menselijk onthoudbare woorden.

Geregistreerde claimtypen volgens RFC 7519 Sectie 4.1

  • iss (Issuer) & sub (Subject): Hoofdlettergevoelige StringOrURI die de autoriteit identificeert die het token heeft uitgegeven en de principal (gebruikers-ID of serviceaccount) die het vertegenwoordigt.
  • aud (Audience): Hoofdlettergevoelige StringOrURI of JSON-array van StringOrURI-waarden die de beoogde ontvangers aanduiden. Volgens RFC 8725 moeten resourceservers aud valideren om te voorkomen dat een geldig token dat is uitgegeven voor Service A opnieuw wordt afgespeeld (replay) tegen Service B.
  • exp (Expiration), nbf (Not Before) & iat (Issued At): NumericDate-waarden in Unix-epoch-seconden (Math.floor(Date.now() / 1000)).
  • jti (JWT ID): Unieke hoofdlettergevoelige token-identificatie (zoals een UUIDv4) gebruikt voor intrekking (denylists) en preventie van replay-aanvallen.

JWT Generator vs. JWT Decoder vs. HMAC Generator: De juiste tool kiezen

Kort antwoord: Gebruik de JWT Token Generator om nieuwe driedelige RFC 7519 Bearer-tokens op te bouwen en te ondertekenen vanuit JSON-claims. Gebruik de JWT-decoder & -inspecteur om bestaande JWT's te parseren en te verifiëren, of kies de HMAC Generator wanneer je ruwe hex- of Base64 keyed-hash-handtekeningen nodig hebt voor webhook-payloads zoals Stripe of GitHub.

Hoewel alle drie de tools steunen op browser-native Web Crypto-hashing, richt elke tool zich op een specifiek protocolformaat en een andere fase van API-ontwikkeling.

Kenmerk JWT Token Generator (Deze tool) JWT-decoder & -inspecteur HMAC Generator & Verifier
Hoofddoel JSON-claims opstellen en een ondertekende JWT genereren Bestaande JWT decoderen, tijdstempels inspecteren en verifiëren Losstaande keyed-hash MAC berekenen over willekeurige invoer
Vereiste invoer Header alg + JSON-claims + geheime sleutel Compacte driedelige JWT + optionele geheime sleutel Ruwe tekst of JSON-bericht + geheime sleutel
Uitvoerformaat Driedelige Base64URL-JWT (<header>.<payload>.<signature>) Gedecodeerde JSON-header/payload, verloopstatus, geldigheidscheck Losstaande hexadecimale of Base64-digest-string
Onderliggende spec RFC 7519 (JWT) & RFC 7515 (JWS) RFC 7519 (JWT) & RFC 7515 (JWS) RFC 2104 (HMAC) & FIPS 198-1
Ideaal gebruik Bearer-tokens maken voor lokale API- & middleware-tests Oplossen van 401-fouten, OIDC ID-tokens en TTL's Verifiëren van webhook X-Hub-Signature-256 of API-request-MAC's

Nadat je hier een testtoken hebt aangemaakt, kun je het resulterende token plakken in de JWT-decoder & -inspecteur om downstream-verificatie te simuleren en te controleren hoe de exp- en nbf-aftellingen zich gedragen.

Veelgestelde vragen

JWT-tokengenerator FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online jwt generator.

Wat is de minimale lengte van de geheime sleutel voor HS256, HS384 en HS512?

RFC 7518 Sectie 3.2 schrijft voor dat een HMAC-sleutel minstens zo groot moet zijn als de hash-outputlengte: minimaal 32 bytes (256 bits) voor HS256, 48 bytes (384 bits) voor HS384 en 64 bytes (512 bits) voor HS512. Strikte backend-libraries zoals Nimbus JOSE+JWT, jjwt en PyJWT geven weak-key-exceptions of waarschuwingen als je kortere ASCII-strings aanlevert.

Waarom produceert mijn eigen HS256-code een handtekening van 86 tekens in plaats van 43 tekens?

Een HS256-handtekening van 86 tekens ontstaat wanneer code de 32-byte HMAC-SHA256-digest eerst omzet naar een hexadecimale string van 64 tekens en vervolgens die 64 ASCII-tekens Base64URL-codeert. RFC 7515 vereist dat de ruwe 32 binaire bytes rechtstreeks Base64URL-gecodeerd worden, wat zonder padding altijd exact 43 Base64URL-tekens oplevert.

Wanneer kies ik symmetrische HMAC (HS256) boven asymmetrische RSA of ECDSA (RS256 of ES256)?

Gebruik symmetrische HS256, HS384 of HS512 wanneer dezelfde vertrouwde backend-service (of lokale testomgeving) het token zowel ondertekent als verifieert, aangezien beide bewerkingen één geheime sleutel delen en minimale CPU-overhead vragen. Wanneer meerdere downstream-microservices of externe clients tokens moeten verifiëren zonder zelf nieuwe tokens te mogen aanmaken, gebruik je asymmetrische ES256, RS256 of EdDSA waarbij alleen de identity provider over de private ondertekeningssleutel beschikt.

Hoe moet ik exp-, nbf- en iat-tijdstempels formatteren bij het genereren van een JWT?

Formatteer exp, nbf en iat als numerieke Unix-epoch-seconden (bijvoorbeeld 1767225600), nooit als ISO 8601-datumstrings tussen aanhalingstekens en nooit als 13-cijferige JavaScript-milliseconden. Voor een access-token van 15 minuten stel je iat in op de huidige epochtijd in seconden en exp op iat + 900.

Kan ik verlopen of toekomstige JWT's genereren om API-foutafhandeling te testen?

Ja. In tegenstelling tot productie-OAuth2-servers die alleen op dat moment geldige tokens uitgeven, kun je met deze client-side generator exp bewust in het verleden of nbf in de toekomst zetten. Zo schrijf je eenvoudig deterministische integratietests die bevestigen dat je auth-middleware verlopen of nog niet geldige tokens weigert met 401 Unauthorized en daarbij de geconfigureerde clock-skew-marge respecteert.