कैसे सुरक्षित सी कोड लिखने के लिए बफर ओवरफ्लो को रोकने के लिए

बफर ओवरफ्लो सी प्रोग्रामिंग में सबसे लगातार और खतरनाक सुरक्षा भेद्यता में से एक बने रहते हैं। दशकों तक अच्छी तरह से डोक्यूमेंट होने के बावजूद, वे डेटा भ्रष्टाचार, सिस्टम दुर्घटनाओं और रिमोट कोड निष्पादन जैसे गंभीर मुद्दों का कारण बने रहे। सुरक्षित सी कोड लिखने के लिए बफर ओवरफ्लो कैसे होते हैं और उन्हें रोकने के लिए एक अनुशासित दृष्टिकोण की गहरी समझ की आवश्यकता होती है। यह लेख मजबूत, अतिप्रवाह प्रतिरोधी सी कोड लिखने के लिए एक व्यापक गाइड प्रदान करता है, बुनियादी अवधारणाओं, सुरक्षित कार्यों, सत्यापन तकनीकों, संकलन संरक्षण और आधुनिक रक्षात्मक उपायों को कवर करता है।

बफ़र ओवरफ्लो को समझना

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

परिणाम इस बात पर निर्भर करते हैं कि क्या ओवरराइट किया जाता है। स्टैक पर एक वापसी पता ओवरराइटिंग हमलावर नियंत्रित कोड के लिए निष्पादन को रीडायरेक्ट कर सकता है। ओवरराइटिंग पॉइंटर्स मनमाने ढंग से स्मृति लिखने का नेतृत्व कर सकते हैं। यहां तक कि सरल दुर्घटनाओं को इनकार-ऑफ-सर्विस हमलों के लिए लीवरेज किया जा सकता है। मैकेनिक्स को समझना रोकथाम का पहला कदम है।

स्टैक-आधारित ओवरफ्लो

स्थानीय चर, जिसमें बफर को अंदर की ओर घोषित किया गया है, स्टैक पर संग्रहीत किए जाते हैं। स्टैक में रिटर्न एड्रेस, सेव्ड फ्रेम पॉइंटर्स और अन्य कंट्रोल डेटा भी हैं। जब एक रैखिक बफर जैसे को ओवर रन किया जाता है, तो डेटा रिटर्न एड्रेस में फैल जाता है और परे। मॉरिस वर्म (1988) जैसे क्लासिक शोषण ने अनधिकृत एक्सेस हासिल करने के लिए स्टैक ओवरफ्लो का इस्तेमाल किया।

हेप आधारित ओवरफ्लो

गतिशील रूप से आवंटित बफर (for , , आदि) ढेर पर रहते हैं। यहां ओवरफ्लो, सभी ऑक्लेटर द्वारा उपयोग किए जाने वाले मेटाडाटा को भ्रष्ट कर सकते हैं, जिससे हेप छिड़काव या उपयोग के बाद-मुक्त हमलों के माध्यम से दुर्घटनाग्रस्त या शोषण हो सकता है। हेप ओवरफ्लो का उपयोग करना कठिन है लेकिन समान रूप से खतरनाक है।

आम भेद्य कार्य और उनके सुरक्षित विकल्प

C मानक पुस्तकालय कई कार्य प्रदान करता है जो सीमा की जाँच नहीं करते हैं। उनका उपयोग बफर ओवरफ्लो का सबसे आम कारण है। उन्हें सुरक्षित समकक्षों के साथ बदलना एक मूलभूत सर्वोत्तम अभ्यास है।

स्ट्रिंग कॉपी और कॉन्सैटेशन

• ] ]] - Unsafe: प्रतिलिपियाँ जब तक एक null terminator, कोई लंबाई सीमा नहीं.
  ]Safe विकल्प: - अधिकांश n वर्णों पर प्रतियां; ध्यान दें कि यह नहीं है कि यदि स्रोत n से अधिक लंबा है, तो हमेशा मैन्युअल रूप से null-terminate.
• अभी तक बेहतर: - बीएसडी और कई लिनक्स प्रणालियों पर उपलब्ध; हमेशा शून्य-terminates और truthation का पता लगाने के लिए स्रोत स्ट्रिंग की लंबाई वापस लौटें।
• ] ] - असुरक्षित: बिना बाध्यता के concatenate.
  ]Safe वैकल्पिक: ] - सबसे n वर्णों पर appends और हमेशा null-terminates.

स्वरूपित आउटपुट और इनपुट

• ] ] - Unsafe: बिना किसी आकार की जाँच के साथ एक बफर में स्वरूपित उत्पादन लिखने के लिए।
  ] ]Safe वैकल्पिक: - आकार-1 वर्णों के लिए प्लस null टर्मिनेटर को सीमा उत्पादन।
