സെക്യുർ കോഡിംഗ്

സോഫ്‌റ്റ്‌വെയറിലെ പൊതുവെ ചൂഷണം ചെയ്യപ്പെടുന്ന വൾനറബിലിറ്റികൾക്ക് പിന്നിലെ പ്രധാന കാരണങ്ങളായ വൈകല്യങ്ങൾ, ബഗുകൾ, ലോജിക് ന്യൂനതകൾ എന്നിവ പോലുള്ള മനഃപൂർവമല്ലാത്ത സെക്യുരിറ്റി വൾനറബിലികൾ തടയാൻ വേണ്ടി കമ്പ്യൂട്ടർ സോഫ്റ്റ്‌വെയർ തയ്യാറാക്കുന്ന രീതിയാണ് **സെക്യുർ കോഡിംഗ്**. സോഫ്‌റ്റ്‌വെയർ ശക്തവും സാധ്യതയുള്ള ആക്രമണങ്ങളെ പ്രതിരോധിക്കുന്നതുമാണെന്ന് ഉറപ്പാക്കാനുള്ള നടപടികൾ നടപ്പിലാക്കുന്നത് ഭാഗമായി ഇതും ഉൾപ്പെടുന്നു.റിപ്പോർട്ട് ചെയ്യപ്പെട്ട ആയിരക്കണക്കിന് വൾനറബിലിറ്റികൾ വിശകലനം ചെയ്യുന്നതിലൂടെ, മിക്ക വൾനറബിലിറ്റികളും താരതമ്യേന ചെറിയ സാധാരണ സോഫ്റ്റ്‌വെയർ പ്രോഗ്രാമിംഗ് പിശകുകളിൽ നിന്നാണ് ഉണ്ടാകുന്നതെന്ന് സെക്യുരിറ്റി പ്രൊഫഷണലുകൾ കണ്ടെത്തി. ഈ പിശകുകളിലേക്ക് നയിക്കുന്ന സുരക്ഷിതമല്ലാത്ത കോഡിംഗ് സമ്പ്രദായങ്ങൾ തിരിച്ചറിയുന്നതിലൂടെയും സുരക്ഷിത ബദലുകളെ കുറിച്ച് ഡെവലപ്പർമാരെ ബോധവത്കരിക്കുന്നതിലൂടെയും, സോഫ്റ്റ്വെയർ വിപണിയിൽ എത്തിക്കുന്നതിന് മുമ്പ് സോഫ്റ്റ്‌വെയറിലെ വൾനറബിലിറ്റികൾ ഗണ്യമായി കുറയ്ക്കാനോ ഇല്ലാതാക്കാനോ വേണ്ടി ഓർഗനൈസേഷനുകൾക്ക് സജീവമായ നടപടികൾ കൈക്കൊള്ളാനാകും.

സൈബർ സുരക്ഷയുമായി ബന്ധപ്പെട്ട ഭീഷണികളെ ഫലപ്രദമായി നേരിടാൻ, സിസ്റ്റങ്ങളിൽ ശരിയായ സെക്യുർ കോഡ് അല്ലെങ്കിൽ "ബേക്ക് ഇൻ" ചെയ്യണമെന്ന് ചില പണ്ഡിതന്മാർ നിർദ്ദേശിച്ചിട്ടുണ്ട്. സെക്യുർ സോഫ്റ്റ്‌വെയറിൽ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതിനാൽ, ഇത് ഇൻസൈഡർ ആക്രമണങ്ങളിൽ നിന്ന് സംരക്ഷണം ഉണ്ടെന്ന് ഉറപ്പാക്കുകയും ആപ്ലിക്കേഷൻ സുരക്ഷയ്ക്കുള്ള ഭീഷണി കുറയ്ക്കുകയും ചെയ്യുന്നു.
## ബഫർ-ഓവർഫ്ലോ പ്രിവൻഷൻ
ഒരു പ്രോസസ്സ് ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള ബഫറിനപ്പുറം ഡാറ്റ സംഭരിക്കാൻ ശ്രമിക്കുമ്പോൾ ബഫർ ഓവർഫ്ലോകൾ മൂലം, ഒരു സാധാരണ സോഫ്റ്റ്‌വെയറിൽ സെക്യുരിറ്റി വൾനറബിലിറ്റി സംഭവിക്കുന്നു. ഉദാഹരണത്തിന്, ഡാറ്റാ സംഭരിക്കുന്നതിന് 8 സ്ലോട്ടുകൾ ഉണ്ടെങ്കിൽ, 9 ഐറ്റങ്ങൾ സൂക്ഷിക്കാൻ ശ്രമിച്ചാൽ ഒരു പ്രശ്നമുണ്ടാകും. കമ്പ്യൂട്ടർ മെമ്മറിയിൽ, ഡാറ്റാ ഓവർഫ്ലോ സംഭവിക്കുകയും, ആ ഡാറ്റ അടുത്ത ലൊക്കേഷനിൽ അത് സംഭരിക്കപ്പെടാം, അത് ഒരു സെക്യുരിറ്റി വൾനറബിലിറ്റിക്ക് (സ്റ്റാക്ക് സ്മാഷിംഗ്) അല്ലെങ്കിൽ പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നതിന് (സെഗ്‌മെന്റേഷൻ തകരാർ) കാരണമാകും.

