Buffer Overflow என்றால் என்ன? ஒரு நடைமுறை விளக்கம்

Buffer overflow என்பது ஒரு நிரல் நிர்ணীত அளவுள்ள நினைவக பகுதியில் அந்த பகுதிக்கு ஆற்றல் பெற முடியாத வளவான தரவை எழுதும் போது நிகழ்கிறது. கூடுதல் bytes அருகிலுள்ள நினைவகத்தில் ஓடிப்போகிறது, மற்றும் அந்த buffer க்கு அருகில் என்ன இருக்கிறது என்பதைப் பொறுத்து, நீங்கள் மாறிகளை சிதைக்கலாம், நிரலை செயலிழக்க செய்யலாம், அல்லது செயல்பாட்ட ஓட்டத்தை முழுவதுமாக கடத்திக் கொள்ளலாம். இது மென்பொருள் பாதுகாப்பில் மிகப் பழைய குறை வகுப்புகளில் ஒன்றாகும் மற்றும் இன்றும் CTF கள், CVE கள், மற்றும் உட்பொதிந்த firmware இல் தோன்றுகிறது.

பாதிக்கப்பட்ட வடிவம்

C இல் ஒரு உரிய உதாரணம்:

#include <string.h>

void greet(char *name) {
    char buffer[64];
    strcpy(buffer, name);
}

int main(int argc, char **argv) {
    greet(argv[1]);
    return 0;
}

strcpy நீங்கள் அதற்கு அனுப்பும் எந்த string ஐயும் buffer இல் நகலெடுக்கிறது, எந்த எல்லைப் பரীட்சை இல்லாமல். argv[1] 64 bytes க்கு நீளமாக இருந்தால், நகல் வரிசையின் முடிவைக் கடந்து சென்று கொண்டு இருக்கிறது. Stack இல், buffer மற்ற স்থানীய மாறிகள், சேமிக்கப்பட்ட பதிவேடுகள், மற்றும் இறுதியில் greet() முடிந்த பிறகு CPU எங்கே பாய்கிறது என்பதைக் கூறும் return address க்கு கீழே உள்ளது. அந்த return address ஐ நீங்கள் கட்டுப்படுத்தும் address உடன் மேலெழுதுங்கள், மற்றும் நீங்கள் அடுத்தில் என்ன வியங்கிறது என்பதைக் கட்டுப்படுத்துகிறீர்கள்.

இது ஏன் இன்னும் compile செய்து chạy செய்கிறது

C மற்றும் C++ raw arrays இல் தானியங்கி எல்லைப் பரீட்சை செய்யாது. strcpy, gets, sprintf, மற்றும் strcat போன்ற functions ஒரு buffer இன் முடிவு தாண்டி மகிழ்ச்சியுடன் எழுதும் ஏனெனில் அவை ஒரு null terminator அல்லது source length பற்றி மட்டுமே கவலைப்படுகின்றன, address இன் உண்மையான அளவை அல்ல. அதை strncpy அல்லது snprintf உடன் ஒப்பிடுங்கள், இது ஒரு தெளிவான அளவு argument எடுக்கிறது மற்றும் அங்கே நிறுத்துகிறது. பாதிக்கம் உண்மையில் இல்லை