sha2 / bcrypt Rust: पूर्ण गाइड उदाहरण सहित

आधुनिक डेवलपमेंट में डेटा सुरक्षा किसी भी एप्लिकेशन का एक महत्वपूर्ण पहलू है। Rust भाषा के लिए sha2 और bcrypt लाइब्रेरीज़ क्रिप्टोग्राफिक हैशिंग के लिए शक्तिशाली और सुरक्षित टूल प्रदान करती हैं। sha2 SHA-2 (सिक्योर हैश एल्गोरिदम 2) एल्गोरिदम परिवार को लागू करता है, जिसमें SHA-224, SHA-256, SHA-384, SHA-512, और उनके ट्रंकेटेड वेरिएंट (SHA-512/224, SHA-512/256) शामिल हैं। bcrypt एक अनुकूली क्रिप्टोग्राफिक हैश फंक्शन है, जिसे विशेष रूप से पासवर्ड को सुरक्षित रूप से स्टोर करने के लिए डिज़ाइन किया गया है। यह "सॉल्ट" (salt) और कॉन्फ़िगरेबल राउंड (कॉस्ट फैक्टर) का उपयोग करता है, जो इसे रेनबो टेबल अटैक और ब्रूट-फोर्स के प्रति प्रतिरोधी बनाता है।

इसकी आवश्यकता क्यों है? SHA-2 का उपयोग डेटा इंटीग्रिटी की जाँच, डिजिटल सिग्नेचर बनाने, वर्जन कंट्रोल सिस्टम (Git), ब्लॉकचेन और कई अन्य क्षेत्रों में किया जाता है जहाँ तेज़ और विश्वसनीय हैश की आवश्यकता होती है। वहीं, bcrypt वेब एप्लिकेशन, डेटाबेस और ऑथेंटिकेशन सिस्टम में पासवर्ड हैशिंग के लिए डी-फैक्टो मानक है। इसका मुख्य लाभ इसकी कॉन्फ़िगरेबल "धीमी गति" है: आप राउंड की संख्या बढ़ा सकते हैं ताकि हमलावरों की बढ़ती कंप्यूटिंग पावर की भरपाई हो सके।

इस लेख में हम दोनों लाइब्रेरीज़ पर विस्तार से चर्चा करेंगे: इंस्टॉलेशन, मुख्य मेथड, वास्तविक उपयोग के उदाहरण और सामान्य गलतियाँ। आप सीखेंगे कि डेटा को सही तरीके से कैसे हैश करें, पासवर्ड कैसे वेरिफाई करें और इन फंक्शन्स को अपने Rust प्रोजेक्ट्स में कैसे इंटीग्रेट करें।

इंस्टॉलेशन

Rust में sha2 और bcrypt का उपयोग करने के लिए, उन्हें अपने प्रोजेक्ट की Cargo.toml फ़ाइल में जोड़ना होगा। अपने प्रोजेक्ट की रूट डायरेक्टरी में टर्मिनल खोलें और निम्न कमांड चलाएँ:

cargo add sha2 bcrypt

यह कमांड लाइब्रेरीज़ के नवीनतम संस्करणों को [dependencies] सेक्शन में जोड़ देगी। वैकल्पिक रूप से, आप मैन्युअल रूप से Cargo.toml को एडिट कर सकते हैं:

[dependencies]
sha2 = "0.10"
bcrypt = "0.15"

इसके बाद, डिपेंडेंसी डाउनलोड करने और यह सुनिश्चित करने के लिए कि सब कुछ सही ढंग से इंस्टॉल हुआ है, cargo build चलाएँ।

त्वरित शुरुआत: न्यूनतम कार्यशील उदाहरण

आइए एक सरल उदाहरण से शुरू करते हैं: SHA-256 के साथ एक स्ट्रिंग को हैश करना और bcrypt के साथ पासवर्ड वेरिफिकेशन।

use sha2::{Sha256, Digest};
use bcrypt::{hash, verify, DEFAULT_COST};

