பாதிப்புகளை சுரண்டுவதற்கான ஒரு பார்வை

இந்த தலைப்பைத் தொடர்ந்து விவாதிக்க நான் எதிர்பார்த்துக் கொண்டிருந்தபோது, ​​பாதிப்புகள் குறித்த வரலாறு, கோட்பாடு மற்றும் நடைமுறைகளை நான் உங்களுக்குச் சொல்கிறேன். பாதுகாப்பு குறைபாடுகள் நிறைய செலவாகும் என்பதை நாம் அனைவரும் இப்போது கேள்விப்பட்டிருக்கிறோம், எங்கள் மென்பொருளை புதுப்பித்த நிலையில் வைத்திருக்க வேண்டும் என்பதை நாம் அனைவரும் அறிவோம், பாதுகாப்பு புதுப்பிப்புகளால் பல புதுப்பிப்புகள் ஏற்படுகின்றன என்பதை நாம் அனைவரும் அறிவோம். ஆனால் இந்த பிழைகள் எவ்வாறு கண்டுபிடிக்கப்பட்டு சுரண்டப்படுகின்றன என்பதைப் பற்றி இன்று நான் உங்களுக்கு கொஞ்சம் கூறுவேன் 🙂 ஆனால் இதற்கு முன் ஒரு சிறந்த கண்ணோட்டத்தைப் பெறுவதற்காக சில விவரங்களை தெளிவுபடுத்தப் போகிறோம்.

நீங்கள் தொடங்குவதற்கு முன்

முதலில் நான் உங்களுக்குச் சொல்ல விரும்புகிறேன், நான் அறிந்த முதல், சுரண்ட கற்றுக்கொண்ட முதல் பாதிப்பு குறித்து நாங்கள் கவனம் செலுத்தப் போகிறோம் இடையக வழிதல், இந்த பாதிப்பில், வேடிக்கையான விஷயங்களைச் செய்ய நினைவக சரிபார்ப்பு இல்லாததை நாங்கள் பயன்படுத்திக் கொள்கிறோம் 🙂 ஆனால் இதைப் பற்றி இன்னும் கொஞ்சம் தெளிவுபடுத்துவோம்.

இது ஒரு உண்மையான உலக காட்சியாக இருக்கப்போவதில்லை

அவர்கள் பார்க்கும் எந்தவொரு நிரலையும் உடைக்க அவர்களுக்குக் கற்பிக்க என்னால் முடியாது - முதலில் இது அவர்களின் கணினிகளுக்கு ஆபத்தானது, இரண்டாவதாக, ஏனெனில் இது எனது வழக்கமான சொற்களை விட அதிகமாக எடுக்கும்.

நாங்கள் 80 களில் ஒரு பயணத்திற்கு செல்கிறோம்

எனது மடிக்கணினியில் நான் என்ன செய்ய முடியும் என்பதை நான் உங்களுக்குக் காட்டப் போகிறேன், ஆனால் இன்று அதை ஒரு எளிய வழியில் செய்ய முடியும் என்று அர்த்தமல்ல these இந்த கருத்துக்கள் பல ஏற்கனவே பல முறை சுரண்டப்பட்டுள்ளன, புதிய பாதுகாப்பு முறைகள் மற்றும் புதிய வழிமுறைகள் தவிர்க்கப்படுகின்றன அவை வெளிவந்துள்ளன 😛 ஆனால் அது நம்மை ஒரே இடத்திற்குத் திருப்புகிறது, அதையெல்லாம் சொல்ல இடமில்லை

இது உங்கள் செயலியில் வேலை செய்யாமல் போகலாம்

நான் மிகவும் எளிமையான உதாரணத்தைப் பயன்படுத்தப் போகிறேன் என்றாலும், ஆரம்பத்தில் இருந்தே இது பற்றிய விவரங்கள் பல மற்றும் பலவகைப்பட்டவை என்பது தெளிவாக இருக்க வேண்டும் என்று நான் விரும்புகிறேன், அது என்னைப் போலவே வெளியே வர முடியும், நீங்கள் அதை முயற்சி செய்ய விரும்பினால் , விரும்பிய விளைவும் அடையப்படாமல் போகலாம் 🙂 ஆனால் இந்த இடத்தில் என்னால் விளக்க முடியாது என்று நீங்கள் கற்பனை செய்து கொள்ளலாம், குறிப்பாக இந்த அறிமுகத்துடன் நான் ஏற்கனவே 300 க்கும் மேற்பட்ட சொற்களை எடுத்துள்ளேன், எனவே நாம் நேராக எங்கள் புள்ளியை அடைகிறோம்.

என்ன ஒரு தாங்கல் வழிதல்

இதற்கு பதிலளிக்க இந்த கலவையின் முதல் பாதியை நாம் முதலில் புரிந்து கொள்ள வேண்டும்.

அடிதாங்கிகள்

எல்லாமே ஒரு கணினியில் நினைவகத்தைப் பற்றியது என்பதால், சில வகையான தகவல் கொள்கலன் இருக்க வேண்டும் என்பது தர்க்கரீதியானது. நாம் பேசும்போது உள்ளீடுகள் o வெளியீடுகளை, நாம் நேரடியாக கருத்துக்கு வருகிறோம் பஃப்பர்கள். இதைச் சுருக்கமாக வைக்க, அ தாங்கல் இது வரையறுக்கப்பட்ட அளவின் நினைவக இடமாகும், இதில் நாம் ஒரு அளவிலான தகவல்களை சேமிக்கப் போகிறோம், எளிய

பெயர் குறிப்பிடுவது போல, ஒரு இடையகத்தை கையாளக்கூடியதை விட அதிகமான தகவல்களை நிரப்பும்போது, ​​வழிதல் ஏற்படுகிறது. ஆனால் இது ஏன் முக்கியமானது?

ஸ்டேக்

அடுக்குகள் என்றும் அழைக்கப்படுகின்றன, அவை ஒரு சுருக்கமான தரவு வகையாகும், அதில் நம்மால் முடியும் அடுக்கு தகவல், அவற்றின் முக்கிய பண்பு என்னவென்றால், அவை ஒரு வரிசைப்படுத்தலைக் கொண்டுள்ளன LIFO (முதல் அவுட்டில் கடைசி). தட்டுகளின் அடுக்கைப் பற்றி ஒரு நொடி யோசிப்போம், அவற்றை ஒவ்வொன்றாக மேலே வைக்கிறோம், பின்னர் அவற்றை ஒவ்வொன்றாக மேலே இருந்து வெளியே எடுத்துக்கொள்கிறோம், இது நாம் போட்ட கடைசி தட்டை (மேலே உள்ள ஒன்று ) என்பது நாம் வெளியே எடுக்கப் போகும் முதல் தட்டு, வெளிப்படையாக ஒரு நேரத்தில் ஒரு தட்டை மட்டுமே எடுக்க முடியும் என்றால், அதை அந்த வரிசையில் செய்ய முடிவு செய்தால்: பி.

இப்போது இந்த இரண்டு கருத்துகளையும் நீங்கள் அறிந்திருக்கிறீர்கள், அவற்றை நாம் ஒழுங்காக வைக்க வேண்டும். அடுக்குகள் முக்கியம், ஏனென்றால் நாங்கள் இயக்கும் ஒவ்வொரு நிரலும் அதன் சொந்தமானது மரணதண்டனை அடுக்கு. ஆனால் இந்த அடுக்கு ஒரு உள்ளது குறிப்பிட்ட பண்பு, கீழே வளரும். இதைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய ஒரே விஷயம் என்னவென்றால், ஒரு நிரல் இயங்கும்போது, ​​ஒரு செயல்பாடு அழைக்கப்படும் போது, ​​அடுக்கு நினைவகத்தில் உள்ள எக்ஸ் எண்ணிலிருந்து ஒரு எண்ணுக்கு (எக்ஸ்என்) செல்கிறது. ஆனால் தொடர நாம் இன்னும் ஒரு கருத்தை புரிந்து கொள்ள வேண்டும்.

