Rust में क्रिप्टोग्राफी: एन्क्रिप्शन और हैश

Rust में क्रिप्टोग्राफी: ring और sha2 लाइब्रेरीज़ के साथ एन्क्रिप्शन और हैशिंग

Rust भाषा ने सबसे सुरक्षित सिस्टम प्रोग्रामिंग भाषाओं में से एक के रूप में प्रतिष्ठा अर्जित की है। इसकी सख्त टाइप सिस्टम, कचरा संग्रहकर्ता के बिना मेमोरी प्रबंधन और एब्स्ट्रैक्शन की शून्य लागत इसे क्रिप्टोग्राफिक एल्गोरिदम को लागू करने के लिए एक आदर्श विकल्प बनाती है। इस लेख में, हम Rust में क्रिप्टोग्राफी के लिए दो प्रमुख लाइब्रेरीज़ पर विचार करेंगे: ring (उच्च-स्तरीय, सुरक्षित) और sha2 (हैश का शुद्ध कार्यान्वयन)। आप सीखेंगे कि सममित एन्क्रिप्शन (AES-GCM) और हैशिंग (SHA-256) कैसे करें, साथ ही HMAC से भी परिचित होंगे।

क्रिप्टोग्राफी के लिए Rust क्यों?

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

मेमोरी सुरक्षा — Rust गारंटी देता है कि कुंजियाँ और एन्क्रिप्टेड डेटा गलती से कॉपी या मेमोरी में नहीं छोड़े जाएंगे।
प्रदर्शन — Rust पर क्रिप्टोग्राफिक ऑपरेशन C/C++ के बराबर हैं, और अक्सर तेज़ भी होते हैं।
उपयोग में आसानी — लाइब्रेरीज़ गलती करने के न्यूनतम जोखिम के साथ एक स्वच्छ API प्रदान करती हैं (उदाहरण के लिए, nonce का स्वचालित प्रबंधन)।

ring लाइब्रेरी: एक बहुमुखी उपकरण

ring एक क्रॉस-प्लेटफ़ॉर्म क्रिप्टोग्राफिक लाइब्रेरी है जो सुरक्षा और सरलता पर ध्यान केंद्रित करती है। इसमें AES-GCM, ChaCha20-Poly1305, ECDSA, Ed25519 और कई अन्य एल्गोरिदम के लिए समर्थन शामिल है। ring पुराने या असुरक्षित प्रोटोकॉल का समर्थन नहीं करता है, जो डेवलपर को गलती से कमज़ोर एन्क्रिप्शन चुनने से बचाता है।

स्थापना:

[dependencies]ring = "0.17"

उदाहरण: AES-GCM एन्क्रिप्शन और डिक्रिप्शन

AES-GCM (Galois/Counter Mode) डेटा की गोपनीयता और प्रमाणीकरण दोनों प्रदान करता है। नीचे दिए गए उदाहरण में, हम एक यादृच्छिक कुंजी और nonce उत्पन्न करते हैं, संदेश को एन्क्रिप्ट करते हैं, और फिर सफलतापूर्वक इसे डिक्रिप्ट करते हैं।

use ring::{aead, rand};use ring::rand::SecureRandom;

fn main() -> Result<(), Box<dyn std::error::Error>> {    // यादृच्छिक कुंजी उत्पन्न करना (256 बिट)    let rng = rand::SystemRandom::new();    let mut key_bytes = [0u8; 32];    rng.fill(&mut key_bytes)?;    let key = aead::UnboundKey::new(&aead::AES_256_GCM, &key_bytes)?;    let sealing_key = aead::SealingKey::new(key.clone());    let opening_key = aead::OpeningKey::new(key);

    // एन्क्रिप्ट करने के लिए डेटा    let plaintext = b"PythonLib के लिए गुप्त संदेश";    let mut nonce_bytes = [0u8; 12]; // GCM के लिए 96 बिट    rng.fill(&mut nonce_bytes)?;    let nonce = aead::Nonce::assume_unique_for_key(nonce_bytes);

    // एन्क्रिप्शन (इन-प्लेस)    let mut ciphertext = plaintext.to_vec();    let tag = sealing_key.seal_in_place_separate_tag(nonce, aead::Aad::empty(), &mut ciphertext)?;    ciphertext.extend_from_slice(tag.as_ref());

    println!("एन्क्रिप्टेड: {:02x?}", ciphertext);

    // डिक्रिप्शन    let mut opened = ciphertext.clone();    let plaintext_len = opening_key.open_in_place(nonce, aead::Aad::empty(), &mut opened)?;    let decrypted = &opened[..plaintext_len];

    println!("डिक्रिप्टेड: {}", String::from_utf8(decrypted.to_vec())?);    Ok(())}

महत्वपूर्ण: Nonce (एक बार उपयोग की जाने वाली संख्या) एक ही कुंजी के साथ प्रत्येक एन्क्रिप्शन के लिए अद्वितीय होना चाहिए। ring स्वचालित रूप से nonce उत्पन्न नहीं करता है — यह डेवलपर की जिम्मेदारी है। उदाहरण में, हम यादृच्छिक nonce उत्पन्न करने के लिए SystemRandom का उपयोग करते हैं।