rustls Rust: पूर्ण गाइड, उदाहरण और उपयोग विधि

1. rustls क्या है और इसकी आवश्यकता क्यों?

rustls Rust भाषा में TLS (Transport Layer Security) प्रोटोकॉल का एक आधुनिक, सुरक्षित और उच्च-प्रदर्शन वाला कार्यान्वयन है। OpenSSL या native-tls जैसी लाइब्रेरी के विपरीत, rustls पूरी तरह से Rust में लिखी गई है और इसमें C लाइब्रेरी से कोई बंधन नहीं है। यह उन प्रोजेक्ट्स के लिए आदर्श है जहाँ मेमोरी सुरक्षा, अनिर्धारित व्यवहार (undefined behavior) से बचाव और आसान बिल्ड प्रक्रिया महत्वपूर्ण होती है।

rustls की आवश्यकता क्यों? सबसे पहले, यह "dependency hell" की समस्या को हल करता है: आपको सर्वर पर OpenSSL इंस्टॉल करने या libssl-dev के वर्जन से जूझने की ज़रूरत नहीं है। दूसरा, rustls डिफ़ॉल्ट रूप से केवल सुरक्षित क्रिप्टोग्राफ़िक एल्गोरिदम (TLS 1.2 और 1.3) का उपयोग करता है और पुराने सिफर को छोड़ देता है। तीसरा, यह async/await और Tokio, async-std जैसे फ्रेमवर्क के माध्यम से Rust इकोसिस्टम के साथ पूरी तरह से एकीकृत होता है।

मुख्य उपयोग के मामले: HTTPS सर्वर और क्लाइंट बनाना, सुरक्षित WebSocket कनेक्शन, gRPC के साथ काम करना, और TCP पर ट्रैफ़िक एन्क्रिप्शन की आवश्यकता वाले अन्य सभी मामले। rustls का उपयोग curl, Firefox (Neqo के माध्यम से) और कई औद्योगिक Rust एप्लिकेशन में सक्रिय रूप से किया जाता है।

2. इंस्टॉलेशन (स्थापना)

अपने प्रोजेक्ट में Cargo पैकेज मैनेजर के माध्यम से rustls जोड़ें। बुनियादी उपयोग के लिए दो डिपेंडेंसी पर्याप्त हैं:

# Cargo.toml
[dependencies]
rustls = "0.23"           # मुख्य लाइब्रेरी
webpki-roots = "0.26"     # विश्वसनीय रूट सर्टिफिकेट (क्लाइंट के लिए)
tokio = { version = "1", features = ["full"] }  # एसिंक्रोनस उदाहरण के लिए
tokio-rustls = "0.26"     # Tokio के लिए एसिंक्रोनस रैपर

यदि आपको केवल सिंक्रोनस (ब्लॉकिंग) मोड चाहिए, तो आप tokio-rustls के बिना भी काम चला सकते हैं। सर्टिफिकेट के साथ काम करने के लिए rcgen (सेल्फ-साइन्ड सर्टिफिकेट जनरेशन) और rustls-pemfile (PEM फ़ाइलें पढ़ना) की भी आवश्यकता हो सकती है।

# cargo add के माध्यम से इंस्टॉलेशन (यदि cargo-edit का उपयोग कर रहे हैं)
cargo add rustls webpki-roots tokio tokio-rustls

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

एक सरल HTTPS क्लाइंट बनाते हैं जो example.com से पेज लोड करता है। यह उदाहरण सिस्टम रूट सर्टिफिकेट का उपयोग करके rustls की बुनियादी सेटिंग दिखाता है।

