JWT टूल

संबंधित सुझाव

JWT डिकोड, वेरिफाई और जनरेट क्या है?

उपयोग के मामले

• JWT को ऑनलाइन डिकोड करें: OAuth 2.0 / OIDC लॉगिन डिबगिंग के दौरान टोकन को तेजी से अलग करके Header एल्गोरिदम और Payload Claims की जाँच करें
• JWT सिग्नेचर वेरिफाई करें: रियल-टाइम में टोकन सिग्नेचर वेरिफाई करने के लिए Secret / पब्लिक की का उपयोग करें और तय करें कि 401 'बैड सिग्नेचर', 'एक्सपायर्ड' या 'एल्गोरिदम मिसमैच' है
• इंटीग्रेशन के दौरान टेस्ट JWT जनरेट करें: टोकन जारी करने के लिए बैकएंड को अस्थायी रूप से कोड बदलने की जरूरत के बिना, ब्राउज़र में टेस्ट की-पेयर के साथ JWT जारी करें
• PEM ↔ JWK कन्वर्जन: OIDC IdP ने आपको JWK दिया लेकिन सर्वर को PEM चाहिए (या इसके विपरीत) — OpenSSL स्क्रिप्ट लिखने के बजाय जगह पर कन्वर्ट करें
• 401 Unauthorized को डायगनोज करें: एक्सपायरी, alg-गेटवे मैच, की मैच और PEM फॉर्मेटिंग को स्टेप-बाय-स्टेप चेक करें
• RS256 बनाम PS256 की तुलना करें: कई OIDC प्रोवाइडर डिफॉल्ट रूप से RS256 का उपयोग करते हैं जबकि AWS SigV4 PS256 को प्राथमिकता देता है — उसी RSA की-पेयर के साथ एल्गोरिदम स्विच करें और नतीजों की तुलना करें
• JWT के आंतरिक कामकाज को सीखें: alg बदलें, Payload एडिट करें, ब्राउज़र में की बदलें और देखें कि सिग्नेचर रियल-टाइम में कैसे टूटता है — RFC पढ़ने से बहुत तेज

उपयोग कैसे करें

1. टोकन पेस्ट करें या टाइप करें: JWT स्ट्रिंग को इनपुट फील्ड में रखें; टूल स्वचालित रूप से Header, Payload और Signature को अलग करता है और प्रत्येक को फॉर्मेट किए गए JSON के रूप में प्रदर्शित करता है
2. एल्गोरिदम चुनें: HS256 / RS256 / ES256 / PS256 / EdDSA के बीच स्विच करें; टूल Header.alg से अनुमान लगाता है और किसी भी मिसमैच को फ्लैग करता है
3. एक की इम्पोर्ट करें: HMAC Secret, PEM स्ट्रिंग या JWK JSON पेस्ट करें; असममित एल्गोरिदम के लिए, तुरंत टेस्ट की पाने के लिए 'की-पेयर जनरेट' पर क्लिक करें
4. वेरिफाई करें या फिर से साइन करें: Decode मोड में, पब्लिक की से वेरिफाई करें और '✅ सिग्नेचर वैध / ❌ सिग्नेचर अमान्य' देखें; Encode मोड में, Claims एडिट करें और नया टोकन बनाने के लिए प्राइवेट की से साइन करें

Output Example

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

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

विशेषताएं

