JWT-tokengenerator

Bygg och signera RFC 7519 JSON Web Tokens lokalt i webbläsaren med Web Crypto HMAC (HS256, HS384, HS512) samt registrerade och anpassade JSON-claims.

Inga uppladdningarIngen registreringOmedelbara resultat
HS256 · HS384 · HS512 · noneSnabbanspråk (iat / exp / jti)100% Lokalt • Noll Uppladdningar
Skapa & signera JWT
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis JWT-tokengenerator?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Web Crypto HMAC-signering i webbläsaren

Beräknar HS256-, HS384- och HS512-JWS-signaturer lokalt via SubtleCrypto så att testhemligheter och claim-payloads aldrig lämnar din dator.

Registrerade & anpassade claims enligt RFC 7519

Konfigurera standardfälten iss, sub, aud, exp, nbf, iat och jti tillsammans med nästlade anpassade JSON-claims, RBAC-rollarrayer och OAuth2-scopes.

Strikt Base64URL-serialisering utan utfyllnad

Serialiserar UTF-8 JSON-headers, payloads och binära MAC-taggar med det URL-säkra alfabetet enligt RFC 4648 där avslutande utfyllnad tas bort enligt RFC 7515.

Deterministiska testdata för auth & gränsfall

Skapa aktiva, bakåtdaterade, utgångna eller framtidsdaterade nbf-tokens direkt för att testa API-gateway-middleware, tidsförskjutningstolerans (clock skew) och auktoriseringsregler.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Web Crypto HMAC-signering i webbläsaren Beräknar HS256-, HS384- och HS512-JWS-signaturer lokalt via SubtleCrypto så att testhemligheter och claim-payloads aldrig lämnar din dator. Begränsade alternativ utan avancerad anpassning
Registrerade & anpassade claims enligt RFC 7519 Konfigurera standardfälten iss, sub, aud, exp, nbf, iat och jti tillsammans med nästlade anpassade JSON-claims, RBAC-rollarrayer och OAuth2-scopes. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder JWT-tokengenerator i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Välj HMAC-algoritm & JOSE-header

Välj HS256, HS384 eller HS512 för att fylla i den skyddade JOSE-headern (alg och typ: JWT), tillsammans med valfria headerparametrar som kid.

2

Konfigurera registrerade & anpassade claims

Ange Unix NumericDate-tidsstämplar (iat, nbf, exp) och standardfält för identitet (iss, sub, aud, jti), eller klistra in och ladda upp anpassade JSON-claims.

3

Signera med hemlig nyckel & kopiera token

Ange din delade HMAC-hemlighet för att generera den kryptografiska signaturen i webbläsaren och kopiera den kompakta JWT-strängen för Authorization Bearer-headers.

Hur man bygger och signerar en RFC 7519 JSON Web Token

Snabbsvar: Serialisera JOSE-headern och JSON claims-payloaden som minifierade UTF-8-strängar, koda varje segment med Base64URL utan utfyllnad, sammanfoga dem med en punkt för att bilda ASCII-signeringsindatan, beräkna HMAC-SHA2-kontrollsumman med din hemliga nyckel och lägg till den Base64URL-kodade signaturen på slutet.

Att generera en standardkompatibel JWT i JWS Compact Serialization (RFC 7515 avsnitt 3.1) omvandlar en JOSE-header, en uppsättning JSON-claims och en symmetrisk hemlig nyckel till en tredelad sträng formaterad som <header>.<payload>.<signature>.

1. Konstruera JOSE-headern och API Claims-payloaden

Börja med en HS256-skyddad header och en JSON-payload som kombinerar registrerade claims enligt RFC 7519 (iss, sub, aud, iat, exp) med anpassade applikations-claims (role):

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

Här representerar 1767225600 tidpunkten 2026-01-01T00:00:00Z och 1767229200 representerar 2026-01-01T01:00:00Z (en livslängd på 1 timme).

2. Bygg Base64URL-signeringsindata utan utfyllnad

Varje JSON-objekt minifieras till UTF-8-byte utan extra blanksteg, kodas med Base64URL (alfabet med - och _, där =-utfyllnad tas bort) och sammanfogas med en ASCII-punkt (.):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Reproducerbar testvektor för HMAC-SHA256-signering

Web Crypto importerar dina hemliga byte via crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) och signerar de exakta ASCII-byten för <base64url-header>.<base64url-payload>. Du kan verifiera deterministisk paritet mellan OpenSSL, Node.js crypto, Python PyJWT och denna generator genom att använda den kanoniska HS256-testvektorn med UTF-8-hemligheten your-256-bit-secret:

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

