प्रमाणीकरण और प्राधिकरण (Authentication and Authorization In NodeJs)

प्रमाणीकरण (Authentication) और प्राधिकरण (Authorization), RESTful APIs के लिए सुरक्षा के महत्वपूर्ण हिस्से हैं। प्रमाणीकरण यह सुनिश्चित करता है कि यूज़र वह है जो वह होने का दावा करता है, और प्राधिकरण यह तय करता है कि उस यूज़र को किन संसाधनों तक पहुंचने की अनुमति है। इस सेक्शन में हम समझेंगे कि API सुरक्षा के लिए प्रमाणीकरण और प्राधिकरण को Node.js और Express.js के साथ कैसे लागू किया जा सकता है।

Key Concepts and Terminologies (मुख्य अवधारणाएँ और टर्मिनोलॉजी)

1. Authentication (प्रमाणीकरण): यह प्रक्रिया उपयोगकर्ता की पहचान को सत्यापित करती है, उदाहरण के लिए, लॉगिन करने के लिए यूज़रनेम और पासवर्ड की आवश्यकता होती है।
2. Authorization (प्राधिकरण): यह प्रक्रिया यह तय करती है कि एक सत्यापित उपयोगकर्ता को किन संसाधनों या एंडपॉइंट्स तक पहुंचने की अनुमति है।
3. JWT (JSON Web Token): एक लोकप्रिय प्रमाणीकरण टूल है, जो क्लाइंट-सर्वर कम्युनिकेशन को सुरक्षित करने के लिए यूज़र को एक एन्क्रिप्टेड टोकन प्रदान करता है।
4. Middleware (मिडलवेयर): Express.js में मिडलवेयर का उपयोग प्रमाणीकरण और प्राधिकरण लॉजिक को लागू करने के लिए किया जाता है।
5. Bearer Token: यह HTTP हेडर में यूज़र की पहचान करने के लिए इस्तेमाल होने वाला एक टोकन है, जिसे प्रमाणीकरण के बाद क्लाइंट से सर्वर तक भेजा जाता है।

Prerequisite Knowledge (पूर्व-आवश्यक ज्ञान)

• Node.js और Express.js का बेसिक ज्ञान।
• JWT का बेसिक परिचय।
• HTTP Headers और Authorization Bearer Tokens का सामान्य उपयोग।

Step-by-Step Explanation (स्टेप बाय स्टेप गाइड)

1. Install Required Packages (आवश्यक पैकेज इंस्टॉल करें)

सबसे पहले JWT प्रमाणीकरण के लिए आवश्यक पैकेज इंस्टॉल करें:

npm install jsonwebtoken bcryptjs

• jsonwebtoken: JWT टोकन जेनरेट और वेरीफाई करने के लिए।
• bcryptjs: पासवर्ड को सुरक्षित तरीके से एन्क्रिप्ट करने के लिए।

2. Create User Model and Hash Password (यूज़र मॉडल और पासवर्ड हैशिंग)

एक यूज़र मॉडल सेट करें और पासवर्ड को सुरक्षित करने के लिए bcryptjs का उपयोग करें:

const bcrypt = require('bcryptjs');
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    username: String,
    password: String
});

// पासवर्ड को सेव करने से पहले हैश करें
userSchema.pre('save', async function(next) {
    if (this.isModified('password')) {
        this.password = await bcrypt.hash(this.password, 10);
    }
    next();
});

const User = mongoose.model('User', userSchema);

3. Create JWT Token on Login (लॉगिन पर JWT टोकन जेनरेट करें)

लॉगिन के समय JWT टोकन जेनरेट करें:

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey';

// लॉगिन हैंडलर
app.post('/login', async (req, res) => {
    const { username, password } = req.body;
    const user = await User.findOne({ username });

    if (!user) {
        return res.status(400).send('User not found');
    }

    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
        return res.status(401).send('Invalid password');
    }

    // JWT टोकन जेनरेट करें
    const token = jwt.sign({ id: user._id }, secretKey, { expiresIn: '1h' });
    res.json({ token });
});

4. Protect Routes with JWT Middleware (JWT मिडलवेयर से रूट्स सुरक्षित करें)

JWT टोकन को मिडलवेयर के माध्यम से सत्यापित करें और रूट्स को सुरक्षित करें:

