JWT-avkodare & Inspektör

Avkoda, inspektera och verifiera RFC 7519 JSON Web Tokens lokalt i webbläsaren.

Inga uppladdningarIngen registreringOmedelbara resultat
RFC 7519-anspråk & datumHS256 / HS384 / HS512-verifiering100% Lokalt • Noll Uppladdningar
Avkoda JWT
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis JWT-avkodare & Inspektör?

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

100 % Klientsidig Tokeninspektion

OAuth2-åtkomsttokens, OIDC ID-tokens och delade signeringshemligheter från produktion tolkas uteslutande i webbläsarens minne utan någon nätverksöverföring.

Web Crypto-verifiering av HS256, HS384 & HS512

Beräknar om och validerar RFC 7515 JWS HMAC-SHA2-signaturer lokalt via SubtleCrypto med råa UTF-8- eller Base64URL-kodade hemliga nycklar.

Realtidskontroll av Tidsstämplar (exp, nbf & iat)

Översätter RFC 7519 NumericDate-fält i Unix-epokformat till UTC- och lokala ISO 8601-tidsstämplar med nedräkning i realtid för utgångs- och aktiveringstid.

Strikt Efterlevnad av RFC 7519 & Base64URL

Avkodar Base64URL-segment utan utfyllnad med fullt stöd för multibyte UTF-8, tar bort Authorization Bearer-prefix och flaggar overifierade alg:none-headers.

Utiliome jämfört med molnalternativ

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

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
100 % Klientsidig Tokeninspektion OAuth2-åtkomsttokens, OIDC ID-tokens och delade signeringshemligheter från produktion tolkas uteslutande i webbläsarens minne utan någon nätverksöverföring. Begränsade alternativ utan avancerad anpassning
Web Crypto-verifiering av HS256, HS384 & HS512 Beräknar om och validerar RFC 7515 JWS HMAC-SHA2-signaturer lokalt via SubtleCrypto med råa UTF-8- eller Base64URL-kodade hemliga nycklar. 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-avkodare & Inspektör i 3 enkla steg

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

1

Klistra In eller Ladda Upp Din JSON Web Token

Klistra in en tredelad punktseparerad JWT-sträng (med eller utan Authorization Bearer-prefix) eller släpp en lokal .jwt- eller .txt-fil i inspektören.

2

Inspektera JOSE-header, Claims & Livscykel

Granska den formaterade JSON-headern och payloaden tillsammans med avkodade UTC- och lokala tidsstämplar för exp-, nbf- och iat-claims för att felsöka klockförskjutning eller utgångna tokens.

3

Verifiera HMAC-signaturen Lokalt

Ange din delade hemliga nyckel för HS256, HS384 eller HS512 för att validera tokenintegriteten direkt i webbläsaren via Web Crypto API.

Hur man avkodar och verifierar en JSON Web Token steg för steg

Snabbsvar: Dela upp den kompakta JWT-strängen vid dess två punktavgränsare till Base64URL-segment för header, payload och signatur. Avkoda de två första segmenten som UTF-8 JSON för att inspektera claims och NumericDate-tidsstämplar, och beräkna sedan om HMAC-kontrollsumman över den råa ASCII-strängen header.payload med din hemliga nyckel för att bekräfta äktheten.

En RFC 7519 JSON Web Token som överförs i JWS Compact Serialization består av tre Base64URL-strängar utan utfyllnad som sammanfogas med punkter: <header>.<payload>.<signature>. Om du kopierar ett HTTP-headervärde som Authorization: Bearer <token> tar avkodaren bort det inledande Bearer -prefixet innan strängen delas upp vid ..

Betrakta denna standardiserade HS256-signerade kompakta token:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

1. Avkodad skyddad JOSE-header

När det första segmentet (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9) avkodas från Base64URL erhålls 27 UTF-8-byte som beskriver den kryptografiska algoritmen och medietypen:

{
  "alg": "HS256",
  "typ": "JWT"
}

2. Avkodad Claims-payload & NumericDate-tidsstämplar

Base64URL-avkodning av det andra segmentet (eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) visar uppsättningen av JSON-claims:

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

Här motsvarar iat (1516239022) tidpunkten 2018-01-18T01:30:22Z i UTC. När du inspekterar en åtkomsttoken från produktion som innehåller fullständiga livscykelgränser, utvärderar inspektören varje NumericDate-claim mot din aktuella systemklocka:

{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "iat": 1735689600,
  "nbf": 1735689600,
  "exp": 1735693200
}
  • iat (1735689600): Utfärdad 2025-01-01T00:00:00Z.
  • nbf (1735689600): Giltig tidigast 2025-01-01T00:00:00Z.
  • exp (1735693200): Löper ut 2025-01-01T01:00:00Z (exakt 3 600 sekunders TTL).

3. Lokal verifiering av HMAC-SHA256-signatur