fn main() {
    // SHA-256 हैशिंग
    let data = b"Hello, world!";
    let mut hasher = Sha256::new();
    hasher.update(data);
    let result = hasher.finalize();
    println!("SHA-256 हैश: {:x}", result);

    // Bcrypt पासवर्ड हैशिंग
    let password = "my_secure_password";
    let hashed = hash(password, DEFAULT_COST).unwrap();
    println!("Bcrypt हैश: {}", hashed);

    // पासवर्ड वेरिफिकेशन
    let is_valid = verify(password, &hashed).unwrap();
    println!("पासवर्ड सही है: {}", is_valid);
}

यह कोड दोनों लाइब्रेरीज़ की मूल क्षमताओं को प्रदर्शित करता है। आउटपुट में 64-कैरेक्टर का SHA-256 हेक्स हैश और एक लंबी bcrypt स्ट्रिंग (जो $2b$ से शुरू होती है) शामिल होगी।

मुख्य मेथड और फंक्शन

आइए sha2 और bcrypt के प्रमुख फंक्शन और मेथड पर नज़र डालते हैं। प्रत्येक के लिए सिग्नेचर, विवरण और एक कार्यशील उदाहरण दिया गया है।

1. sha2::Sha256::new()

सिग्नेचर: pub fn new() -> Sha256

विवरण: SHA-256 हैशर का एक नया इंस्टेंस बनाता है। यह डेटा हैश करने का प्रारंभिक बिंदु है।

use sha2::{Sha256, Digest};

let mut hasher = Sha256::new();
hasher.update(b"test data");
let hash = hasher.finalize();
println!("{:x}", hash);

2. sha2::Sha256::update()

सिग्नेचर: pub fn update(&mut self, data: impl AsRef<[u8]>)

विवरण: हैशर में डेटा जोड़ता है। इसे कई बार कॉल किया जा सकता है, जिससे बड़े डेटा को टुकड़ों में हैश करना आसान हो जाता है।

use sha2::{Sha256, Digest};

let mut hasher = Sha256::new();
hasher.update(b"part1");
hasher.update(b"part2");
let hash = hasher.finalize();
println!("{:x}", hash);

3. sha2::Digest::finalize()

सिग्नेचर: pub fn finalize(self) -> GenericArray<u8, Self::OutputSize>

विवरण: हैशिंग प्रक्रिया पूरी करता है और अंतिम हैश मान लौटाता है। इसके बाद हैशर का पुन: उपयोग नहीं किया जा सकता।

use sha2::{Sha256, Digest};

let mut hasher = Sha256::new();
hasher.update(b"data");
let hash = hasher.finalize();
println!("{:x}", hash);

4. bcrypt::hash()

सिग्नेचर: pub fn hash<S: AsRef<[u8]>>(password: S, cost: u32) -> Result<String, BcryptError>

विवरण: दिए गए पासवर्ड को हैश करता है और एक स्ट्रिंग लौटाता है जिसमें हैश, सॉल्ट और कॉस्ट फैक्टर शामिल होता है। cost पैरामीटर हैशिंग की जटिलता को नियंत्रित करता है (डिफ़ॉल्ट: DEFAULT_COST = 12)।

use bcrypt::{hash, DEFAULT_COST};

let hashed = hash("my_password", DEFAULT_COST).unwrap();
println!("{}", hashed);

5. bcrypt::verify()

सिग्नेचर: pub fn verify<S: AsRef<[u8]>>(password: S, hash: &str) -> Result<bool, BcryptError>

विवरण: एक पासवर्ड और पहले से जनरेट किए गए bcrypt हैश की तुलना करता है। अगर पासवर्ड मेल खाता है तो true लौटाता है, अन्यथा false।

use bcrypt::{hash, verify, DEFAULT_COST};

let hashed = hash("my_password", DEFAULT_COST).unwrap();
let is_valid = verify("my_password", &hashed).unwrap();
println!("पासवर्ड सही है: {}", is_valid);

निष्कर्ष

इस गाइड में, हमने Rust में sha2 और bcrypt लाइब्रेरीज़ का उपयोग करना सीखा। SHA-256 तेज़ और सुरक्षित हैशिंग के लिए आदर्श है, जबकि bcrypt पासवर्ड स्टोरेज के लिए बेहतरीन है। दोनों लाइब्रेरीज़ का उपयोग करना आसान है और ये आपके Rust प्रोजेक्ट्स में क्रिप्टोग्राफिक सुरक्षा जोड़ने के लिए आवश्यक टूल हैं।