JWT संपूर्ण गाइड 2026

"JWT? क्या यह सिर्फ एक टोकन नहीं है?"

हाँ, है। लेकिन जब वह "सिर्फ टोकन" सही ढंग से लागू नहीं किया जाता, तो यह एक गंभीर सुरक्षा समस्या बन जाता है। 2026 के अनुसंधान के अनुसार, AI द्वारा जनरेट किए गए प्रमाणीकरण कोड में 48% सुरक्षा कमजोरियाँ मौजूद हैं।

यह गाइड JWT की संरचना से लेकर व्यावहारिक सुरक्षा सर्वोत्तम अभ्यासों तक सब कुछ कवर करती है।

---

JWT क्या है?

JWT (JSON Web Token) दो पक्षों के बीच सुरक्षित रूप से जानकारी प्रसारित करने का एक कॉम्पैक्ट और स्व-निहित तरीका है।

मुख्य विशेषताएं

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

• API प्रमाणीकरण: Bearer टोकन के साथ API अनुरोध
• SSO (Single Sign-On): कई सेवाओं में प्रमाणीकरण साझा करना
• जानकारी का आदान-प्रदान: हस्ताक्षरित डेटा का प्रसारण
• Authorization: अनुमतियों/भूमिकाओं की जानकारी शामिल करना

---

JWT संरचना

JWT तीन Base64URL एन्कोडेड भागों से बना है जो . (डॉट) से अलग होते हैं।

xxxxx.yyyyy.zzzzz
  |      |      |
Header  Payload  Signature

1. Header

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

2. Payload (Claims)

{
  "sub": "user123",
  "name": "राहुल शर्मा",
  "email": "rahul@example.com",
  "role": "admin",
  "iat": 1708502400,
  "exp": 1708588800
}

पंजीकृत Claims

सार्वजनिक/निजी Claims

{
  "role": "admin",           // निजी claim
  "email": "user@example.com",
  "permissions": ["read", "write"]
}

3. Signature

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret
)

---

हस्ताक्षर एल्गोरिथम

सममित कुंजी (Symmetric)

// Node.js - HS256
const jwt = require('jsonwebtoken');

const token = jwt.sign(
  { userId: 123, role: 'admin' },
  'your-256-bit-secret',  // समान secret से सत्यापित
  { algorithm: 'HS256', expiresIn: '1h' }
);

असममित कुंजी (Asymmetric)

// RS256 - असममित
const privateKey = fs.readFileSync('private.pem');
const publicKey = fs.readFileSync('public.pem');

// जारी करना (Private Key)
const token = jwt.sign(payload, privateKey, { algorithm: 'RS256' });

// सत्यापन (Public Key)
const decoded = jwt.verify(token, publicKey, { algorithms: ['RS256'] });

एल्गोरिथम चयन गाइड

---

व्यावहारिक कार्यान्वयन

Node.js (Express)

const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();
const SECRET = process.env.JWT_SECRET; // पर्यावरण चर से लोड करें

// टोकन जारी करना
app.post('/login', async (req, res) => {
  const { email, password } = req.body;

  // उपयोगकर्ता सत्यापन (उदाहरण)
  const user = await verifyCredentials(email, password);
  if (!user) {
    return res.status(401).json({ error: 'Invalid credentials' });
  }

  const token = jwt.sign(
    {
      sub: user.id,
      email: user.email,
      role: user.role,
    },
    SECRET,
    {
      expiresIn: '1h',
      issuer: 'your-app-name',
    }
  );

  res.json({ token });
});

// मिडलवेयर से सत्यापन
const authMiddleware = (req, res, next) => {
  const authHeader = req.headers.authorization;

  if (!authHeader?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Missing token' });
  }

  const token = authHeader.split(' ')[1];

  try {
    const decoded = jwt.verify(token, SECRET, {
      issuer: 'your-app-name',
      algorithms: ['HS256'],
    });
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Invalid token' });
  }
};

// संरक्षित रूट
app.get('/protected', authMiddleware, (req, res) => {
  res.json({ message: `Hello, ${req.user.email}` });
});

Python (FastAPI)

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt
from datetime import datetime, timedelta
import os

app = FastAPI()
security = HTTPBearer()
SECRET = os.environ.get("JWT_SECRET")

# टोकन जारी करना
def create_token(user_id: str, role: str) -> str:
    payload = {
        "sub": user_id,
        "role": role,
        "iat": datetime.utcnow(),
        "exp": datetime.utcnow() + timedelta(hours=1),
    }
    return jwt.encode(payload, SECRET, algorithm="HS256")

# टोकन सत्यापन
def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    token = credentials.credentials
    try:
        payload = jwt.decode(token, SECRET, algorithms=["HS256"])
        return payload
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

# संरक्षित एंडपॉइंट
@app.get("/protected")
def protected_route(user: dict = Depends(verify_token)):
    return {"message": f"Hello, {user['sub']}"}

---

सुरक्षा कमजोरियाँ और प्रतिउपाय

1. Algorithm None हमला

// दुर्भावनापूर्ण header
{
  "alg": "none",
  "typ": "JWT"
}

प्रतिउपाय:

// अनुमत एल्गोरिथम निर्दिष्ट करें
jwt.verify(token, secret, { algorithms: ['HS256'] }); // ठीक है
jwt.verify(token, secret); // खतरनाक

2. कमजोर Secret Key

// खतरनाक
const SECRET = 'secret123';

// सुरक्षित (न्यूनतम 256 बिट)
const SECRET = crypto.randomBytes(32).toString('hex');

3. संवेदनशील जानकारी का खुलासा