Avkodning bevisar endast att de två första segmenten är giltig Base64URL-kodad JSON; det bevisar inte att innehållet är oförvanskat. När du anger den delade hemligheten your-256-bit-secret för det första exemplet ovan skickar verifieraren exakt den signerade ASCII-indatan (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) och Base64URL-signaturen på 43 tecken (SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c) till crypto.subtle.verify("HMAC", key, signatureBytes, signingInputBytes). Även en ändring av en enda bit i den avkodade JSON-payloaden ändrar den förväntade MAC-taggen på 32 byte och utlöser omedelbart ett signaturfel.

RFC 7519-struktur, Base64URL-kodning och säkerhetsdetaljer i JWS

Snabbsvar: En RFC 7519 JWT i JWS Compact Serialization består av tre Base64URL-segment utan utfyllnad som separeras med punkter. Avkodning omvandlar endast Base64URL-kodning till läsbar UTF-8 JSON; integritet och autenticitet beror helt på att den kryptografiska signaturen verifieras mot en strikt lista över tillåtna algoritmer.

Att förstå hur JOSE-specifikationerna (RFC 7515 JWS, RFC 7518 JWA, RFC 7519 JWT och RFC 8725 JWT Best Current Practices) samverkar förhindrar subtila autentiseringsbuggar och säkerhetshål.

Base64URL jämfört med standard-Base64 (RFC 4648 avsnitt 5)

Standard-Base64 använder +, / och utfyllnadstecknet = som krockar med avgränsare i URL-frågesträngar, sökvägssegment och cookie-tolkare. JWS kräver Base64URL-kodning utan utfyllnad:

  • Index 62 mappas till - (bindestreck-minus) istället för +.
  • Index 63 mappas till _ (understreck) istället för /.
  • Avslutande =-utfyllnadstecken utelämnas vid serialisering och återställs vid avkodning via (4 - (segment.length % 4)) % 4.
  • Avkodade byte måste tolkas som UTF-8 via TextDecoder("utf-8"), inte med webbläsarens atob() som ger Latin-1-strängar och förvränger multibyte Unicode-tecken i namn eller lokaliserade claims. För fristående payloads som inte är JWT, använd Base64-kodare & Avkodare.

Specifikationer för JWA HMAC-SHA2-algoritmer (RFC 7518 avsnitt 3.2)

  • HS256 (HMAC med SHA-256): Genererar en autentiseringstagg på 256 bitar (32 byte) kodad som 43 Base64URL-tecken. Kräver en hemlig nyckel på minst 256 bitar (32 byte).
  • HS384 (HMAC med SHA-384): Genererar en autentiseringstagg på 384 bitar (48 byte) kodad som 64 Base64URL-tecken. Kräver en hemlig nyckel på minst 384 bitar (48 byte).
  • HS512 (HMAC med SHA-512): Genererar en autentiseringstagg på 512 bitar (64 byte) kodad som 86 Base64URL-tecken. Kräver en hemlig nyckel på minst 512 bitar (64 byte).

NumericDate-precision och tidsmarginal för klockförskjutning (Clock Skew)

RFC 7519 avsnitt 2 definierar NumericDate som ett numeriskt JSON-värde som representerar sekunder (inte millisekunder) sedan 1970-01-01T00:00:00Z UTC, exklusive skottsekunder. Standardiserade verifierare avvisar en token om inte current_time < exp + leeway (token har inte löpt ut) och current_time >= nbf - leeway (token är aktiv), där leeway (tidsmarginal) vanligtvis är 30 till 60 sekunder för att hantera NTP-avvikelser mellan distribuerade servrar.

Kritiska sårbarheter vid verifiering (RFC 8725)

  1. Osäkrad nedgradering via alg: "none": Lita aldrig dynamiskt på headerns alg-fält. Om en backend accepterar {"alg":"none","typ":"JWT"} med ett tomt signatursegment (header.payload.) kan en angripare förfalska godtyckliga administratörsbehörigheter utan nyckel.
  2. Algoritmförväxling (RS256 till HS256): Om en server förväntar sig en asymmetrisk RS256-token verifierad med en publik RSA-nyckel, men dess JWT-bibliotek väljer verifieringsmetod enbart baserat på den inkommande alg-headern, kan en angripare ändra alg till HS256 och signera token symmetriskt genom att använda den publikt tillgängliga RSA-nyckelns råa byte som HMAC-hemlighet.
  3. Overifierade decode()-anrop i produktion: Att anropa hjälpmetoder som jwt.decode(token) istället för jwt.verify(token, secret, { algorithms: ["HS256"] }) tolkar opålitlig användarindata utan att kontrollera signaturen.

JWT-avkodare jämfört med JWT-generator: Vilket verktyg behöver du?

Snabbsvar: Använd JWT-avkodare & Inspektör för att tolka, granska tidsstämplar och verifiera signaturen på en befintlig token från ett API-anrop eller en identitetsleverantör. Använd JWT-generator när du behöver skapa anpassade claims och kryptografiskt signera en helt ny HS256-, HS384- eller HS512-token för testning.

