JWT-decoder & -inspecteur

Decodeer, inspecteer en verifieer RFC 7519 JSON Web Tokens lokaal in je browser.

Geen uploadsGeen registratieDirect resultaat
RFC 7519-claims & datumsHS256 / HS384 / HS512 verifiëren100% Lokaal • Geen Uploads
JWT decoderen
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis JWT-decoder & -inspecteur gebruiken?

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

100% Client-side Token-inspectie

Productie-OAuth2-toegangstokens, OIDC ID-tokens en gedeelde geheime sleutels worden uitsluitend in het browsergeheugen geparseerd zonder enige netwerkoverdracht.

Web Crypto HS256, HS384 & HS512 Verificatie

Herberekent en valideert RFC 7515 JWS HMAC-SHA2-handtekeningen lokaal via SubtleCrypto met behulp van ruwe UTF-8- of Base64URL-gecodeerde geheime sleutels.

Live Controle van exp, nbf & iat Tijdstempels

Vertaalt RFC 7519 Unix-epoch NumericDate-velden naar UTC- en lokale ISO 8601-tijdstempels met realtime aftelklokken voor vervaldatum en activering.

Strikte RFC 7519 & Base64URL Naleving

Decodeert Base64URL-segmenten zonder padding met volledige multi-byte UTF-8-ondersteuning, verwijdert Authorization Bearer-voorvoegsels en markeert onveilige alg:none-headers.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
100% Client-side Token-inspectie Productie-OAuth2-toegangstokens, OIDC ID-tokens en gedeelde geheime sleutels worden uitsluitend in het browsergeheugen geparseerd zonder enige netwerkoverdracht. Beperkte opties zonder geavanceerde aanpassing
Web Crypto HS256, HS384 & HS512 Verificatie Herberekent en valideert RFC 7515 JWS HMAC-SHA2-handtekeningen lokaal via SubtleCrypto met behulp van ruwe UTF-8- of Base64URL-gecodeerde geheime sleutels. 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-decoder & -inspecteur te gebruiken in 3 eenvoudige stappen

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

1

Plak of Upload je JSON Web Token

Plak een driedelige, door punten gescheiden JWT-string (met of zonder Authorization Bearer-voorvoegsel) of sleep een lokaal .jwt- of .txt-bestand naar de inspecteur.

2

Inspecteer JOSE-header, Claims & Levenscyclus

Bekijk de geformatteerde JSON-header en -payload naast gedecodeerde UTC- en lokale tijdstempels voor exp-, nbf- en iat-claims om clock-skew of vervalproblemen op te sporen.

3

Verifieer de HMAC-handtekening Lokaal

Voer je gedeelde geheime sleutel (shared secret) voor HS256, HS384 of HS512 in om de integriteit van het token direct in je browser te valideren via de Web Crypto API.

Stap voor Stap een JSON Web Token Decoderen en Verifiëren

Kort antwoord: Splits het compacte JWT op de twee puntscheidingstekens in Base64URL-segmenten voor header, payload en handtekening. Decodeer de eerste twee segmenten als UTF-8 JSON om claims en NumericDate-tijdstempels te inspecteren, en herbereken vervolgens de HMAC-digest over de ruwe ASCII-string header.payload met je geheime sleutel om de authenticiteit te bevestigen.

Een RFC 7519 JSON Web Token dat wordt verzonden in JWS Compact Serialization bestaat uit drie Base64URL-strings zonder padding, verbonden door punten: <header>.<payload>.<signature>. Als je een HTTP-headerwaarde zoals Authorization: Bearer <token> kopieert, verwijdert de decoder het voorloop-voorvoegsel Bearer voordat er op . wordt gesplitst.

Bekijk dit standaard met HS256 ondertekende compacte token:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

1. Gedecodeerde Beveiligde JOSE-header

Het Base64URL-decoderen van het eerste segment (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9) levert 27 UTF-8-bytes op die het cryptografische algoritme en het mediatype beschrijven:

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

