Narzędzie JWT

Powiązane Rekomendacje

Czym jest Dekodowanie, Weryfikacja i Generowanie JWT?

Przypadki użycia

• Dekodowanie JWT online: szybkie rozdzielanie tokena podczas debugowania logowania OAuth 2.0 / OIDC, aby inspekcjonować algorytm Header i Claims Payload
• Weryfikacja podpisów JWT: użyj Secretu / klucza publicznego, aby zweryfikować podpisy tokenów w czasie rzeczywistym i określić, czy 401 to 'zły podpis', 'wygasły' czy 'niedopasowany algorytm'
• Generowanie testowych JWT podczas integracji: wydaj JWT w przeglądarce z testową parą kluczy, bez potrzeby tymczasowej zmiany kodu backendu, aby wygenerować token
• Konwersja PEM ↔ JWK: OIDC IdP dał ci JWK, ale serwer potrzebuje PEM (lub odwrotnie) — konwertuj na miejscu zamiast pisać skrypt OpenSSL
• Diagnozowanie 401 Unauthorized: krok po kroku sprawdzaj wygaśnięcie, dopasowanie alg do bramy, dopasowanie klucza i formatowanie PEM
• Porównywanie RS256 vs PS256: wielu dostawców OIDC domyślnie używa RS256, podczas gdy AWS SigV4 preferuje PS256 — przełączaj algorytmy z tą samą parą kluczy RSA i porównuj wyniki
• Nauka wewnętrznych mechanizmów JWT: zmień alg, edytuj Payload, zamień klucz w przeglądarce i obserwuj, jak podpis się łamie w czasie rzeczywistym — znacznie szybciej niż czytanie RFC

Jak Używać

1. Wklej lub wpisz token: umieść ciąg JWT w polu wejściowym; narzędzie automatycznie rozdziela Header, Payload i Signature i wyświetla każdy jako JSON
2. Wybierz algorytm: przełączaj między HS256 / RS256 / ES256 / PS256 / EdDSA; narzędzie wywnioskuje z Header.alg i oznacza wszelkie niedopasowania
3. Importuj klucz: wklej sekret HMAC, ciąg PEM lub JSON JWK; dla algorytmów asymetrycznych kliknij 'Generuj parę kluczy', aby natychmiast uzyskać klucz testowy
4. Weryfikuj lub podpisz ponownie: w trybie Decode weryfikuj kluczem publicznym i zobacz '✅ podpis ważny / ❌ podpis nieważny'; w trybie Encode edytuj Claims i podpisz kluczem prywatnym, aby wygenerować nowy token

Output Example

A real MP3 file encoded to a Data URI — copy-ready:

Header (Base64URL): eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload (Base64URL): eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkphbmUgRG9lIiwiaWF0IjoxNzE2MjM5MDIyfQ
Signature: kZJfaYjK3iCkVFL5EL9zGRZ5SmD8_x2h6B5c7pVFfVGo

Funkcje

• Dekodowanie + Weryfikacja + Generowanie w jednym miejscu: wklej token, aby rozdzielić Header/Payload/Signature, przełącz algorytm i klucz, aby zweryfikować podpis, edytuj Claims i podpisz ponownie, aby wygenerować nowy token — obejmuje pełny łańcuch rozwiązywania problemów JWT
• Wszystkie 13 algorytmów obsługiwane: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — obejmuje OAuth 2.0, OIDC, JWS, bramy API i korporacyjne SSO
• Formaty PEM i JWK: klucze RSA, ECDSA i Ed25519 akceptują ciągi PEM (z nagłówkami -----BEGIN PUBLIC KEY-----) i JSON JWK (pola kid/kty/n/e) — bezpośrednio wstaw wyjście OIDC /.well-known/jwks.json
• Wiele form wprowadzania sekretu HMAC: surowy ciąg UTF-8, bajty hex lub zakodowany Base64/Base64URL — przełączaj jednym kliknięciem, aby nigdy nie zdarzyło się 'wygląda tak samo, ale podpis nie przechodzi'
• Automatyczne generowanie par kluczy: pary kluczy RSA-2048, RSA-4096, P-256, P-384 i Ed25519 generowane w przeglądarce, prezentowane w formatach PEM i JWK do natychmiastowego użycia testowego
• Semantyczne podświetlanie Claims: exp / iat / nbf automatycznie konwertowane na czytelny czas z podświetlonym statusem wygasły / jeszcze-nieważny / wydany; alg / typ / kid w Header oznaczone indywidualnie
• 100% po stronie klienta, zero przesyłania: każde parsowanie, weryfikacja i podpisywanie działa przez natywny Web Crypto API przeglądarki — tokeny, klucze i payload nigdy nie opuszczają przeglądarki, zgodnie z zasadą bezpieczeństwa 'nigdy nie wklejaj produkcyjnych tokenów do losowych narzędzi online'
• Kopiowanie jednym kliknięciem: Header, Payload, Signature i nowo wygenerowany token są niezależnie kopiowalne do dokumentacji, ticketów i poleceń curl