Båda verktygen körs 100 % lokalt i din webbläsare med hjälp av Web Crypto API, men de fyller motsatta behov i livscykeln för autentiseringsfelsökning. Använd JWT-avkodare & Inspektör när du granskar en befintlig token; byt till JWT-generator när du vill skapa nya signerade testtokens från grunden.

Funktion JWT-avkodare & Inspektör (Detta verktyg) JWT-generator
Primärt arbetsflöde Tolka, granska och verifiera en befintlig JWT Konstruera claims och signera en ny JWT
Indataformat Kompakt token (<header>.<payload>.<signature>) + valfri hemlighet JOSE-headerval + JSON-claims + hemlig HMAC-nyckel
Genererad utdata Formaterad JSON för header/payload, tidsstämpelanalys, signaturstatus Signerad kompakt tredelad Base64URL Bearer-token
Web Crypto-operation SubtleCrypto.verify() (HMAC-SHA256/384/512) SubtleCrypto.sign() (HMAC-SHA256/384/512)
Hantering av tidsstämplar Konverterar exp, nbf och iat till UTC/lokala datum & nedräkningar Fyller i NumericDate-sekunder (Unix-epok) för anpassade TTL-tider
Bästa tekniska användningsområde Felsökning av 401 Unauthorized-svar, OIDC-tokens och klockförskjutning Generering av lokal testdata för API-autentisering, RBAC-tester och utgångna tokens

Om du arbetar med råa Base64- eller Base64URL-strängar som inte är tredelade JOSE-tokens (exempelvis HTTP Basic Auth-inloggningsuppgifter eller binära datamängder), använd Base64-kodare & Avkodare.

FAQ

JWT-avkodare & Inspektör FAQ och teknisk guide

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

Är det säkert att klistra in JWTs från produktion i en online-avkodare?

Att klistra in aktiva Bearer-tokens på serverbaserade webbplatser medför en risk att aktiva sessionsuppgifter läcker till externa åtkomstloggar, analysverktyg eller synkroniserad webbläsarhistorik. Denna avkodare tolkar Base64URL-segment och kör Web Crypto HMAC-verifiering helt lokalt i din webbläsarflik utan några nätverksanrop. Följ ändå principen om minsta privilegium: maskera eller rotera delade hemligheter om de någonsin har exponerats utanför betrodda miljöer.

Varför kan vem som helst avkoda min JWT-payload utan att känna till min hemliga nyckel?

En vanlig tredelad JWT är en JSON Web Signature (JWS, RFC 7515), inte en krypterad JSON Web Encryption-token (JWE, RFC 7516). I en JWS är headern och payloaden enbart Base64URL-kodad UTF-8 JSON för URL-säker transport. Den hemliga nyckeln skyddar integriteten och äktheten via signaturen så att ingen kan ändra claims oupptäckt, men den ger ingen konfidentialitet. Lagra aldrig lösenord i klartext, API-hemligheter eller okrypterade känsliga personuppgifter (PII) i JWS-claims.

Varför misslyckas signaturverifieringen trots att min hemliga nyckel ser rätt ut?

Fyra problem orsakar nästan alla falskt negativa HMAC-fel: (1) felaktig nyckelkodning, där utfärdaren signerade med råa binära byte avkodade från en Base64/Base64URL-sträng medan du verifierade med de bokstavliga UTF-8-tecknen (eller omvänt); (2) oavsiktliga inledande eller avslutande blanksteg eller radbrytningar som kopierats med hemligheten eller token; (3) omkodning av formaterad (pretty-printed) JSON istället för verifiering mot de exakta ursprungliga Base64URL ASCII-segmenten; eller (4) försök att verifiera en asymmetrisk RS256- eller ES256-token med en delad HMAC-hemlighet istället för utfärdarens publika nyckel.

Varför visar min exp-tidsstämpel i JWT ett datum tiotusentals år framåt i tiden?

RFC 7519 avsnitt 2 definierar NumericDate i sekunder sedan Unix-epoken (10 siffror, exempelvis 1767225600), medan JavaScripts Date.now() returnerar millisekunder sedan Unix-epoken (13 siffror, exempelvis 1767225600000). Om millisekunder skickas direkt in i exp eller iat multipliceras epokvärdet med 1000, vilket flyttar en tidsstämpel från 2026 bortom år 58000 och förhindrar att token löper ut normalt.

Hur ser jag om en JWT är signerad (JWS) eller krypterad (JWE)?

Räkna punktavgränsarna och inspektera den avkodade JOSE-headern. En signerad JWS har två punkter som skiljer tre Base64URL-delar åt (header, payload, signatur) och innehåller en alg-parameter som HS256, RS256 eller ES256. En krypterad RFC 7516 JWE har fyra punkter som skiljer fem Base64URL-delar åt (header, krypterad nyckel, initieringsvektor, chiffertext, autentiseringstagg) och inkluderar en enc-parameter för innehållskryptering, exempelvis A256GCM.