2. Gedecodeerde Claims-payload & NumericDate-tijdstempels

Het Base64URL-decoderen van het tweede segment (eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) onthult de JSON-claimsset:

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

Hier wordt iat (1516239022) omgezet naar 2018-01-18T01:30:22Z in UTC. Bij het inspecteren van een productie-toegangstoken met volledige levenscyclusgrenzen evalueert de inspecteur elke NumericDate-claim ten opzichte van je huidige systeemklok:

{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "iat": 1735689600,
  "nbf": 1735689600,
  "exp": 1735693200
}
  • iat (1735689600): Uitgegeven op 2025-01-01T00:00:00Z.
  • nbf (1735689600): Niet geldig vóór 2025-01-01T00:00:00Z.
  • exp (1735693200): Verloopt op 2025-01-01T01:00:00Z (exacte TTL van 3.600 seconden).

3. Lokale HMAC-SHA256 Handtekeningverificatie

Decoderen bewijst alleen dat de eerste twee segmenten geldige Base64URL-gecodeerde JSON zijn; het bewijst niet dat de claims ongewijzigd zijn. Wanneer je het gedeelde geheim your-256-bit-secret voor het eerste voorbeeld hierboven invoert, geeft de verificatietool de exacte ASCII-ondertekeningsinvoer (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) en de 43 tekens lange Base64URL-handtekening (SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c) door aan crypto.subtle.verify("HMAC", key, signatureBytes, signingInputBytes). Elke wijziging van slechts één bit in de gedecodeerde JSON-payload verandert de verwachte 32-byte MAC-tag en veroorzaakt onmiddellijk een ongeldige handtekening.

RFC 7519-structuur, Base64URL-codering en JWS-beveiligingsnuances

Kort antwoord: Een RFC 7519 JWT in JWS Compact Serialization bestaat uit drie Base64URL-segmenten zonder padding, gescheiden door punten. Decoderen zet alleen de Base64URL-codering terug om in leesbare UTF-8 JSON; integriteit en authenticiteit zijn strikt afhankelijk van het verifiëren van de cryptografische handtekening tegen een expliciete allowlist van algoritmen.

Inzicht in de wisselwerking tussen JOSE-specificaties (RFC 7515 JWS, RFC 7518 JWA, RFC 7519 JWT en RFC 8725 JWT Best Current Practices) voorkomt subtiele authenticatiebugs en beveiligingslekken.

Base64URL versus Standaard Base64 (RFC 4648 Sectie 5)

Standaard Base64 gebruikt +, / en = padding-tekens die botsen met URL-queryscheidingstekens, padsegmenten en cookie-parsers. JWS vereist Base64URL-codering zonder padding (unpadded Base64URL):

  • Index 62 wordt afgebeeld op - (koppelteken-minteken) in plaats van +.
  • Index 63 wordt afgebeeld op _ (liggend streepje) in plaats van /.
  • Achterliggende = padding-tekens worden weggelaten bij het serialiseren en tijdens het decoderen hersteld via (4 - (segment.length % 4)) % 4.
  • Gedecodeerde bytes moeten worden geïnterpreteerd als UTF-8 via TextDecoder("utf-8"), en niet via browser atob() Latin-1-strings, die multi-byte Unicode-tekens in namen of gelokaliseerde claims beschadigen. Gebruik voor losstaande niet-JWT-payloads de Base64-encoder & -decoder.

JWA HMAC-SHA2 Algoritmespecificaties (RFC 7518 Sectie 3.2)

  • HS256 (HMAC met SHA-256): Produceert een 256-bits (32-byte) authenticatietag gecodeerd als 43 Base64URL-tekens. Vereist een geheime sleutel van minimaal 256 bits (32 bytes).
  • HS384 (HMAC met SHA-384): Produceert een 384-bits (48-byte) authenticatietag gecodeerd als 64 Base64URL-tekens. Vereist een geheime sleutel van minimaal 384 bits (48 bytes).
  • HS512 (HMAC met SHA-512): Produceert een 512-bits (64-byte) authenticatietag gecodeerd als 86 Base64URL-tekens. Vereist een geheime sleutel van minimaal 512 bits (64 bytes).

NumericDate-precisie en Clock-Skew-marge (Leeway)

RFC 7519 Sectie 2 definieert NumericDate als een numerieke JSON-waarde die seconden (geen milliseconden) voorstelt vanaf 1970-01-01T00:00:00Z UTC, waarbij schrikkelseconden worden genegeerd. Conforme verificatietools wijzen een token af tenzij current_time < exp + leeway (token is niet verlopen) en current_time >= nbf - leeway (token is actief), waarbij leeway doorgaans 30 tot 60 seconden bedraagt om NTP-klokafwijkingen tussen gedistribueerde hosts op te vangen.

Kritieke Kwetsbaarheden bij Verificatie (RFC 8725)

  1. Onbeveiligde alg: "none" Downgrade: Vertrouw nooit dynamisch op het alg-veld van de header. Als een backend {"alg":"none","typ":"JWT"} met een leeg handtekeningsegment (header.payload.) accepteert, kan een aanvaller zonder sleutel willekeurige beheerdersclaims vervalsen.
  2. Algoritmeverwarring (RS256 naar HS256): Als een server een asymmetrisch RS256-token verwacht dat wordt geverifieerd met een publieke RSA-sleutel, maar de JWT-bibliotheek puur op basis van de binnenkomende alg-header handelt, kan een aanvaller alg wijzigen in HS256 en het token symmetrisch ondertekenen met de openbaar beschikbare publieke RSA-sleutelbytes als het HMAC-geheim.
  3. Ongeverifieerde decode()-aanroepen in Productie: Het aanroepen van hulpmethoden zoals jwt.decode(token) in plaats van jwt.verify(token, secret, { algorithms: ["HS256"] }) parseert onbetrouwbare gebruikersinvoer zonder de handtekening te controleren.

JWT-decoder versus JWT Generator: Welke Tool Heb Je Nodig?

Kort antwoord: Gebruik JWT-decoder & -inspecteur om een bestaand token uit een API-verzoek of identity provider te parseren, tijdstempels te controleren en de handtekening te verifiëren. Gebruik JWT Generator wanneer je aangepaste claims wilt opstellen en een gloednieuw HS256-, HS384- of HS512-token cryptografisch wilt ondertekenen voor testdoeleinden.

Beide tools werken 100% lokaal in je browser via de Web Crypto API, maar bedienen tegenovergestelde kanten van de authenticatie-debuggingcyclus. Gebruik JWT-decoder & -inspecteur wanneer je een bestaand token wilt onderzoeken; schakel over naar JWT Generator wanneer je vanaf nul nieuwe ondertekende testtokens wilt aanmaken.

Kenmerk JWT-decoder & -inspecteur (Deze Tool) JWT Generator
Primaire Workflow Een bestaand JWT parseren, controleren en verifiëren Claims opbouwen en een nieuw JWT ondertekenen
Invoerformaat Compact token (<header>.<payload>.<signature>) + optioneel geheim JOSE-headeropties + JSON-claims + geheime HMAC-sleutel
Geproduceerde Uitvoer Geformatteerde header/payload-JSON, tijdstempelcontrole, geldigheid handtekening Ondertekend compact driedelig Base64URL Bearer-token
Web Crypto-bewerking SubtleCrypto.verify() (HMAC-SHA256/384/512) SubtleCrypto.sign() (HMAC-SHA256/384/512)
Tijdstempelverwerking Zet exp, nbf en iat om in UTC/lokale datums & aftelklokken Vult Unix-epoch NumericDate-seconden in voor aangepaste TTL's
Beste Engineering-toepassing Debuggen van 401 Unauthorized-responses, OIDC-tokens en clock-skew Genereren van lokale API-authenticatie-fixtures, RBAC-tests en tests met verlopen tokens

