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

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

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो मेमोरी सुरक्षा और C/C++ के बराबर प्रदर्शन प्रदान करती है। अपनी सख्त टाइप सिस्टम और स्वामित्व मॉडल के कारण, Rust क्रिप्टोग्राफ़िक एल्गोरिदम को लागू करने के लिए आदर्श है, जहाँ त्रुटियाँ गंभीर कमज़ोरियाँ पैदा कर सकती हैं। इस लेख में, हम देखेंगे कि बुनियादी क्रिप्टोग्राफ़िक संचालन: सममित एन्क्रिप्शन, हैशिंग और HMAC गणना करने के लिए लोकप्रिय लाइब्रेरी ring और sha2 का उपयोग कैसे करें।

ring लाइब्रेरी: क्रिप्टोग्राफी के लिए बहुमुखी उपकरण

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

आरंभ करने के लिए, अपने Cargo.toml में निर्भरता जोड़ें:

[dependencies]ring = "0.17"

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

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

ring का उपयोग करके स्ट्रिंग को एन्क्रिप्ट और डिक्रिप्ट करने का उदाहरण:

use ring::aead::{Aad, LessSafeKey, Nonce, UnboundKey, AES_256_GCM};use ring::error::Unspecified;use ring::rand::{SecureRandom, SystemRandom};

fn encrypt(plaintext: &[u8], key: &[u8; 32]) -> Result<Vec<u8>, Unspecified> {    let rng = SystemRandom::new();    let unbound_key = UnboundKey::new(&AES_256_GCM, key)?;    let key = LessSafeKey::new(unbound_key);

    // रैंडम nonce जनरेट करें (12 बाइट)    let mut nonce_bytes = [0u8; 12];    rng.fill(&mut nonce_bytes)?;    let nonce = Nonce::assume_unique_for_key(nonce_bytes);

    // एन्क्रिप्टेड डेटा + प्रमाणीकरण टैग के लिए बफर    let mut in_out = plaintext.to_vec();    key.seal_in_place_append_tag(nonce, Aad::empty(), &mut in_out)?;

    // nonce + एन्क्रिप्टेड डेटा लौटाएं    let mut result = nonce_bytes.to_vec();    result.extend_from_slice(&in_out);    Ok(result)}

fn decrypt(ciphertext: &[u8], key: &[u8; 32]) -> Result<Vec<u8>, Unspecified> {    let unbound_key = UnboundKey::new(&AES_256_GCM, key)?;    let key = LessSafeKey::new(unbound_key);

    // nonce निकालें (पहले 12 बाइट)    let (nonce_bytes, encrypted) = ciphertext.split_at(12);    let nonce = Nonce::assume_unique_for_key(nonce_bytes.try_into().unwrap());

    let mut in_out = encrypted.to_vec();    let plaintext = key.open_in_place(nonce, Aad::empty(), &mut in_out)?;    Ok(plaintext.to_vec())}

fn main() {    let key = b"01234567890123456789012345678901"; // AES-256 के लिए 32 बाइट    let data = b"गुप्त संदेश";

    let encrypted = encrypt(data, key).unwrap();    println!("एन्क्रिप्टेड: {:?}", encrypted);

    let decrypted = decrypt(&encrypted, key).unwrap();    println!("डिक्रिप्टेड: {}", String::from_utf8(decrypted).unwrap());}

यह कोड एन्क्रिप्शन के पूरे चक्र को प्रदर्शित करता है: रैंडम nonce जनरेशन, प्रमाणीकरण टैग के साथ एन्क्रिप्शन और उसके बाद डिक्रिप्शन। ध्यान दें कि एक ही कुंजी के साथ प्रत्येक एन्क्रिप्शन के लिए nonce अद्वितीय होना चाहिए।

sha2 लाइब्रेरी के साथ हैशिंग

sha2 लाइब्रेरी SHA-2 परिवार के एल्गोरिदम के कार्यान्वयन प्रदान करती है, जिसमें SHA-256, SHA-384 और SHA-512 शामिल हैं। हैशिंग का उपयोग डेटा अखंडता की जाँच, पासवर्ड भंडारण और डिजिटल हस्ताक्षर बनाने के लिए किया जाता है।

निर्भरता जोड़ें:

[dependencies]sha2 = "0.10"

SHA-256 के साथ स्ट्रिंग हैशिंग का उदाहरण:

use sha2: