Rust OAuth क्लाइंट: oauth2-rs लाइब्रेरी

oauth2-rs लाइब्रेरी: Rust में OAuth 2.0 का कार्यान्वयन

आधुनिक वेब डेवलपमेंट में OAuth 2.0 एक्सेस डेलिगेशन के लिए मानक प्रोटोकॉल है। oauth2-rs लाइब्रेरी Rust भाषा में OAuth 2.0 क्लाइंट का पूर्ण कार्यान्वयन प्रदान करती है। यह Google, GitHub, Yandex, VK और अन्य लोकप्रिय सेवाओं के माध्यम से प्रमाणीकरण को एकीकृत करने की अनुमति देती है।

यह लाइब्रेरी सभी प्रमुख ग्रांट्स (फ्लो) को सपोर्ट करती है: Authorization Code, Client Credentials, Implicit, और Refresh Token। सुरक्षा पर विशेष ध्यान दिया गया है: पब्लिक क्लाइंट के लिए PKCE (Proof Key for Code Exchange) और टोकन का अनिवार्य सत्यापन शामिल है।

oauth2-rs की स्थापना

Cargo.toml में डिपेंडेंसी जोड़ें:

[dependencies]
oauth2 = "4.4"
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }

इसके अलावा, HTTP-क्लाइंट (async सपोर्ट के साथ reqwest अनुशंसित) और JSON के लिए serde सीरियलाइज़र की आवश्यकता होगी।

OAuth क्लाइंट की बुनियादी सेटिंग

Google OAuth 2.0 के लिए एक उदाहरण देखें। पहले कॉन्फ़िगरेशन बनाएँ:

use oauth2::{
    AuthorizationCode, AuthUrl, ClientId, ClientSecret, 
    RedirectUrl, TokenUrl, CsrfToken, Scope,
    basic::BasicClient, TokenResponse
};

let client_id = ClientId::new("YOUR_GOOGLE_CLIENT_ID".to_string());
let client_secret = ClientSecret::new("YOUR_GOOGLE_CLIENT_SECRET".to_string());
let auth_url = AuthUrl::new("https://accounts.google.com/o/oauth2/v2/auth".to_string())
    .expect("Invalid auth URL");
let token_url = TokenUrl::new("https://oauth2.googleapis.com/token".to_string())
    .expect("Invalid token URL");

let client = BasicClient::new(
    client_id,
    Some(client_secret),
    auth_url,
    Some(token_url)
).set_redirect_uri(
    RedirectUrl::new("http://localhost:8080/callback".to_string())
        .expect("Invalid redirect URL")
);

प्राधिकरण URL जनरेट करना

एक लिंक बनाएँ जिस पर उपयोगकर्ता को रीडायरेक्ट करना है:

let (auth_url, csrf_token) = client
    .authorize_url(CsrfToken::new_random)
    .add_scope(Scope::new("openid".to_string()))
    .add_scope(Scope::new("email".to_string()))
    .url();

println!("लिंक पर जाएँ: {}", auth_url);
// कॉलबैक पर जाँच के लिए csrf_token को सहेजें

CsrfToken क्रॉस-साइट रिक्वेस्ट फोर्जरी (CSRF) हमलों से बचाता है। इसे अस्थायी रूप से (जैसे, सेशन या कुकी में) सहेजें और कॉलबैक प्रोसेस करते समय जाँचें।

कॉलबैक प्रोसेसिंग और टोकन प्राप्त करना

उपयोगकर्ता द्वारा एक्सेस की पुष्टि करने के बाद, सेवा उसे redirect_uri पर code पैरामीटर के साथ रीडायरेक्ट करेगी। Rust में हैंडलर का उदाहरण:

use actix_web::{web, HttpRequest, HttpResponse};
use oauth2::AuthorizationCode;

async fn callback(query: web::Query<std::collections::HashMap<String, String>>) -> HttpResponse {
    let code = query.get("code")
        .expect("प्राधिकरण कोड गायब है");
    let state = query.get("state")
        .expect("state गायब है");

    // सेव किए गए csrf_token के विरुद्ध state जाँचें
    // ...

    let token_result = client
        .exchange_code(AuthorizationCode::new(code.clone()))
        .request_async(&reqwest::Client::new())
        .await;

    match token_result {
        Ok(token) => {
            let access_token = token.access_token().secret();
            let refresh_token = token.refresh_token()
                .map(|rt| rt.secret().clone());
            // टोकन को डेटाबेस या सेशन में सहेजें
            HttpResponse::Ok().body("प्रमाणीकरण सफल!")
        },
        Err(e) => {
            eprintln!("कोड एक्सचेंज में त्रुटि: {:?}", e);
            HttpResponse::InternalServerError().body("प्रमाणीकरण त्रुटि")
        }
    }
}