ബഫർ ഓവർഫ്ലോയ്ക്ക് സാധ്യതയുള്ള ഒരു സി പ്രോഗ്രാമിന്റെ ഉദാഹരണം

```c++
int vulnerable_function(char * large_user_input) {
    char dst[SMALL];
    strcpy(dst, large_user_input);
}
```

യുസർ ഇൻപുട്ട് ലക്ഷ്യം വച്ചുള്ള ബഫറിനേക്കാൾ വലുതാണെങ്കിൽ, ഒരു ബഫർ ഓവർഫ്ലോ സംഭവിക്കും. ഈ സുരക്ഷിതമല്ലാത്ത പ്രോഗ്രാം പരിഹരിക്കാൻ, സാധ്യമായ രീതിയിൽ ബഫർ ഓവർഫ്ലോ തടയാൻ strncpy ഉപയോഗിക്കണം.

```c++
int secure_function(char * user_input) {
    char dst[BUF_SIZE];
    // copy a maximum of BUF_SIZE bytes
    strncpy(dst, user_input, BUF_SIZE);
}
```
malloc ഉപയോഗിച്ച് ഹീപ്പിൽ മെമ്മറി ഡൈനാമിക് ആയി അലോക്കേറ്റ് ചെയ്യുക എന്നതാണ് മറ്റൊരു സുരക്ഷിതമായ ബദൽ.

```c++
char * secure_copy(char * src) {
    size_t len = strlen(src);
    char * dst = (char *) malloc(len + 1);
    if (dst != NULL) {
        strncpy(dst, src, len);
        // append null terminator 
        dst[len] = '\0';
    }
    return dst;
}
```

മുകളിലെ കോഡ് സ്‌നിപ്പെറ്റിൽ, ***src***-യുടെ ഉള്ളടക്കങ്ങൾ ***dst***-ലേക്ക് പകർത്താൻ പ്രോഗ്രാം ശ്രമിക്കുന്നു, അതേസമയം ഡെസ്റ്റിനേഷൻ ബഫറിനായി മതിയായ മെമ്മറി അനുവദിക്കാൻ വേണ്ടി malloc-ന്റെ റിട്ടേൺ മൂല്യം പരിശോധിക്കുന്നു.
## ഫോർമാറ്റ്-സ്ട്രിംഗ് ആക്രമണം തടയൽ
ഒരു മലിഷ്യസ് ഉപയോക്താവ് ഫോർമാറ്റിംഗ് കഴിവുകൾ ചൂഷണം ചെയ്യാൻ ലക്ഷ്യമിട്ട് പ്രിന്റ്എഫ്()(printf()) പോലുള്ള ഒരു ഫംഗ്‌ഷനിലേക്ക് ക്രാഫ്റ്റ് ചെയ്‌ത ഇൻപുട്ട് നൽകുമ്പോൾ ഒരു ഫോർമാറ്റ് സ്‌ട്രിംഗ് അറ്റാക്ക് സംഭവിക്കുന്നു. ഇൻപുട്ട് കൈകാര്യം ചെയ്യുന്നതിലൂടെ, ആക്രമണകാരിക്ക് പ്രോഗ്രാമിന്റെ മെമ്മറി സ്റ്റാക്കിൽ നിന്നുള്ള സെൻസിറ്റീവ് ഡാറ്റ വായിക്കാനോ അനധികൃതമായി കണ്ടന്റ് എഴുതാനോ കഴിയും, ഇത് മൂലം സിസ്റ്റത്തിന്റെ സുരക്ഷയിൽ വീഴ്ച സംഭവിക്കാൻ സാധ്യതയുണ്ട്.