Att signera headern {"alg":"HS256","typ":"JWT"} och payloaden ovan med your-256-bit-secret ger alltid exakt denna token på 147 tecken, redo för en HTTP Authorization: Bearer <token>-header eller verifiering tur och retur i JWT-avkodare & Inspektör:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

JWS HMAC-signeringsflöde, claim-semantik och regler för nyckelentropi

Snabbsvar: RFC 7518 kräver att signeringsnycklar för HMAC matchar eller överstiger hash-utdatans längd: minst 256 bitar (32 byte) för HS256, 384 bitar (48 byte) för HS384 och 512 bitar (64 byte) för HS512. Svaga ASCII-lösenfraser gör symmetriska JWT-tokens sårbara för offline brute-force- och ordlisteattacker.

Att implementera eller testa utfärdande av JWT kräver strikt efterlevnad av reglerna på bytenivå i RFC 7515 (JWS), RFC 7518 (JWA) och RFC 7519 (JWT).

Exakt JWS-signeringsindata och kodning av binär kontrollsumma

Enligt RFC 7515 avsnitt 5.1 beräknas JWS-signaturen över ASCII-byten för de Base64URL-kodade segmenten, aldrig över råa JSON-strängar:

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

Två serialiseringsdetaljer påverkar interoperabiliteten mellan olika programmeringsspråk:

  1. Binär kontrollsumma kontra hex-sträng: HMAC_SHA2 matar ut råa binära byte (32 byte för HS256, 48 byte för HS384, 64 byte för HS512). Du måste Base64URL-koda dessa råa byte direkt (vilket ger 43, 64 respektive 86 tecken), inte en mellanliggande hexadecimal sträng med gemener.
  2. Determinism vid JSON-serialisering: Även om JSON-objekt enligt RFC 8259 är oordnade nyckel-värde-mappningar, signerar JWS den exakta UTF-8-bytesekvensen som serialiserades vid skapandet. Om nycklar ändrar ordning eller formateras med blanksteg ändras Base64URL-payloaden och genererar en helt annan signatur.

Storlek på HMAC-algoritmer & motståndskraft mot brute-force (RFC 7518 avsnitt 3.2)

  • HS256 (SHA-256, 512-bitars internt block): 256-bitars (32-byte) kontrollsumma, 43-teckens Base64URL-signatur. Minst 32-byte CSPRNG-hemlighet.
  • HS384 (SHA-384, 1024-bitars internt block): 384-bitars (48-byte) kontrollsumma, 64-teckens Base64URL-signatur. Minst 48-byte CSPRNG-hemlighet.
  • HS512 (SHA-512, 1024-bitars internt block): 512-bitars (64-byte) kontrollsumma, 86-teckens Base64URL-signatur. Minst 64-byte CSPRNG-hemlighet.

Eftersom varje klient som innehar en JWT har tillgång till både signeringsindatan i klartext (<header>.<payload>) och den resulterande MAC-taggen, kan en angripare testa kandidatnycklar helt offline med miljontals hashningar per sekund utan att utlösa hastighetsbegränsningar (rate limits) i API:et. Generera alltid hemligheter från en kryptografiskt säker slumptalsgenerator snarare än ord som är lätta för människor att minnas.

Registrerade claim-typer i RFC 7519 avsnitt 4.1

  • iss (Issuer) & sub (Subject): Skiftlägeskänslig StringOrURI som identifierar den utfärdare som skapade token samt den huvudman (användar-ID eller tjänstekonto) den representerar.
  • aud (Audience): Skiftlägeskänslig StringOrURI eller JSON-array av StringOrURI-värden som identifierar avsedda mottagare. Enligt RFC 8725 måste resursservrar validera aud för att förhindra att en giltig token utfärdad för Tjänst A återanvänds mot Tjänst B.
  • exp (Expiration), nbf (Not Before) & iat (Issued At): NumericDate-värden i Unix-epoksekunder (Math.floor(Date.now() / 1000)).
  • jti (JWT ID): Unik skiftlägeskänslig token-identifierare (exempelvis ett UUIDv4) som används för spärrlistor vid återkallning och skydd mot replay-attacker.

JWT-generator kontra JWT-avkodare kontra HMAC-generator: Välj rätt verktyg

Snabbsvar: Använd JWT-tokengenerator för att bygga och signera nya tredelade RFC 7519 Bearer-tokens från JSON-claims. Använd JWT-avkodare & Inspektör för att tolka och verifiera befintliga JWT:er, eller använd HMAC-generator när du behöver råa hex- eller Base64-kodade nyckelhash-signaturer för webhook-payloads som Stripe eller GitHub.