சுட்டிகள்

இது சி உலகில் தொடங்கும் போது பல புரோகிராமர்களை பைத்தியம் பிடிக்கும் ஒரு கருத்து, உண்மையில் சி நிரலாக்கத்தின் பெரும் சக்தி ஒரு பகுதியாக சுட்டிகள் பயன்படுத்துவதால் ஏற்படுகிறது. எளிமையாக வைக்க, ஒரு சுட்டிக்காட்டி நினைவக முகவரிக்கு சுட்டிக்காட்டுகிறது. இது சிக்கலானதாகத் தெரிகிறது, ஆனால் அது அவ்வளவு சிக்கலானது அல்ல, நம் அனைவருக்கும் நம் கணினிகளில் ரேம் இருக்கிறதா? சரி, இதை ஒரு என வரையறுக்கலாம் தொகுதிகளின் தொடர்ச்சியான ஏற்பாடு, இந்த இடங்கள் பொதுவாக அறுகோண எண்களில் வெளிப்படுத்தப்படுகின்றன (0 முதல் 9 வரை, பின்னர் A முதல் F வரை, 0x0, 0x1, 0x6, 0xA, 0xF, 0x10 போன்றவை). இங்கே ஒரு ஆர்வமான குறிப்பாக, 0x10 இல்லை இது 10 to க்கு சமம், நாம் அதை தசம வரிசைக்கு மாற்றினால் அது 15 என்று சொல்வது போலவே இருக்கும். இது முதலில் ஒன்றுக்கு மேற்பட்டவற்றைக் குழப்புகிறது, ஆனால் அதற்கு கீழே இறங்குவோம்.

பதிவுகள்

செயலிகள் பலவற்றோடு வேலை செய்கின்றன பதிவுகள், இடங்களை இயற்பியல் நினைவகத்திலிருந்து செயலிக்கு அனுப்பும், 64-பிட்களைப் பயன்படுத்தும் கட்டமைப்புகளுக்கு, பதிவேடுகளின் எண்ணிக்கை இங்கே விவரிக்க பெரியது மற்றும் கடினம், ஆனால் யோசனையைப் பெற, பதிவேடுகள் சுட்டிகள் போன்றவை, அவை மற்றவற்றுடன் குறிக்கின்றன , நினைவக இடம் (இடம்).

இப்போது பயிற்சி

இப்போது வரை செயலாக்க இது நிறைய தகவல்களைக் கொண்டுள்ளது என்பதை நான் அறிவேன், ஆனால் உண்மையில் அவை சற்றே சிக்கலான பிரச்சினைகள், நான் மிக எளிமையான முறையில் விளக்க முயற்சிக்கிறேன், இடையகங்களைப் பயன்படுத்தும் ஒரு சிறிய நிரலைப் பார்க்கப் போகிறோம், நாங்கள் போகிறோம் வழிதல் பற்றி இதைப் புரிந்துகொள்ள அதை உடைக்க, வெளிப்படையாக இது ஒன்றல்ல இது ஒரு உண்மையான நிரல், இன்று பயன்படுத்தப்பட்ட பல எதிர் நடவடிக்கைகளை நாம் "தவிர்க்க" போகிறோம், இதற்கு முன்பு விஷயங்கள் எவ்வாறு செய்யப்பட்டன என்பதைக் காண்பிப்பதற்காக 🙂 மற்றும் இவற்றில் சில மிகவும் சிக்கலான விஷயங்களைக் கற்றுக்கொள்ள கொள்கைகள் அவசியம்

GDB,