Als je werkt met ruwe Base64- of Base64URL-strings die geen driedelige JOSE-tokens zijn (zoals HTTP Basic Auth-inloggegevens of binaire datablobs), gebruik dan de Base64-encoder & -decoder.

Veelgestelde vragen

JWT-decoder & -inspecteur FAQ en Technische Gids

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

Is het veilig om productie-JWT's in een online decoder te plakken?

Het plakken van actieve bearer-tokens in servergestuurde websites brengt het risico met zich mee dat live sessiegegevens uitlekken naar externe toegangslogboeken, analytics-payloads of browsersynchronisatie. Deze decoder parseert Base64URL-segmenten en voert Web Crypto HMAC-verificatie volledig binnen je lokale browsertabblad uit zonder netwerkverzoeken. Hanteer desondanks altijd het least-privilege-principe: verberg of roteer gedeelde geheimen als ze ooit buiten vertrouwde omgevingen zijn blootgesteld.

Waarom kan iedereen mijn JWT-payload decoderen zonder mijn geheime sleutel te kennen?

Een standaard driedelig JWT is een JSON Web Signature (JWS, RFC 7515), geen versleuteld JSON Web Encryption-token (JWE, RFC 7516). In een JWS zijn de header en payload enkel Base64URL-gecodeerde UTF-8 JSON voor URL-veilig transport. De geheime sleutel beschermt de integriteit en authenticiteit via de handtekening zodat niemand ongemerkt claims kan wijzigen, maar biedt geen enkele vertrouwelijkheid. Sla nooit wachtwoorden in platte tekst, API-geheimen of onversleutelde gevoelige persoonsgegevens (PII) op in JWS-claims.

Waarom mislukt de handtekeningverificatie zelfs als mijn geheime sleutel er correct uitziet?

Vier problemen veroorzaken bijna alle vals-negatieve HMAC-fouten: (1) een mismatch in sleutelcodering, waarbij de uitgever heeft ondertekend met ruwe binaire bytes gedecodeerd uit een Base64/Base64URL-geheime string terwijl jij verifieert met de letterlijke UTF-8-tekens (of andersom); (2) per ongeluk meegekopieerde spaties of regeleinden aan het begin of einde van het geheim of token; (3) het opnieuw coderen van geformatteerde (pretty-printed) JSON in plaats van te verifiëren tegen de exacte originele Base64URL ASCII-segmenten; of (4) proberen een asymmetrisch RS256- of ES256-token te verifiëren met een gedeeld HMAC-geheim in plaats van de publieke sleutel van de uitgever.

Waarom toont mijn JWT exp-tijdstempel een datum tienduizenden jaren in de toekomst?

RFC 7519 Sectie 2 definieert NumericDate in Unix-epoch-seconden (10 cijfers, zoals 1767225600), terwijl JavaScript Date.now() Unix-epoch-milliseconden retourneert (13 cijfers, zoals 1767225600000). Door milliseconden rechtstreeks door te geven aan exp of iat wordt de epoch-offset met 1000 vermenigvuldigd, waardoor een tijdstempel uit 2026 voorbij het jaar 58000 wordt geschoven en het token niet normaal verloopt.

Hoe zie ik of een JWT ondertekend (JWS) of versleuteld (JWE) is?

Tel de puntscheidingstekens en inspecteer de gedecodeerde JOSE-header. Een ondertekende JWS heeft twee punten die drie Base64URL-delen scheiden (header, payload, handtekening) en bevat een alg-parameter zoals HS256, RS256 of ES256. Een versleutelde RFC 7516 JWE heeft vier punten die vijf Base64URL-delen scheiden (header, versleutelde sleutel, initialisatievector, cijfertekst, authenticatietag) en bevat daarnaast een enc-parameter voor inhoudsversleuteling zoals A256GCM.