Decode JWT

Rekomendasi Terkait

Kasus penggunaan

• Dekode JWT online: pisahkan token dengan cepat saat debugging login OAuth 2.0 / OIDC untuk memeriksa algoritma Header dan Claims Payload
• Verifikasi tanda tangan JWT: gunakan Secret / kunci publik untuk memverifikasi tanda tangan token secara real-time dan tentukan apakah 401 adalah 'tanda tangan buruk', 'kedaluwarsa', atau 'algoritma tidak cocok'
• Generate JWT pengujian selama integrasi: terbitkan JWT di browser dengan pasangan kunci pengujian, tanpa perlu backend sementara mengubah kode untuk menerbitkan token
• Konversi PEM ↔ JWK: OIDC IdP memberi Anda JWK tetapi server membutuhkan PEM (atau sebaliknya) — konversi di tempat daripada menulis skrip OpenSSL
• Diagnosis 401 Unauthorized: periksa kedaluwarsa, kecocokan alg-gateway, kecocokan kunci, dan pemformatan PEM langkah demi langkah
• Bandingkan RS256 vs PS256: banyak penyedia OIDC menggunakan RS256 secara default sementara AWS SigV4 lebih memilih PS256 — ganti algoritma dengan pasangan kunci RSA yang sama dan bandingkan hasilnya
• Pelajari mekanisme internal JWT: ganti alg, edit Payload, ganti kunci di browser dan lihat bagaimana tanda tangan rusak secara real-time — jauh lebih cepat daripada membaca RFC

Fitur

• Dekode + Verifikasi + Generate dalam satu tempat: tempel token untuk memisahkan Header/Payload/Signature, ganti algoritma dan kunci untuk memverifikasi tanda tangan, edit Claims dan tanda tangani ulang untuk membuat token baru — mencakup seluruh rantai pemecahan masalah JWT
• Semua 13 algoritma didukung: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — mencakup OAuth 2.0, OIDC, JWS, gateway API, dan SSO perusahaan
• Format PEM dan JWK: kunci RSA, ECDSA, dan Ed25519 menerima string PEM (dengan header -----BEGIN PUBLIC KEY-----) dan JSON JWK (field kid/kty/n/e) — langsung tempel output OIDC /.well-known/jwks.json
• Berbagai format input Secret HMAC: string UTF-8 mentah, byte hex, atau Base64/Base64URL terenkripsi — ganti dengan satu klik, agar tidak pernah terjadi 'terlihat sama tapi tanda tangan gagal'
• Generasi pasangan kunci otomatis: pasangan kunci RSA-2048, RSA-4096, P-256, P-384, dan Ed25519 dihasilkan di browser, disajikan dalam format PEM dan JWK untuk penggunaan pengujian langsung
• Penyorotan semantik Claims: exp / iat / nbf secara otomatis dikonversi ke waktu yang dapat dibaca dengan status kedaluwarsa / belum-valid / diterbitkan disorot; alg / typ / kid di Header diberi label secara individual
• 100% sisi klien, nol unggah: setiap parse, verifikasi, dan tanda tangan berjalan melalui Web Crypto API native browser — token, kunci, dan payload tidak pernah meninggalkan browser, mengikuti prinsip keamanan 'jangan pernah tempel token produksi ke alat online acak'
• Salin satu klik: Header, Payload, Signature, dan token yang baru dihasilkan dapat disalin secara independen untuk dokumentasi, tiket, dan perintah curl

Cara Penggunaan

1. Tempel atau ketik token: letakkan string JWT di bidang input; alat secara otomatis memisahkan Header, Payload, dan Signature dan menampilkan masing-masing sebagai JSON yang diformat
2. Pilih algoritma: beralih antara HS256 / RS256 / ES256 / PS256 / EdDSA; alat menyimpulkan dari Header.alg dan menandai ketidakcocokan apa pun
3. Impor kunci: tempel Secret HMAC, string PEM, atau JSON JWK; untuk algoritma asimetris, klik 'Generate pasangan kunci' untuk mendapatkan kunci pengujian segera
4. Verifikasi atau tanda tangani ulang: di mode Decode, verifikasi dengan kunci publik dan lihat '✅ tanda tangan valid / ❌ tanda tangan tidak valid'; di mode Encode, edit Claims dan tanda tangani dengan kunci pribadi untuk membuat token baru

Pertanyaan Umum

Apa itu Dekode, Verifikasi, dan Generate JWT?

Code Examples

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'])

Supported Video Formats

Output Example

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

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

Privacy & Security

Meja kerja JWT ini berjalan 100% di browser Anda, didukung oleh Web Crypto API native browser. Token yang Anda tempel, Header, Payload, Signature, Secret HMAC, kunci pribadi RSA/ECDSA apa pun, pasangan kunci yang dihasilkan apa pun, dan setiap perhitungan tanda tangan/verifikasi tetap di perangkat Anda — mereka tidak pernah pergi ke server, tidak pernah dicatat, tidak pernah dianalisis, dan tidak pernah di-cache. Halaman dapat digunakan secara offline setelah dimuat. Praktik terbaik: jangan pernah tempel token produksi yang berumur panjang atau kunci pribadi produksi ke alat online apa pun, termasuk yang ini. Alat ini cocok untuk debugging, pengujian integrasi, pembelajaran, dan pembuatan token pengujian — secret produksi dan kunci pribadi harus ditangani di lingkungan yang terkontrol dan lokal.

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

Troubleshooting