சந்தேகத்திற்கு இடமின்றி சி புரோகிராமர்களால் பயன்படுத்தப்பட்ட ஒரு சிறந்த திட்டம். அதன் பல நற்பண்புகளில், இதுவரை நாம் பேசி வந்த அனைத்தையும், பதிவேடுகள், ஸ்டேக், பஃப்பர்கள் போன்றவற்றைப் பார்க்க இது அனுமதிக்கிறது என்ற உண்மையை நாங்கள் கொண்டுள்ளோம் எங்கள் உதாரணத்திற்கு நாம் பயன்படுத்தப் போகும் நிரலைப் பார்ப்போம்.

retinput.c

இது மிகவும் எளிமையான நிரல், நாங்கள் நூலகத்தைப் பயன்படுத்தப் போகிறோம் stdio.h தகவல்களைப் பெற்று அதை ஒரு முனையத்தில் காண்பிக்க முடியும். எனப்படும் ஒரு செயல்பாட்டை நாம் காணலாம் return_input இது உருவாக்குகிறது தாங்கல் என்று வரிசை, இதன் நீளம் 30 ஆகும் பைட்டுகள் (கரி தரவு வகை 1 பைட் நீளமானது).

செயல்பாடு gets(array); பணியகம் மற்றும் செயல்பாடு மூலம் தகவல்களைக் கோருங்கள் printf() வரிசையின் உள்ளடக்கத்தை திருப்பி திரையில் காண்பிக்கும்.

சி இல் எழுதப்பட்ட ஒவ்வொரு நிரலும் செயல்பாட்டுடன் தொடங்குகிறது main(), இது return_input ஐ அழைக்கும் பொறுப்பில் மட்டுமே இருக்கும், இப்போது நாங்கள் நிரலை தொகுக்கப் போகிறோம்.

நான் இப்போது செய்ததை கொஞ்சம் எடுத்துக்கொள்வோம். விருப்பம் -ggdb ஒழுங்காக பிழைதிருத்தம் செய்ய gdb க்கான தகவலுடன் நிரலை தொகுக்க வேண்டும் என்று gcc க்கு சொல்கிறது. -fno-stack-protector இது ஒரு விருப்பமாகும், வெளிப்படையாக நாம் பயன்படுத்தக்கூடாது, ஆனால் நாம் பயன்படுத்தப் போகிறோம், ஏனெனில் இல்லையெனில் அடுக்கில் இடையக வழிதல் உருவாக்க முடியும். முடிவில் நான் முடிவை சோதித்தேன். ./a.out இது நான் தொகுத்ததை இயக்கும், அது என்னிடம் தகவல்களைக் கேட்டு திருப்பித் தருகிறது. இயங்கும்

எச்சரிக்கைகள்

இங்கே மற்றொரு குறிப்பு. எச்சரிக்கைகளைப் பார்க்க முடியுமா? நாம் குறியீட்டில் பணிபுரியும் போது அல்லது தொகுக்கும்போது இது கணக்கில் எடுத்துக்கொள்ள வேண்டிய ஒன்று, இது சற்று வெளிப்படையானது மற்றும் இன்று செயல்பாட்டைக் கொண்ட சில நிரல்கள் உள்ளன gets() குறியீட்டில். ஜென்டூவின் ஒரு நன்மை என்னவென்றால், ஒவ்வொரு நிரலையும் தொகுப்பதன் மூலம், என்ன தவறு இருக்க முடியும் என்பதை என்னால் காண முடிகிறது, ஒரு "சிறந்த" நிரல் அவற்றில் இருக்கக்கூடாது, ஆனால் இந்த எச்சரிக்கைகள் எத்தனை பெரிய நிரல்களில் உள்ளன என்பதை நீங்கள் ஆச்சரியப்படுவீர்கள், ஏனெனில் அவை மிகப் பெரியவை, அது அவற்றைக் கண்காணிப்பது கடினம். ஒரே நேரத்தில் பல எச்சரிக்கைகள் இருக்கும்போது ஆபத்தான செயல்பாடுகள். இப்போது நாம் தொடர்ந்தால்