// मिडलवेयर: टोकन को वेरीफाई करें
const authenticateToken = (req, res, next) => {
    const token = req.headers['authorization']?.split(' ')[1];
    if (!token) return res.status(403).send('Token required');

    jwt.verify(token, secretKey, (err, user) => {
        if (err) return res.status(403).send('Invalid token');
        req.user = user;
        next();
    });
};

// प्रोटेक्टेड रूट
app.get('/profile', authenticateToken, (req, res) => {
    res.send('Welcome to the protected profile route');
});

प्रमाणीकरण और प्राधिकरण को समझना (Understanding Authentication and Authorization)

प्रमाणीकरण (Authentication) और प्राधिकरण (Authorization) RESTful APIs की सुरक्षा में महत्वपूर्ण भूमिका निभाते हैं। प्रमाणीकरण यह सुनिश्चित करता है कि उपयोगकर्ता वास्तव में वही है जो वह होने का दावा करता है, जबकि प्राधिकरण यह तय करता है कि प्रमाणीकृत उपयोगकर्ता को किन संसाधनों या सेवाओं तक पहुंचने की अनुमति है।

प्रमाणीकरण (Authentication)

प्रमाणीकरण का उद्देश्य उपयोगकर्ता की पहचान सत्यापित करना है। यह प्रक्रिया आमतौर पर यूज़रनेम और पासवर्ड के माध्यम से की जाती है। सफल प्रमाणीकरण के बाद, यूज़र को एक टोकन (जैसे JWT – JSON Web Token) प्रदान किया जाता है, जिसका उपयोग प्रत्येक अनुरोध में प्रमाणीकरण के लिए किया जाता है।

प्राधिकरण (Authorization)

प्राधिकरण यह निर्धारित करता है कि प्रमाणीकरण के बाद उपयोगकर्ता को क्या कार्य करने की अनुमति है। उदाहरण के लिए, नॉर्मल यूज़र को सामान्य डेटा तक पहुंच मिल सकती है, जबकि एडमिन यूज़र को संवेदनशील डेटा तक भी पहुंच प्राप्त हो सकती है। यह प्रक्रिया उपयोगकर्ता की भूमिका (Role) पर आधारित होती है।

Example Code (कोड उदाहरण)

1. प्रमाणीकरण: JWT टोकन के साथ लॉगिन (Authentication with JWT Token)

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey';

// लॉगिन और JWT टोकन बनाना
app.post('/login', (req, res) => {
    const { username, password } = req.body;

    // पासवर्ड और यूज़र नेम की वैधता जांचें (यहां सामान्य प्रक्रिया दिखा रहे हैं)
    // सही होने पर JWT टोकन प्रदान करें
    const token = jwt.sign({ username: username, role: 'user' }, secretKey, { expiresIn: '1h' });
    res.json({ token });
});

2. JWT टोकन को सत्यापित करना और प्रोटेक्टेड रूट्स तक पहुंचने की अनुमति देना (Verify JWT and Protect Routes)

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey';

// मिडलवेयर: JWT सत्यापन
const authenticateToken = (req, res, next) => {
    const token = req.headers['authorization']?.split(' ')[1];
    if (!token) return res.status(403).send('Token required');

    jwt.verify(token, secretKey, (err, user) => {
        if (err) return res.status(403).send('Invalid token');
        req.user = user; // यूज़र की जानकारी को सुरक्षित रखें
        next();
    });
};

// प्रोटेक्टेड रूट्स (केवल प्रमाणीकृत यूज़र्स के लिए)
app.get('/profile', authenticateToken, (req, res) => {
    res.send(`Welcome ${req.user.username}, to your profile`);
});

3. प्राधिकरण: केवल विशेष भूमिकाओं (जैसे एडमिन) के लिए रूट्स (Authorization for Admin Only)

// प्राधिकरण आधारित मिडलवेयर: एडमिन्स के लिए
const authorizeRole = (role) => {
    return (req, res, next) => {
        if (req.user.role !== role) {
            return res.status(403).send('Access Denied');
        }
        next();
    };
};

// केवल एडमिन्स के लिए रूट
app.get('/admin', authenticateToken, authorizeRole('admin'), (req, res) => {
    res.send('Welcome Admin');
});

JWT (JSON Web Tokens) को लागू करना (Implementing JWT – JSON Web Tokens)