Przykłady kodu

const crypto = require('node:crypto')

function b64url(input) {
  return Buffer.from(input)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}

function hmacSign(data, secret) {
  return b64url(crypto.createHmac('sha256', secret).update(data).digest())
}

function sign(payload, secret) {
  const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
  const body = b64url(JSON.stringify(payload))
  const signature = hmacSign(`${header}.${body}`, secret)
  return `${header}.${body}.${signature}`
}

function verify(token, secret) {
  const [h, p, s] = token.split('.')
  const expected = hmacSign(`${h}.${p}`, secret)
  const a = Buffer.from(s)
  const b = Buffer.from(expected)
  return a.length === b.length && crypto.timingSafeEqual(a, b)
}

const SECRET = 'my-super-secret-key'
const payload = { userId: 42, role: 'admin', exp: Math.floor(Date.now() / 1000) + 3600 }
const token = sign(payload, SECRET)

console.log(token)
console.log(verify(token, SECRET))       // true
console.log(verify(token, 'wrong-key'))  // false

<!doctype html>
<html>
  <body>
    <pre id="out"></pre>
    <script>
      const out = document.getElementById('out')

      const b64url = buf =>
        btoa(String.fromCharCode(...new Uint8Array(buf)))
          .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

      const b64urlStr = str => b64url(new TextEncoder().encode(str))

      async function sign(payload, secret) {
        const header = b64urlStr(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
        const body = b64urlStr(JSON.stringify(payload))
        const data = new TextEncoder().encode(`${header}.${body}`)

        const key = await crypto.subtle.importKey(
          'raw',
          new TextEncoder().encode(secret),
          { name: 'HMAC', hash: 'SHA-256' },
          false,
          ['sign']
        )

        const sig = await crypto.subtle.sign('HMAC', key, data)
        return `${header}.${body}.${b64url(sig)}`
      }

      ;(async () => {
        const token = await sign({ user: 'alice', role: 'admin' }, 'browser-demo-secret')
        out.textContent = token
      })()
    </script>
  </body>
</html>

import { jwtVerify, importSPKI } from 'jose'
import { readFile } from 'node:fs/promises'

const token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IjEifQ.payload.signature'
const publicKeyPem = await readFile('public.pem', 'utf8')

try {
  const { payload, protectedHeader } = await jwtVerify(
    token,
    await importSPKI(publicKeyPem, 'RS256'),
    {
      issuer: 'https://idp.example.com',
      audience: 'my-app',
      algorithms: ['RS256'],     // critical: algorithm whitelist blocks alg:none and HS256-substitution attacks
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // common: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Parse (no signature check, just look at Header and Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

print(jwt.decode(token, options={'verify_signature': False}))
# {'sub': '1234'}

# Full verification
claims = jwt.decode(
    token,
    'my-super-secret-key',
    algorithms=['HS256'],
    audience='my-app',
    issuer='my-service',
)
print(claims['sub'])

Porównanie 5 typów algorytmów podpisu JWT: który wybrać?

JWT to nie jeden algorytm — 5 rodzin algorytmów oferuje różne kompromisy w zakresie kluczy, wydajności, bezpieczeństwa i kompatybilności. Najpierw oceń scenariusz, potem wybierz algorytm — pozwoli to uniknąć wielu problemów.

Best Practices

Często Zadawane Pytania

Rozwiązywanie problemów

Privacy & Security

Ten warsztat JWT działa w 100% w Twojej przeglądarce, wspierany przez natywny Web Crypto API przeglądarki. Token, który wklejasz, Header, Payload, Signature, sekret HMAC, wszelkie klucze prywatne RSA/ECDSA, wszelkie wygenerowane pary kluczy i każde obliczenie podpisu/weryfikacji pozostają na Twoim urządzeniu — nigdy nie podróżują do serwera, nigdy nie są logowane, nigdy analizowane i nigdy buforowane. Strona może być używana offline po załadowaniu. Najlepsza praktyka: nigdy nie wklejaj długotrwałych tokenów produkcyjnych ani produkcyjnych kluczy prywatnych do żadnego narzędzia online, w tym tego. To narzędzie jest odpowiednie do debugowania, testowania integracji, nauki i generowania tokenów testowych — produkcyjne sekrety i klucze prywatne powinny być obsługiwane w kontrolowanym, lokalnym środowisku.

Supported Video Formats

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — official debugger and library index
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFJOSE working group overview