Rust अनुप्रयोगों की सुरक्षा: शुरुआती लोगों के लिए शीर्ष 10 कमजोरियाँ

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Rust अनुप्रयोगों की सुरक्षा: शुरुआती लोगों के लिए शीर्ष 10 कमजोरियाँ

Rust को एक सुरक्षित सिस्टम भाषा के रूप में प्रस्तुत किया जाता है जो संकलन चरण में कमजोरियों के पूरे वर्गों को रोकता है। हालाँकि, इसका मतलब यह नहीं है कि Rust अनुप्रयोग पूरी तरह से अभेद्य हैं। शुरुआती डेवलपर्स अक्सर ऐसी गलतियाँ करते हैं जो गंभीर सुरक्षा समस्याओं का कारण बन सकती हैं। इस लेख में, हम Rust अनुप्रयोगों में शीर्ष 10 कमजोरियों पर चर्चा करेंगे जिनके बारे में हर नौसिखिए को पता होना चाहिए।

1. `unsafe` कोड का गलत उपयोग

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

// खतरनाक उदाहरणunsafe {    let ptr = std::ptr::null::<i32>();    println!("{}", *ptr); // UB! Segmentation fault}

// सुरक्षित विकल्पfn safe_access(ptr: *const i32) -> Option<i32> {    if ptr.is_null() {        return None;    }    unsafe { Some(*ptr) }}

सिफारिश: unsafe के उपयोग को कम से कम करें। यदि यह आवश्यक है, तो इसे छोटे फंक्शनों में अलग करें और इनवेरिएंट का सावधानीपूर्वक दस्तावेजीकरण करें।

2. `Send` और `Sync` के माध्यम से डेटा रेस

Rust स्वामित्व प्रणाली के माध्यम से डेटा रेस से बचाता है, लेकिन Send और Sync ट्रेट्स का गलत कार्यान्वयन इस सुरक्षा को भंग कर सकता है।

use std::cell::UnsafeCell;use std::sync::Arc;

struct UnsafeCounter(UnsafeCell<u32>);

// खतरनाक कार्यान्वयनunsafe impl Send for UnsafeCounter {}unsafe impl Sync for UnsafeCounter {}

fn main() {    let counter = Arc::new(UnsafeCounter(UnsafeCell::new(0)));    let mut handles = vec![];        for _ in 0..10 {        let c = counter.clone();        handles.push(std::thread::spawn(move || {            // डेटा रेस!            unsafe { *c.0.get() += 1; }        }));    }}

सिफारिश: मैन्युअल सिंक्रोनाइज़ेशन कार्यान्वयन के बजाय Arc<Mutex<T>> या Arc<RwLock<T>> का उपयोग करें।

3. असुरक्षित डेटा डीसीरियलाइज़ेशन

बाहरी स्रोतों (JSON, YAML, bincode) से डेटा डीसीरियलाइज़ करते समय, एक हमलावर विशेष रूप से तैयार किया गया payload डाल सकता है।

use serde::Deserialize;

#[derive(Deserialize)]struct Config {    path: String,    buffer_size: usize,}

fn load_config(data: &str) -> Result<Config, serde_json::Error> {    // संभावित कमजोरी: बहुत बड़ी संख्याएँ    let config: Config = serde_json::from_str(data)?;        if config.buffer_size > 1_000_000 {        return Err(serde_json::Error::custom("Buffer too large"));    }    Ok(config)}

सिफारिश: डीसीरियलाइज़ेशन के बाद हमेशा मानों की सीमाओं की जाँच करें। कस्टम वैलिडेटर के लिए #[serde(deserialize_with = "...")] का उपयोग करें।

4. `Box<dyn Error>` के माध्यम से मेमोरी लीक

बार-बार Box<dyn Error> लौटाने से मेमोरी लीक हो सकती है, खासकर बड़े डेटा वॉल्यूम के साथ काम करते समय।

// समस्याग्रस्त दृष्टिकोणfn process_data(data: &[u8]) -> Result<(), Box<dyn std::error::Error>> {    // ... प्रसंस्करण    Ok(())}

// बेहतर दृष्टिकोण#[derive(Debug)]enum AppError {    InvalidData(String),    IoError(std::io::Error),}

fn process_data_safe(data: &[u8]) -> Result<(), AppError> {    // ... प्रसंस्करण    Ok(())}

सिफारिश: बेहतर प्रदर्शन और सुरक्षा के लिए thiserror या anyhow का उपयोग करके अपने स्वयं के त्रुटि प्रकार बनाएँ।