நிரலை பிழைதிருத்தம் செய்தல்

இப்போது இந்த பகுதி சற்று குழப்பமானதாக இருக்கலாம், ஆனால் நான் ஏற்கனவே போதுமான அளவு எழுதியுள்ளதால், எல்லாவற்றையும் விளக்க என்னால் முடியாது, எனவே நான் மிக வேகமாக செல்கிறேன் என்று நீங்கள் கண்டால் மன்னிக்கவும்

குறியீட்டை நிராயுதபாணியாக்குவது

எங்கள் தொகுக்கப்பட்ட இயந்திர மொழி நிரலைப் பார்த்து ஆரம்பிக்கலாம்.

இது எங்கள் முக்கிய செயல்பாட்டின் குறியீடு சட்டமன்ற, இதுதான் எங்கள் செயலி புரிந்துகொள்கிறது, இடதுபுறத்தில் உள்ள கோடு நினைவகத்தில் உள்ள இயற்பியல் முகவரி, தி <+ n> என அழைக்கப்படுகிறது ஆப்செட், அடிப்படையில் செயல்பாட்டின் தொடக்கத்திலிருந்து (பிரதான) அந்த அறிக்கைக்கான தூரம் (என அழைக்கப்படுகிறது ஆப்கோட்). பின்னர் நாம் அறிவுறுத்தல் வகை (மிகுதி / mov / callq…) மற்றும் ஒன்று அல்லது அதற்கு மேற்பட்ட பதிவேடுகளைக் காண்கிறோம். சுருக்கமாக இது மூல / தோற்றம் மற்றும் இலக்கு ஆகியவற்றைத் தொடர்ந்து வரும் அறிகுறி என்று நாம் கூறலாம். <return_input> எங்கள் இரண்டாவது செயல்பாட்டைக் குறிக்கிறது, பார்ப்போம்.

திரும்ப_உள்ளீடு

இது இன்னும் கொஞ்சம் சிக்கலானது, ஆனால் நீங்கள் இரண்டு விஷயங்களைச் சரிபார்க்க வேண்டும் என்று நான் விரும்புகிறேன், ஒரு குறிச்சொல் உள்ளது <gets@plt> கடைசியாக ஒரு ஒப்கோட் என்று அழைக்கப்படுகிறது retq செயல்பாட்டின் முடிவைக் குறிக்கிறது. நாங்கள் இரண்டு பிரேக் பாயிண்டுகளை வைக்கப் போகிறோம், ஒன்று செயல்பாட்டில் gets மற்றும் மற்றொரு retq.

ரன்

இப்போது நடவடிக்கை எவ்வாறு தொடங்குகிறது என்பதைப் பார்க்க நிரலை இயக்கப் போகிறோம்.

நாம் இருக்கும் ஆப்கோடை குறிக்கும் ஒரு சிறிய அம்பு தோன்றுவதை நாம் காணலாம், அவர்கள் திசையை கணக்கில் எடுத்துக்கொள்ள விரும்புகிறேன் 0x000055555555469b, அழைப்புக்குப் பிறகு இது முகவரி return_input செயல்பாட்டில் main , இது முக்கியமானது, ஏனெனில் நீங்கள் அதைப் பெறும்போது நிரல் திரும்ப வேண்டும் உள்ளீடு, செயல்பாட்டில் இறங்குவோம். இப்போது செயல்பாட்டில் நுழைவதற்கு முன்பு நினைவகத்தை சரிபார்க்கப் போகிறோம் gets.