സി പ്രിന്റ്എഫ് ഫംഗ്ഷൻ stdout-ലേക്ക് ഔട്ട്പുട്ട് എഴുതുന്നു. പ്രിന്റ്എഫ് ഫംഗ്‌ഷന്റെ പരാമീറ്റർ ശരിയായി ഫോർമാറ്റ് ചെയ്‌തിട്ടില്ലെങ്കിൽ, നിരവധി സെക്യുരിറ്റി ബഗുകൾ സംഭവിക്കാവുന്നതാണ്. ഫോർമാറ്റ് സ്ട്രിംഗ് ആക്രമണത്തിന് ഇരയാകാവുന്ന ഒരു പ്രോഗ്രാം ചുവടെയുണ്ട്.
```c++
int vulnerable_print(char * malicious_input) {
	printf(malicious_input);
}
```
പ്രോഗ്രാമിലേക്ക് അയച്ച ഒരു മലിഷ്യസ് ആർഗ്യുമെന്റ് "%s%s%s%s%s%s%s" ആയിരിക്കാം, അത് തെറ്റായ മെമ്മറി റീഡുകൾ മൂലം പ്രോഗ്രാമിനെ ക്രാഷ് ചെയ്യും.
## ഇന്റിജർ-ഓവർഫ്ലോ പ്രിവൻഷൻ
പൂർണ്ണസംഖ്യകൾക്കായി(integer) അനുവദിച്ച മെമ്മറിയുമായി പൊരുത്തപ്പെടാൻ കഴിയാത്തത്ര വലിയ ഒരു സംഖ്യ ഉപയോഗിച്ച് ഒരു കണക്കുകൂട്ടൽ നടത്തുമ്പോൾ, ഇത് പിശകുകളോ വൾനറബിലിറ്റികളോ ഉണ്ടാക്കിയേക്കാം. ഒരു പ്രോഗ്രാമിലെ ഇന്റിജർ ഓവർഫ്ലോ പരിശോധിക്കുന്നതിരുന്നാൽ  അത് മൂലം ബഗുകൾക്കും സുരക്ഷാ പ്രശ്നങ്ങൾക്കും ഇടയാക്കും.

x, y എന്നിവയുടെ ആകെത്തുക ഒരു നിർവ്വചിച്ച മൂല്യമായ MAX-നേക്കാൾ കുറവോ തുല്യമോ ആണെന്ന് സ്ഥിരീകരിക്കാൻ ശ്രമിക്കുന്ന സി++ ഫംഗ്‌ഷൻ ചുവടെ ചേർത്തിട്ടുണ്ട്:

```c++
bool sumIsValid_flawed(unsigned int x, unsigned int y) {
	unsigned int sum = x + y;
	return sum <= MAX;
}
```


സങ്കലന പ്രവർത്തനത്തിൽ ഇന്റിജർ ഓവർഫ്ലോ പരിശോധിക്കുന്നില്ല എന്നതാണ് ഈ കോഡിന്റെ പ്രശ്നം. x, y എന്നിവയുടെ ആകെത്തുക `unsigned int`ന്റെ വിലയേക്കാൾ കൂടുതലാണെങ്കിൽ, കൂട്ടിച്ചേർക്കൽ പ്രവർത്തനം മൂലം ഓവർഫ്ലോ ചെയ്യും, ഒരുപക്ഷേ x, y എന്നിവയുടെ ആകെത്തുക MAX-നേക്കാൾ കൂടുതലാണെങ്കിലും, MAX-നേക്കാൾ കുറവോ തുല്യമോ ആയ മൂല്യത്തിന് കാരണമാകാം.‌

തുക x, y എന്നിവയെക്കാൾ വലുതോ തുല്യമോ ആണെന്ന് സ്ഥിരീകരിക്കുന്നതിലൂടെ ഓവർഫ്ലോ പരിശോധിക്കുന്ന ഒരു ഫംഗ്‌ഷൻ ചുവടെ കൊടുത്തിട്ടുണ്ട്. തുക ഓവർഫ്ലോ ആണെങ്കിൽ, തുക x-ൽ കുറവോ അല്ലെങ്കിൽ y-ൽ കുറവോ ആയിരിക്കും.

```c++
bool sumIsValid_secure(unsigned int x, unsigned int y) {
	unsigned int sum = x + y;
	return sum >= x && sum >= y && sum <= MAX;
}
```


## അവലംബം