c लेखन सुरक्षित सी और सुरक्षित सी Idioms




security buffer-overflow (6)

यानिक मोय ने पीएचडी के दौरान सी के लिए होयर / फ़्लॉइड कमजोर पूर्व शर्त प्रणाली विकसित की और इसे सीईआरटी प्रबंधित स्ट्रिंग लाइब्रेरी पर लागू किया । उन्हें कई कीड़े मिलीं (उनके ज्ञापन के पृष्ठ 1 9 7 देखें)। अच्छी खबर यह है कि लाइब्रेरी अब अपने काम के लिए सुरक्षित है।

"औसत आदमी स्वतंत्र नहीं होना चाहता। वह बस सुरक्षित होना चाहता है।" - एचएल मेनकेन

मैं बहुत सुरक्षित लिखने का प्रयास कर रहा हूं। नीचे मैं उन तकनीकों की सूची देता हूं जो मैं उपयोग करता हूं और पूछता हूं कि वे सुरक्षित हैं क्योंकि मुझे लगता है कि वे हैं। कृपया मेरे कोड / preconceptions को shreds फाड़ने में संकोच नहीं करते हैं। कोई भी जवाब जो सबसे छोटी भेद्यता को भी पाता है या मुझे एक नया विचार सिखाता है, उसका अत्यधिक महत्व होगा

एक धारा से पढ़ना:

जीएनयू सी प्रोग्रामिंग ट्यूटोरियल getline के अनुसार:

गेटलाइन फ़ंक्शन स्वचालित रूप से रीयलॉक फ़ंक्शन के माध्यम से आवश्यक स्मृति के ब्लॉक को बड़ा कर देगा, इसलिए अंतरिक्ष की कमी कभी नहीं होती - एक कारण है कि गेटलाइन इतनी सुरक्षित है। [..] ध्यान दें कि गेटलाइन आपके इनपुट की लाइन को सुरक्षित रूप से संभाल सकती है, चाहे कितनी देर हो।

मुझे लगता है कि सभी इनपुट के तहत , गेटलाइन को स्ट्रीम से पढ़ने पर होने वाले बफर ओवरफ़्लो को रोकना चाहिए।

  • क्या मेरी धारणा सही है? क्या वहां इनपुट और / या आवंटन योजनाएं हैं जिसके अंतर्गत इसका शोषण हो सकता है? उदाहरण के लिए यदि स्ट्रीम से पहला अक्षर कुछ विचित्र नियंत्रण चरित्र है , तो शायद 0x08 बैकस्पेस (सीटीएल-एच) हो सकता है।
  • क्या गेटलाइन को सुरक्षित रूप से साबित करने के लिए कोई काम किया गया है?

विफलता पर मॉलोक रिटर्न शून्य

यदि मॉलोक एक त्रुटि मालोक का सामना करता है तो एक नल पॉइंटर देता है। यह एक सुरक्षा जोखिम प्रस्तुत करता है क्योंकि कोई भी अभी भी एक पूर्ण (0x0) सूचक में पॉइंटर अंकगणित लागू कर सकता है, इस प्रकार विकिपीडिया recommends

/* Allocate space for an array with ten elements of type int. */
int *ptr = (int*)malloc(10 * sizeof (int));
if (ptr == NULL) {
    /* Memory could not be allocated, the program should handle 
       the error here as appropriate. */
} 

सुरक्षित sscanf:

sscanf का उपयोग करते समय मुझे इनपुट स्ट्रिंग के आकार के आकार को निकालने के लिए आकार को आवंटित करने की आदत में प्राप्त हुआ है, उम्मीद है कि ओवरराउन की संभावना से बचें। उदाहरण के लिए:

const char *inputStr = "a01234b4567c";
const char *formatStr = "a%[0-9]b%[0-9]c":
char *str1[strlen(inputStr)];
char *str2[strlen(inputStr)];

sscanf(inputStr, formatStr, str1, str2);

चूंकि str1 और str2 inputStr का आकार हैं और इनपुट एसआरटी से स्ट्रेलन (इनपुटएसआरआर) से अधिक वर्ण नहीं पढ़े जा सकते हैं, यह इनपुट एसआरटी के लिए सभी संभावित मानों को बफर ओवरफ्लो के कारण असंभव लगता है?

  • क्या मैं सही हूँ? क्या अजीब कोने के मामले मैंने सोचा नहीं है?
  • क्या इसे लिखने के बेहतर तरीके हैं? पुस्तकालय जो पहले से ही हल कर चुके हैं?

सामान्य सवाल:

जबकि मैंने बड़ी संख्या में प्रश्न पोस्ट किए हैं, मैं उम्मीद नहीं करता कि कोई भी उन सभी का जवाब दे। प्रश्न मैं जिन उत्तरों की तलाश में हूं, उनके लिए दिशानिर्देश अधिक हैं। मैं वास्तव में सुरक्षित सी मानसिकता सीखना चाहता हूं।

  • वहां अन्य सुरक्षित सी मुहावरे क्या हैं?
  • मुझे हमेशा किन जांचने की आवश्यकता है?
  • इन नियमों को लागू करने के लिए मैं यूनिट परीक्षण कैसे लिख सकता हूं?
  • मैं एक टेस्टेबिलिटी या सिद्ध रूप से सही तरीके से बाधाओं को कैसे लागू कर सकता हूं?
  • सी के लिए कोई भी सिफारिश की स्थिर / गतिशील विश्लेषण तकनीकों या उपकरण?
  • आप कौन सी सुरक्षित सी प्रथाओं का पालन करते हैं और आप उन्हें अपने और दूसरों को कैसे औचित्य देते हैं?

संसाधन:

कई संसाधनों को उत्तर से उधार लिया गया था।


इनपुट के लिए fgets() उपयोग न करें, fgets() उपयोग करें। fgets() उपयोग करने के लिए, यदि आपका बफर स्वचालित रूप से आवंटित किया जाता है (यानी, "स्टैक पर"), तो इस मुहावरे का उपयोग करें:

char buf[N];
...
if (fgets(buf, sizeof buf, fp) != NULL)

अगर आप buf के आकार को बदलने का फैसला करते हैं तो यह काम करेगा। मैं इस फॉर्म को पसंद करता हूं:

#define N whatever
char buf[N];
if (fgets(buf, N, fp) != NULL)

क्योंकि पहला फॉर्म दूसरा तर्क निर्धारित करने के लिए buf का उपयोग करता है, और स्पष्ट है।

fclose() के वापसी मूल्य की जांच करें।


आप here लेस हैटन की वेबसाइट और अपनी पुस्तक सफर सी पर भी देख सकते हैं जिसे आप अमेज़ॅन से प्राप्त कर सकते हैं।



मुझे लगता है कि आपका एसएसकेएनएफ उदाहरण गलत है। इस तरह इस्तेमाल होने पर यह अभी भी बहती जा सकती है।

इसे आज़माएं, जो पढ़ने के लिए बाइट्स की अधिकतम संख्या निर्दिष्ट करता है:

void main(int argc, char **argv)
{
  char buf[256];
  sscanf(argv[0], "%255s", &buf);
}

बफर ओवरफ्लो के खिलाफ सुरक्षा के बारे में इस आईबीएम देव लेख पर एक नज़र डालें।

परीक्षण के मामले में, मैं एक ऐसा प्रोग्राम लिखूंगा जो यादृच्छिक लंबाई के यादृच्छिक तार उत्पन्न करता है और उन्हें अपने कार्यक्रम में खिलाता है, और सुनिश्चित करें कि उन्हें उचित तरीके से संभाला जा सके।


अच्छा दिन,

डेविड व्हीलर की उत्कृष्ट सुरक्षित कोडिंग साइट पर यह देखने के लिए एक अच्छी जगह है।

उनकी मुफ्त ऑनलाइन पुस्तक " लिनक्स और यूनिक्स हाउटो के लिए सुरक्षित प्रोग्रामिंग " एक उत्कृष्ट संसाधन है जिसे नियमित रूप से अपडेट किया जाता है।

आप कुछ और संकेत प्राप्त करने के लिए अपने उत्कृष्ट स्थिर विश्लेषक flawfinder को भी देखना चाहेंगे। लेकिन याद रखें, कोई स्वचालित उपकरण अनुभवी आंखों की अच्छी जोड़ी के प्रतिस्थापन नहीं है, या जैसे डेविड रंगीन रूप से इसे रखता है ..

फ्लॉफाइंडर जैसे किसी भी स्थिर विश्लेषण उपकरण, केवल एक उपकरण है। मानव विचार के लिए कोई उपकरण प्रतिस्थापित नहीं कर सकता! संक्षेप में, "एक उपकरण के साथ एक मूर्ख अभी भी मूर्ख है" । यह सोचने की गलती है कि विश्लेषण उपकरण (जैसे फ्लॉफाइंडर) सुरक्षा प्रशिक्षण और ज्ञान के लिए एक विकल्प हैं

मैंने कई वर्षों से व्यक्तिगत रूप से डेविड के संसाधनों का उपयोग किया है और उन्हें उत्कृष्ट होने के लिए खोजा है।

HTH

चियर्स,





exploit