// खतरनाक: Payload Base64 डिकोड किया जा सकता है
{
  "password": "user_password",  // कभी नहीं करें!
  "creditCard": "1234-5678-9012-3456"
}

// सुरक्षित
{
  "sub": "user123",
  "role": "admin"
}

4. टोकन चोरी

प्रतिउपाय रणनीतियाँ:

• छोटा समाप्ति समय (15 मिनट ~ 1 घंटा)
• Refresh Token का उपयोग करें
• HTTPS अनिवार्य
• HttpOnly कुकीज़ (XSS रोकथाम)

5. JWT Replay Attack

// jti (JWT ID) का उपयोग करें
const token = jwt.sign({
  sub: user.id,
  jti: crypto.randomUUID(), // अद्वितीय ID
}, SECRET);

// सर्वर पर jti ब्लैकलिस्ट प्रबंधित करें

---

Access Token + Refresh Token

यह क्यों आवश्यक है?

कार्यान्वयन उदाहरण

// लॉगिन पर दोनों टोकन जारी करें
app.post('/login', async (req, res) => {
  const user = await verifyCredentials(req.body);

  const accessToken = jwt.sign(
    { sub: user.id, type: 'access' },
    ACCESS_SECRET,
    { expiresIn: '15m' }
  );

  const refreshToken = jwt.sign(
    { sub: user.id, type: 'refresh' },
    REFRESH_SECRET,
    { expiresIn: '7d' }
  );

  // Refresh Token HttpOnly कुकी के रूप में
  res.cookie('refreshToken', refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict',
    maxAge: 7 * 24 * 60 * 60 * 1000,
  });

  res.json({ accessToken });
});

// टोकन नवीनीकरण
app.post('/refresh', (req, res) => {
  const refreshToken = req.cookies.refreshToken;

  try {
    const decoded = jwt.verify(refreshToken, REFRESH_SECRET);

    const newAccessToken = jwt.sign(
      { sub: decoded.sub, type: 'access' },
      ACCESS_SECRET,
      { expiresIn: '15m' }
    );

    res.json({ accessToken: newAccessToken });
  } catch (err) {
    res.status(401).json({ error: 'Invalid refresh token' });
  }
});

---

JWT डिबगिंग

टोकन डिकोडिंग

JWT Decoder में अपना टोकन पेस्ट करें:

• Header जाँचें
• Payload जाँचें
• समाप्ति समय जाँचें
• हस्ताक्षर सत्यापित करें (जब secret प्रदान किया जाए)

CLI डिकोडिंग

# Header डिकोड करें
echo "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9" | base64 -d

# Payload डिकोड करें
echo "eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4ifQ" | base64 -d

---

सर्वोत्तम अभ्यास चेकलिस्ट

जारी करना

• मजबूत secret key (256 बिट या अधिक)
• एल्गोरिथम निर्दिष्ट करें (HS256, RS256)
• छोटा समाप्ति समय (15 मिनट ~ 1 घंटा)
• आवश्यक claims शामिल करें (sub, iat, exp, iss)
• संवेदनशील जानकारी नहीं

सत्यापन

• एल्गोरिथम व्हाइटलिस्ट (algorithms: ['HS256'])
• समाप्ति समय सत्यापन
• जारीकर्ता (iss) सत्यापन
• श्रोता (aud) सत्यापन

संग्रहण और प्रसारण

• HTTPS अनिवार्य
• HttpOnly कुकी (XSS रोकथाम)
• SameSite विशेषता (CSRF रोकथाम)
• localStorage से बचें (XSS के प्रति संवेदनशील)

---

अक्सर पूछे जाने वाले प्रश्न

Q1: JWT vs Session, कब किसका उपयोग करें?

A:

• JWT: Stateless API, माइक्रोसर्विसेज, मोबाइल ऐप्स
• Session: पारंपरिक वेब ऐप्स, सर्वर-साइड रेंडरिंग, तत्काल लॉगआउट आवश्यक

Q2: अगर JWT चोरी हो जाए तो?

A: Access Token समाप्त होने तक वैध रहता है। इसलिए:

• छोटा समाप्ति समय सेट करें (15 मिनट)
• Refresh Token Rotation
• संदेह होने पर सभी टोकन अमान्य करें

Q3: localStorage में क्यों नहीं स्टोर करना चाहिए?

A: यह XSS हमलों के प्रति संवेदनशील है। चूंकि JavaScript इसे एक्सेस कर सकता है, दुर्भावनापूर्ण स्क्रिप्ट टोकन चुरा सकती है। HttpOnly कुकीज़ अधिक सुरक्षित हैं।

Q4: क्या RS256 HS256 से अधिक सुरक्षित है?

A: यह "अधिक सुरक्षित" नहीं बल्कि "अलग उद्देश्य" है।

• HS256: समान secret साझा, एकल सर्वर
• RS256: public key से सत्यापित, कई सेवाएं

Q5: क्या टोकन ब्लैकलिस्ट आवश्यक है?

A: यदि तत्काल लॉगआउट आवश्यक है, तो हाँ। लेकिन यह stateless के लाभ को कम करता है। छोटा समाप्ति समय + Refresh Token एक विकल्प है।

---

निष्कर्ष

JWT सुरक्षा के मुख्य बिंदु:

1. मजबूत secret: 256 बिट या अधिक यादृच्छिक
2. एल्गोरिथम सत्यापन: व्हाइटलिस्ट दृष्टिकोण
3. छोटी अवधि: Access 15 मिनट, Refresh 7 दिन
4. सुरक्षित संग्रहण: HttpOnly + Secure कुकीज़
5. संवेदनशील जानकारी नहीं: Payload को कोई भी डिकोड कर सकता है

---

संबंधित उपकरण