Secure coding
பாதுகாப்பான குறியீடு என்பது கணினி மென்பொருளை உருவாக்கும் நடைமுறையாகும், இது பாதுகாப்பு பாதிப்புகளின் தற்செயலான அறிமுகத்திலிருந்து பாதுகாக்கிறது. குறைபாடுகள், பிழைகள் மற்றும் தர்க்கக் குறைபாடுகள் ஆகியவை பொதுவாக சுரண்டப்படும் மென்பொருள் பாதிப்புகளுக்கு முதன்மையான காரணமாகும். ஆயிரக்கணக்கான அறிக்கையிடப்பட்ட பாதிப்புகளின் பகுப்பாய்வு மூலம், பாதுகாப்பு வல்லுநர்கள் பெரும்பாலான பாதிப்புகள் ஒப்பீட்டளவில் சிறிய எண்ணிக்கையிலான பொதுவான மென்பொருள் நிரலாக்க பிழைகளிலிருந்து உருவாகின்றன என்பதைக் கண்டறிந்துள்ளனர். இந்த பிழைகளுக்கு வழிவகுக்கும் பாதுகாப்பற்ற குறியீட்டு நடைமுறைகளை அடையாளம் காண்பதன் மூலமும், பாதுகாப்பான மாற்று வழிகளைப் பற்றி டெவலப்பர்களுக்குக் கற்பிப்பதன் மூலமும், மென்பொருளில் உள்ள பாதிப்புகளை கணிசமாகக் குறைக்க அல்லது அகற்றுவதற்கு நிறுவனங்கள் செயலூக்கமான நடவடிக்கைகளை எடுக்க முடியும். சைபர் பாதுகாப்பு தொடர்பான அச்சுறுத்தல்களை திறம்பட எதிர்கொள்ள, முறையான பாதுகாப்பு குறியிடப்பட வேண்டும் அல்லது அமைப்புகளில் "வேகவைக்கப்பட வேண்டும்" என்று சில அறிஞர்கள் பரிந்துரைத்துள்ளனர். மென்பொருளில் பாதுகாப்பு வடிவமைக்கப்படுவதால், இது உள் தாக்குதல்களிலிருந்து பாதுகாப்பு இருப்பதை உறுதிசெய்கிறது மற்றும் பயன்பாட்டு பாதுகாப்புக்கான அச்சுறுத்தலைக் குறைக்கிறது. ஒரு செயல்முறை ஒரு நிலையான-நீளம் இடையகத்திற்கு அப்பால் தரவைச் சேமிக்க முயற்சிக்கும்போது, ஒரு பொதுவான மென்பொருள் பாதுகாப்பு பாதிப்பான இடையக நிரம்பி வழிவது தடுப்பு இடையக நிரம்பி வழிகிறது. எடுத்துக்காட்டாக, பொருட்களை சேமிக்க 8 இடங்கள் இருந்தால், 9 பொருட்களை சேமிக்க முயற்சி செய்தால் சிக்கல் ஏற்படும். கணினி நினைவகத்தில் நிரம்பி வழியும் தரவு அடுத்த இடத்தில் தரவை மேல் எழுதக்கூடும், இதன் விளைவாக பாதுகாப்பு பாதிப்பு (ஸ்டேக் ஸ்மாஷிங்) அல்லது நிரல் முடிவு (பிரிவு தவறு) ஏற்படலாம். இடையக மேல்நிலைக்கு ஆளாகக்கூடிய ஒரு சி நிரலின் எடுத்துக்காட்டு, பயனர் உள்ளீடு இலக்கு இடையகத்தை விட பெரியதாக இருந்தால், இடையக மேல்நிலை ஏற்படும். இந்த பாதுகாப்பற்ற நிரலை சரிசெய்ய, சாத்தியமான இடையக overflow.int பாதுகாப்பான _ செயல்பாட்டைத் தடுக்க strncpy ஐப் பயன்படுத்தவும் (சார்ட் * பயனர் _ உள்ளீடு) {சார்ட் dst [BUF _ SIZE];// அதிகபட்சமாக BUF _ SIZE பைட்டுகளை நகலெடுக்கவும் (dst, பயனர் _ உள்ளீடு, BUF _ SIZE);} மற்றொரு பாதுகாப்பான மாற்று என்னவென்றால், malloc.char * பாதுகாப்பான _ நகல் (சார்ட் * எஸ்ஆர்சி) {அளவு _ டி லென் = ஸ்ட்ர்லன் (எஸ்ஆர்சி); சார்ட் * டிஎஸ்டி = (சார்ட் *) மல்லோக் (லென் + 1); என்றால் (டிஎஸ்டி! ஃபார்மேட்-ஸ்ட்ரிங் தாக்குதல் தடுப்பு ஒரு ஃபார்மேட் ஸ்ட்ரிங் தாக்குதல் என்பது ஒரு தீங்கிழைக்கும் பயனர் குறிப்பிட்ட உள்ளீடுகளை வழங்கும்போது, அவை இறுதியில் பிரிண்ட்எஃப் () போன்ற வடிவமைப்பைச் செய்யும் செயல்பாட்டிற்கு ஒரு வாதமாக உள்ளிடப்படும். தாக்குதலில் எதிர்ப்பாளர் அடுக்கிலிருந்து வாசிப்பது அல்லது எழுதுவது அடங்கும். சி பிரிண்ட்ஃப் செயல்பாடு ஸ்டாட்அவுட்டுக்கு வெளியீட்டை எழுதுகிறது. பிரிண்ட்எஃப் செயல்பாட்டின் அளவுரு சரியாக வடிவமைக்கப்படவில்லை என்றால், பல பாதுகாப்பு பிழைகள் அறிமுகப்படுத்தப்படலாம். கீழே ஒரு நிரல் உள்ளது, இது ஒரு வடிவமைப்பு சரம் attack.int பாதிக்கப்படக்கூடிய _ பிரிண்ட் (சார * தீங்கிழைக்கும் _ உள்ளீடு) {பிரிண்ட்ஃப் (தீங்கிழைக்கும் _ உள்ளீடு);} நிரலுக்கு அனுப்பப்பட்ட தீங்கிழைக்கும் வாதம் "% s% s% s% s% s% s% s% s" ஆக இருக்கலாம், இது முறையற்ற நினைவக வாசிப்புகளிலிருந்து நிரலை செயலிழக்கச் செய்யலாம். ஒரு எண்கணித செயல்பாட்டின் விளைவாக கிடைக்கக்கூடிய இடத்திற்குள் குறிப்பிடப்பட முடியாத அளவுக்கு பெரிய ஒரு முழு எண் ஏற்படும் போது முழு எண்-உட்செலுத்துதல் தடுப்பு முழு எண் உட்செலுத்துதல் ஏற்படுகிறது. முழு எண் மேல்புறத்தை சரியாக சரிபார்க்காத ஒரு நிரல் சாத்தியமான மென்பொருள் பிழைகள் மற்றும் சுரண்டல்களை அறிமுகப்படுத்துகிறது. கீழே C + + இல் உள்ள ஒரு செயல்பாடு உள்ளது, இது x மற்றும் y இன் கூட்டுத்தொகை வரையறுக்கப்பட்ட மதிப்பை விட குறைவாகவோ அல்லது சமமாகவோ இருப்பதை உறுதிப்படுத்த முயற்சிக்கிறது MAX: bool sumIsValid _ floed (கையொப்பமிடப்படாத int x, கையொப்பமிடப்படாத int y) {கையொப்பமிடப்படாத int sum = x + y; திரும்ப தொகை <= MAX;} குறியீட்டின் சிக்கல் என்னவென்றால், இது கூட்டல் செயல்பாட்டில் முழு எண் நிரம்பி வழிவதை சரிபார்க்காது. x மற்றும் y இன் கூட்டுத்தொகை கையொப்பமிடப்படாத int இன் அதிகபட்ச சாத்தியமான மதிப்பை விட அதிகமாக இருந்தால், கூட்டல் செயல்பாடு நிரம்பி வழியும், மேலும் x மற்றும் y இன் கூட்டுத்தொகை MAX ஐ விட அதிகமாக இருந்தாலும், MAX ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருக்கும். x மற்றும் y இரண்டிற்கும் கூட்டுத்தொகை அதிகமாகவோ அல்லது சமமாகவோ இருப்பதை உறுதி செய்வதன் மூலம் நிரம்பி வழிவதை சரிபார்க்கும் ஒரு செயல்பாடு கீழே உள்ளது. கூட்டுத்தொகை நிரம்பி வழிந்தால், தொகை x க்கும் குறைவாகவோ அல்லது y க்கும் குறைவாகவோ இருக்கும். பூல் சுமைஐஸ்வாலிட் _ செக்யூர் (கையொப்பமிடப்படாத இன்ட் x, கையொப்பமிடப்படாத இன்ட் y) {கையொப்பமிடப்படாத இன்ட் தொகை = x + y; ரிட்டர்ன் தொகை> = x & & தொகை> = y & & & தொகை <= MAX;} பாதை பயணத் தடுப்பு பாதை பயணமானது ஒரு பாதிப்பைக் குறிக்கிறது, இதன் மூலம் நம்பத்தகாத மூலத்திலிருந்து வழங்கப்பட்ட பாதைகள் அங்கீகரிக்கப்படாத கோப்பு அணுகல் சாத்தியமாகும். எடுத்துக்காட்டாக, ஒரு கோப்பு பெயரை எடுத்துக்கொள்வதன் மூலம் ஒரு கட்டுரையைப் பெறும் ஒரு ஸ்கிரிப்டைக் கவனியுங்கள், பின்னர் அது ஸ்கிரிப்ட்டால் படிக்கப்பட்டு பகுப்பாய்வு செய்யப்படுகிறது. அத்தகைய ஸ்கிரிப்ட் நாய் உணவைப் பற்றிய ஒரு கட்டுரையை மீட்டெடுக்க பின்வரும் கற்பனையான URL ஐப் பயன்படுத்தலாம்ஃ https://www.example.net/cgi-bin/article.sh?name=dogfood.html ஸ்கிரிப்ட்டில் உள்ளீடு சரிபார்ப்பு இல்லையென்றால், கோப்பு பெயர் எப்போதும் செல்லுபடியாகும் என்று நம்புவதற்கு பதிலாக, ஒரு தீங்கிழைக்கும் பயனர் வலை சேவையகத்திலிருந்து உள்ளமைவு கோப்புகளை மீட்டெடுக்க ஒரு URL ஐ உருவாக்கலாம்ஃ https://www.example.net/cgi-bin/article.sh?name=./././././etc/passwd ஸ்கிரிப்டைப் பொறுத்து, இது/முதலியன/கடவுச்சொல் கோப்பை அம்பலப்படுத்தலாம், இது யுனிக்ஸ் போன்ற அமைப்புகளில் (மற்றவற்றுடன்) பயனர் ஐடிகள், அவர்களின் உள்நுழைவு பெயர்கள், வீட்டு அடைவு பாதைகள் மற்றும் ஷெல்ல்களைக் கொண்டுள்ளது. (இதே போன்ற தாக்குதலுக்கு SQL ஊசியைப் பார்க்கவும்.) பயன்பாட்டு பாதுகாப்பு பாதுகாப்பு நிரலாக்க பாதுகாப்பு பிழை முன்னிருப்பாக குறிப்புகள் குறிப்புகள் கணினி பாதுகாப்பு பாதுகாப்பைப் பார்க்கவும்