Även om alla tre verktygen bygger på webbläsarens inbyggda Web Crypto-hashning, riktar sig vart och ett mot ett specifikt protokollformat och skede inom API-utveckling.

Funktion JWT-tokengenerator (Detta verktyg) JWT-avkodare & Inspektör HMAC-generator & Verifierare
Primärt mål Skapa JSON-claims och utfärda en signerad JWT Avkoda, inspektera tidsstämplar och verifiera en befintlig JWT Beräkna en fristående nyckel-hashad MAC över godtycklig indata
Nödvändig indata Header alg + JSON-claims + hemlig nyckel Kompakt tredelad JWT + valfri hemlig nyckel Råtext eller JSON-meddelande + hemlig nyckel
Utdataformat Tredelad Base64URL JWT (<header>.<payload>.<signature>) Avkodad JSON-header/payload, utgångsstatus, giltighetskontroll Fristående hexadecimal eller Base64-kodad kontrollsumma
Styrande specifikation RFC 7519 (JWT) & RFC 7515 (JWS) RFC 7519 (JWT) & RFC 7515 (JWS) RFC 2104 (HMAC) & FIPS 198-1
Idealt användningsfall Skapa Bearer-tokens för lokala API- och middleware-tester Felsöka 401-fel, OIDC ID-tokens och TTL-tider Verifiera webhook X-Hub-Signature-256 eller MAC för API-anrop

När du har skapat en test-token här kan du klistra in den resulterande strängen i JWT-avkodare & Inspektör för att simulera verifiering i bakomliggande system och inspektera hur nedräkningen för exp och nbf beter sig.

FAQ

JWT-tokengenerator FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis jwt generator online.

Vilken är den minsta tillåtna längden på den hemliga nyckeln för HS256, HS384 och HS512?

RFC 7518 avsnitt 3.2 kräver att en HMAC-nyckel måste ha en storlek som är större än eller lika med hash-utdatans längd: minst 32 byte (256 bitar) för HS256, 48 byte (384 bitar) för HS384 och 64 byte (512 bitar) för HS512. Strikta backend-bibliotek som Nimbus JOSE+JWT, jjwt och PyJWT kastar undantag eller varningar för svaga nycklar om du anger kortare ASCII-strängar.

Varför producerar min egen HS256-kod en signatur på 86 tecken istället för 43 tecken?

En HS256-signatur på 86 tecken uppstår när koden först konverterar HMAC-SHA256-kontrollsumman på 32 byte till en hexadecimal sträng på 64 tecken och sedan Base64URL-kodar dessa 64 ASCII-tecken. RFC 7515 kräver att man Base64URL-kodar de råa 32 binära byten direkt, vilket alltid ger exakt 43 Base64URL-tecken utan utfyllnad.

När bör jag välja symmetrisk HMAC (HS256) framför asymmetrisk RSA eller ECDSA (RS256 eller ES256)?

Använd symmetrisk HS256, HS384 eller HS512 när samma betrodda backend-tjänst (eller lokala testmiljö) både signerar och verifierar token, eftersom båda operationerna delar en enda hemlig nyckel och körs med minimal CPU-belastning. När flera nedströms mikrotjänster eller tredjepartsklienter behöver verifiera tokens utan att få möjlighet att utfärda nya, bör du använda asymmetrisk ES256, RS256 eller EdDSA där endast identitetsleverantören innehar den privata signeringsnyckeln.

Hur ska jag formatera tidsstämplarna exp, nbf och iat när jag genererar en JWT?

Formatera exp, nbf och iat som numeriska Unix-epoksekunder (till exempel 1767225600), aldrig som citerade ISO 8601-datumsträngar och aldrig som 13-siffriga JavaScript-millisekunder. För en åtkomsttoken på 15 minuter sätter du iat till aktuell epoktid i sekunder och exp till iat + 900.

Kan jag generera utgångna eller framtidsdaterade JWT:er för att testa felhantering i API:er?

Ja. Till skillnad från OAuth2-servrar i produktion som endast utfärdar giltiga tokens, låter denna klientbaserade generator dig medvetet sätta exp i det förflutna eller nbf i framtiden. Det gör det enkelt att skriva deterministiska integrationstester som bekräftar att din autentiserings-middleware avvisar utgångna eller för tidiga tokens med 401 Unauthorized samtidigt som konfigurerad tolerans för tidsförskjutning (clock skew) respekteras.