Tomes (and I'm talking of real big tomes) are available on secure coding in C and C++. They describe the details of the language, why C, C++ are so insecure and coding patterns and anti-patterns. They tell you what to chew and what to eschew. At the end of it all - when you come down to writing code - how many of these best practices do you remember?
The answer to the above questions is best left to your judgement. In this secure programming series, I intend to bring before you collections of programming best practices collected from the following sources:
- My own experience and the invaluable experience that I have obtained when reviewing source code.
- Numerous books available on the topic (my favourite being Secure Programming in C and C++ by Robert Seacord). I recently picked up Exceptional C++ and More Exceptional C++ by Herb Sutter and wonder how I did without these ones!
This article gives you tips to follow when allocating and deallocating memory in C and C++. If your code does not follow them, then you run a risk of making your programs susceptible to all types of attacks (describing the attacks does not fall in the scope of the article).
Without wasting any more of your time (or mine), let us dig in.
Secure Memory Allocation Tips Common to C and C++
Use static buffers wherever possible. The compiler automatically frees such memory.
Previously allocated memory should be manually freed, after it is no longer required.
Don't laugh, meet someone who's making a switch from Java into C, C++ and you'll know what I'm talking about.
Given an option to choose between
new to allocate memory, go in for the latter - use
new, don't use
When using C and C++ code together, if
new has been used to allocate memory, use
delete to free it. Do not use
free. Likewise, if
calloc has been used to allocate memory, use
free when deallocating. Do not use
Unfortunately, many programmers feel they can get away with using
free when allocation has been done by
new (and vice versa) because they discovered while debugging that
new was implemented using
malloc and that
delete was implemented using
free! Don't fall in this trap.
Often a function requires to set a buffer supplied by the caller. The length of the buffer may be unknown to the caller so the caller may not know how much memory to allocate before supplying that buffer to the function. In such cases, the function should provide a means for the caller to determine how many bytes are required to be allocated.
A common way to do this is by allowing the caller to call the function with a special argument so that it will return the number of bytes the caller must allocate for the buffer.
When shipping code libraries (or SDKs as they are called), provide wrapper functions that encapsulate
delete. This helps prevent single-threaded and multi-threaded runtime issues.
Use unsigned integer types to hold the number of bytes to be allocated, when allocating memory dynamically. This weeds out negative numbers. Also check the length of memory allocated against a maximum value.
Do not allocate and deallocate memory in a loop as this may slow down the program and may sometime cause security malfunctions.
NULL to a pointer after freeing (or deleting) it. This prevents the program from crashing should the pointer be accidentally freed again. Calling
NULL pointers is guaranteed not to cause a problem.
Compilers are known to vaporise calls to
memset() that appear after all modifications to the memory location is complete for that flow. Use
SecureZeroMemory() to prevent this from happening.
When storing secrets such as passwords in memory, overwrite them with random data before deleting them. Need to note that
delete merely make previously allocated memory unavailable, they don't really '
delete' data contained in that memory.
An easy way to find out if your code is leaking memory is by executing it and examining its memory usage either using Task Manager on Windows or top on Linux.
Secure Memory Allocation Tips in C
Ensure that 0 (zero) bytes are not allocated using
malloc. According to the documentation, behaviour for
malloc() for this case is undefined.
Always check the pointer to the memory returned by
malloc. If this pointer turn out to be
NULL, the memory allocation should be considered unsuccessful and no operations should be performed using that pointer.
When allocating an array of objects, remember to free the array in a loop.
Do not use
realloc when allocating buffers that will store sensitive data in them. The implementation of
realloc copies and moves around the data based on your reallocations. This implies that your sensitive data ends up in several other areas in memory which you would have no means of "scrubbing".
Secure Memory Allocation Tips in C++
When allocating collections use...
thing* pt = new thing;
The vector defined above is clearly defined on the stack and therefore memory deallocation will be handled by the compiler. If the storage needs a longer lifetime, say as part of a larger class instance, then make it a member variable and initialize the storage with
assign() when required.
new to allocate an array of objects, use the
delete [ ] convention when freeing memory. Using
delete without the subscript operator
[ ] will result in a memory leak.
auto_ptr more often than you currently do when allocating so that deallocation is handled automatically. Remember the following guidelines when dealing with
- An existing non-const
auto_ptr can be reassigned to own a different object by using its
auto_ptr::reset() function deletes the existing owned object before owning the new one.
- Only one
auto_ptr can own an object. So after one
auto_ptr (say, P1) has been assigned to another
auto_ptr (say, P2) do not use P1 any longer to call a method on the object as P1 is reset to
NULL. Remember that the copy of an
auto_ptr is not equivalent to the original.
- Do not put
auto_ptrs into standard containers. This is because doing this creates a copy of the
auto_ptr and as mentioned above, the copy of an
auto_ptr is not equivalent to the original.
- Dereferencing an
auto_ptr is the only allowed operation on a const
auto_ptr cannot be used to manage arrays.
new, enclose it within a
catch block. The
new operator throws an exception and does not return a value. To force the
new operator to return a value, use the
nothrow qualifier as shown below:
thing * pt = new (std::nothrow) thing;
I hope you enjoyed reading these tips. If you did, please vote and rate this article below. I shall wait for your comments and feedback. I will collate comments from all of you and update the article - not to mention - and give you all credits. Please feel free to email me at email@example.com. Good luck and secure programming!
Thanks to Jerry Evans, Ogrig, Mauro H. Leggieri, SilentSilent, Darka, Rob Hemstede and Peterchen for their quality comments and reviews that influenced the previous versions of this article.