• एक ही जगह पर डिकोड + वेरिफाई + जनरेट: टोकन पेस्ट करके Header/Payload/Signature अलग करें, सिग्नेचर वेरिफाई करने के लिए एल्गोरिदम और की बदलें, नया टोकन बनाने के लिए Claims एडिट करके फिर से साइन करें — पूरे JWT ट्रबलशूटिंग चेन को कवर करता है
• सभी 13 एल्गोरिदम सपोर्टेड: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — OAuth 2.0, OIDC, JWS, API गेटवे और एंटरप्राइज SSO को कवर करता है
• PEM और JWK फॉर्मेट: RSA, ECDSA और Ed25519 कीज PEM स्ट्रिंग्स (-----BEGIN PUBLIC KEY----- हेडर्स के साथ) और JWK JSON (kid/kty/n/e फील्ड्स) स्वीकार करती हैं — OIDC /.well-known/jwks.json आउटपुट सीधे पेस्ट करें
• HMAC Secret की कई इनपुट फॉर्म्स: कच्ची UTF-8 स्ट्रिंग, हेक्स बाइट्स या Base64/Base64URL एन्कोडेड — एक क्लिक में स्विच करें, ताकि 'दिखने में एक जैसा है लेकिन सिग्नेचर फेल हो जाता है' कभी न हो
• ऑटोमेटिक की-पेयर जनरेशन: RSA-2048, RSA-4096, P-256, P-384 और Ed25519 की-पेयर ब्राउज़र में जनरेट होती हैं, तुरंत टेस्ट यूज़ के लिए PEM और JWK फॉर्मेट में प्रस्तुत की जाती हैं
• Claims की सेमेंटिक हाइलाइटिंग: exp / iat / nbf स्वचालित रूप से पढ़ने योग्य समय में कन्वर्ट होते हैं, एक्सपायर्ड / अभी-अमान्य / जारी किया गया स्टेटस हाइलाइट के साथ; Header में alg / typ / kid अलग-अलग लेबल किए जाते हैं
• 100% क्लाइंट-साइड, जीरो अपलोड: हर पार्स, वेरिफाई और साइन ब्राउज़र के नेटिव Web Crypto API के जरिए चलता है — टोकन, कीज और payload कभी ब्राउज़र नहीं छोड़ते, 'प्रोडक्शन टोकन को कभी भी रैंडम ऑनलाइन टूल्स में पेस्ट न करें' सुरक्षा सिद्धांत का पालन करते हुए
• वन-क्लिक कॉपी: Header, Payload, Signature और नया जनरेट किया गया टोकन स्वतंत्र रूप से कॉपी करने योग्य हैं; डॉक्यूमेंटेशन, टिकट और curl कमांड्स के लिए

कोड उदाहरण

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

5 प्रकार के JWT साइनिंग एल्गोरिदम की तुलना: कौन सा चुनें?

JWT एक एल्गोरिदम नहीं है — 5 अलग-अलग एल्गोरिदम कुंजी, प्रदर्शन, सुरक्षा और अनुकूलता के मामले में अलग-अलग ट्रेडऑफ़ देते हैं। पहले परिदृश्य तय करें, फिर एल्गोरिदम चुनें — कई गलतियाँ बच जाती हैं।

Best Practices

सामान्य प्रश्न

समस्या निवारण

Privacy & Security

यह JWT वर्कबेंच आपके ब्राउज़र में 100% चलता है, ब्राउज़र के नेटिव Web Crypto API द्वारा समर्थित। आप जो टोकन पेस्ट करते हैं, Header, Payload, Signature, HMAC Secret, कोई भी RSA/ECDSA प्राइवेट की, कोई भी जनरेट की गई की-पेयर और हर सिग्नेचर/वेरिफिकेशन गणना आपके डिवाइस पर रहती है — वे कभी सर्वर पर नहीं जाते, कभी लॉग नहीं होते, कभी विश्लेषित नहीं होते और कभी कैश नहीं होते। पेज लोड होने के बाद ऑफलाइन उपयोग किया जा सकता है। सर्वोत्तम अभ्यास: कभी भी लंबे समय तक चलने वाले प्रोडक्शन टोकन या प्रोडक्शन प्राइवेट कीज को इस सहित किसी भी ऑनलाइन टूल में पेस्ट न करें। यह टूल डिबगिंग, इंटीग्रेशन टेस्टिंग, सीखने और टेस्ट टोकन जनरेशन के लिए उपयुक्त है — प्रोडक्शन secrets और प्राइवेट कीज को नियंत्रित, स्थानीय वातावरण में संसाधित किया जाना चाहिए।

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