Secure coding

Secure coding is the practice of developing computer software in a way that guards against the accidental introduction of security vulnerabilities. Defects, bugs and logic flaws are consistently the primary cause of commonly exploited software vulnerabilities.[1] Through the analysis of thousands of reported vulnerabilities, security professionals have discovered that most vulnerabilities stem from a relatively small number of common software programming errors. By identifying the insecure coding practices that lead to these errors and educating developers on secure alternatives, organizations can take proactive steps to help significantly reduce or eliminate vulnerabilities in software before deployment.

Buffer-overflow prevention

Buffer overflows, a common software security vulnerability, happen when a process tries to store data beyond a fixed-length buffer. For example, if there are 8 slots to store items in, there will be a problem if there is an attempt to store 9 items. In computer memory the overflowed data may overwrite data in the next location which can result in a security vulnerability (stack smashing) or program termination (segmentation fault).[1]

An example of a C program prone to a buffer overflow is

int vulnerable_function(char * large_user_input) {
	char dst[SMALL];
	strcpy(dst, large_user_input);

If the user input is larger than the destination buffer, a buffer overflow will occur. To fix this unsafe program, use strncpy to prevent a possible buffer overflow.

int secure_function(char * user_input) {
	char dst[BUF_SIZE];
    //copy a maximum of BUF_SIZE bytes
	strncpy(dst, user_input,BUF_SIZE);

Another secure alternative is to dynamically allocate memory on the heap using malloc.

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;

In the above code snippet, the program attempts to copy the contents of src into dst, while also checking the return value of malloc to ensure that enough memory was able to be allocated for the destination buffer.