முக்கிய செயல்பாட்டை உங்களுக்காக மீண்டும் வைத்திருக்கிறேன், மேலும் நான் குறிப்பிடும் குறியீட்டை நான் முன்னிலைப்படுத்தியுள்ளேன், நீங்கள் பார்க்க முடியும் என, எண்டியன்ஸ் இரண்டு பிரிவுகளாக பிரிக்கப்பட்டுள்ளது, அவை திசையை கணக்கில் எடுத்துக்கொள்ள விரும்புகிறேன் 0x7fffffffdbf0 (கமாண்டோவுக்குப் பிறகு இடதுபுறத்தில் இருந்து முதலாவது x/20x $rsp) பெறுதலின் முடிவுகளை சரிபார்க்க நாம் பயன்படுத்த வேண்டிய இடம் இது என்பதால், தொடரலாம்:

நிரலை உடைத்தல்

நான் அவற்றை முன்னிலைப்படுத்தியுள்ளேன் 0x44444444ஏனென்றால் அவை எங்கள் டி.எஸ்ஸின் பிரதிநிதித்துவம்-இப்போது நாம் சேர்க்கத் தொடங்கினோம் உள்ளீடு நிரலுக்கு, மற்றும் நீங்கள் பார்க்க முடியும் என, நாங்கள் விரும்பிய முகவரியிலிருந்து இரண்டு வரிகள் மட்டுமே, முந்தைய படியில் நாம் முன்னிலைப்படுத்திய முகவரிகளுக்கு சற்று முன் இருக்கும் வரை அதை நிரப்பப் போகிறோம்.

திரும்பும் பாதையை மாற்றுதல்

இப்போது நாம் குறியீட்டின் இந்த பகுதியை உள்ளிட முடிந்தது, இது செயல்பாட்டின் வருவாயைக் குறிக்கிறது, முகவரியை மாற்றினால் என்ன ஆகும் என்று பார்ப்போம் a ஒரு கணம் முன்பு இருந்ததைப் பின்தொடரும் ஆப்கோடின் இருப்பிடத்திற்குச் செல்வதற்குப் பதிலாக, நாங்கள் திரும்பிச் சென்றால் நீங்கள் என்ன நினைக்கிறீர்கள் return_input? ஆனால் இதற்காக, பைனரியில் நாம் விரும்பும் முகவரியை எழுதுவது அவசியம், அதை செயல்பாட்டுடன் செய்யப் போகிறோம் printf from bash

இப்போது நாங்கள் இரண்டு முறை தகவல்களைப் பெற்றுள்ளோம்-நிச்சயமாக அதற்கான நிரல் உருவாக்கப்படவில்லை, ஆனால் நாங்கள் குறியீட்டை உடைத்து அதைச் செய்யக்கூடாத ஒன்றை மீண்டும் செய்ய முடிந்தது.

பிரதிபலிப்புகள்

இந்த எளிய மாற்றத்தை ஒரு என்று கருதலாம் பயன்படுத்தி மிகவும் அடிப்படை 🙂 அவர் திட்டத்தை உடைத்து, அவர் செய்ய விரும்பும் ஒன்றைச் செய்ய முடிந்தது.

பார்க்க மற்றும் சேர்க்க வேண்டிய எல்லையற்ற பட்டியலில் இது முதல் படியாகும், ஒரு ஆர்டரை மீண்டும் செய்வதை விட அதிகமான விஷயங்களைச் சேர்க்க வழிகள் உள்ளன, ஆனால் இந்த நேரத்தில் நான் நிறைய எழுதியுள்ளேன் ஷெல்கோடிங் கட்டுரைகளை விட அதிகமாக எழுதுவது ஒரு பொருள், நான் சொல்லும் முழுமையான புத்தகங்கள். நான் விரும்பிய தலைப்புகளில் இன்னும் கொஞ்சம் ஆராய்ந்து பார்க்க முடியாவிட்டால் மன்னிக்கவும், ஆனால் நிச்சயமாக ஒரு வாய்ப்பு கிடைக்கும் 🙂 வாழ்த்துக்கள் மற்றும் இங்கு வந்ததற்கு நன்றி.