JWT (JSON Web Token) एक सुरक्षित तरीका है जिससे आप RESTful API में प्रमाणीकरण (Authentication) को लागू कर सकते हैं। यह एक एन्क्रिप्टेड टोकन होता है जो सर्वर द्वारा यूज़र को लॉगिन के बाद जारी किया जाता है। हर बार जब यूज़र सर्वर पर अनुरोध करता है, तो उसे यह टोकन पास करना होता है, जिससे सर्वर यह पहचान सकता है कि यूज़र प्रमाणीकृत है या नहीं। JWT प्रमाणीकरण के लिए व्यापक रूप से उपयोग किया जाता है क्योंकि यह सुरक्षित, हल्का, और स्टेटलेस है।

JWT के तीन मुख्य हिस्से होते हैं:

1. Header: टोकन के प्रकार और एन्क्रिप्शन मेथड के बारे में जानकारी।
2. Payload: यूज़र से संबंधित डेटा (जैसे यूज़र आईडी, रोल)।
3. Signature: हेडर और पेलोड को एक सीक्रेट की के साथ एन्क्रिप्ट किया जाता है, जो इसे सुरक्षित बनाता है।

JWT प्रमाणीकरण कैसे काम करता है?

1. यूज़र लॉगिन करता है और सर्वर को क्रेडेंशियल्स (यूज़रनेम और पासवर्ड) भेजता है।
2. सर्वर क्रेडेंशियल्स को सत्यापित करता है। यदि वे सही हैं, तो सर्वर JWT टोकन जारी करता है।
3. यूज़र हर API अनुरोध के साथ इस टोकन को Authorization हेडर में भेजता है।
4. सर्वर टोकन को वेरीफाई करता है और अनुरोध को प्रोसेस करता है।

Example Code (JWT को लागू करना)

1. JWT टोकन जारी करना (Generating JWT Token on Login)

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey';

// लॉगिन पर JWT टोकन जारी करें
app.post('/login', (req, res) => {
    const { username, password } = req.body;

    // पासवर्ड की वैधता की जांच करें (यहां सादा उदाहरण)
    // यदि सही है, तो JWT टोकन जारी करें
    const token = jwt.sign({ username: username }, secretKey, { expiresIn: '1h' });
    res.json({ token });
});

2. JWT टोकन का सत्यापन (Verifying JWT Token for Protected Routes)

JWT को वेरीफाई करने के लिए एक मिडलवेयर बनाएं, ताकि आप हर अनुरोध पर यह सुनिश्चित कर सकें कि यूज़र प्रमाणीकृत है।

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey';

// JWT सत्यापन मिडलवेयर
const authenticateToken = (req, res, next) => {
    const token = req.headers['authorization']?.split(' ')[1];
    if (!token) return res.status(403).send('Token required');

    // JWT टोकन को वेरीफाई करें
    jwt.verify(token, secretKey, (err, user) => {
        if (err) return res.status(403).send('Invalid token');
        req.user = user; // यूज़र की जानकारी को रिक्वेस्ट में सेट करें
        next();
    });
};

// प्रोटेक्टेड रूट
app.get('/dashboard', authenticateToken, (req, res) => {
    res.send(`Welcome to your dashboard, ${req.user.username}`);
});

3. JWT का उपयोग प्राधिकरण के साथ (Using JWT for Authorization)

आप JWT में उपयोगकर्ता की भूमिका (role) भी सेट कर सकते हैं और उसे विभिन्न रूट्स तक पहुंचने के लिए उपयोग कर सकते हैं। उदाहरण के लिए, केवल एडमिन को ही कुछ विशेष रूट्स तक पहुंचने की अनुमति हो:

सत्र प्रबंधन (Session Management)

सत्र प्रबंधन (Session Management) एक महत्वपूर्ण प्रक्रिया है जिसका उपयोग वेब एप्लिकेशन में यूज़र्स की पहचान और उनकी गतिविधियों को ट्रैक करने के लिए किया जाता है। जब एक उपयोगकर्ता लॉगिन करता है, तो एक सत्र (session) बनता है जो उपयोगकर्ता की जानकारी और स्थिति को संग्रहीत करता है। सत्र को तब तक बनाए रखा जाता है जब तक उपयोगकर्ता एप्लिकेशन से लॉगआउट नहीं करता या सत्र समाप्त नहीं हो जाता।

सत्र प्रबंधन का उद्देश्य यह सुनिश्चित करना है कि उपयोगकर्ता को उनकी पहचान के आधार पर एक निरंतर अनुभव प्राप्त हो और उन्हें बार-बार लॉगिन करने की आवश्यकता न हो। Node.js और Express.js में सत्र प्रबंधन को कई तरीकों से लागू किया जा सकता है, जिनमें कुकीज (cookies), सेशन स्टोरेज, और JWT (JSON Web Tokens) शामिल हैं।