• ] ] ]] ]]] ]]] ]] ]] ]] ]]] ]]]] ]]]]] ]]]] ]]]]]]]]] [[[[[[FLT:[FLT:[[FLT:[[[FLT:[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
• ] ] ] ]] ]] ]]] ] ] ]]]] ]]]]] [[FLT:[FLT:]]]]]]]]]]]] ]]]]]]]] ]]]]]]]]]]]]] [[[[[[[[[[[[[[[FLT: [[FLT:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
• ] ]] - कोई सीमा नहीं चेक। का प्रयोग करें या क्षेत्र चौड़ाई दर्शक के साथ।

मेमोरी कॉपी और मूव

• ] ] ] ]
  ]]]Safer वैकल्पिक: (हाथ overlapping) और हमेशा n ≤ dest आकार सुनिश्चित करने के लिए।
• कुछ प्लेटफॉर्म एनेक्स के (C11) से प्रदान करते हैं, लेकिन गोद लेने की सीमित है।

प्रमाणीकरण और आकार प्रबंधन

सुरक्षित कार्यों के साथ भी, आपको इनपुट की लंबाई को मान्य करना होगा, उचित बफर आकार सुनिश्चित करना और संभावित ट्रैक्शन को सुंदर ढंग से संभालना होगा।

इनपुट लंबाई की जाँच करें

बाह्य इनपुट (उपयोगकर्ता इनपुट, नेटवर्क डेटा, फ़ाइल सामग्री) की प्रतिलिपि बनाने या प्रसंस्करण से पहले, इसकी अधिकतम स्वीकार्य लंबाई निर्धारित करें और उस डेटा को अस्वीकार या रद्द करें जो उससे अधिक हो। उदाहरण के लिए:

#define MAX_INPUT 255
char buffer[MAX_INPUT + 1]; // +1 for null
if (strlen(user_input) > MAX_INPUT) {
 // Handle error: reject or truncate
 fputs("Input too long", stderr);
 return -1;
}
strncpy(buffer, user_input, sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';

ज्ञात सीमाओं के साथ फिक्स्ड-आकार के बफ़र का उपयोग करें

जब भी संभव हो, बफर को एक स्थिर आकार के साथ परिभाषित करें और इसे पूरे कोड में लागू करें। परिवर्तनीय-लंबाई सरणी (VLAs) से बचें जो बड़े आकार की आपूर्ति के लिए स्टैक ओवरफ्लो का कारण बन सकते हैं। इसके बजाय, स्पष्ट आकार की जांच के साथ गतिशील रूप से आवंटित करें।

Truncation स्पष्ट रूप से संभाल

] और ] जैसे कार्य डेटा को त्रुट कर सकते हैं। त्रुटेशन का पता लगाने के लिए रिटर्न वैल्यू से अवगत रहें और यह तय करें कि क्या त्रुटना डेटा स्वीकार्य है या यदि कोई त्रुटि बढ़नी चाहिए। भेदन को अनदेखा करने से बफर को अप्रत्याशित स्थिति में छोड़ दिया जा सकता है।

कम्पाइलर सुरक्षा ध्वज और रनटाइम सुरक्षा

आधुनिक कम्पाइलर उन झंडे की पेशकश करते हैं जो बफर ओवरफ्लो डिटेक्शन और कोड परिवर्तन के बिना शमन जोड़ते हैं। उन्हें अपने निर्माण प्रणाली में सक्षम करें।

• ] ]] / ] - रिटर्न एड्रेस से पहले स्टैक कैनरी (रैंडम वैल्यू) डालें। यदि कोई बफर रिटर्न एड्रेस को संशोधित करने से पहले कैनरी को ओवरफ्लो करता है, तो यह कार्यक्रम पूरी तरह से शोषण से पहले गर्भपात करता है।
• ] ] ] - ] और ]]] जैसे असुरक्षित कार्यों को बदल देता है, जिसमें चेक किए गए संस्करण हैं जो अगर गंतव्य बफर बहुत छोटा है। या उच्च अनुकूलन की आवश्यकता है।
• ] ]] ]] ] ] ] ]] ]]] ]]] ]]] ]]] ]] ]]]] ]]]]]]]]] [[[[[[[[[[[[FLT:[[[[FLT:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] [[[[[[[[[[[[[[[[[
• ] ] ]] ] ]]] ]] ]] ] ]]] ]]]]] ]]]] ]] ]]] ]]]]]]]]]]] [[[[[[[[[[FLT:[[[FLT:[FLT:[[[[FLT:[FLT:[[FLT:[[[FLT:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
• ] ] ]] ] ]] ] ] ]] ]]] ]] ]] ]] []]]] ]]]]]] [[[[[[[[FLT:[[[[[FLT:]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[

#include <stdio.h>
#include <string.h>

int safe_string_copy(char *dest, size_t dest_size, const char *src) {
 if (!dest || !src || dest_size == 0) {
 return -1; // Invalid parameters
 }
 size_t src_len = strlen(src);
 if (src_len >= dest_size) {
 // Source too large; truncation or error
 // Option: copy what fits and null-terminate
 strncpy(dest, src, dest_size - 1);
 dest[dest_size - 1] = '\0';
 return 1; // Truncation occurred
 }
 strncpy(dest, src, dest_size);
 // strncpy fills remaining with null, so dest_size fits; no need to null-terminate if src shorter
 return 0; // Success, no truncation
}

#include <stdlib.h>
#include <limits.h>
#include <errno.h>

void *safe_malloc_array(size_t nmemb, size_t size) {
 if (nmemb == 0 || size == 0) {
 return NULL; // Or handle zero-size allocation
 }
 if (nmemb > SIZE_MAX / size) {
 // Integer overflow would occur
 errno = ENOMEM;
 return NULL;
 }
 return malloc(nmemb * size);
}

char log_message[256];
int ret = snprintf(log_message, sizeof(log_message),
 "User %s logged in from %s", username, ip_address);
if (ret < 0) {
 // Output error
} else if ((size_t)ret >= sizeof(log_message)) {
 // Truncation occurred; handle if needed
}