// src/main.rs
use std::sync::Arc;
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
use rustls::pki_types::ServerName;
use webpki_roots::TLS_SERVER_ROOTS;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. विश्वसनीय रूट सर्टिफिकेट के साथ क्लाइंट कॉन्फ़िगरेशन बनाएँ
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(TLS_SERVER_ROOTS.clone())
        .with_no_client_auth();

    // 2. TLS कनेक्टर बनाएँ
    let connector = TlsConnector::from(Arc::new(config));

    // 3. TCP कनेक्शन स्थापित करें
    let stream = TcpStream::connect("example.com:443").await?;

    // 4. TLS में रैप करें
    let server_name = ServerName::try_from("example.com")?;
    let mut tls_stream = connector.connect(server_name, stream).await?;

    // 5. HTTP अनुरोध भेजें
    use tokio::io::AsyncWriteExt;
    tls_stream.write_all(b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n").await?;

    // 6. प्रतिक्रिया पढ़ें
    use tokio::io::AsyncReadExt;
    let mut response = String::new();
    tls_stream.read_to_string(&mut response).await?;
    println!("सर्वर का जवाब:\n{}", response);

    Ok(())
}

यह कोड example.com के साथ एक सुरक्षित कनेक्शन स्थापित करता है, HTTP अनुरोध भेजता है और प्रतिक्रिया प्रिंट करता है। ध्यान दें: हम सर्वर सर्टिफिकेट को सत्यापित करने के लिए webpki-roots का उपयोग कर रहे हैं — यह सुरक्षित है और OpenSSL इंस्टॉल करने की आवश्यकता नहीं है।

4. मुख्य मेथड्स/फंक्शन्स/क्लासेस

4.1. rustls::ClientConfig::builder()

सिग्नेचर: pub fn builder() -> ConfigBuilder<WantsVerifier, WantsVersions>

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

उदाहरण:

let config = rustls::ClientConfig::builder()
    .with_root_certificates(webpki_roots::TLS_SERVER_ROOTS.clone())
    .with_no_client_auth();

4.2. rustls::ServerConfig::builder()

सिग्नेचर: pub fn builder() -> ConfigBuilder<WantsVerifier, WantsVersions>

विवरण: सर्वर साइड के लिए कॉन्फ़िगरेशन बनाता है। इसमें आपको अपना सर्टिफिकेट और प्राइवेट की सेट करनी होती है।

उदाहरण:

let config = rustls::ServerConfig::builder()
    .with_no_client_auth()
    .with_single_cert(cert_chain, private_key)?;

4.3. rustls::ClientConnection

विवरण: यह एक सक्रिय TLS क्लाइंट कनेक्शन का प्रतिनिधित्व करता है। यह rustls::Connection ट्रेट को इम्प्लीमेंट करता है और डेटा पढ़ने/लिखने के लिए मेथड्स प्रदान करता है।

मुख्य मेथड्स:

• new(config, server_name) — नया क्लाइंट कनेक्शन बनाता है
• read_tls(reader) — TLS डेटा पढ़ता है
• write_tls(writer) — TLS डेटा लिखता है
• process_new_packets() — प्राप्त पैकेट्स को प्रोसेस करता है

4.4. rustls::ServerConnection

विवरण: सर्वर साइड के लिए TLS कनेक्शन। क्लाइंट कनेक्शन के समान ही मेथड्स प्रदान करता है, लेकिन सर्वर की भूमिका में।

4.5. rustls::pki_types::ServerName

विवरण: सर्वर के DNS नाम या IP एड्रेस को दर्शाने वाला टाइप। TLS हैंडशेक के दौरान SNI (Server Name Indication) के लिए उपयोग होता है।

उदाहरण:

let server_name = ServerName::try_from("example.com")?;

5. निष्कर्ष

rustls Rust प्रोग्रामर्स के लिए TLS को लागू करने का सबसे सुरक्षित और आधुनिक तरीका है। इसकी शुद्ध Rust इम्प्लीमेंटेशन, आसान इंस्टॉलेशन और Tokio/async-std के साथ बेहतरीन एकीकरण इसे प्रोडक्शन-रेडी प्रोजेक्ट्स के लिए आदर्श बनाता है। चाहे आप HTTPS सर्वर बना रहे हों, सुरक्षित WebSocket कनेक्शन चाहते हों, या gRPC का उपयोग कर रहे हों, rustls आपकी सभी TLS ज़रूरतों को पूरा करेगा।