सत्र प्रबंधन के प्रकार:

1. सर्वर-साइड सत्र (Server-side sessions): सर्वर पर उपयोगकर्ता की सत्र जानकारी संग्रहीत की जाती है, और उपयोगकर्ता को एक यूनिक सत्र आईडी भेजी जाती है, जिसे कुकी के रूप में संग्रहीत किया जाता है। हर अनुरोध पर, यह सत्र आईडी सर्वर द्वारा सत्यापित की जाती है।
2. JWT आधारित सत्र (JWT-based sessions): JWT का उपयोग करके सत्र प्रबंधन किया जाता है, जहां सत्र की जानकारी और प्रमाणीकरण टोकन क्लाइंट-साइड पर सुरक्षित रूप से संग्रहीत किया जाता है और हर अनुरोध के साथ भेजा जाता है।

Example Code (सत्र प्रबंधन को लागू करना)

1. Server-side Session Management using Express-session

Express.js में, आप express-session का उपयोग करके सर्वर-साइड सत्र प्रबंधन कर सकते हैं। यह तरीका उपयोगकर्ता की सत्र जानकारी को सर्वर पर संग्रहीत करता है।

npm install express-session

अब, सत्र प्रबंधन लागू करें:

const express = require('express');
const session = require('express-session');
const app = express();

// सत्र को कॉन्फ़िगर करें
app.use(session({
    secret: 'mySecretKey',   // सत्र को सुरक्षित रखने के लिए एक सीक्रेट की
    resave: false,           // हर अनुरोध पर सत्र को फिर से सेव न करें
    saveUninitialized: true, // बिना बदलाव किए सत्र को सेव करें
    cookie: { secure: false } // केवल सुरक्षित कनेक्शन पर कुकी भेजें
}));

// सत्र में उपयोगकर्ता डेटा सेव करें
app.post('/login', (req, res) => {
    req.session.user = { username: req.body.username };  // सत्र में यूज़र डेटा सेव करें
    res.send('User logged in');
});

// सत्र से डेटा प्राप्त करें
app.get('/dashboard', (req, res) => {
    if (!req.session.user) {
        return res.status(401).send('Unauthorized');
    }
    res.send(`Welcome ${req.session.user.username}`);
});

// सत्र समाप्त करें
app.post('/logout', (req, res) => {
    req.session.destroy(err => {
        if (err) {
            return res.status(500).send('Unable to log out');
        }
        res.send('User logged out');
    });
});

app.listen(3000, () => {
    console.log('Server is running on http://localhost:3000');
});

2. JWT Based Session Management

JWT आधारित सत्र प्रबंधन में, सर्वर पर सत्र को स्टोर करने की आवश्यकता नहीं होती। इसके बजाय, JWT को क्लाइंट-साइड पर स्टोर किया जाता है और हर अनुरोध के साथ सर्वर पर भेजा जाता है।

JWT आधारित सत्र प्रबंधन को लागू करने के लिए JWT टोकन जेनरेट करने और सत्यापित करने की प्रक्रिया को लागू करें। यह प्रक्रिया ऊपर के JWT (JSON Web Tokens) को लागू करना सेक्शन में दी गई है।

सत्र प्रबंधन के सर्वोत्तम अभ्यास (Best Practices)

1. सुरक्षित सत्र कुकीज़ का उपयोग करें: सत्र कुकी को केवल सुरक्षित कनेक्शन (HTTPS) के माध्यम से भेजें, ताकि सत्र हाईजैकिंग से बचा जा सके।
2. सत्र समाप्ति (Session Expiry): सत्र की समय सीमा सेट करें, ताकि उपयोगकर्ता की सत्र जानकारी को लंबे समय तक बिना सक्रियता के संग्रहीत न किया जाए।
3. Cross-Site Request Forgery (CSRF) से बचाव: सत्र-आधारित प्रणालियों के लिए CSRF टोकन का उपयोग करें ताकि दुर्भावनापूर्ण अनुरोधों से बचा जा सके।
4. सत्र डेटा एन्क्रिप्ट करें: कुकीज़ और टोकन के अंदर संग्रहीत सत्र डेटा को सुरक्षित रखने के लिए एन्क्रिप्शन का उपयोग करें।