Rust में प्रमाणीकरण और प्राधिकरण: पूर्ण गाइड

Rust में प्रमाणीकरण और प्राधिकरण: डेवलपर्स के लिए पूर्ण गाइड

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो हाई-लोड और सुरक्षित वेब सेवाओं के लिए तेज़ी से लोकप्रिय हो रही है। लेकिन Rust में प्रमाणीकरण (पहचान सत्यापन) और प्राधिकरण (एक्सेस अधिकार जांच) को लागू करने के लिए एक विशेष दृष्टिकोण की आवश्यकता होती है, क्योंकि इसकी सख्त टाइप सिस्टम और बिल्ट-इन समाधानों की कमी है। इस लेख में, हम प्रमुख लाइब्रेरीज़ और व्यावहारिक उदाहरणों पर चर्चा करेंगे।

प्रमाणीकरण के लिए Rust क्यों?

सुरक्षा Rust की सर्वोच्च प्राथमिकता है। कंपाइलर मेमोरी लीक, डेटा रेस और C/C++ में पाई जाने वाली कई कमजोरियों को रोकता है। हालांकि, मैन्युअल रूप से प्रमाणीकरण लागू करने से त्रुटियाँ हो सकती हैं, इसलिए समुदाय ने कई परिपक्व लाइब्रेरीज़ बनाई हैं।

Rust में प्रमाणीकरण के लिए मुख्य लाइब्रेरीज़

1. actix-web-httpauth — Actix-web फ्रेमवर्क के लिए

Actix-web इकोसिस्टम में HTTP प्रमाणीकरण (Basic, Bearer, Digest) लागू करने के लिए सबसे लोकप्रिय लाइब्रेरी।

2. jsonwebtoken — JWT के साथ काम करना

Rust के लिए JSON Web Tokens (JWT) का पूर्ण कार्यान्वयन। RS256, HS256, ES256 और अन्य एल्गोरिदम को सपोर्ट करता है।

3. bcrypt — पासवर्ड हैशिंग

bcrypt एल्गोरिदम के साथ पासवर्ड हैश करने के लिए विश्वसनीय लाइब्रेरी, जो ऑटोमैटिक सॉल्ट जनरेशन के साथ आती है।

4. argon2 — आधुनिक हैशिंग

अगर bcrypt पुराना लगता है, तो Argon2 का उपयोग करें — Password Hashing Competition का विजेता।

5. tower-http — प्राधिकरण के लिए middleware

Tower-आधारित किसी भी HTTP सर्वर में एक्सेस अधिकार जांच के लिए पुन: प्रयोज्य middleware बनाने की अनुमति देता है।

व्यावहारिक उदाहरण: Actix-web में JWT के माध्यम से प्रमाणीकरण

रजिस्ट्रेशन और लॉगिन के साथ एक न्यूनतम सर्वर उदाहरण देखें। पहले Cargo.toml में डिपेंडेंसी जोड़ें:

[dependencies]
actix-web = "4"
actix-web-httpauth = "0.8"
jsonwebtoken = "9"
bcrypt = "0.15"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

अब यूज़र स्ट्रक्चर और JWT बनाने/जांचने के फंक्शन लिखें:

use actix_web::{web, App, HttpServer, HttpResponse, HttpRequest};
use actix_web_httpauth::extractors::bearer::BearerAuth;
use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey};
use bcrypt::{hash, verify, DEFAULT_COST};
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    sub: String, // यूज़र का ईमेल
    exp: usize,  // टोकन की समाप्ति समय
}

#[derive(Debug, Serialize, Deserialize)]
struct User {
    email: String,
    password_hash: String,
}

// यूज़र स्टोरेज (वास्तविकता में — डेटाबेस)
static USERS: once_cell::sync::Lazy<std::sync::Mutex<Vec<User>>> =
    once_cell::sync::Lazy::new(|| std::sync::Mutex::new(vec![]));

async fn register(info: web::Json<UserInput>) -> HttpResponse {
    let hashed = hash(&info.password, DEFAULT_COST).unwrap();
    let user = User {
        email: info.email.clone(),
        password_hash: hashed,
    };
    USERS.lock().unwrap().push(user);
    HttpResponse::Ok().json("User registered")
}

async fn login(info: web::Json<UserInput>) -> HttpResponse {
    let users = USERS.lock().unwrap();
    if let Some(user) = users.iter().find(|u| u.email == info.email) {
        if verify(&info.password, &user.password_hash).unwrap() {
            let claims = Claims {
                sub: info.email.clone(),
                exp: 10000000000,
            };
            let token = encode(
                &Header::default(),
                &claims,
                &EncodingKey::from_secret(b"secret_key"),
            ).unwrap();
            return HttpResponse::Ok().json(token);
        }
    }
    HttpResponse::Unauthorized().json("Invalid credentials")
}

async fn protected(auth: BearerAuth) -> HttpRe