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

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

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

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

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

प्रोजेक्ट सेटअप

एक नया प्रोजेक्ट बनाएं और Cargo.toml में निर्भरताएँ जोड़ें:

[dependencies]\nring = "0.17"\nsha2 = "0.10"\nhex = "0.4"  # बाइट्स को आसानी से प्रदर्शित करने के लिए

सममित एन्क्रिप्शन: ring के साथ AES-GCM

AES-GCM (Galois/Counter Mode) सममित एन्क्रिप्शन का एक आधुनिक मानक है जो गोपनीयता और प्रमाणीकरण (अखंडता जांच) दोनों प्रदान करता है। ring लाइब्रेरी एक सरल और सुरक्षित API प्रदान करती है।

डेटा एन्क्रिप्ट करना

एन्क्रिप्शन के लिए आवश्यक हैं: एक कुंजी (256 बिट), एक nonce (96 बिट) और सादा टेक्स्ट। एक ही कुंजी के साथ प्रत्येक एन्क्रिप्शन के लिए nonce अद्वितीय होना चाहिए।

use ring::aead::{Aad, LessSafeKey, Nonce, UnboundKey, AES_256_GCM};\nuse ring::rand::{SecureRandom, SystemRandom};\n\nfn encrypt_aes_gcm(key: &[u8; 32], plaintext: &[u8]) -> Vec<u8> {\n    let rng = SystemRandom::new();\n    let unbound_key = UnboundKey::new(&AES_256_GCM, key).unwrap();\n    let key = LessSafeKey::new(unbound_key);\n\n    // यादृच्छिक nonce उत्पन्न करना\n    let mut nonce_bytes = [0u8; 12];\n    rng.fill(&mut nonce_bytes).unwrap();\n    let nonce = Nonce::assume_unique_for_key(nonce_bytes);\n\n    // खाली अतिरिक्त डेटा (AAD) के साथ एन्क्रिप्शन\n    let mut in_out = plaintext.to_vec();\n    let tag = key.seal_in_place_separate_tag(nonce, Aad::empty(), &mut in_out).unwrap();\n    \n    // nonce + एन्क्रिप्टेड डेटा + प्रमाणीकरण टैग लौटाएं\n    let mut result = nonce_bytes.to_vec();\n    result.extend_from_slice(&in_out);\n    result.extend_from_slice(tag.as_ref());\n    result\n}

डिक्रिप्शन

डिक्रिप्शन के लिए, nonce, टैग और एन्क्रिप्टेड टेक्स्ट निकालें, फिर open_in_place को कॉल करें।

fn decrypt_aes_gcm(key: &[u8; 32], ciphertext: &[u8]) -> Option<Vec<u8>> {\n    if ciphertext.len() < 28 { return None; } // 12 (nonce) + 16 (टैग) न्यूनतम\n\n    let (nonce_bytes, rest) = ciphertext.split_at(12);\n    let (encrypted, tag_bytes) = rest.split_at(rest.len() - 16);\n    \n    let nonce = Nonce::assume_unique_for_key(*nonce_bytes);\n    let unbound_key = UnboundKey::new(&AES_256_GCM, key).unwrap();\n    let key = LessSafeKey::new(unbound_key);\n\n    let mut in_out = encrypted.to_vec();\n    in_out.extend_from_slice(tag_bytes); // ring टैग को अंत में अपेक्षित करता है\n    \n    match key.open_in_place(nonce, Aad::empty(), &mut in_out) {\n        Ok(plaintext) => {\n            let plain_len = plaintext.len();\n            Some(plaintext[..plain_len].to_vec())\n        },\n        Err(_) => None // गलत कुंजी या दूषित डेटा\n    }\n}

उपयोग का उदाहरण

fn main() {\n    let key = b"0123456789abcdef0123456789abcdef"; // 32 बाइट्स\n    let data = b"Rust के लिए गुप्त संदेश!";\n    \n    let encrypted = encrypt_aes_gcm(key, data);\n    println!("एन्क्रिप्टेड (hex): {}", hex::encode(&encrypted));\n    \n    if let Some(decrypted) = decrypt_aes_gcm(key, &encrypted) {\n        println!("डिक्रिप्टेड: {}", String::from_utf8(decrypted).unwrap())